Loop.h

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

#include "mg/Pvector.h"
#include "topo/LSPoint_vector.h"
#include "topo/Boundary.h"
#include "topo/TrimLoop.h"

class MGInterval;
class MGPosition;
class MGCurve;
class MGStraight;
class MGSurface;
class MGLCisect_vector;
class MGLLisect_vector;
class MGPVertex;
class MGLEPoint;
class MGLPoint;
class MGLoop;
class MGEdge;
class MGFSurface;
class MGFace;
//
//Define MGLoop Class.


class MG_DLL_DECLR MGLoop:public MGBoundary{

public:

enum LoopKind{
    UNDEFINED=-1,
    INACTIVE=0,
    PERIMITER_LOOP=1,
    OUTER_LOOP=2,   
    INNER_LOOP=3,   
    NETWORK=4
};
    
MG_DLL_DECLR friend MGEdge* edge_from_iterator(pcellItr i);
MG_DLL_DECLR friend const MGEdge* edge_from_iterator(const_pcellItr i);


MG_DLL_DECLR friend MGVector eval(const MGLEPoint& t, int nderi=0);


MG_DLL_DECLR friend int inside_outer_loop(
    const MGPosition& uv,
    const std::vector<const MGLoop*>& loop,
    const MGSurface* surf=0
);


MGLoop();

explicit MGLoop(MGEdge* edge);

MGLoop(const MGLoop& loop2);

MGLoop(const MGCurve& param_curve, const MGCurve& world_curve);
MGLoop(const MGCurve& param_curve, const MGInterval& range1,
       const MGCurve& world_curve, const MGInterval& range2);
MGLoop(std::auto_ptr<MGCurve>& param_curve, std::auto_ptr<MGCurve>& world_curve);



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

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

bool operator<(const MGLoop& gel2)const;
bool operator<(const MGComplex& gel2)const;
bool operator<(const MGGel& gel2)const;


bool active() const;

void append(MGEdge* edge);

void append_edge_from_crv(
    const MGSurface& srf,
    const MGCurve& wcrv,
    double& tLast,
    double terror,
    const std::vector<double>& pspan,
    int peri_num,
    bool orientation_is_opposite=false
);

double area()const;

bool both_end_on_perimeter(int& pid_s, int& pid_e,const MGFSurface* srf=0) const;

MGLoop* clone(MGCell& parent)const;
MGLoop* clone()const;

MGLoop* clone_without_binders(MGCell& parent) const;
MGLoop* clone_without_binders() const;

bool closed() const;

MGLEPoint closest(const MGPosition& P, double& distance) const;

bool closest_world(
    const MGStraight& sl,
    MGLEPoint& closest,
    double& dist
)const;

int common(
    const MGLoop& loop2,
    std::vector<MGLEPoint>& pranges1,
    std::vector<double>& branges1,
    std::vector<MGLEPoint>& pranges2,
    std::vector<double>& branges2
)const;

double compute_area()const;

void copy_boundary(const MGBoundary& loop);

void copy_boundary_without_binders(const MGBoundary& loop);

MGPvector<MGCurve> curves()const;

MGPvector<MGCurve> curves_world()const;

MGEdge* edge(int i);
const MGEdge* edge(int i) const;

bool edge_exist() const{return pcell_exist();};

int edge_num(const MGEdge* e)const;

MGPosition end_point() const;

MGLEPoint end_LPoint() const;

double error()const;

MGVector eval(const MGLPoint& t, int nderi=0)const;

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

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

const MGEdge* first_edge() const;
MGEdge* first_edge();

int get_loop_id_in_face()const;

int inside(double u, double v) const;
int inside(const MGPosition& uv) const;

long identify_type()const;

MGLCisect_vector isect(const MGCurve& param_curve) const;

MGLCisect_vector isect(
    double error,//error to get intersection of the loops and sl.
    const MGCurve& param_curve
) const;

std::vector<MGLEPoint> isect_1D(                        
    double f,           
    int coordinate=0    
) const;    

MGLCisect_vector isect_with_endpoints
(const MGCurve& param_curve) const;

bool is_inactive(const MGFSurface* srf=0) const;

bool is_inner_boundary(const MGFSurface* srf=0) const;

bool is_outer_boundary(const MGFSurface* srf=0) const;

bool is_perimeter_boundary(const MGFSurface* srf=0) const;

bool is_network(const MGFSurface* srf=0) const{return m_kind==NETWORK;};

MGLLisect_vector isect(const MGLoop& loop2)const;

void join(bool start, const MGLoop& loop2);
void join(bool start, MGLoop* loop2);
void join(bool start, std::auto_ptr<MGLoop>& loop2);

void join_C1_edges(
    int parameter_normalization=2
        //=0: no parameter normalization.
        //=1: normalize to range=(n, n+1) for the n-th edge.
        //=2: normalize to make the average length of the 1st derivative 
        //    is as equal to 1. as possible. Let the n-th edge's parameter range
        //    is (TSn, TEn), then, TSn=TEn-1.
);

const MGEdge* last_edge() const;
MGEdge* last_edge();

void make_close();

bool make_vertex(
    const MGLEPoint& lp,
    MGEdge*& pre,       
    MGEdge*& aft,       
    MGPVertex** pvertex=0 
);

int manifold_dimension() const{return 1;};

bool merge_network(
    const MGCurve& param_curve,
    double error    
);

bool merge_trim(const MGCurve& param_curve);
bool merge_trim(const MGCurve& param_curve, const MGInterval& range1);
bool merge_trim(const MGCurve& param_curve, const MGCurve& world_curve);
bool merge_trim(const MGCurve& param_curve, const MGInterval& range1,
           const MGCurve& world_curve);
bool merge_trim(const MGLoop& loop2);

MGPosition mid_point()const;

void negate();

void negate_as_boundary(const MGCellNB* parent=0);

int number_of_edges()const{return number_of_pcells();};

bool on_perimeter_end(int& pid_e,const MGFSurface* surf=0)const;
bool on_perimeter_start(int& pid_s,const MGFSurface* surf=0)const;

bool on_surface_perimeter(const MGFace& f)const;

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

void prepend(MGEdge* e);

bool remove_pendent_edge(const MGFSurface& face);

void remove_garbage_edge(double error);

const MGSurface* surface()const;

MGLEPoint start_LPoint() const;

MGPosition start_point() const;

std::vector<MGEdge*> subdivide(
    const std::vector<MGLEPoint>& ranges
);

MGEdge* subdivide(
    MGLEPoint& le1, MGLEPoint& le2
);  

void trim(const MGLEPoint& t1, const MGLEPoint& t2);

void trim_end(const MGLEPoint& t1);

void trim_start(const MGLEPoint& t1);

protected:

MGLoop(
    std::list<MGCellNB*> boundaries 
);

MGLoop(
    const MGLoop& loop,     
    MGCellMap& cmap 
);

MGLoop* clone(MGCell& parent,MGCellMap& cmap) const;
MGLoop* clone(MGCellMap& cmap) const;

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

void ReadMembers(MGIfstream& buf);

void WriteMembers(MGOfstream& buf) const;


private:
    mutable LoopKind m_kind;    

    mutable double m_area;      

    mutable int m_perim_num_s; 
    mutable int m_perim_num_e; 

void compute_kind(const MGFSurface* srf=0)const;

void get_kind(const MGFSurface* srf=0) const;

bool get_perimeter_num(int& pid_s, int& pid_e,const MGFSurface* srf=0) const;

int in_on_curves(
    const MGPosition& uv,   
    const double error[3],
    const MGPvector<MGCurve>& crvs,
    const MGStraight& sl    
)const; 

int inside_test(
    const MGPosition& uv    
)const;

std::vector<MGLEPoint> isect_1D_tess(                       
    double f,           
    int coordinate=0    
) const;    

MGLSPoint_vector isect_binder(const MGFSurface& face) const;

void make_loop(std::auto_ptr<MGCurve>& param_curve, std::auto_ptr<MGCurve>& world_curve);

bool makeVertexWithLcis(
    const MGLEPoint& lp,
    MGLCisect_vector& lcis,
    MGPVertex*& pvertex 
);

bool merge_trim(const MGCurve& param_curve, const MGInterval& range1,
       const MGCurve* world_curve);

bool merge_loop(const MGLoop& loop2);

void trim_param_set(const MGLEPoint& t, bool start);

friend class MGFace;
friend class MGEdge;

};

extern MG_DLL_DECLR void build_networks(
    const MGFSurface& surf,     
    const MGPvector<MGCurve>& pcurves,
    MGPvector<MGLoop>& networks 
);

extern MG_DLL_DECLR std::auto_ptr<MGLoop> trim_out_subloop(const MGLEPoint& ts, const MGLEPoint& te);
 // end of TOPO group
#endif