vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass > Class Template Reference

Class handling the representation and development of 2D cell complex. More...

#include <algorithms/complex.h>

Inheritance diagram for vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >:
Inheritance graph
[legend]

List of all members.

Public Types

typedef graph::Vertex
< CellContent > 
cell
 Type of a cell vertex.
typedef cell_graph::arc_t cell_arc
 Type of an arc in the cell graph.
typedef CellContent cell_content
typedef cell_graph::edge_t cell_edge
 Type of an edge in the cell graph.
typedef graph::VVGraph
< CellContent, CellEdgeContent,
compact > 
cell_graph
 Type of the cell graph.
typedef CellJunctionContent cell_junction_content
typedef complex_graph::edge1_t cell_junction_edge
 Type of the edges from cell to junction in the cell complex graph.
typedef VVComplexGraph
< CellContent, JunctionContent,
CellJunctionContent,
JunctionCellContent, compact > 
complex_graph
 Type of the cell complex graph.
typedef cell_graph::const_edge_t const_cell_edge
 Type of an edge in the cell graph.
typedef
complex_graph::const_edge1_t 
const_cell_junction_edge
 Type of the edges from cell to junction in the cell complex graph.
typedef
complex_graph::const_edge2_t 
const_junction_cell_edge
 Type of the edges from junction to cell in the cell complex graph.
typedef wall_graph::const_edge_t const_wall
 Type of an edge in the wall graph;.
typedef
complex_graph::division_data 
division_data
 Type of the division data used for the complex.
typedef
complex_graph::division_result_t 
division_result_t
typedef graph::Vertex
< JunctionContent > 
junction
 Type of a junction vertex.
typedef JunctionCellContent junction_cell_content
typedef complex_graph::edge2_t junction_cell_edge
 Type of the edges from junction to cell in the cell complex graph.
typedef JunctionContent junction_content
typedef Model model_t
typedef wall_graph::edge_t wall
 Type of an edge in the wall graph;.
typedef wall_graph::arc_t wall_arc
 Type of an arc in the wall graph;.
typedef WallContent wall_content
typedef graph::VVGraph
< JunctionContent, WallContent,
compact > 
wall_graph
 Type of the wall graph.

Public Member Functions

template<typename JunctionContainer >
bool addCell (const cell &c, const JunctionContainer &junctions)
 Add a new cell to the complex.
bool addCell (const cell &c, const junction &j1, const junction &j2, const junction &j3, const junction &j4, const junction &j5, const junction &j6, const junction &j7, const junction &j8, const junction &j9)
 Add a new cell with nine vertices to the complex.
bool addCell (const cell &c, const junction &j1, const junction &j2, const junction &j3, const junction &j4, const junction &j5, const junction &j6, const junction &j7, const junction &j8)
 Add a new cell with height vertices to the complex.
bool addCell (const cell &c, const junction &j1, const junction &j2, const junction &j3, const junction &j4, const junction &j5, const junction &j6, const junction &j7)
 Add a new cell with seven vertices to the complex.
bool addCell (const cell &c, const junction &j1, const junction &j2, const junction &j3, const junction &j4, const junction &j5, const junction &j6)
 Add a new cell with six vertices to the complex.
bool addCell (const cell &c, const junction &j1, const junction &j2, const junction &j3, const junction &j4, const junction &j5)
 Add a new cell with five vertices to the complex.
bool addCell (const cell &c, const junction &j1, const junction &j2, const junction &j3, const junction &j4)
 Add a new cell with four vertices to the complex.
bool addCell (const cell &c, const junction &j1, const junction &j2, const junction &j3)
 Add a new cell with three vertices to the complex.
virtual bool addCellExtra (const cell &c)
 Method to override to add a cell in extra graphs.
template<typename JunctionContainer >
bool addCellUnsorted (const cell &c, const JunctionContainer &j)
 Add a new cell to the complex.
const celladjacentCell (const cell &c, const junction &j) const
 Returns the cell adjacent the c sharing the wall (j, S.nextTo(c,j)).
std::pair< cell, celladjacentCells (const junction &j1, const junction &j2) const
 Returns the cell(s) sharing the wall (j1,j2).
bool border (const junction &j1, const junction &j2) const
 True if the wall from j1 to j2 is at the border of the cell complex.
bool border (const cell &c, const junction &j) const
 True if the wall on the cell c starting at junction j is on the border.
bool border (const junction &j) const
 True if the junction is on the border.
bool border (const cell &c) const
 True if a cell has an border face.
virtual void clear ()
 Erase the graphs of the complex.
virtual void clearOldGraphs ()
 Called after the division, erased the old graphs maintained during the division itself.
void deleteCell (const cell &c)
 Delete a cell from the graph.
virtual void deleteCellInGraphs (const cell &c, const std::vector< junction > &deleted)
 Function to override and call to handle cell deletion if other graphs are maintained.
bool deleteJunction (const junction &j)
 Erase a junction.
virtual void deleteJunctionExtra (const junction &)
 Called after a junction have been erased.
template<typename AlgoParameter >
division_result_t divideCell (const cell &to_divide, const AlgoParameter &params, const cell &cell_kept)
 Divide a cell.
division_result_t divideCell (const cell &to_divide, const division_data &params, const cell &cell_kept)
 Divide a cell.
template<typename AlgoParameter , typename CellContainer >
division_result_t divideCell (const cell &c, const AlgoParameter &params, const CellContainer &to_keep)
 Divide a cell with the cells to keep defined by any kind of container.
template<typename AlgoParameter >
division_result_t divideCell (const cell &c, const AlgoParameter &params, const std::vector< cell > &to_keep)
 Divide a cell of the complex.
template<typename CellContainer >
division_result_t divideCell (const cell &c, const division_data &ddata, const CellContainer &to_keep)
 Divide a cell with the cells to keep defined by any kind of container.
division_result_t divideCell (const cell &c, const division_data &ddata)
division_result_t divideCell (const cell &c, const division_data &ddata, const std::vector< cell > &to_keep)
 Divide a cell of the complex.
const junctioninterfaceWall (const cell &c1, const cell &c2) const
std::pair< junction, junctioninterfaceWallSpan (const cell &c1, const cell &c2) const
std::pair< junction, junctionmergeCells (const cell &c1, const cell &c2)
 Merge two adjacent cells.
void reconnectCellGraph (const cell &cl, const cell &cr, const cell &c)
virtual void reconnectGraphs (const cell &c, const cell &cl, const cell &cr, const junction &u1, const junction &u2, const junction &v1, const junction &v2, const junction &nu, const junction &nv)
 Virtual method to reconnect the graphs after cell division.
void reconnectWallGraph (const junction &u1, const junction &u2, const junction &v1, const junction &v2, const junction &nu, const junction nv)
virtual void saveSubgraphs (const std::vector< cell > &cells_to_keep, const std::set< junction > &junctions_to_keep)
 Virtual method to redefine to save the status of the graphs maintained by an extension.
bool serialize (storage::VVEStorage &)
 Serialization method.
const junctionsplitWall (const cell &c, const junction &j1, const junction &x=junction(0))
 Split a wall in two and return the new junction.
const junctionsplitWall (const junction &j1, const junction &j2, const junction &x=junction(0))
 Split a wall in two and return the new junction.
virtual void splitWallExtra (const junction &, const junction &, const junction &)
 Called after a wall was split was done.
 VVComplex (const VVComplex &other)
 Copy constructor.
 VVComplex (Model *mod)
 Constructor.
virtual ~VVComplex ()
 Virtual destructor allow for inheritance.

Public Attributes

cell_graph C
 Cell graph.
Modelmodel
 Model linked to this complex.
cell_graph OldC
 Saved cell graph.
complex_graph OldS
 Saved complex graph.
wall_graph OldW
 Saved wall graph.
complex_graph S
 Cell complex graph.
bool save_parameters
 If true, the parameters are also serialized.
wall_graph W
 Wall graph.

Protected Member Functions

void connectFromJunctions (const cell &old_c, const cell &c, const cell &cc)
 Find the connections of cell c in the cell graph, when it's correctly connected in the vv graph.

Detailed Description

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
class vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >

Class handling the representation and development of 2D cell complex.

Definition at line 1944 of file complex.h.


Member Typedef Documentation

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
typedef graph::Vertex<CellContent> vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::cell

Type of a cell vertex.

Definition at line 1962 of file complex.h.

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
typedef cell_graph::arc_t vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::cell_arc

Type of an arc in the cell graph.

Definition at line 1992 of file complex.h.

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
typedef cell_graph::edge_t vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::cell_edge

Type of an edge in the cell graph.

Definition at line 1987 of file complex.h.

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
typedef graph::VVGraph<CellContent,CellEdgeContent,compact> vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::cell_graph

Type of the cell graph.

Definition at line 1972 of file complex.h.

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
typedef complex_graph::edge1_t vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::cell_junction_edge

Type of the edges from cell to junction in the cell complex graph.

Definition at line 2017 of file complex.h.

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
typedef VVComplexGraph<CellContent,JunctionContent,CellJunctionContent,JunctionCellContent,compact> vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::complex_graph

Type of the cell complex graph.

Definition at line 1982 of file complex.h.

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
typedef cell_graph::const_edge_t vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::const_cell_edge

Type of an edge in the cell graph.

Definition at line 1997 of file complex.h.

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
typedef complex_graph::const_edge1_t vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::const_cell_junction_edge

Type of the edges from cell to junction in the cell complex graph.

Definition at line 2022 of file complex.h.

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
typedef complex_graph::const_edge2_t vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::const_junction_cell_edge

Type of the edges from junction to cell in the cell complex graph.

Definition at line 2032 of file complex.h.

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
typedef wall_graph::const_edge_t vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::const_wall

Type of an edge in the wall graph;.

Definition at line 2012 of file complex.h.

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
typedef complex_graph::division_data vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::division_data
template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
typedef graph::Vertex<JunctionContent> vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::junction

Type of a junction vertex.

Definition at line 1967 of file complex.h.

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
typedef complex_graph::edge2_t vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::junction_cell_edge

Type of the edges from junction to cell in the cell complex graph.

Definition at line 2027 of file complex.h.

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
typedef wall_graph::edge_t vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::wall

Type of an edge in the wall graph;.

Definition at line 2002 of file complex.h.

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
typedef wall_graph::arc_t vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::wall_arc

Type of an arc in the wall graph;.

Definition at line 2007 of file complex.h.

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
typedef graph::VVGraph<JunctionContent,WallContent,compact> vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::wall_graph

Type of the wall graph.

Definition at line 1977 of file complex.h.


Constructor & Destructor Documentation

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::VVComplex ( Model mod  )  [inline]

Constructor.

Definition at line 2081 of file complex.h.

02082       : model(mod)
02083       , save_parameters(false)
02084       { }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::VVComplex ( const VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass > &  other  )  [inline]

Copy constructor.

Definition at line 2089 of file complex.h.

02090       : model(other.model)
02091       , C(other.C)
02092       , W(other.W)
02093       , S(other.S)
02094       , save_parameters(other.save_parameters)
02095       { }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
virtual vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::~VVComplex (  )  [inline, virtual]

Virtual destructor allow for inheritance.

Definition at line 2100 of file complex.h.

02100 {}


Member Function Documentation

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
template<typename JunctionContainer >
bool vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::addCell ( const cell c,
const JunctionContainer &  junctions 
) [inline]

Add a new cell to the complex.

Parameters:
c Vertex holding the cell center
j Container holding the counter-clockwise ordered cycle defining the cell.
Note:
c must not be in the complex already or result is undefined. However, all or part of the junctions may be in the vv graph already.
Returns:
false if the addition fails

Definition at line 2272 of file complex.h.

02273       {
02274         if(!S.addCell(c, junctions) ) return false;
02275         return this->addCellExtra(c);
02276       }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
bool vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::addCell ( const cell c,
const junction j1,
const junction j2,
const junction j3,
const junction j4,
const junction j5,
const junction j6,
const junction j7,
const junction j8,
const junction j9 
) [inline]

Add a new cell with nine vertices to the complex.

Definition at line 2241 of file complex.h.

02244     {
02245       std::vector<junction> junctions(9, junction(0));
02246       junctions[0] = j1;
02247       junctions[1] = j2;
02248       junctions[2] = j3;
02249       junctions[3] = j4;
02250       junctions[4] = j5;
02251       junctions[5] = j6;
02252       junctions[6] = j7;
02253       junctions[7] = j8;
02254       junctions[8] = j9;
02255       return this->addCell(c, junctions);
02256     }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
bool vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::addCell ( const cell c,
const junction j1,
const junction j2,
const junction j3,
const junction j4,
const junction j5,
const junction j6,
const junction j7,
const junction j8 
) [inline]

Add a new cell with height vertices to the complex.

Definition at line 2222 of file complex.h.

02225     {
02226       std::vector<junction> junctions(8, junction(0));
02227       junctions[0] = j1;
02228       junctions[1] = j2;
02229       junctions[2] = j3;
02230       junctions[3] = j4;
02231       junctions[4] = j5;
02232       junctions[5] = j6;
02233       junctions[6] = j7;
02234       junctions[7] = j8;
02235       return this->addCell(c, junctions);
02236     }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
bool vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::addCell ( const cell c,
const junction j1,
const junction j2,
const junction j3,
const junction j4,
const junction j5,
const junction j6,
const junction j7 
) [inline]

Add a new cell with seven vertices to the complex.

Definition at line 2205 of file complex.h.

02207     {
02208       std::vector<junction> junctions(7, junction(0));
02209       junctions[0] = j1;
02210       junctions[1] = j2;
02211       junctions[2] = j3;
02212       junctions[3] = j4;
02213       junctions[4] = j5;
02214       junctions[5] = j6;
02215       junctions[6] = j7;
02216       return this->addCell(c, junctions);
02217     }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
bool vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::addCell ( const cell c,
const junction j1,
const junction j2,
const junction j3,
const junction j4,
const junction j5,
const junction j6 
) [inline]

Add a new cell with six vertices to the complex.

Definition at line 2189 of file complex.h.

02191     {
02192       std::vector<junction> junctions(6, junction(0));
02193       junctions[0] = j1;
02194       junctions[1] = j2;
02195       junctions[2] = j3;
02196       junctions[3] = j4;
02197       junctions[4] = j5;
02198       junctions[5] = j6;
02199       return this->addCell(c, junctions);
02200     }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
bool vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::addCell ( const cell c,
const junction j1,
const junction j2,
const junction j3,
const junction j4,
const junction j5 
) [inline]

Add a new cell with five vertices to the complex.

Definition at line 2174 of file complex.h.

02176     {
02177       std::vector<junction> junctions(5, junction(0));
02178       junctions[0] = j1;
02179       junctions[1] = j2;
02180       junctions[2] = j3;
02181       junctions[3] = j4;
02182       junctions[4] = j5;
02183       return this->addCell(c, junctions);
02184     }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
bool vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::addCell ( const cell c,
const junction j1,
const junction j2,
const junction j3,
const junction j4 
) [inline]

Add a new cell with four vertices to the complex.

Definition at line 2160 of file complex.h.

02162     {
02163       std::vector<junction> junctions(4, junction(0));
02164       junctions[0] = j1;
02165       junctions[1] = j2;
02166       junctions[2] = j3;
02167       junctions[3] = j4;
02168       return this->addCell(c, junctions);
02169     }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
bool vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::addCell ( const cell c,
const junction j1,
const junction j2,
const junction j3 
) [inline]

Add a new cell with three vertices to the complex.

Definition at line 2148 of file complex.h.

Referenced by vvcomplex::VVComplex< MANDATORY_COMPLEX_TEMPLATE_ARGS, RESOLVE_LEAF_CLASS(LeafClass, Tissue< ALL_COMPLEX_TEMPLATE_ARGS >)>::addCell(), and vvcomplex::VVComplex< MANDATORY_COMPLEX_TEMPLATE_ARGS, RESOLVE_LEAF_CLASS(LeafClass, Tissue< ALL_COMPLEX_TEMPLATE_ARGS >)>::addCellUnsorted().

02149     {
02150       std::vector<junction> junctions(3, junction(0));
02151       junctions[0] = j1;
02152       junctions[1] = j2;
02153       junctions[2] = j3;
02154       return this->addCell(c, junctions);
02155     }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
virtual bool vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::addCellExtra ( const cell c  )  [inline, virtual]

Method to override to add a cell in extra graphs.

Note:
Do not forget to call this method again if you extend the complex.

Definition at line 2283 of file complex.h.

Referenced by vvcomplex::VVComplex< MANDATORY_COMPLEX_TEMPLATE_ARGS, RESOLVE_LEAF_CLASS(LeafClass, Tissue< ALL_COMPLEX_TEMPLATE_ARGS >)>::addCell().

02284     {
02285       bool result = this->addCell_cell_graph(c) && this->addCell_wall_graph(c);
02286       return result;
02287     }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
template<typename JunctionContainer >
bool vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::addCellUnsorted ( const cell c,
const JunctionContainer &  j 
) [inline]

Add a new cell to the complex.

This function add one cell to the complex. The set of junctions is first sorted in counterclockwise order around the position of the cell c and then the addCell() method is called. For the sorting to work, the cell center need to be correctly positioned with its normal and the junctions just need to be positioned.

Parameters:
c First cell of the complex
j Set of junctions of the cell

Definition at line 2422 of file complex.h.

02423       {
02424         Point3d normal = model->normal(c);
02425         Point3d cpos, ref, u1, u2;
02426         cpos = model->position(c);
02427         normal.normalize();
02428         bool ref_found = false;
02429         std::set<AngledJunction> sorted;
02430         forall(const junction& v,j)
02431         {
02432           if(ref_found)
02433           {
02434             const Point3d& pos = model->position(v);
02435             Point3d u = pos - cpos;
02436             Point3d proj = normalized(u - (u*normal)*normal);
02437             double cosa = proj*u1;
02438             double sina = (u1^proj)*normal;
02439             double angle = std::atan2(sina, cosa);
02440             sorted.insert(AngledJunction(v, angle));
02441           }
02442           else
02443           {
02444             ref = model->position(v);
02445             u1 = normalized(ref - cpos);
02446             sorted.insert(AngledJunction(v, 0));
02447             ref_found = true;
02448           }
02449         }
02450         std::vector<junction> sorted_list;
02451         forall(const AngledJunction& aj,sorted)
02452         {
02453           sorted_list.push_back(aj.v);
02454         }
02455         return this->addCell(c, sorted_list);
02456       }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
const cell& vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::adjacentCell ( const cell c,
const junction j 
) const [inline]

Returns the cell adjacent the c sharing the wall (j, S.nextTo(c,j)).

Definition at line 2743 of file complex.h.

02744     {
02745       return S.adjacentCell(c, j);
02746     }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
std::pair<cell,cell> vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::adjacentCells ( const junction j1,
const junction j2 
) const [inline]

Returns the cell(s) sharing the wall (j1,j2).

Returns:
a pair of cells (c1,c2) such that in c1, j1 is before j2 and in c2, j2 is before j1.

Definition at line 2754 of file complex.h.

02755     {
02756       return S.adjacentCells(j1, j2);
02757     }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
bool vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::border ( const junction j1,
const junction j2 
) const [inline]

True if the wall from j1 to j2 is at the border of the cell complex.

Definition at line 2876 of file complex.h.

02877     {
02878       return S.border(j1, j2);
02879     }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
bool vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::border ( const cell c,
const junction j 
) const [inline]

True if the wall on the cell c starting at junction j is on the border.

Definition at line 2868 of file complex.h.

02869     {
02870       return S.border(c, j);
02871     }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
bool vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::border ( const junction j  )  const [inline]

True if the junction is on the border.

Definition at line 2860 of file complex.h.

02861     {
02862       return S.valence(j) != W.valence(j);
02863     }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
bool vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::border ( const cell c  )  const [inline]

True if a cell has an border face.

Definition at line 2846 of file complex.h.

02847     {
02848       size_t nb_walls = 0;
02849       forall(const junction& j, S.neighbors(c))
02850       {
02851         if(W.valence(j) > 2)
02852           nb_walls++;
02853       }
02854       return C.empty(c) or nb_walls != C.valence(c);
02855     }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
virtual void vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::clear (  )  [inline, virtual]

Erase the graphs of the complex.

Definition at line 2135 of file complex.h.

02136     {
02137       S.clear();
02138       C.clear();
02139       W.clear();
02140       OldS.clear();
02141       OldC.clear();
02142       OldW.clear();
02143     }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
virtual void vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::clearOldGraphs (  )  [inline, virtual]

Called after the division, erased the old graphs maintained during the division itself.

Definition at line 2645 of file complex.h.

Referenced by vvcomplex::VVComplex< MANDATORY_COMPLEX_TEMPLATE_ARGS, RESOLVE_LEAF_CLASS(LeafClass, Tissue< ALL_COMPLEX_TEMPLATE_ARGS >)>::divideCell().

02646     {
02647       OldC.clear();
02648       OldW.clear();
02649     }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
void vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::connectFromJunctions ( const cell old_c,
const cell c,
const cell cc 
) [inline, protected]

Find the connections of cell c in the cell graph, when it's correctly connected in the vv graph.

Warning:
For internal use only

Definition at line 2899 of file complex.h.

02900     {
02901       C.insertEdge(c, cc);
02902       // Connect c to its neighbors
02903       cell pn(0);
02904       forall( const junction& jn , S.neighbors(c))
02905       {
02906         const junction& jp = S.prevTo(c, jn);
02907         const cell& n = S.nextTo(jn, c);
02908         // If we are not at a border ...
02909         if(n != c and S.edge(jp, n))
02910         {
02911           if(n != cc)
02912           {
02913             // Two cases:
02914             // 1 - old_c is in the neighborhood of n -> we replace it by the 
02915             // current
02916             // 2 - cc is in the neighborhood of n -> we figure if we should 
02917             // place it before or after
02918             cell_edge e = C.replace(n, old_c, c);
02919             if(e.isNull()) // c was not in the neighborhood of n
02920             {
02921               const cell& cc1 = S.nextTo(jp, c);
02922               if(cc1 == cc)
02923               {
02924                 C.spliceBefore(n, cc, c);
02925               }
02926               else
02927               {
02928                 C.spliceAfter(n, cc, c);
02929               }
02930             }
02931             if(pn.isNull())
02932             {
02933               C.insertEdge(c, n);
02934             }
02935             else
02936             {
02937               C.spliceAfter(c, pn, n);
02938             }
02939           }
02940           pn = n;
02941         }
02942       }
02943     }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
void vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::deleteCell ( const cell c  )  [inline]

Delete a cell from the graph.

Definition at line 2683 of file complex.h.

02684     {
02685       const std::vector<junction>& deleted =  S.deleteCell(c);
02686       this->deleteCellInGraphs(c, deleted);
02687     }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
virtual void vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::deleteCellInGraphs ( const cell c,
const std::vector< junction > &  deleted 
) [inline, virtual]

Function to override and call to handle cell deletion if other graphs are maintained.

Definition at line 2693 of file complex.h.

Referenced by vvcomplex::VVComplex< MANDATORY_COMPLEX_TEMPLATE_ARGS, RESOLVE_LEAF_CLASS(LeafClass, Tissue< ALL_COMPLEX_TEMPLATE_ARGS >)>::deleteCell().

02694     {
02695       C.erase(c);
02696       forall(const junction& j,deleted)
02697         W.erase(j);
02698     }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
bool vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::deleteJunction ( const junction j  )  [inline]

Erase a junction.

This is possible only if the junction do not change the structure of the cell graph.

Definition at line 2816 of file complex.h.

02817     {
02818       size_t nb_cells = S.valence(j);
02819       size_t nb_junctions = W.valence(j);
02820       if(nb_cells > 2)
02821         return false;
02822       if(nb_cells == 2 and nb_junctions != 2)
02823         return false;
02824       if(nb_cells > 0)
02825       {
02826         const cell& c = S.anyIn(j);
02827         const junction& pj = S.prevTo(c, j);
02828         const junction& nj = S.nextTo(c, j);
02829         W.replace(pj, j, nj);
02830         W.replace(nj, j, pj);
02831       }
02832       W.erase(j);
02833       S.erase(j);
02834       this->deleteJunctionExtra(j);
02835       return true;
02836     }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
virtual void vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::deleteJunctionExtra ( const junction  )  [inline, virtual]
template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
template<typename AlgoParameter >
division_result_t vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::divideCell ( const cell to_divide,
const AlgoParameter &  params,
const cell cell_kept 
) [inline]

Divide a cell.

Convenience function where a single cell is to be kept

Reimplemented in tissue::Tissue< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >.

Definition at line 2671 of file complex.h.

02674       {
02675         std::vector<cell> k;
02676         k.push_back(cell_kept);
02677         return this->divideCell(to_divide, params, k);
02678       }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
division_result_t vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::divideCell ( const cell to_divide,
const division_data params,
const cell cell_kept 
) [inline]

Divide a cell.

Convenience function where a single cell is to be kept

Reimplemented in tissue::Tissue< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >.

Definition at line 2656 of file complex.h.

02659     {
02660       std::vector<cell> k;
02661       k.push_back(cell_kept);
02662       return this->divideCell(to_divide, params, k);
02663     }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
template<typename AlgoParameter , typename CellContainer >
division_result_t vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::divideCell ( const cell c,
const AlgoParameter &  params,
const CellContainer &  to_keep 
) [inline]

Divide a cell with the cells to keep defined by any kind of container.

Reimplemented in tissue::Tissue< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >.

Definition at line 2620 of file complex.h.

02623       {
02624         std::vector<cell> tk(to_keep.begin(), to_keep.end());
02625         return this->divideCell(c, params, tk);
02626       }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
template<typename AlgoParameter >
division_result_t vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::divideCell ( const cell c,
const AlgoParameter &  params,
const std::vector< cell > &  to_keep 
) [inline]

Divide a cell of the complex.

Parameters:
c Cell to divide
params Parameter of the algorithm to use. The type of the params will decide which algorithm to use.
to_keep Set of cells to keep to update the data in the new cells
See also:
updateFromOld

Definition at line 2556 of file complex.h.

02559       {
02560         // Exit if division fails
02561         const division_data& result = findDivisionPoints(c, static_cast<leaf_class&>(*this), params);
02562         if(!result)
02563         {
02564           OldS.clear();
02565           this->clearOldGraphs();
02566           cerr << "Error, division failed" << endl;
02567           return division_result_t();
02568         }
02569 
02570         return divideCell(c, result, to_keep);
02571       }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
template<typename CellContainer >
division_result_t vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::divideCell ( const cell c,
const division_data ddata,
const CellContainer &  to_keep 
) [inline]

Divide a cell with the cells to keep defined by any kind of container.

Reimplemented in tissue::Tissue< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >.

Definition at line 2537 of file complex.h.

02540       {
02541         std::vector<cell> tk(to_keep.begin(), to_keep.end());
02542         return this->divideCell(c, ddata, tk);
02543       }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
division_result_t vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::divideCell ( const cell c,
const division_data ddata,
const std::vector< cell > &  to_keep 
) [inline]

Divide a cell of the complex.

In the updateFromOld call, cl will be the cell having the wall (u-v) and cr the cell having the wall (v-u). In the same way, cl has the vertices of c from v to u and cr from u to v.

Parameters:
c Cell to divide
ddata Specification of where the division points should appear
to_keep Set of cells to keep to update the data in the new cells
See also:
updateFromOld

Definition at line 2473 of file complex.h.

Referenced by tissue::Tissue< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::divideCell(), and vvcomplex::VVComplex< MANDATORY_COMPLEX_TEMPLATE_ARGS, RESOLVE_LEAF_CLASS(LeafClass, Tissue< ALL_COMPLEX_TEMPLATE_ARGS >)>::divideCell().

02476     {
02477       std::set<junction> junctions_to_keep;
02478 
02479       forall(const cell& k,to_keep)
02480       {
02481         forall( const junction& j , S.neighbors(k))
02482         {
02483           junctions_to_keep.insert(j);
02484         }
02485       }
02486 
02487       OldS = S.subgraph(to_keep, junctions_to_keep);
02488       this->saveSubgraphs(to_keep, junctions_to_keep);
02489 
02490       division_result_t res = S.divideCell(c, ddata);
02491       if(!res)
02492         return res;
02493 
02494       // Set the position of u
02495       if(!ddata.divide_at_u1)
02496       {
02497         const Point3d& pu1 = model->position(res.u1);
02498         const Point3d& pu2 = model->position(res.u2);
02499         double ru = ((ddata.pu-pu1)*(pu2-pu1)) / normsq(pu2-pu1);
02500         model->setPositionHint(res.u, res.u1, res.u2, ru);
02501         model->setPosition(res.u, ddata.pu);
02502       }
02503 
02504       // Set the position of v
02505       if(!ddata.divide_at_v1)
02506       {
02507         const Point3d& pv1 = model->position(res.v1);
02508         const Point3d& pv2 = model->position(res.v2);
02509         double rv = ((ddata.pv-pv1)*(pv2-pv1)) / normsq(pv2-pv1);
02510         model->setPositionHint(res.v, res.v1, res.v2, rv);
02511         model->setPosition(res.v, ddata.pv);
02512       }
02513 
02514       // Set new centers, clear, and update concentrations from parent
02515       //FindCenter(cl, static_cast<leaf_class&>(*this));
02516       //FindCenter(cr, static_cast<leaf_class&>(*this));
02517 
02518       // Connect the other graphs
02519       this->reconnectGraphs(c, res.cl, res.cr, res.u1, res.u2, res.v1, res.v2, res.u, res.v);
02520 
02521       model->updateFromOld(res.cl, res.cr, c, ddata, static_cast<leaf_class&>(*this));
02522       OldS.clear();
02523       this->clearOldGraphs();
02524       return res;
02525     }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
const junction& vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::interfaceWall ( const cell c1,
const cell c2 
) const [inline]
Returns:
the junction in c1 starting the wall common between c1 and c2.

Definition at line 2763 of file complex.h.

02764     {
02765       return S.interfaceWall(c1, c2);
02766     }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
std::pair<junction, junction> vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::interfaceWallSpan ( const cell c1,
const cell c2 
) const [inline]
Returns:
the pair of junctions in c1 such that the interface between c1 and c2 starts at the first junction and end at the second. In case the c1 is entirely contained in c2 (or the other way around), both junctions will be the same.

Definition at line 2774 of file complex.h.

02775     {
02776       return S.interfaceWallSpan(c1, c2);
02777     }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
std::pair<junction, junction> vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::mergeCells ( const cell c1,
const cell c2 
) [inline]

Merge two adjacent cells.

Only c1 is kept, c2 is being deleted.

Returns:
the junctions at the start and end of the wall that has been removed

Definition at line 2708 of file complex.h.

02709     {
02710       std::vector<junction> deleted_junctions;
02711       std::pair<junction,junction> result = S.mergeCells(c1, c2, &deleted_junctions);
02712 
02713       const junction& j1 = result.first;
02714       const junction& j2 = result.second;
02715 
02716       // Remove junctions from W
02717       forall(const junction& j, deleted_junctions)
02718       {
02719         W.erase(j);
02720       }
02721       W.spliceAfter(j1, S.prevTo(c1, j1), j2);
02722       W.spliceBefore(j2, S.nextTo(c1, j2), j1);
02723 
02724       // Update cell graph
02725       const cell& after = C.nextTo(c1, c2);
02726       forall(const cell& c, C.neighbors(c2, C.nextTo(c2, c1)))
02727       {
02728         if(c == c1) break;
02729         C.spliceBefore(c1, after, c);
02730         C.replace(c, c2, c1);
02731       }
02732 
02733       // Erase c2 from C and S
02734       C.erase(c2);
02735 
02736       return result;
02737     }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
virtual void vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::reconnectGraphs ( const cell c,
const cell cl,
const cell cr,
const junction u1,
const junction u2,
const junction v1,
const junction v2,
const junction nu,
const junction nv 
) [inline, virtual]

Virtual method to reconnect the graphs after cell division.

This method input all the parameters for the cell division. The division itself already occurred only for the complex graph at that point. This function maintain the consistency with other graphs.

Note:
Don't forget to call this method from your overloaded version.

Definition at line 2607 of file complex.h.

Referenced by vvcomplex::VVComplex< MANDATORY_COMPLEX_TEMPLATE_ARGS, RESOLVE_LEAF_CLASS(LeafClass, Tissue< ALL_COMPLEX_TEMPLATE_ARGS >)>::divideCell().

02611     {
02612       reconnectWallGraph(u1, u2, v1, v2, nu, nv);
02613       reconnectCellGraph(cl, cr, c);
02614     }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
virtual void vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::saveSubgraphs ( const std::vector< cell > &  cells_to_keep,
const std::set< junction > &  junctions_to_keep 
) [inline, virtual]

Virtual method to redefine to save the status of the graphs maintained by an extension.

Note:
Don't forget to call this method.

Definition at line 2634 of file complex.h.

Referenced by vvcomplex::VVComplex< MANDATORY_COMPLEX_TEMPLATE_ARGS, RESOLVE_LEAF_CLASS(LeafClass, Tissue< ALL_COMPLEX_TEMPLATE_ARGS >)>::divideCell().

02636     {
02637       OldC = C.subgraph(cells_to_keep);
02638       OldW = W.subgraph(junctions_to_keep);
02639     }

template<typename Model , typename CellContent , typename JunctionContent , typename WallContent , typename CellEdgeContent , typename CellJunctionContent , typename JunctionCellContent , bool compact, typename LeafClass >
bool vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::serialize ( storage::VVEStorage store  )  [inline]

Serialization method.

By default, only the three main graphs are serialized: S, T and W. No parameter and no old graph are saved.

Warning:
You need to include <storage/complex.h> to use this serialization method

Definition at line 31 of file complex.h.

References vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::C, storage::VVEStorage::field(), vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::S, vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::save_parameters, and vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::W.

00032   {
00033     if(!store.field("S", S))
00034     {
00035       return false;
00036     }
00037     if(!store.field("C", C))
00038     {
00039       return false;
00040     }
00041     if(!store.field("W", W))
00042     {
00043       return false;
00044     }
00045     if(save_parameters)
00046     {
00047     }
00048     return true;
00049   }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
const junction& vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::splitWall ( const cell c,
const junction j1,
const junction x = junction(0) 
) [inline]

Split a wall in two and return the new junction.

Definition at line 2793 of file complex.h.

02794     {
02795       const junction& j2 = S.nextTo(c, j1);
02796       const junction& j = algorithms::insert(j1, j2, W, x);
02797       S.splitWall(c, j1, j);
02798       this->splitWallExtra(j1, j2, j);
02799       return j;
02800     }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
const junction& vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::splitWall ( const junction j1,
const junction j2,
const junction x = junction(0) 
) [inline]

Split a wall in two and return the new junction.

Definition at line 2782 of file complex.h.

02783     {
02784       const junction& j = algorithms::insert(j1, j2, W, x);
02785       S.splitWall(j1, j2, j);
02786       this->splitWallExtra(j1, j2, j);
02787       return j;
02788     }

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
virtual void vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::splitWallExtra ( const junction ,
const junction ,
const junction  
) [inline, virtual]

Called after a wall was split was done.

The argument is the junction inserted. Getting the original wall is easily done using W.anyIn(j) and W.nextTo(W.anyIn(j)).

Definition at line 2808 of file complex.h.

Referenced by vvcomplex::VVComplex< MANDATORY_COMPLEX_TEMPLATE_ARGS, RESOLVE_LEAF_CLASS(LeafClass, Tissue< ALL_COMPLEX_TEMPLATE_ARGS >)>::splitWall().

02808 { }


Member Data Documentation

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
cell_graph vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::C
template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
Model* vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::model
template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
cell_graph vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::OldC
template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
complex_graph vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::OldS
template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
wall_graph vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::OldW
template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
complex_graph vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::S

Cell complex graph.

Definition at line 2065 of file complex.h.

Referenced by vvcomplex::VVComplex< MANDATORY_COMPLEX_TEMPLATE_ARGS, RESOLVE_LEAF_CLASS(LeafClass, Tissue< ALL_COMPLEX_TEMPLATE_ARGS >)>::addCell(), vvcomplex::VVComplex< MANDATORY_COMPLEX_TEMPLATE_ARGS, RESOLVE_LEAF_CLASS(LeafClass, Tissue< ALL_COMPLEX_TEMPLATE_ARGS >)>::adjacentCell(), vvcomplex::VVComplex< MANDATORY_COMPLEX_TEMPLATE_ARGS, RESOLVE_LEAF_CLASS(LeafClass, Tissue< ALL_COMPLEX_TEMPLATE_ARGS >)>::adjacentCells(), vvcomplex::VVComplex< MANDATORY_COMPLEX_TEMPLATE_ARGS, RESOLVE_LEAF_CLASS(LeafClass, Tissue< ALL_COMPLEX_TEMPLATE_ARGS >)>::border(), vvcomplex::VVComplex< MANDATORY_COMPLEX_TEMPLATE_ARGS, RESOLVE_LEAF_CLASS(LeafClass, Tissue< ALL_COMPLEX_TEMPLATE_ARGS >)>::clear(), vvcomplex::VVComplex< MANDATORY_COMPLEX_TEMPLATE_ARGS, RESOLVE_LEAF_CLASS(LeafClass, Tissue< ALL_COMPLEX_TEMPLATE_ARGS >)>::connectFromJunctions(), vvcomplex::VVComplex< MANDATORY_COMPLEX_TEMPLATE_ARGS, RESOLVE_LEAF_CLASS(LeafClass, Tissue< ALL_COMPLEX_TEMPLATE_ARGS >)>::deleteCell(), vvcomplex::VVComplex< MANDATORY_COMPLEX_TEMPLATE_ARGS, RESOLVE_LEAF_CLASS(LeafClass, Tissue< ALL_COMPLEX_TEMPLATE_ARGS >)>::deleteJunction(), vvcomplex::VVComplex< MANDATORY_COMPLEX_TEMPLATE_ARGS, RESOLVE_LEAF_CLASS(LeafClass, Tissue< ALL_COMPLEX_TEMPLATE_ARGS >)>::divideCell(), vvcomplex::findCenter(), vvcomplex::FindOppositeWall(), vvcomplex::VVComplex< MANDATORY_COMPLEX_TEMPLATE_ARGS, RESOLVE_LEAF_CLASS(LeafClass, Tissue< ALL_COMPLEX_TEMPLATE_ARGS >)>::interfaceWall(), vvcomplex::VVComplex< MANDATORY_COMPLEX_TEMPLATE_ARGS, RESOLVE_LEAF_CLASS(LeafClass, Tissue< ALL_COMPLEX_TEMPLATE_ARGS >)>::interfaceWallSpan(), vvcomplex::VVComplex< MANDATORY_COMPLEX_TEMPLATE_ARGS, RESOLVE_LEAF_CLASS(LeafClass, Tissue< ALL_COMPLEX_TEMPLATE_ARGS >)>::mergeCells(), vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::serialize(), vvcomplex::VVComplex< MANDATORY_COMPLEX_TEMPLATE_ARGS, RESOLVE_LEAF_CLASS(LeafClass, Tissue< ALL_COMPLEX_TEMPLATE_ARGS >)>::splitWall(), and vvcomplex::testDivisionOnVertices().

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
bool vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::save_parameters

If true, the parameters are also serialized.

Not that this parameter will never be serialized ...

Definition at line 2076 of file complex.h.

Referenced by vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::serialize().

template<typename Model, typename CellContent, typename JunctionContent, typename WallContent = graph::_EmptyEdgeContent, typename CellEdgeContent = graph::_EmptyEdgeContent, typename CellJunctionContent = graph::_EmptyEdgeContent, typename JunctionCellContent = graph::_EmptyEdgeContent, bool compact = false, typename LeafClass = template_utils::this_class>
wall_graph vvcomplex::VVComplex< Model, CellContent, JunctionContent, WallContent, CellEdgeContent, CellJunctionContent, JunctionCellContent, compact, LeafClass >::W

The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
Generated on Fri May 31 15:38:39 2013 for VVE by  doxygen 1.6.3