|
| Trash_T | trash_ |
| int | keep_trash_ |
typedef PersistantHashSet<
Cell * > | Trash_T |
Printing |
|
| void | print (std::ostream &os=std::cout) const |
| | Print list of Cells in this CellComplex.
|
| void | print_statistics (std::ostream &os=std::cout) const |
| | Print sizes of data structures in this CellComplex.
|
| template<class V, class E, class F, class T> |
| std::ostream & | operator<< (std::ostream &stream, const CellComplex< V, E, F, T > &bm) |
Public Types |
|
|
typedef PersistantHashSet<
Vertex * > | Vertex_Hash_T |
typedef PersistantHashSet<
Edge * > | Edge_Hash_T |
typedef PersistantHashSet<
Face * > | Face_Hash_T |
typedef PersistantHashMap<
std::pair< Vertex *, Edge * >,
Vertex *, PairHasher< Vertex *,
Edge * > > | Switch0_Hash_T |
typedef PersistantHashMap<
Tuple, Edge *, TupleHasher<
Tuple > > | Switch1_Hash_T |
typedef PersistantHashMap<
std::pair< Edge *, Face * >,
Face *, PairHasher< Edge *,
Face * > > | Switch2_Hash_T |
typedef PersistantHashSet<
Face * > | Inverted_Hash_T |
Public Member Functions |
| | CellComplex (PersistantStore &) |
| | Constructor.
|
| virtual | ~CellComplex () |
| | Destructor.
|
| PersistantStore & | get_store () const |
| | Get the persistant store.
|
|
|
| bool | is_member (Vertex *) const |
| | True if Vertex is a member of this CellComplex.
|
| bool | is_member (Edge *) const |
| | True if Edge is a member of this CellComplex.
|
| bool | is_member (Face *) const |
| | True if Face is a member of this CellComplex.
|
| bool | is_inverse_handed (Face *) const |
| | True if Face is a member of this CellComplex.
|
|
These functions allow one to get information about the toplogical structure relative to a given Cell or Cells. These should be used as much as possible in place of directly accessing the topological stored in the Cells themselves.
Operations that would normally return a list of Cells, append them to an STL data structure instead. This is more efficient and more usefull in most cases.
|
| int | lower (Edge *e, std::vector< Vertex * > &vs) |
| | Append the Vertexs of given Edge to vector.
|
| int | lower (Edge *e, std::list< Vertex * > &vs) |
| | Append the Vertexs of given Edge to list.
|
| int | lower (Face *f, std::vector< Edge * > &es) |
| | Append the Edges of given Face to vector.
|
| int | lower (Face *f, std::list< Edge * > &es) |
| | Append the Edges of given Face to list.
|
| int | upper (Edge *e, std::vector< Face * > &fs) |
| | Append the Faces of given Edge to vector.
|
| int | upper (Edge *e, std::list< Face * > &fs) |
| | Append the Faces of given Edge to list.
|
| int | upper (Vertex *v, std::vector< Edge * > &es) |
| | Append the Edges of given Vertex to vector.
|
| int | upper (Vertex *v, std::list< Edge * > &es) |
| | Append the Edges of given Vertex to list.
|
| Vertex * | get_opposite_vertex (Edge *e, Vertex *v) |
| | Get Vertex opposite from given Vertex along given Edge.
|
| Face * | get_opposite_face (Edge *e, Face *f) |
| | Get Face opposite from given Face.
|
| void | enqueue_faces (Vertex *vert, std::deque< Face * > &faces) |
| | En-queues all faces around a Vertex to a std::deque.
|
| void | enqueue_edges (Vertex *vert, std::deque< Edge * > &edges) |
| | En-queues all Edges around a Vertex to a std::deque.
|
| Edge * | find_common_edge (Vertex *v0, Vertex *v1) |
| | Finds an Edge common to two Vertexs.
|
| Edge * | find_common_edge (Face *f0, Face *f1) |
| | Finds an edge common to two faces.
|
| void | find_adjacent_faces (Face *f, std::list< Face * > &faces) |
| | En-queues all faces adjacent to current face.
|
| void | find_adjacent_edges (Edge *e, std::list< Edge * > &edges) |
| | En-queues all edges of faces that are adjacent to given edge.
|
| void | find_adjacent_faces (Face *f, std::deque< Face * > &faces) |
| | En-queues all faces adjacent to current face.
|
| void | find_adjacent_edges (Edge *e, std::deque< Edge * > &edges) |
| | En-queues all edges of faces that are adjacent to given edge.
|
|
These functions allow navigation through the toplogy in an oriented (counter-clockwise) way.
We define a Tuple to be oriented correctly if the result of repeatedly calling  results in a counter clockwise traversal of the Tuple's Face.
Calling Switch(2,t) over a boundary (thus walking off the complex) will result in a fixed point. The tuple returned will be a copy (use CellTuple==) of the original tuple.
|
| Tuple | Switch (int, const Tuple &) const |
| | Apply a Switch operator to Tuple.
|
| Tuple | get_tuple () const |
| | Get any oriented tuple.
|
| Tuple | get_tuple (Face *) const |
| | Get an oriented tuple with given Face.
|
| Tuple | get_tuple (Vertex *, Face *) const |
| | Get an oriented tuple with given Face and Vertex.
|
| Tuple | get_tuple (Edge *, Face *) const |
| | Get an oriented tuple with given Face and Edge.
|
| Tuple | get_tuple (Vertex *) const |
| | Get an oriented tuple with given Vertex.
|
| Tuple | get_tuple (Edge *) const |
| | Get an oriented tuple with given Edge.
|
| Tuple | get_tuple (Vertex *v, Edge *e) const |
| | Get a possibly unoriented tuple with given Edge and Vertex.
|
|
| int | switch_size (int) const |
| | Debugging: get the size of a switch hash. At certain times, we will know exactly what size the switch structures should have. Allow assertions on this information.
|
|
| int | get_num_vertices () const |
| Vertex_Hash_T::iterator | get_vertexs_begin () const |
| Vertex_Hash_T::iterator | get_vertexs_end () const |
| Vertex_Hash_T::iterator | get_vertices_begin () const |
| Vertex_Hash_T::iterator | get_vertices_end () const |
| int | get_num_edges () const |
| Edge_Hash_T::iterator | get_edges_begin () const |
| Edge_Hash_T::iterator | get_edges_end () const |
| int | get_num_faces () const |
| Face_Hash_T::iterator | get_faces_begin () const |
| Face_Hash_T::iterator | get_faces_end () const |
|
These are very strait forward, but necessary for ruby to iterate
- Todo:
- write real iterator wrappers for ruby
|
| Vertex * | get_next_vertex (typename Vertex_Hash_T::iterator &) const |
| Edge * | get_next_edge (typename Edge_Hash_T::iterator &) const |
| Face * | get_next_face (typename Face_Hash_T::iterator &) const |
Protected Member Functions |
|
These are functions for adding or removing Cells. Only subclasses can call them. The storage for the new vertex/edge/face is owned by the CellComplex, not by the subclass. |
| virtual void | add_vertex (Vertex *) |
| | Adds the given Edge to the CellComplex.
|
| virtual void | add_edge (Edge *e) |
| | Adds the given Edge to the CellComplex.
|
| virtual void | add_face (Face *, Edge **, int, bool inverse_handed=false) |
| | Adds the given Face to the CellComplex.
|
| virtual void | delete_vertex (Vertex *) |
| | Remove a vertex and all its super-cells from the CellComplex.
|
| virtual void | delete_edge (Edge *) |
| | Remove a edge and all its super-cells from the CellComplex.
|
| virtual void | delete_face (Face *) |
| | Remove a face from the CellComplex.
|
|
| void | trash_cell (Cell *) |
| | Don't yet free this memory to avoid pointers getting reused.
|
| void | keep_trash () |
| | Start holding trash. keep_trash and empty_trash nest: you can safely call keep_trash in one algorithm even if another has already called it.
|
| void | empty_trash () |
| | Notify that the current algorithm no longer needs the trash: it is safe to reuse memory again. keep_trash and empty_trash nest: you can safely call keep_trash in one algorithm even if another has already called it. Memory is only deallocated if all nesting levels have emptied their trash.
|
Private Member Functions |
| | CellComplex (const CellComplex< Vertex, Edge, Face, Tuple > &other) |
CellComplex< Vertex, Edge,
Face, Tuple > & | operator= (const CellComplex< Vertex, Edge, Face, Tuple > &other) |
Private Attributes |
| Vertex_Hash_T | vertexs |
| | hash_set of Vertex Cells
|
| Edge_Hash_T | edges |
| | hash_set of Edge Cells
|
| Face_Hash_T | faces |
| | hash_set of Face Cells
|
| PersistantMemoryPool< Cell > | pool_ |
| Switch0_Hash_T | switch0 |
| | Map to implement Switch0 operator.
|
| Switch1_Hash_T | switch1 |
| | Map to implement Switch1 operator.
|
| Switch2_Hash_T | switch2 |
| | Map to implement Switch2 operator.
|
| Inverted_Hash_T | inverted_faces |
| | Set of inverted faces.
|
Furthermore, using the above code, there are two directions the Switch operators could move you, clockwise, or counter-clockwise, depending on the initial tuple. Thus, to remain oriented correctly, we tuples to be oriented correctly is repeated applications of: tuple= Switch(1, Switch(0, tuple)) moves the tuple around in a counter clockwise manner.
template<class Vertex, class Edge, class Face, class Tuple>
| Tuple CellComplex< Vertex, Edge, Face, Tuple >::Switch |
( |
int |
snum, |
|
|
const Tuple & |
ct | |
|
) |
| | const [inline] |
Apply a Switch operator to Tuple.
This function applies one of the Switch operators to a Tuple of Cells. The switch operator is specified by the dimension of Cell to be switched.
- 0 Switch on Vertex
- 1 Switch on Edge
- 2 Switch on Face
An invalid switch number will result in the same tuple being returned.
This is the essential operator for navigating through the CellComplex. No other method of navigating should be used. This function is often used with the various get_tuple() varieties.
Switches are stored as hash_maps for time efficiency. There is a separate hash_map for each of the three switch types, although all switching should use this function, and not direct access to hashes, as we may change the implementation later.
Why the uppercase name? Because lowercase switch is a reserved word in C++.
- Note:
- If you attempt to switch1 on an edge with a self loop, you get back the same tuple.
If you attempt to switch2 on a tuple which has no opposite face, you get back the same tuple. Watch out for this one, as it may destroy your orientation if you don't notice it happening. In a well defined mesh, the only place this should happen is when the edge of your tuple is a boundary. Thus, when you have a boundary remember to check if there is an opposite face first.
The exact definition of the action of the switches is defined by the add_edge() and add_face() methods.
- Todo:
- Currently we have no good ideas how to set up switches for faces with edge sets that do not form simple cycles. Thus, we do not currently allow Faces with such edge sets. Some BoundaryFaces have such a topology, in this case, we currently add only those edges of the face which do make a simple cycle, this leaves the BoundaryComplex technically incorrectly defined. As we never use tuples of the BoundaryMesh, this problem is not currently pressing, although it should be fixed in the future.
- Parameters:
-
| snum | The dimension to switch on |
| ct | The Tuple to switch on |
- Returns:
- The restult of the given Switch operator
Definition at line 89 of file cellcomplex_C.h.
References CellComplex< Vertex, Edge, Face, Tuple >::switch0, CellComplex< Vertex, Edge, Face, Tuple >::switch1, and CellComplex< Vertex, Edge, Face, Tuple >::switch2.
Referenced by ConformalMesher::excavate_holes(), CellComplex< Vertex, Edge, Face, Tuple >::get_tuple(), ConformalMesher::segment_appears(), EPSWrite::shade_triangle(), and Visualization::visual_switch().
