Cell.h

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

#include <vector>
#include "mg/Box.h"
#include "mg/Position.h"
#include "topo/CellNB.h"
class MGComplex;
class MGBoundary;
class MGGeometry;
class MGCellMap;

//
//Define MGCell Class.


class MG_DLL_DECLR MGCell:public MGCellNB{

public:

typedef std::vector<MGBoundary*>::iterator boundaryItr;
typedef std::vector<MGBoundary*>::const_iterator const_boundaryItr;
typedef std::vector<MGBoundary*>::reverse_iterator boundaryRItr;
typedef std::vector<MGBoundary*>::const_reverse_iterator const_boundaryRItr;
typedef boundaryItr iterator;
typedef const_boundaryItr const_iterator;
typedef boundaryRItr reverse_iterator;
typedef const_boundaryRItr const_reverse_iterator;


MGCell();

MGCell(const MGCell& cell);

MGCell(const MGGeometry& geo);
explicit MGCell(MGGeometry* geo);

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

MGCell(const MGGeometry& geo, 
        const std::vector<MGBoundary*>& boundaries);
MGCell(MGGeometry* geo, 
        const std::vector<MGBoundary*>& boundaries);

virtual ~MGCell();

virtual MGCell& operator=(const MGCell& gel2);

virtual bool operator<(const MGCell& gel2)const;


virtual int append_boundary(MGBoundary* bound);

MGBoundary* boundary(int i) {return m_boundaries[i];};
const MGBoundary* boundary(int i) const {return m_boundaries[i];};

const std::vector<MGBoundary*>& boundaries() const{return m_boundaries;};

MGVector boundary_direction(int i, int j) const;

const_boundaryItr boundaryIterator(const MGBoundary* bnd) const;
boundaryItr boundaryIterator(MGBoundary* bnd);

const MGBox& box() const;

MGPosition center_param() const;

virtual MGCell* clone() const=0;
virtual MGCell* clone_without_boundaries() const=0;

virtual MGCell* clone_binder(const MGCellBase& c) const=0;

void connect(int i1, int j1,
    MGCell* cell2, int i2, int j2);

virtual void draw3DVertex(mgVBO& vbo)const=0;

void erase_boundary(iterator i);
void erase_boundary(int i);

void erase_boundary(MGBoundary* bnd);

virtual MGBoundary* free_boundary(const MGBoundary* bound);

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

virtual long identify_type()const=0;

virtual MGCellNB* make_binder() const=0;

virtual int manifold_dimension() const=0;

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

std::vector<const MGCellNB*> neighbours(int i, int j=0) const;

int number_of_boundaries() const{ return int(m_boundaries.size());};

double parameter_error()const;

virtual int prepend_boundary(MGBoundary* bound);

virtual void sort_boundaries();

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

protected:
    mutable MGBox m_box;    
    std::vector<MGBoundary*> m_boundaries;
    mutable double m_perror;    

virtual MGCell* clone(MGCellMap& cmap)const=0;

virtual void compute_box() const;

virtual void set_box_as_null()const{m_box.set_null();};

void copy_all_boundaries(const MGCellBase& cell);

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

void copy_box(const MGCellBase& cell2) const;

void copy_perror(const MGCellBase& cell2) const;

MGCell& set_cell(const MGCell& cell);

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

virtual void ReadMembers(MGIfstream& buf);

virtual void WriteMembers(MGOfstream& buf) const;

private:

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 get_all_boundary_binders(std::vector<MGCellNB*>& cvec) const;

virtual MGGeometry* make_binder_extent() const=0;

virtual void make_extent() const=0;

void negate_boundary();

friend class MGComplex;
friend class MGBoundary;

};
 // end of TOPO group
#endif