cellcomplex.gmap.gmap module

class cellcomplex.gmap.gmap.DartProxy(gmap, dartid)

Bases: object

alpha(degree)

get_position()

property position

set_alpha(degree, dart)

set_position(pos)

class cellcomplex.gmap.gmap.GMap(degree=2)

Bases: object

add(gmap)

add topology of gmap into self. Return mapping of element of gmap into self.

add_dart(dartid=None)

Create a new dart and return its id

add_darts(nb)

add_sdart(dartid=None)

alpha(*degrees_and_dart)

Return the alpha_i(alpha_j(…(dart))

are_linked_darts(degree, dart1, dart2)

Are the two darts linked with a relation alpha_degree

are_sewable_dart(dart1, dart2, degree=None)

Check if two elements of degree ‘degree’ that start at dart1 and dart2 are sewable.

cell_center(dart, degree)

chamfering(dart, degree, geomratio=0.3)

check_validity()

Test the validity of the structure. Check if there is pending dart for alpha_0 and alpha_1 (fixed point)

closure()

compatible_min_free_degree(dart1, dart2)

contract_cell(dart, degree)

copy()

dart()

dartdisplay(add=False, textsize=None)

darts()

Return a list of id representing the darts of the structure

darts2pglscene(textsize=None)

decrease_degree()

degree_of_link(dart1, dart2)

Find the degree of the link between the two darts

detect_sewable_cell(dart1, dart2, degree)

display(degree=None, add=False, randomcolor=True)

dual()

eulercharacteristic()

expand(gmap, degree, mapping)

Insert gmap into self. links between gmap and self are specified using ‘degree’ and ‘mapping’. ‘mapping’ gives a mapping between darts of gmap to darts of self.

get_embedding_dart(propnameordict, degree, dart)

Return the dart that contains the embedding. If no dart still exists, return dart

get_embedding_dart_and_value(propnameordict, degree, dart)

Return the dart that contains the embedding. If no dart still exists, return dart

get_position(dart)

Return the coordinates with the vertex <alpha_1,…,alpha_i>(dart)

has_position(dart)

Return the coordinates with the vertex <alpha_1,…,alpha_i>(dart)

has_property(propnameordict, degree, dart)

iboundary(degree=None)

ichamfering(dart, degree)

iclosure(degree)

increase_degree()

insert(gmap, degree, mapping)

Insert gmap into self. links between gmap and self are specified using ‘degree’ and ‘mapping’. ‘mapping’ gives a mapping between darts of gmap to darts of self.

intuitive_sew(dart1, dart2, degree)

is_contractible(dart, degree)

is_expansible(gmap, degree, mapping)

Test if gmap can be inserted into self. links between gmap and self are specified using ‘degree’ and ‘mapping’. ‘mapping’ gives a mapping between darts of gmap to darts of self.

is_free(dart, degree)

Test if dart is free for alpha_degree (if it is a fixed point)

is_insertable(gmap, degree, mapping)

Test if gmap can be inserted into self. links between gmap and self are specified using ‘degree’ and ‘mapping’. ‘mapping’ gives a mapping between darts of gmap to darts of self.

is_orientable()

is_removable_cell(dart, degree)

is_valid()

Test the validity of the structure. Check if there is pending dart for alpha_0 and alpha_1 (fixed point)

iterate_over_each_adjacent_cell(dart, degree)

iterate_over_each_connex_components()

iterate_over_each_dart_of_a_i_cell(dart, degree)

iterate_over_each_i_cell(degree)

iterate_over_each_incident_cell(dart, degree, incidentdegree)

link_darts(degree, dart1, dart2)

Link the two darts with a relation alpha_degree

min_free_degree(dart)

Return mninimum degree for which a dart is free

nb_cells(degree)

nb_connex_components()

nb_darts()

orbit(dart, list_of_alpha_value)

Return the orbit of dart using a list of alpha relation. Example of use: gmap.orbit(0,[0,1]). In python, you can use the set structure to process only once all darts of the orbit.

orbit_alphas_for_elements(degree, maxdegree=None)

Return the alpha value for the orbit giving an element of a given degree. For instance a vertex is given by the orbit <alpha_1, …., alpha_gmap_degree>.

orbit_alphas_to_sew(degree)

Return the alpha value for the orbit to sew: <0, degree -2, degree +2, …, gmap.degree alphas_for_orbits_to_sew = { 2 : { 0 : [2], 1 : None , 2 : [0] },

3 : { 0 : [2,3], 1: [3], 2 : [0], 3 : [0,1] } }

orbit_iter(dart, list_of_alpha_value)

Return the orbit of dart using a list of alpha relation. Example of use: gmap.orbit(0,[0,1]). In python, you can use the set structure to process only once all darts of the orbit.

orderedorbit(dart, list_of_alpha_value)

Return the orbit of dart using a list of alpha relation. Example of use. gmap.orbit(0,[0,1]). Warning: No fixed point for the given alpha should be contained.

orderedorbit_iter(dart, list_of_alpha_value)

Return the orbit of dart using a list of alpha relation. Example of use. gmap.orbit(0,[0,1]). Warning: No fixed point for the given alpha should be contained.

orientation()

overlink_darts(degree, dart1, dart2)

Link the two darts with a relation alpha_degree. Do not check if they are free

pointvalency(pointdart)

print_alphas(darts=None)

property(propnameordict, degree, dart)

remove_cell(dart, degree)

remove_dart(dart)

restriction(darts)

return a copy of self restricted to the given set of darts

scale(scaling)

set_alpha(degree, dart, oppdart)

set_position(dart, position)

Associate coordinates with the vertex <alpha_1,…,alpha_i>(dart)

set_property(propnameordict, degree, dart, value)

sew_dart(dart1, dart2, degree=None, verbose=False)

Sew two elements of degree ‘degree’ that start at dart1 and dart2. Determine first the orbits of dart to sew. Sew pairs of corresponding darts.

translate(translation)

unlink_darts(degree, dart1, dart2=None)

Unlink the two darts with the relation alpha_degree. If dart2 is not given, it will uses the dart linked with dart1. If it is given, it check if it is the good one.

unsew_dart(dart1, degree=None)

Sew two elements of degree ‘degree’ that start at dart1 and dart2. Determine first the orbits of dart to sew. Check if they are compatible Sew pairs of corresponding darts.

cellcomplex.gmap.gmap.pointvalency(gmap, pointdart)