Loading...
Searching...
No Matches
Gudhi::skeleton_blocker::Skeleton_blocker_sub_complex< ComplexType > Class Template Reference

Simplicial subcomplex of a complex represented by a skeleton/blockers pair. More...

`#include <include/gudhi/Skeleton_blocker/Skeleton_blocker_sub_complex.h>`

## Public Member Functions

Vertex_handle | add_vertex (Root_vertex_handle global)
void | add_edge_without_blockers (Root_vertex_handle v1_root, Root_vertex_handle v2_root)
void | add_blocker (const Root_simplex_handle &blocker_root)
void | make_restricted_complex (const ComplexType &parent_complex, const Simplex &simplex)
void | clear ()
boost::optional< Vertex_handle > | get_address (Root_vertex_handle global) const
std::vector< boost::optional< Vertex_handle > > | get_addresses (const Root_simplex_handle &s) const
Public Member Functions inherited from Gudhi::skeleton_blocker::Skeleton_blocker_complex< SkeletonBlockerDS >
Vertex_handle | operator[] (Root_vertex_handle global) const
| Return a local Vertex_handle of a vertex given a global one.
Graph_vertex & | operator[] (Vertex_handle address)
| Return the vertex node associated to local Vertex_handle.
const Graph_vertex & | operator[] (Vertex_handle address) const
| Return the vertex node associated to local Vertex_handle.
Vertex_handle | add_vertex ()
| Adds a vertex to the simplicial complex and returns its Vertex_handle.
void | remove_vertex (Vertex_handle address)
| Remove a vertex from the simplicial complex.
bool | contains_vertices (const Simplex &sigma) const
virtual boost::optional< Vertex_handle > | get_address (Root_vertex_handle id) const
| Given an Id return the address of the vertex having this Id in the complex.
Root_vertex_handle | get_id (Vertex_handle local) const
Vertex_handle | convert_handle_from_another_complex (const Skeleton_blocker_complex &other, Vertex_handle vh_in_other) const
| Convert an address of a vertex of a complex to the address in the current complex.
int | degree (Vertex_handle local) const
| return the graph degree of a vertex.
boost::optional< Edge_handle > | operator[] (const std::pair< Vertex_handle, Vertex_handle > &ab) const
| return an edge handle if the two vertices forms an edge in the complex
Graph_edge & | operator[] (Edge_handle edge_handle)
| returns the stored node associated to an edge
const Graph_edge & | operator[] (Edge_handle edge_handle) const
| returns the stored node associated to an edge
Vertex_handle | first_vertex (Edge_handle edge_handle) const
| returns the first vertex of an edge
Vertex_handle | second_vertex (Edge_handle edge_handle) const
| returns the first vertex of an edge
Simplex | get_vertices (Edge_handle edge_handle) const
| returns the simplex made with the two vertices of the edge
Edge_handle | add_edge (Vertex_handle a, Vertex_handle b)
| Adds an edge between vertices a and b.
void | add_edge (const Simplex &s)
| Adds all edges of s in the complex.
Edge_handle | add_edge_without_blockers (Vertex_handle a, Vertex_handle b)
| Adds an edge between vertices a and b without blockers.
void | add_edge_without_blockers (Simplex s)
| Adds all edges of s in the complex without adding blockers.
virtual Edge_handle | remove_edge (Vertex_handle a, Vertex_handle b)
| Removes an edge from the simplicial complex and all its cofaces.
void | remove_edge (Edge_handle edge)
| Removes edge and its cofaces from the simplicial complex.
void | keep_only_vertices ()
| The complex is reduced to its set of vertices. All the edges and blockers are removed.
bool | contains_edge (Vertex_handle a, Vertex_handle b) const
bool | contains_edges (const Simplex &sigma) const
bool | is_popable_blocker (Blocker_handle sigma) const
void | remove_popable_blockers ()
void | remove_popable_blockers (Vertex_handle v)
void | remove_all_popable_blockers (Vertex_handle v)
| Removes all the popable blockers of the complex passing through v and delete them. Also remove popable blockers in the neighborhood if they became popable.
void | remove_star (Vertex_handle v)
void | remove_star (Vertex_handle a, Vertex_handle b)
void | remove_star (Edge_handle e)
void | remove_star (const Simplex &sigma)
void | add_simplex (const Simplex &sigma)
| add a simplex and all its faces.
virtual contractible_status | is_contractible () const
| Test if the complex is reducible using a strategy defined in the class (by default it tests if the complex is a cone)
Blocker_handle | add_blocker (const Simplex &blocker)
| Adds the simplex to the set of blockers and returns a Blocker_handle toward it if was not present before and 0 otherwise.
void | remove_blocker (const Blocker_handle sigma)
| Removes the simplex from the set of blockers.
void | remove_blockers ()
| Remove all blockers, in other words, it expand the simplicial complex to the smallest flag complex that contains it.
void | delete_blocker (Blocker_handle sigma)
bool | contains_blocker (const Blocker_handle s) const
bool | contains_blocker (const Simplex &s) const
Link_complex | link (Vertex_handle v) const
Link_complex | link (Edge_handle edge) const
Link_complex | link (const Simplex &simplex) const
boost::optional< Simplex > | get_simplex_address (const Root_simplex_handle &s) const
| Compute the local vertices of 's' in the current complex If one of them is not present in the complex then the return value is uninitialized.
Root_simplex_handle | get_id (const Simplex &local_simplex) const
| returns a simplex with vertices which are the id of vertices of the argument.
virtual bool | contains (const Simplex &s) const
| returns true iff the simplex s belongs to the simplicial complex.
int | num_connected_components () const
| returns the number of connected components in the graph of the 1-skeleton.
bool | is_cone () const
| Test if the complex is a cone.
Complex_vertex_range | vertex_range () const
| Returns a Complex_vertex_range over all vertices of the complex.
Complex_neighbors_vertices_range | vertex_range (Vertex_handle v) const
| Returns a Complex_edge_range over all edges of the simplicial complex that passes through v.
Complex_edge_range | edge_range () const
| Returns a Complex_edge_range over all edges of the simplicial complex.
Complex_edge_around_vertex_range | edge_range (Vertex_handle v) const
| Returns a Complex_edge_range over all edges of the simplicial complex that passes through 'v'.
Complex_triangle_around_vertex_range | triangle_range (Vertex_handle v) const
| Range over triangles around a vertex of the simplicial complex. Methods .begin() and .end() return a Triangle_around_vertex_iterator.
Complex_triangle_range | triangle_range () const
| Range over triangles of the simplicial complex. Methods .begin() and .end() return a Triangle_around_vertex_iterator.
Complex_simplex_around_vertex_range | star_simplex_range (Vertex_handle v) const
| Returns a Complex_simplex_around_vertex_range over all the simplices around a vertex of the complex.
Complex_coboundary_range | coboundary_range (const Simplex &s) const
| Returns a Complex_simplex_coboundary_iterator over the simplices of the coboundary of a simplex.
Complex_simplex_range | complex_simplex_range () const
| Returns a Complex_simplex_range over all the simplices of the complex.
| Skeleton_blocker_complex (size_t num_vertices_=0, Visitor *visitor_=NULL)
| constructs a simplicial complex with a given number of vertices and a visitor.
template<typename SimpleHandleOutputIterator>
| Skeleton_blocker_complex (SimpleHandleOutputIterator simplices_begin, SimpleHandleOutputIterator simplices_end, bool is_flag_complex=false, Visitor *visitor_=NULL)
| Constructor with a list of simplices.
bool | operator== (const Skeleton_blocker_complex &other) const
virtual | ~Skeleton_blocker_complex ()
void | set_visitor (Visitor *other_visitor)
| allows to change the visitor.
Complex_blocker_around_vertex_range | blocker_range (Vertex_handle v)
| Returns a range of the blockers of the complex passing through a vertex.
Const_complex_blocker_around_vertex_range | const_blocker_range (Vertex_handle v) const
| Returns a range of the blockers of the complex passing through a vertex.
Complex_blocker_range | blocker_range ()
| Returns a range of the blockers of the complex.
Const_complex_blocker_range | const_blocker_range () const
| Returns a range of the blockers of the complex.
bool | link_condition (Vertex_handle a, Vertex_handle b, bool ignore_popable_blockers=false) const
bool | link_condition (Edge_handle e, bool ignore_popable_blockers=false) const
void | contract_edge (Edge_handle edge)
void | contract_edge (Vertex_handle a, Vertex_handle b)

## Additional Inherited Members

Public Types inherited from Gudhi::skeleton_blocker::Skeleton_blocker_complex< SkeletonBlockerDS >
typedef SkeletonBlockerDS::Graph_vertex | Graph_vertex
| The type of stored vertex node, specified by the template SkeletonBlockerDS.
typedef SkeletonBlockerDS::Graph_edge | Graph_edge
| The type of stored edge node, specified by the template SkeletonBlockerDS.
typedef SkeletonBlockerDS::Vertex_handle | Vertex_handle
| The type of an handle to a vertex of the complex.
typedef Skeleton_blocker_simplex< Vertex_handle > | Simplex
| A ordered set of integers that represents a simplex.
typedef Simplex * | Blocker_handle
| Handle to a blocker of the complex.
typedef boost::graph_traits< Graph >::edge_descriptor | Edge_handle
| Handle to an edge of the complex.
typedef boost::iterator_range< Complex_simplex_around_vertex_iterator > | Complex_simplex_around_vertex_range
| Range over the simplices of the simplicial complex around a vertex. Methods .begin() and .end() return a Complex_simplex_around_vertex_iterator.
typedef boost::iterator_range< Complex_simplex_coboundary_iterator > | Complex_coboundary_range
| Range over the simplices of the coboundary of a simplex. Methods .begin() and .end() return a Complex_simplex_coboundary_iterator.

## Detailed Description

template<typename ComplexType>
class Gudhi::skeleton_blocker::Skeleton_blocker_sub_complex< ComplexType >

Simplicial subcomplex of a complex represented by a skeleton/blockers pair.

Stores a subcomplex of a simplicial complex. To simplify explanations below, we will suppose that :

- K is the root simplicial complex
- L is a subcomplex of K.

One vertex of K may exists in L but with a different address. To be able to locate the vertices in K from vertices of L, the class stores a map 'addresses' between vertices of K and vertices of L.

Note that the type for handle of vertices of L is 'Vertex_handle' and the type for handle of vertices of K is 'Root_vertex_handle'.

The template ComplexType is type of the root complex. It allows to know if the subcomplex is geometric or not. It has to be either 'Skeleton_blockers_complex' or 'Skeleton_blockers_geometric_complex'.

## Member Function Documentation

## add_blocker()

template<typename ComplexType>

void Gudhi::skeleton_blocker::Skeleton_blocker_sub_complex< ComplexType >::add_blocker | ( | const Root_simplex_handle & | blocker_root | ) |

inline

Add a blocker to the sub-complex. It assumes that all vertices of blocker_root are present in the sub-complex.

## add_edge_without_blockers()

template<typename ComplexType>

void Gudhi::skeleton_blocker::Skeleton_blocker_sub_complex< ComplexType >::add_edge_without_blockers | ( | Root_vertex_handle | v1_root,
|  | Root_vertex_handle | v2_root )

inline

Add an edge (v1_root,v2_root) to the sub-complex. It assumes that both vertices corresponding to v1_root and v2_root are present in the sub-complex.

## add_vertex()

template<typename ComplexType>

Vertex_handle Gudhi::skeleton_blocker::Skeleton_blocker_sub_complex< ComplexType >::add_vertex | ( | Root_vertex_handle | global | ) |

inline

Add a vertex 'global' of K to L. When added to L, this vertex will receive another number, addresses(global), its local address. return the address where the vertex lay on L. The vertex corresponding to 'global' must not be already present in the complex.

## clear()

template<typename ComplexType>

void Gudhi::skeleton_blocker::Skeleton_blocker_sub_complex< ComplexType >::clear | ( |  | ) |

inline virtual

Clears the simplicial complex. After a call to this function, blockers are destroyed. The 1-skeleton and the set of blockers are both empty.

Reimplemented from Gudhi::skeleton_blocker::Skeleton_blocker_complex< SkeletonBlockerDS >.

## get_address()

template<typename ComplexType>

boost::optional< Vertex_handle > Gudhi::skeleton_blocker::Skeleton_blocker_sub_complex< ComplexType >::get_address | ( | Root_vertex_handle | global | ) | const

inline

Compute the local vertex in L corresponding to the vertex global in K. runs in O(log n) if n = num_vertices()

## get_addresses()

template<typename ComplexType>

std::vector< boost::optional< Vertex_handle > > Gudhi::skeleton_blocker::Skeleton_blocker_sub_complex< ComplexType >::get_addresses | ( | const Root_simplex_handle & | s | ) | const

inline

Allocates a simplex in L corresponding to the simplex s in K with its local addresses and returns an AddressSimplex. same as get_address except that it will return a simplex in any case. The vertices that were not found are not added.

## make_restricted_complex()

template<typename ComplexType>

void Gudhi::skeleton_blocker::Skeleton_blocker_sub_complex< ComplexType >::make_restricted_complex | ( | const ComplexType & | parent_complex,
|  | const Simplex & | simplex )

inline

Constructs the restricted complex of 'parent_complex' to vertices of 'simplex'.

The documentation for this class was generated from the following files:

- include/gudhi/Skeleton_blocker/Skeleton_blocker_link_superior.h
- include/gudhi/Skeleton_blocker/Skeleton_blocker_sub_complex.h