Complex.h

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

#include <list>
#include "mg/Box.h"
#include "topo/Topology.h"

//
//Define MGComplex Class.

class MGPosition;
class MGCellNB;
class MGCellMap;
class MGBoundary;

class MG_DLL_DECLR MGComplex: public MGTopology{

public:
typedef std::list<MGCellNB*> container_type;

typedef container_type::iterator cellItr;
typedef container_type::const_iterator const_cellItr;

typedef container_type::iterator pcellItr;
typedef container_type::const_iterator const_pcellItr;

typedef container_type::iterator bcellItr;
typedef container_type::const_iterator const_bcellItr;

MG_DLL_DECLR friend MGComplex operator* (double s, const MGComplex& complex);


MGComplex();

MGComplex(const MGComplex& complex);

MGComplex(const MGCellNB& cell);
MGComplex(MGCellNB* cell);


virtual ~MGComplex();


virtual MGComplex& operator=(const MGGel& gel2);
virtual MGComplex& operator=(const MGComplex& gel2);

MGComplex operator+ (const MGVector& v) const;

MGComplex operator- (const MGVector& v) const;

MGComplex operator* (double s) const;

MGComplex operator* (const MGMatrix& mat) const;

MGComplex operator* (const MGTransf& tr) const;

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

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

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


const_bcellItr bcell_begin() const{ return m_bcells.begin();};
bcellItr bcell_begin() { return m_bcells.begin();};

const_bcellItr bcell_end() const{ return m_bcells.end();};
bcellItr bcell_end() { return m_bcells.end();};

const MGCellNB* bcelli(int i) const;
MGCellNB* bcelli(int i);

const_bcellItr bcellIterator(int i) const;
bcellItr bcellIterator(int i);

bool bcell_exist()const;

MGCellNB* binder(int i) const;

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

const MGBox& box() const;

MGPosition center() const;

virtual MGComplex* clone() const;

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

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

virtual void draw3DVertex(
    mgVBO& vbo
)const;

virtual void draw3DVertex_in_star(mgVBO& vbo)const;

void erase_first_pcell();   

void erase_last_pcell();    

void erase_pcell(MGCellNB* pcell);

const MGCellNB* first_pcell()const;
MGCellNB* first_pcell();

virtual long identify_type()const;

bool includes(const MGCellNB* cell)const;

const MGCellNB* last_pcell()const;
MGCellNB* last_pcell();

virtual int manifold_dimension() const;

int number_of_bcells() const{return int(m_bcells.size());};

int number_of_pcells() const{return int(m_pcells.size());};

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

const_pcellItr pcell_begin() const{ return m_pcells.begin();};
pcellItr pcell_begin() { return m_pcells.begin();};

const_pcellItr pcell_end() const{ return m_pcells.end();};
pcellItr pcell_end() { return m_pcells.end();};

const MGCellNB* pcelli(int i) const;
MGCellNB* pcelli(int i);

const_pcellItr pcellIterator(int i) const;
pcellItr pcellIterator(int i);

bool pcell_exist()const;

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

MGPosition pick_closest(const MGStraight& sl)const;

const MGCellNB* star() const;
MGCellNB* star();

protected:
    mutable MGBox m_box;    

explicit MGComplex(std::list<MGCellNB*>& pcells);

MGComplex(const MGComplex& complex,
        MGCellMap& cmap);       

cellItr append_bcell(MGCellNB* cell)const;

cellItr add_cell(
    MGCellNB* cell, 
    bool pcell,     
    cellItr loc 
);

cellItr append_pcell(MGCellNB* cell);

virtual void compute_box() const;

void copy_without_binders(const MGComplex& comp);

void erase_all_elements();

cellItr prepend_pcell(MGCellNB* cell);

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

virtual void ReadMembers(MGIfstream& buf);

MGComplex& set_complex(const MGComplex& comp2);

virtual void WriteMembers(MGOfstream& buf) const;

private:

    container_type m_pcells;    
    mutable container_type m_bcells;
    

void binderTr(const MGVector& v);

void binderTr(double s);

void binderTr(const MGMatrix& mat);

void binderTr(const MGTransf& tr);

void copy_all_elements(const MGComplex& comp);

void copy_all_elements(
    const MGComplex& comp,
    MGCellMap& cmap     
);

void erase_binder(const MGCellNB*);

friend class MGCellBase;
friend class MGCellNB;
friend class MGCell;
friend class MGEdge;
};
 // end of TOPO group
#endif