Edge.h

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

#include "mg/Box.h"
#include "mg/TrimmedCurve.h"
#include "topo/Complex.h"
#include "topo/CellNB.h"

class MGStraight;
class MGSurface;
class MGPVertex;
class MGBVertex;
class MGLoop;
class MGFace;

//
//Define MGEdge Class.


class MG_DLL_DECLR MGEdge: public MGCellNB{

public:

MG_DLL_DECLR friend MGEdge operator* (double s, const MGEdge& e);


MGEdge();

MGEdge(const MGEdge& e, bool copy_boundary=true, bool no_binder=false);

MGEdge(
    MGGeometry* geo,
    MGPVertex* boundaries[2],
    MGCellNB* binder
    );

MGEdge(const MGCurve& crv);
explicit MGEdge(MGCurve* crv);

MGEdge(const MGCurve& crv, const MGInterval& range);
MGEdge(MGCurve* crv, const MGInterval& range);

MGEdge(
    const MGSurface&surf,
    const MGCurve& pcrv, 
    const MGInterval& prange,
    const MGCurve& wcrv 
    );

~MGEdge();


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

MGEdge operator+ (const MGVector& v) const;

MGEdge operator- (const MGVector& v) const;

MGEdge operator* (double s) const;

MGEdge operator* (const MGMatrix& mat) const;

MGEdge operator* (const MGTransf& tr) const;

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

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

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

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


bool active_end() const{ return m_vertex[1]!=0;}
bool active_start() const{ return m_vertex[0]!=0;}

const MGEdge* aft_edge(bool at_end=true, int* vertexID=0)const;
MGEdge* aft_edge(bool at_end=true, int* vertexID=0);

MGEdge* binder_edge() const;

const MGBox& box() const;

MGPosition center_param() const;

MGEdge* clone() const;
MGEdge* clone_without_boundaries() const;

MGEdge* clone_binder(const MGCellBase& e) const;

void compute_continuity(
    const MGEdge& edge2,
    double diatance[7],
    double tangent[4],
    double normal[4]
)const;

void connect(MGCellBase& cell2);
void connect(MGEdge& cell2);

void connect_at_id(int id1, MGEdge* e2, int id2);

void connect_at_start(MGPVertex& pvert){connect(0,pvert);};

void connect_at_end(MGPVertex& pvert){connect(1,pvert);};

MGCurve* base_curve();
const MGCurve* base_curve() const;

MGCurve* curve_limitted() const;

void delete_binder_edge();

void disconnect_at_id(int id);

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

void draw3DVertex(
    mgVBO& vbo
)const;

//Obtain this edge's parent loop's edge iterator as a member of the parent loop.
//This must have the parent loop, i.e. loop() must not null.
MGComplex::const_pcellItr edge_iterator()const;
MGComplex::pcellItr edge_iterator();

//Obtain this edge number as a member of the parent loop.
//This must have the parent loop, i.e. loop() must not null.
int edge_num()const;

MGPosition end_point()const{return eval(param_e());};

MGVector eval(double t, int nderiv=0)const;

MGVector eval_star(
    double t,       
    int nderi=0 
)const;

bool equal_direction_to_binder()const;

const MGFace* face() const;
MGFace* face();

const MGEdge* first_partner() const;

void free_end_neighbourhood();

void free_neighbourhood(int i, int j=0);

void free_start_neighbourhood();

long identify_type()const;

bool is_connected_and_same_direction(
    bool start,
    const MGEdge& edge2
)const;

bool is_end_point(double t)const;

bool is_start_point(double t)const;

bool is_free()const{ return number_of_partners()==0;};

void join(bool start, MGEdge* e2);

const MGLoop* loop() const;
MGLoop* loop();

MGCellNB* make_binder() const;

MGEdge* make_binder_with_curve()const;

int manifold_dimension() const{return 1;};

const MGEdge* member_partner_edge(int i)const;

MGPosition mid_point()const;

void negate();

std::vector<const MGCellNB*> neighbours() const;

bool on_surface_perimeter() const{return surface_perimeter()>=0;};
bool on_surface_perimeter(const MGFace& f) const{return surface_perimeter(f)>=0;};
bool on_surface_perimeter(const MGSurface& sf) const{return surface_perimeter(sf)>=0;};

double parameter_error()const;

double param_bcell(double tp, const double* guess=0)const;

double param_pcell(double tb, const double* guess=0)const;

double param_e()const;

double param_s()const;

double param_span()const{return param_e()-param_s();};

std::vector<const MGEdge*> partner_edges() const;

MGPosition pick_closest(const MGStraight& sl)const;

void polygonize(double error);

const MGEdge* pre_edge(bool at_start=true) const;
MGEdge* pre_edge(bool at_start=true);

MGInterval range()const;

MGEdge* set_binder_edge(const MGCurve& wcrv)const;
MGEdge* set_binder_edge(const MGCurve& wcrv, const MGInterval& range)const;

MGEdge* set_binder_edge(MGCurve* wcrv)const;
MGEdge* set_binder_edge(MGCurve* wcrv, const MGInterval& range)const;

void set_end(double t); 

void set_start(double t);

void set_only_param_range(double ts, double te);

void set_i_th_binder(int i, MGBVertex& binder)const;

const MGSurface* star_surface()const;

MGPosition start_point()const{return eval(param_s());};

int surface_perimeter() const;
int surface_perimeter(const MGSurface& sf) const;
int surface_perimeter(const MGFace& face) const;

void trim_end(double t){trim(t,false);};

void trim_start(double t){trim(t,true);};

MGTrimmedCurve trimmed_curve() const;

const MGPVertex* vertex(int id)const{return m_vertex[id];};
const MGPVertex* vertex_start()const{return m_vertex[0];};
const MGPVertex* vertex_end()const{return m_vertex[1];};
MGPVertex* vertex(int id){return m_vertex[id];};
MGPVertex* vertex_start(){return m_vertex[0];};
MGPVertex* vertex_end(){return m_vertex[1];};

MGCurve* world_curve();
const MGCurve* world_curve() const;

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

protected:

void ReadMembers(MGIfstream& buf);

void WriteMembers(MGOfstream& buf) const;

private:

    MGPVertex* m_vertex[2]; 
    mutable MGBox m_box;    
    mutable double m_perror;
    mutable int m_equal_to_binder;

void bn_binder_tr(const MGVector& v);
void bn_binder_tr(double s);
void bn_binder_tr(const MGMatrix& mat);
void bn_binder_tr(const MGTransf& tr);

void connect(int id, MGPVertex& pvert);

void set_box_as_null() const;

MGEdge* clone(MGCellMap& cmap) const;

void compute_box() const;

void compute_continuity2(
    const MGInterval& span,
    int npoint,             
    const MGEdge& edge2,    
    double distance[7],     
    double tangent[4],      
    double normal[4]
)const;

void copy_all_boundaries(const MGCellBase& cellin);

void copy_all_boundaries(const MGCellBase& cellin, MGCellMap& cmap);

void copy_box(const MGCellBase& cellin) const;

void copy_perror(const MGCellBase& cellin) const;

void get_all_boundary_binders(std::vector<MGCellNB*>& cvec) const;

MGGeometry* make_binder_extent() const;

void make_extent() const;

void negate_boundary();

void trim(double t, bool start);

friend class MGFace;
friend class MGLoop;

};
 // end of TOPO group
#endif