Frameworks<a class="headerlink" href="#module-pyrigi.framework.framework" title="Link to this heading">¶

Examples

>>> F = Framework.Empty(dim=2)
>>> F.add_vertex((1.5,2), 'a')
>>> F.add_vertex((3,1))
>>> print(F)
Framework in 2-dimensional space consisting of:
Graph with vertices ['a', 1] and edges []
Realization {a:(1.50000000000000, 2), 1:(3, 1)}

add_vertices(points, vertices=None)¶

Add a list of vertices to the framework.

Parameters:

points (Sequence[Point]) – List of points consisting of coordinates in \(\RR^d\). It is checked that all points lie in the same ambient space.
vertices (Sequence[Vertex]) – List of vertices. If the list of vertices is empty, we generate vertices with the method add_vertex(). Otherwise, the list of vertices needs to have the same length as the list of points.

Return type:

Examples

>>> F = Framework.Empty(dim=2)
>>> F.add_vertices([(1.5,2), (3,1)], ['a',0])
>>> print(F)
Framework in 2-dimensional space consisting of:
Graph with vertices ['a', 0] and edges []
Realization {a:(1.50000000000000, 2), 0:(3, 1)}

Notes

For each vertex that has to be added, add_vertex() is called.

animate3D_rotation(plot_style=None, vertex_colors_custom=None, edge_colors_custom=None, total_frames=100, delay=75, rotation_axis=None, **kwargs)[source]¶

Plot this framework in 3D and animate a rotation around an axis.

For additional parameters and implementation details, see animate3D().

Parameters:

plot_style (PlotStyle) – An instance of the PlotStyle class that defines the visual style for plotting, see PlotStyle for more details.
vertex_colors_custom (Sequence[Sequence[Vertex]] | dict[str, Sequence[Vertex]]) – Optional parameter to specify the colors of vertices. It can be a Sequence[Sequence[Vertex]] to define groups of vertices with the same color or a dict[str, Sequence[Vertex]] where the keys are color strings and the values are lists of vertices. The omitted vertices are given the value plot_style.vertex_color.
edge_colors_custom (Sequence[Sequence[Edge]] | dict[str, Sequence[Edge]]) – Optional parameter to specify the colors of edges. It can be a Sequence[Sequence[Edge]] to define groups of edges with the same color or a dict[str, Sequence[Edge]] where the keys are color strings and the values are lists of edges. The omitted edges are given the value plot_style.edge_color.
total_frames (int) – Total number of frames for the animation sequence.
delay (int) – Delay between frames in milliseconds.
rotation_axis (str | Sequence[Number]) – The user can input a rotation axis or vector. By default, a rotation around the z-axis is performed. This can either a character ('x', 'y', or 'z') or a vector (e.g. [1, 0, 0]).

Return type:

Any

Examples

>>> from pyrigi import frameworkDB
>>> F = frameworkDB.Complete(4, dim=3)
>>> F.animate3D_rotation()

delete_edge(edge)¶

Delete an edge from the framework.

Parameters:: edge (Edge)
Return type:: None

delete_edges(edges)¶

Delete a list of edges from the framework.

Parameters:: edges (Sequence[Edge])
Return type:: None

delete_vertex(vertex)¶

Delete a vertex from the framework.

Parameters:: vertex (Vertex)
Return type:: None

delete_vertices(vertices)¶

Delete a list of vertices from the framework.

Parameters:: vertices (Sequence[Vertex])
Return type:: None

property dim: int¶: Return the dimension of the framework.

edge_lengths(numerical=False)[source]¶

Return the dictionary of the edge lengths.

Parameters:: numerical (bool) – If True, numerical positions are used for the computation of the edge lengths.
Return type:: dict[Edge, Number]

Examples

>>> G = Graph([(0,1), (1,2), (2,3), (0,3)])
>>> F = Framework(G, {0:[0,0], 1:[1,0], 2:[1,'1/2 * sqrt(5)'], 3:['1/2','4/3']})
>>> F.edge_lengths(numerical=False)
{(0, 1): 1, (0, 3): sqrt(73)/6, (1, 2): sqrt(5)/2, (2, 3): sqrt((-4/3 + sqrt(5)/2)**2 + 1/4)}
>>> F.edge_lengths(numerical=True)
{(0, 1): 1.0, (0, 3): 1.4240006242195884, (1, 2): 1.118033988749895, (2, 3): 0.5443838790578374}

classmethod from_points(points)[source]¶

Generate a framework from a list of points.

The list of vertices of the underlying graph is taken to be [0,...,len(points)-1]. The underlying graph has no edges.

Parameters:: points (Sequence[Point]) – The realization of the framework that this method outputs is provided as a list of points.
Return type:: Framework

Examples

>>> F = Framework.from_points([(1,2), (2,3)])
>>> print(F)
Framework in 2-dimensional space consisting of:
Graph with vertices [0, 1] and edges []
Realization {0:(1, 2), 1:(2, 3)}

generate_stl_bars(scale=1.0, width_of_bars=8.0, height_of_bars=3.0, holes_diameter=4.3, filename_prefix='bar_', output_dir='stl_output')[source]¶

Generate STL files for the bars of the framework.

The STL files are generated in the working folder. The naming convention for the files is bar_i-j.stl, where i and j are the vertices of an edge.

Parameters:

scale (float) – Scale factor for the lengths of the edges, default is 1.0.
width_of_bars (float) – Width of the bars, default is 8.0 mm.
height_of_bars (float) – Height of the bars, default is 3.0 mm.
holes_diameter (float) – Diameter of the holes at the ends of the bars, default is 4.3 mm.
filename_prefix (str) – Prefix for the filenames of the generated STL files, default is bar_.
output_dir (str) – Name or path of the folder where the STL files are saved, default is stl_output. Relative to the working directory.

Return type:

Examples

>>> G = Graph([(0,1), (1,2), (2,3), (0,3)])
>>> F = Framework(G, {0:[0,0], 1:[1,0], 2:[1,'1/2 * sqrt(5)'], 3:[1/2,'4/3']})
>>> F.generate_stl_bars(scale=20)
STL files for the bars have been generated in the folder `stl_output`.

property graph: Graph¶

Return a copy of the underlying graph.

Examples

>>> F = Framework.Random(Graph([(0,1), (1,2), (0,2)]))
>>> print(F.graph)
Graph with vertices [0, 1, 2] and edges [[0, 1], [0, 2], [1, 2]]

inf_flexes(include_trivial=False, vertex_order=None, numerical=False, tolerance=1e-09, fixed_vertices=[])[source]¶

Return a basis of the space of infinitesimal flexes.

Return a lift of a basis of the quotient of the vector space of infinitesimal flexes modulo trivial infinitesimal flexes, if include_trivial=False. Return a basis of the vector space of infinitesimal flexes if include_trivial=True.

Definitions

Infinitesimal flex

Parameters:

include_trivial (bool) – Boolean that decides, whether the trivial flexes should be included.
vertex_order (Sequence[Vertex]) – A list of vertices, providing the ordering for the entries of the infinitesimal flexes. If none is provided, the list from Graph.vertex_list() is taken.
numerical (bool) – Determines whether the output is symbolic (default) or numerical.
tolerance (float) – Used tolerance when computing the infinitesimal flex numerically.
fixed_vertices (Sequence[Vertex]) – Fixed vertices are assigned a flex of length 0. The default value is an empty list. They can be provided as a sequence of vertices.

Return type:

list[MutableDenseMatrix] | list[list[float]]

Examples

>>> F = Framework.Complete([[0,0], [1,0], [1,1], [0,1]])
>>> F.delete_edges([(0,2), (1,3)])
>>> F.inf_flexes(include_trivial=False)
[Matrix([
[1],
[0],
[1],
[0],
[0],
[0],
[0],
[0]])]
>>> F = Framework(
...     Graph([[0, 1], [0, 3], [0, 4], [1, 3], [1, 4], [2, 3], [2, 4]]),
...     {0: [0, 0], 1: [0, 1], 2: [0, 2], 3: [1, 2], 4: [-1, 2]},
... )
>>> F.inf_flexes()
[Matrix([
[0],
[0],
[0],
[0],
[0],
[1],
[0],
[0],
[0],
[0]])]

is_congruent(other_framework, numerical=False, tolerance=1e-09)[source]¶

Return whether the given framework is congruent to the framework.

Definitions

Congruent frameworks

Parameters:

other_framework (Framework) – The framework for checking the congruence.
numerical (bool) – Whether the check is symbolic (default) or numerical.
tolerance (float) – Used tolerance when checking numerically.

Return type:

is_congruent_realization(other_realization, numerical=False, tolerance=1e-09)[source]¶

Return whether the given realization is congruent to the framework.

Definitions

Congruent frameworks

Parameters:

other_realization (dict[Vertex, Point] | dict[Vertex, MutableDenseMatrix]) – The realization for checking the congruence.
numerical (bool) – Whether the check is symbolic (default) or numerical.
tolerance (float) – Used tolerance when checking numerically.

Return type:

is_dependent(**kwargs)[source]¶

Return whether the framework is dependent.

See also is_second_order_rigid().

Definitions

Prestress stability

Parameters:

numerical (bool) – If True, numerical infinitesimal flexes and stresses are used in the check for prestress stability. In case that numerical=False, this method only properly works for symbolic coordinates.
tolerance (float) – Numerical tolerance used for the check that something is an approximate zero.
inf_flexes (Sequence[InfFlex]) – Precomputed infinitesimal flexes and equilibrium stresses can be provided to avoid recomputation. If not provided, they are computed here.
stresses (Sequence[Stress]) – Precomputed infinitesimal flexes and equilibrium stresses can be provided to avoid recomputation. If not provided, they are computed here.

Return type:

Examples

>>> from pyrigi import frameworkDB as fws
>>> F = fws.Frustum(3)
>>> F.is_prestress_stable()
True

is_quasi_injective(numerical=False, tolerance=1e-09)[source]¶

Return whether the realization is quasi-injective.

Definitions

Quasi-injectivity

Parameters:

numerical (bool) – Whether the check is symbolic (default) or numerical.
tolerance (float) – Used tolerance when checking numerically.

Return type:

Redundant infinitesimal rigidity

Notes

For comparing whether two vectors are the same, misc.is_zero_vector() is used. See its documentation for the description of the parameters.

is_redundantly_inf_rigid(use_copy=True, **kwargs)[source]¶

Return if the framework is infinitesimally redundantly rigid.

For implementation details and possible parameters, see is_inf_rigid().

Definitions

Parameters:: use_copy (bool) – If False, the framework’s edges are deleted and added back during runtime. Otherwise, a new modified framework is created, while the original framework remains unchanged (default).
Return type:: bool

Examples

>>> F = Framework.Empty(dim=2)
>>> F.add_vertices([(1,0), (1,1), (0,3), (-1,1)], ['a','b','c','d'])
>>> F.add_edges([('a','b'), ('b','c'), ('c','d'), ('a','d'), ('a','c'), ('b','d')])
>>> F.is_redundantly_inf_rigid()
True
>>> F.delete_edge(('a','c'))
>>> F.is_redundantly_inf_rigid()
False

is_second_order_rigid(numerical=False, tolerance=1e-09, inf_flexes=None, stresses=None)[source]¶

Return whether the framework is second-order rigid.

Checking second-order-rigidity for a general framework is computationally hard. If there is only one stress or only one infinitesimal flex, second-order rigidity is identical to prestress stability, so we can apply is_prestress_stable(). See also Theorem 33.

Definitions

Second-order rigidity

Parameters:

numerical (bool) – If True, numerical infinitesimal flexes and stresses are used in the check for prestress stability. In case that numerical=False, this method only properly works for symbolic coordinates.
tolerance (float) – Numerical tolerance used for the check that something is an approximate zero.
inf_flexes (Sequence[InfFlex]) – Precomputed infinitesimal flexes and equilibrium stresses can be provided to avoid recomputation. If not provided, they are computed here.
stresses (Sequence[Stress]) – Precomputed infinitesimal flexes and equilibrium stresses can be provided to avoid recomputation. If not provided, they are computed here.

Return type:

Trivial infinitesimal flex

Examples

>>> from pyrigi import frameworkDB as fws
>>> F = fws.Frustum(3)
>>> F.is_second_order_rigid()
True

is_stress(stress, **kwargs)[source]¶

Alias for is_vector_stress() and is_dict_stress().

One of the alias methods is called depending on the type of the input.

Parameters:: stress (Stress)
Return type:: bool

is_trivial_flex(inf_flex, **kwargs)[source]¶

Alias for is_vector_trivial_inf_flex() and is_dict_trivial_inf_flex().

Ii is distinguished between instances of list and instances of dict to call one of the alias methods.

Definitions

Parameters:: inf_flex (InfFlex)
Return type:: bool

is_vector_inf_flex(inf_flex, vertex_order=None, numerical=False, tolerance=1e-09)[source]¶

Return whether a vector is an infinitesimal flex of the framework.

Definitions

Parameters:

inf_flex (Sequence[Number]) – An infinitesimal flex of the framework specified by a vector.
vertex_order (Sequence[Vertex]) – A list of vertices specifying the order in which inf_flex is given. If none is provided, the list from vertex_list() is taken.
numerical (bool) – A Boolean determining whether the evaluation of the product of the inf_flex and the rigidity matrix is symbolic or numerical.
tolerance (float) – Absolute tolerance that is the threshold for acceptable numerical flexes. This parameter is used to determine the number of digits, to which accuracy the symbolic expressions are evaluated.

Return type:

Nontrivial infinitesimal flex

Examples

>>> from pyrigi import frameworkDB as fws
>>> F = fws.Square()
>>> q = [0,0,0,0,-2,0,-2,0]
>>> F.is_vector_inf_flex(q)
True
>>> q[0] = 1
>>> F.is_vector_inf_flex(q)
False
>>> F = Framework.Complete([[0,0], [1,1]])
>>> F.is_vector_inf_flex(["sqrt(2)","-sqrt(2)",0,0], vertex_order=[1,0])
True

is_vector_nontrivial_inf_flex(inf_flex, vertex_order=None, numerical=False, tolerance=1e-09)[source]¶

Return whether an infinitesimal flex is nontrivial.

Definitions

Parameters:

inf_flex (Sequence[Number]) – An infinitesimal flex of the framework.
vertex_order (Sequence[Vertex]) – A list of vertices specifying the order in which inf_flex is given. If none is provided, the list from Graph.vertex_list() is taken.
numerical (bool) – A Boolean determining whether the evaluation of the product of the inf_flex and the rigidity matrix is symbolic or numerical.
tolerance (float) – Absolute tolerance that is the threshold for acceptable numerical flexes. This parameter is used to determine the number of digits, to which accuracy the symbolic expressions are evaluated.

Return type:

Examples

>>> from pyrigi import frameworkDB as fws
>>> F = fws.Square()
>>> q = [0,0,0,0,-2,0,-2,0]
>>> F.is_vector_nontrivial_inf_flex(q)
True
>>> q = [1,-1,1,1,-1,1,-1,-1]
>>> F.is_vector_inf_flex(q)
True
>>> F.is_vector_nontrivial_inf_flex(q)
False

Notes

This is done by solving a linear system composed of a matrix \(A\) whose columns are given by a basis of the trivial flexes and the vector \(b\) given by the input flex. \(b\) is trivial if and only if there is a linear combination of the columns in \(A\) producing \(b\). In other words, when there is a solution to \(Ax=b\), then \(b\) is a trivial infinitesimal motion. Otherwise, \(b\) is nontrivial.

In the numerical=True case we compute a least squares solution \(x\) of the overdetermined linear system and compare the values in \(Ax\) to the values in \(b\).

is_vector_stress(stress, edge_order=None, numerical=False, tolerance=1e-09)[source]¶

Return whether a vector is an equilibrium stress.

Definitions

Equilibrium stress

Parameters:

stress (Sequence[Number]) – A vector to be checked whether it is a stress of the framework.
edge_order (Sequence[Edge]) – A list of edges, providing the ordering for the entries of the stress. If none is provided, the list from Graph.edge_list() is taken.
numerical (bool) – A Boolean determining whether the evaluation of the product of the stress and the rigidity matrix is symbolic or numerical.
tolerance – Absolute tolerance that is the threshold for acceptable equilibrium stresses. This parameter is used to determine the number of digits, to which accuracy the symbolic expressions are evaluated.

Return type:

Trivial infinitesimal flex

Examples

>>> G = Graph([[0,1],[0,2],[0,3],[1,2],[2,3],[3,1]])
>>> pos = {0: (0, 0), 1: (0,1), 2: (-1,-1), 3: (1,-1)}
>>> F = Framework(G, pos)
>>> omega1 = [-8, -4, -4, 2, 2, 1]
>>> F.is_stress(omega1)
True
>>> omega1[0] = 0
>>> F.is_stress(omega1)
False
>>> from pyrigi import frameworkDB
>>> F = frameworkDB.Complete(5, dim=2)
>>> stresses=F.stresses()
>>> F.is_stress(stresses[0])
True

is_vector_trivial_inf_flex(inf_flex, **kwargs)[source]¶

Return whether an infinitesimal flex is trivial.

See also is_nontrivial_vector_inf_flex() for details, particularly concerning the possible parameters.

Definitions

Parameters:: inf_flex (Sequence[Number]) – An infinitesimal flex of the framework.
Return type:: bool

Examples

>>> from pyrigi import frameworkDB as fws
>>> F = fws.Square()
>>> q = [0,0,0,0,-2,0,-2,0]
>>> F.is_vector_trivial_inf_flex(q)
False
>>> q = [1,-1,1,1,-1,1,-1,-1]
>>> F.is_vector_trivial_inf_flex(q)
True

nontrivial_inf_flexes(**kwargs)[source]¶

Return non-trivial infinitesimal flexes.

See inf_flexes() for possible keywords.

Return type:: list[MutableDenseMatrix]

Definitions

Infinitesimal flex

Examples

>>> import pyrigi.graphDB as graphs
>>> F = Framework.Circular(graphs.CompleteBipartite(3, 3))
>>> F.nontrivial_inf_flexes()
[Matrix([
[       3/2],
[-sqrt(3)/2],
[         1],
[         0],
[         0],
[         0],
[       3/2],
[-sqrt(3)/2],
[         1],
[         0],
[         0],
[         0]])]

plot(plot_style=None, **kwargs)[source]¶

Plot the framework.

The framework can be plotted only if its dimension is less than 3. For plotting a projection of a higher dimensional framework, use plot2D() or plot3D() instead. For various formatting options, see PlotStyle.

Return type:: None
Parameters:: plot_style (PlotStyle)

plot2D(plot_style=None, projection_matrix=None, random_seed=None, coordinates=None, inf_flex=None, stress=None, vertex_colors_custom=None, edge_colors_custom=None, stress_label_positions=None, arc_angles_dict=None, filename=None, dpi=300, fixed_vertices=[], **kwargs)[source]¶

Plot the framework in 2D.

If the framework is in dimensions higher than 2 and projection_matrix with coordinates are None, a random projection matrix containing two orthonormal vectors is generated and used for projection into 2D. For various formatting options, see PlotStyle. Only coordinates or projection_matrix parameter can be used, not both!

Parameters:

plot_style (PlotStyle) – An instance of the PlotStyle class that defines the visual style for plotting, see PlotStyle for more details.
projection_matrix (MutableDenseMatrix) – The matrix used for projecting the realization when the dimension is greater than 2. The matrix must have dimensions (2, dim), where dim is the dimension of the framework. If None, a random projection matrix is generated.
random_seed (int) – The random seed used for generating the projection matrix.
coordinates (Sequence[int]) – Indices of two coordinates to which the framework is projected.
inf_flex (Union[int, InfFlex]) – Optional parameter for plotting a given infinitesimal flex. The standard input format is a Matrix that is the output of e.g. the method inf_flexes(). Alternatively, an int can be specified to directly choose the 0,1,2,…-th nontrivial infinitesimal flex (according to the method nontrivial_inf_flexes()) for plotting. For these input types, it is important to use the same vertex order as the one from Graph.vertex_list(). If the vertex order needs to be specified, a dict[Vertex, Sequence[Number]] can be provided, which maps the vertex labels to vectors (i.e. a sequence of coordinates).
stress (Union[int, Stress]) – Optional parameter for plotting a given equilibrium stress. The standard input format is a Matrix that is the output of e.g. the method stresses(). Alternatively, an int can be specified to directly choose the 0,1,2,…-th equilibrium stress (according to the method stresses()) for plotting. For these input types, it is important to use the same edge order as the one from Graph.edge_list(). If the edge order needs to be specified, a Dict[Edge, Number] can be provided, which maps the edges to numbers (i.e. coordinates).
vertex_colors_custom (Sequence[Sequence[Vertex]] | dict[str, Sequence[Vertex]]) – It is possible to provide custom vertex colors through this parameter. They can either be provided through a partition of vertices or a dictionary with str color keywords that map to lists of vertices.
edge_colors_custom (Sequence[Sequence[Edge]] | dict[str, Sequence[Edge]]) – Optional parameter to specify the colors of edges. It can be a Sequence[Sequence[Edge]] to define groups of edges with the same color or a dict[str, Sequence[Edge]] where the keys are color strings and the values are lists of edges. The omitted edges are given the value plot_style.edge_color.
stress_label_positions (dict[DirectedEdge, float]) – Dictionary specifying the position of stress labels along the edges. Keys are DirectedEdge objects, and values are floats (e.g., 0.5 for midpoint). Omitted edges are given the value 0.5.
arc_angles_dict (Sequence[float] | dict[DirectedEdge, float]) – Optional parameter to specify custom arc angle for edges. Can be a Sequence[float] or a dict[Edge, float] where values define the curvature angle of edges in radians.
filename (str) – The filename under which the produced figure is saved. The default value is None which indicates that the figure is currently not saved. The figure is saved as a .png file using the save method from matplotlib.
dpi (Dots per inched in case the figure is saved. Default is 300 for producing) – a print-quality image.
fixed_vertices (Sequence[Vertex]) – Vertices that are assigned a zero flex in the plot.

Return type:

Examples

>>> from pyrigi import Graph, Framework
>>> G = Graph([(0,1), (1,2), (2,3), (0,3), (0,2), (1,3), (0,4)])
>>> F = Framework(G, {0:(0,0), 1:(1,0), 2:(1,2), 3:(0,1), 4:(-1,0)})
>>> from pyrigi import PlotStyle2D
>>> style = PlotStyle2D(vertex_color="green", edge_color="blue")
>>> F.plot2D(plot_style=style)

Use keyword arguments

>>> F.plot2D(vertex_color="red", edge_color="black", vertex_size=500)

Specify stress and its labels positions

>>> stress_label_positions = {(0, 1): 0.7, (1, 2): 0.2}
>>> F.plot2D(stress=0, stress_label_positions=stress_label_positions)

Specify infinitesimal flex

>>> F.plot2D(inf_flex=0)

Use both stress and infinitesimal flex

>>> F.plot2D(stress=0, inf_flex=0)

Use custom edge colors

>>> edge_colors = {'red': [(0, 1), (1, 2)], 'blue': [(2, 3), (0, 3)]}
>>> F.plot2D(edge_colors_custom=edge_colors)

The following is just to close all figures after running the example:

>>> import matplotlib.pyplot
>>> matplotlib.pyplot.close("all")

plot3D(plot_style=None, projection_matrix=None, random_seed=None, coordinates=None, inf_flex=None, stress=None, vertex_colors_custom=None, edge_colors_custom=None, stress_label_positions=None, filename=None, dpi=300, fixed_vertices=[], **kwargs)[source]¶

Plot the provided framework in 3D.

If the framework is in a dimension higher than 3 and projection_matrix with coordinates are None, a random projection matrix containing three orthonormal vectors is generated and used for projection into 3D. For various formatting options, see PlotStyle. Only the parameter coordinates or projection_matrix can be used, not both at the same time.

Parameters:

plot_style (PlotStyle) – An instance of the PlotStyle class that defines the visual style for plotting, see PlotStyle for more details.
projection_matrix (MutableDenseMatrix) – The matrix used for projecting the realization when the dimension is greater than 3. The matrix must have dimensions (3, dim), where dim is the dimension of the framework. If None, a random projection matrix is generated.
random_seed (int) – The random seed used for generating the projection matrix.
coordinates (Sequence[int]) – Indices of two coordinates to which the framework is projected.
inf_flex (Union[int, InfFlex]) – Optional parameter for plotting a given infinitesimal flex. The standard input format is a Matrix that is the output of e.g. the method inf_flexes(). Alternatively, an int can be specified to directly choose the 0,1,2,…-th nontrivial infinitesimal flex (according to the method nontrivial_inf_flexes()) for plotting. For these input types, is important to use the same vertex order as the one from Graph.vertex_list(). If the vertex order needs to be specified, a dict[Vertex, Sequence[Number]] can be provided, which maps the vertex labels to vectors (i.e. a sequence of coordinates).
stress (Union[int, Stress]) – Optional parameter for plotting a given equilibrium stress. The standard input format is a Matrix that is the output of e.g. the method stresses(). Alternatively, an int can be specified to directly choose the 0,1,2,…-th equilibrium stress (according to the method stresses()) for plotting. For these input types, is important to use the same edge order as the one from Graph.edge_list(). If the edge order needs to be specified, a Dict[Edge, Number] can be provided, which maps the edges to numbers (i.e. coordinates).
vertex_colors_custom (Sequence[Sequence[Vertex]] | dict[str, Sequence[Vertex]]) – Optional parameter to specify the colors of vertices. It can be a Sequence[Sequence[Vertex]] to define groups of vertices with the same color or a dict[str, Sequence[Vertex]] where the keys are color strings and the values are lists of vertices. The omitted vertices are given the value plot_style.vertex_color.
edge_colors_custom (Sequence[Sequence[Edge]] | dict[str, Sequence[Edge]]) – Optional parameter to specify the colors of edges. It can be a Sequence[Sequence[Edge]] to define groups of edges with the same color or a dict[str, Sequence[Edge]] where the keys are color strings and the values are lists of edges. The omitted edges are given the value plot_style.edge_color.
stress_label_positions (dict[DirectedEdge, float]) – Dictionary specifying the position of stress labels along the edges. Keys are DirectedEdge objects, and values are floats (e.g., 0.5 for midpoint). Omitted edges are given the value 0.5.
filename (str) – The filename under which the produced figure is saved. The default value is None which indicates that the figure is currently not saved. The figure is saved as a .png file using the save method from matplotlib.
dpi (Dots per inched in case the figure is saved. Default is 300 for producing) – a print-quality image.
fixed_vertices (Sequence[Vertex]) – Vertices that are assigned a zero flex in the plot.

Return type:

Examples

>>> from pyrigi import frameworkDB
>>> F = frameworkDB.Octahedron(realization="Bricard_plane")
>>> F.plot3D()

>>> from pyrigi import PlotStyle3D
>>> style = PlotStyle3D(vertex_color="green", edge_color="blue")
>>> F.plot3D(plot_style=style)

Use keyword arguments

>>> F.plot3D(vertex_color="red", edge_color="black", vertex_size=500)

Specify stress and its positions

>>> stress_label_positions = {(0, 2): 0.7, (1, 2): 0.2}
>>> F.plot3D(stress=0, stress_label_positions=stress_label_positions)

Specify infinitesimal flex

>>> F.plot3D(inf_flex=0)

Use both stress and infinitesimal flex

>>> F.plot3D(stress=0, inf_flex=0)

Use custom edge colors

>>> edge_colors = {'red': [(5, 1), (1, 2)], 'blue': [(2, 4), (4, 3)]}
>>> F.plot3D(edge_colors_custom=edge_colors)

The following is just to close all figures after running the example:

>>> import matplotlib.pyplot
>>> matplotlib.pyplot.close("all")

projected_realization(proj_dim=None, projection_matrix=None, random_seed=None, coordinates=None)[source]¶

Return the realization projected to a lower dimension and the projection matrix.

Parameters:

proj_dim (int) – The dimension to which the framework is projected. This is determined from projection_matrix if it is provided.
projection_matrix (MutableDenseMatrix) – The matrix used for projecting the placement of vertices. The matrix must have dimensions (proj_dim, dim), where dim is the dimension of the given framework. If None, a numerical random projection matrix is generated.
random_seed (int) – The random seed used for generating the projection matrix.
coordinates (Sequence[int]) – Indices of coordinates to which projection is applied. Providing the parameter overrides the previous ones.

Return type:

tuple[dict[Vertex, Point], MutableDenseMatrix]

Suggested Improvements

Generate random projection matrix over symbolic rationals.

realization(as_points=False, numerical=False)¶

Return a copy of the realization.

Parameters:

as_points (bool) – If True, then the vertex positions type is pyrigi.data_type.Point, otherwise Matrix (default).
numerical (bool) – If True, the vertex positions are converted to floats.

Return type:

dict[Vertex, Point] | dict[Vertex, MutableDenseMatrix]

Examples

>>> F = Framework.Complete([(0,0), (1,0), (1,1)])
>>> F.realization(as_points=True)
{0: [0, 0], 1: [1, 0], 2: [1, 1]}
>>> F.realization()
{0: Matrix([
[0],
[0]]), 1: Matrix([
[1],
[0]]), 2: Matrix([
[1],
[1]])}

rescale(factor, inplace=True)[source]¶

Scale the framework.

Parameters:

factor (Number) – Scaling factor
inplace (bool) – If True (default), then this framework is translated. Otherwise, a new translated framework is returned.

Return type:

rigidity_matrix(vertex_order=None, edge_order=None)[source]¶

Construct the rigidity matrix of the framework.

Definitions

Rigidity matrix

Parameters:

vertex_order (Sequence[Vertex]) – A list of vertices, providing the ordering for the columns of the rigidity matrix. If none is provided, the list from Graph.vertex_list() is taken.
edge_order (Sequence[Edge]) – A list of edges, providing the ordering for the rows of the rigidity matrix. If none is provided, the list from Graph.edge_list() is taken.

Return type:

MutableDenseMatrix

Examples

>>> F = Framework.Complete([(0,0),(2,0),(1,3)])
>>> F.rigidity_matrix()
Matrix([
[-2,  0, 2,  0,  0, 0],
[-1, -3, 0,  0,  1, 3],
[ 0,  0, 1, -3, -1, 3]])

rigidity_matrix_rank(numerical=False, tolerance=1e-09)[source]¶

Return the rank of the rigidity matrix.

Definitions

Rigidity matrix

Parameters:

numerical (bool) –
If True, the rank of the rigidity matrix with entries as floats is computed.

Warning: For numerical=True the numerical rank computation may produce different results than the computation over exact coordinates.
tolerance (float) – Numerical tolerance used for computing the rigidity matrix rank.

Return type:

int

Examples

>>> K4 = Framework.Complete([[0,0], [1,0], [1,1], [0,1]])
>>> K4.rigidity_matrix_rank()   # the complete graph is a circuit
5
>>> K4.delete_edge([0,1])
>>> K4.rigidity_matrix_rank()   # deleting a bar gives full rank
5
>>> K4.delete_edge([2,3])
>>> K4.rigidity_matrix_rank()   #so now deleting an edge lowers the rank
4

rotate(**kwargs)[source]¶

Alias for rotating frameworks based on rotate2D() and rotate3D().

For implementation details and possible parameters, see rotate2D() and rotate3D().

Return type:: None | Framework

rotate2D(angle, rotation_center=[0, 0], inplace=True)[source]¶

Rotate the planar framework counterclockwise.

Parameters:

angle (float) – Rotation angle. If you want the coordinates to stay symbolic even after the rotation, you need to input the angle as a sympy expression.
rotation_center (Point) – The center of rotation. By default, this is the origin.
inplace (bool) – If True (default), then this framework is rotated. Otherwise, a new rotated framework is returned.

Return type:

rotate3D(angle, axis_direction=[0, 0, 1], axis_shift=[0, 0, 0], inplace=True)[source]¶

Rotate the spatial framework counterclockwise around a specified rotation axis.

Parameters:

angle (Number) – Rotation angle around the axis of rotation. If you want the coordinates to stay symbolic even after the rotation, you need to input the angle as a sympy expression.
axis_direction (Sequence[Number]) – Direction of the rotation axis. By default, this is the z-axis.
axis_shift (Point) – A point through which the rotation axis passes. By default, this is the origin.
inplace (bool) – If True (default), then this framework is rotated. Otherwise, a new rotated framework is returned.

Return type:

set_realization(realization)¶

Change the realization of the framework.

Definitions

Realization

Parameters:: realization (dict[Vertex, Point]) – A realization of the underlying graph of the framework. It must contain all vertices from the underlying graph. Furthermore, all points in the realization need to be contained in \(\RR^d\) for \(d\) being the current dimension of the framework.
Return type:: None

Examples

>>> F = Framework.Complete([(0,0), (1,0), (1,1)])
>>> F.set_realization(
...     {vertex: (vertex, vertex + 1) for vertex in F.graph.vertex_list()}
... )
>>> print(F)
Framework in 2-dimensional space consisting of:
Graph with vertices [0, 1, 2] and edges [[0, 1], [0, 2], [1, 2]]
Realization {0:(0, 1), 1:(1, 2), 2:(2, 3)}

set_vertex_pos(vertex, point)¶

Change the coordinates of a single given vertex.

Parameters:

vertex (Vertex) – A vertex whose position is changed.
point (Point) – A new position of the vertex.

Return type:

Examples

>>> F = Framework.from_points([(0,0)])
>>> F.set_vertex_pos(0, (6,2))
>>> print(F)
Framework in 2-dimensional space consisting of:
Graph with vertices [0] and edges []
Realization {0:(6, 2)}

set_vertex_positions(subset_of_realization)¶

Change the coordinates of vertices given by a dictionary.

Parameters:: subset_of_realization (dict[Vertex, Point])
Return type:: None

Examples

>>> F = Framework.Complete([(0,0),(0,0),(1,0),(1,0)])
>>> F.realization(as_points=True)
{0: [0, 0], 1: [0, 0], 2: [1, 0], 3: [1, 0]}
>>> F.set_vertex_positions({1:(0,1),3:(1,1)})
>>> F.realization(as_points=True)
{0: [0, 0], 1: [0, 1], 2: [1, 0], 3: [1, 1]}

set_vertex_positions_from_lists(vertices, points)¶

Change the coordinates of a given list of vertices.

It is necessary that both lists have the same length. No vertex from vertices can be contained multiple times. We apply the method set_vertex_positions() to the corresponding pairs of vertices and points.

Parameters:

vertices (Sequence[Vertex])
points (Sequence[Point])

Return type:

Examples

>>> F = Framework.Complete([(0,0),(0,0),(1,0),(1,0)])
>>> F.realization(as_points=True)
{0: [0, 0], 1: [0, 0], 2: [1, 0], 3: [1, 0]}
>>> F.set_vertex_positions_from_lists([1,3], [(0,1),(1,1)])
>>> F.realization(as_points=True)
{0: [0, 0], 1: [0, 1], 2: [1, 0], 3: [1, 1]}

stress_matrix(stress, edge_order=None, vertex_order=None)[source]¶

Construct the stress matrix of a stress.

Definitions

Stress Matrix

Parameters:

stress (Stress) – A stress of the framework given as a vector.
edge_order (Sequence[Edge]) – A list of edges, providing the ordering of edges in stress. If None, Graph.edge_list() is assumed.
vertex_order (Sequence[Vertex]) – Specification of row/column order of the stress matrix. If None, Graph.vertex_list() is assumed.

Return type:

MutableDenseMatrix

Examples

>>> G = Graph([[0,1],[0,2],[0,3],[1,2],[2,3],[3,1]])
>>> pos = {0: (0, 0), 1: (0,1), 2: (-1,-1), 3: (1,-1)}
>>> F = Framework(G, pos)
>>> omega = [-8, -4, -4, 2, 2, 1]
>>> F.stress_matrix(omega)
Matrix([
[-16,  8,  4,  4],
[  8, -4, -2, -2],
[  4, -2, -1, -1],
[  4, -2, -1, -1]])

stress_matrix_rank(stress, edge_order=None, numerical=False, tolerance=1e-09)[source]¶

Return the rank of the stress matrix for a given stress.

Definitions

Parameters:

stress (Stress) – A stress of the framework given as a vector.
edge_order (Sequence[Edge]) – A list of edges, providing the ordering of edges in stress. If None, Graph.edge_list() is assumed.
numerical (bool) –
If True, the rank of the stress matrix with entries as floats is computed.

Warning: For numerical=True the numerical rank computation may produce different results than the computation over exact coordinates.
tolerance (float) – Numerical tolerance used for computing the rank.

Return type:

int

Examples

>>> F = Framework.Complete([(0, 0), (0, 1), (-1, -1), (1, -1)])
>>> omega = [-8, -4, -4, 2, 2, 1]
>>> F.is_stress(omega)
True
>>> F.stress_matrix(omega)
Matrix([
[-16,  8,  4,  4],
[  8, -4, -2, -2],
[  4, -2, -1, -1],
[  4, -2, -1, -1]])
>>> F.stress_matrix_rank(omega)
1

stresses(edge_order=None, numerical=False, tolerance=1e-09)[source]¶

Return a basis of the space of equilibrium stresses.

Definitions

Equilibrium stress

Parameters:

edge_order (Sequence[Edge]) – A list of edges, providing the ordering for the entries of the stresses. If none is provided, the list from Graph.edge_list() is taken.
numerical (bool) – Determines whether the output is symbolic (default) or numerical.
tolerance (float) – Used tolerance when computing the stresses numerically.

Return type:

list[MutableDenseMatrix] | list[list[float]]

Examples

>>> G = Graph([[0,1],[0,2],[0,3],[1,2],[2,3],[3,1]])
>>> pos = {0: (0, 0), 1: (0,1), 2: (-1,-1), 3: (1,-1)}
>>> F = Framework(G, pos)
>>> F.stresses()
[Matrix([
[-8],
[-4],
[-4],
[ 2],
[ 2],
[ 1]])]

to_tikz(vertex_style='fvertex', edge_style='edge', label_style='labelsty', figure_opts='', vertex_in_labels=False, vertex_out_labels=False, default_styles=True)[source]¶

Create a TikZ code for the framework.

The framework must have dimension 2. For using it in LaTeX you need to use the tikz package. For more examples on formatting options, see also Graph.to_tikz().

Parameters:

vertex_style (str | dict[str, Sequence[Vertex]]) – If a single style is given as a string, then all vertices get this style. If a dictionary from styles to a list of vertices is given, vertices are put in style accordingly. The vertices missing in the dictionary do not get a style.
edge_style (str | dict[str, Sequence[Edge]]) – If a single style is given as a string, then all edges get this style. If a dictionary from styles to a list of edges is given, edges are put in style accordingly. The edges missing in the dictionary do not get a style.
label_style (str) – The style for labels that are placed next to vertices.
figure_opts (str) – Options for the tikzpicture environment.
vertex_in_labels (bool) – A bool on whether vertex names should be put as labels on the vertices.
vertex_out_labels (bool) – A bool on whether vertex names should be put next to vertices.
default_styles (bool) – A bool on whether default style definitions should be put to the options.

Return type:

str

Examples

>>> G = Graph([(0, 1), (1, 2), (2, 3), (0, 3)])
>>> F=Framework(G,{0: [0, 0], 1: [1, 0], 2: [1, 1], 3: [0, 1]})
>>> print(F.to_tikz())
\begin{tikzpicture}[fvertex/.style={circle,inner sep=0pt,minimum size=3pt,fill=white,draw=black,double=white,double distance=0.25pt,outer sep=1pt},edge/.style={line width=1.5pt,black!60!white}]
    \node[fvertex] (0) at (0, 0) {};
    \node[fvertex] (1) at (1, 0) {};
    \node[fvertex] (2) at (1, 1) {};
    \node[fvertex] (3) at (0, 1) {};
    \draw[edge] (0) to (1) (0) to (3) (1) to (2) (2) to (3);
\end{tikzpicture}

>>> print(F.to_tikz(vertex_in_labels=True))
\begin{tikzpicture}[fvertex/.style={circle,inner sep=1pt,minimum size=3pt,fill=white,draw=black,double=white,double distance=0.25pt,outer sep=1pt,font=\scriptsize},edge/.style={line width=1.5pt,black!60!white}]
    \node[fvertex] (0) at (0, 0) {$0$};
    \node[fvertex] (1) at (1, 0) {$1$};
    \node[fvertex] (2) at (1, 1) {$2$};
    \node[fvertex] (3) at (0, 1) {$3$};
    \draw[edge] (0) to (1) (0) to (3) (1) to (2) (2) to (3);
\end{tikzpicture}

translate(vector, inplace=True)[source]¶

Translate the framework.

Parameters:

vector (Union[Point, MutableDenseMatrix]) – Translation vector
inplace (bool) – If True (default), then this framework is translated. Otherwise, a new translated framework is returned.

Return type: