wehub-resource-sync
1723 lines
53 KiB
Python
1723 lines
53 KiB
Python
import random
|
|
|
|
from copy import deepcopy
|
|
from typing import List
|
|
from typing import Optional
|
|
from typing import Union
|
|
|
|
import easygraph as eg
|
|
|
|
|
|
__all__ = [
|
|
"draw_SHS_center",
|
|
"draw_SHS_center_kk",
|
|
"draw_kamada_kawai",
|
|
"draw_hypergraph",
|
|
"draw_dynamic_hypergraph",
|
|
"draw_easygraph_nodes",
|
|
"draw_easygraph_edges",
|
|
"draw_louvain_com",
|
|
"draw_lpa_com",
|
|
"draw_gm_com",
|
|
"draw_ego_graph",
|
|
]
|
|
|
|
from easygraph.functions.drawing.defaults import default_hypergraph_strength
|
|
from easygraph.functions.drawing.defaults import default_hypergraph_style
|
|
from easygraph.functions.drawing.defaults import default_size
|
|
from easygraph.functions.drawing.layout import force_layout
|
|
from easygraph.functions.drawing.utils import draw_circle_edge
|
|
from easygraph.functions.drawing.utils import draw_vertex
|
|
|
|
|
|
def draw_hypergraph(
|
|
hg: "eg.Hypergraph",
|
|
e_style: str = "circle",
|
|
v_label: Optional[List[str]] = None,
|
|
v_size: Union[float, list] = 1.0,
|
|
v_color: Union[str, list] = "r",
|
|
v_line_width: Union[str, list] = 1.0,
|
|
e_color: Union[str, list] = "gray",
|
|
e_fill_color: Union[str, list] = "whitesmoke",
|
|
e_line_width: Union[str, list] = 1.0,
|
|
font_size: float = 1.0,
|
|
font_family: str = "sans-serif",
|
|
push_v_strength: float = 1.0,
|
|
push_e_strength: float = 1.0,
|
|
pull_e_strength: float = 1.0,
|
|
pull_center_strength: float = 1.0,
|
|
):
|
|
r"""Draw the hypergraph structure.
|
|
|
|
Args:
|
|
``hg`` (``eg.Hypergraph``): The EasyGraph's hypergraph object.
|
|
``e_style`` (``str``): The style of hyperedges. The available styles are only ``'circle'``. Defaults to ``'circle'``.
|
|
``v_label`` (``list``): The labels of vertices. Defaults to ``None``.
|
|
``v_size`` (``float`` or ``list``): The size of vertices. Defaults to ``1.0``.
|
|
``v_color`` (``str`` or ``list``): The `color <https://matplotlib.org/stable/gallery/color/named_colors.html>`_ of vertices. Defaults to ``'r'``.
|
|
``v_line_width`` (``float`` or ``list``): The line width of vertices. Defaults to ``1.0``.
|
|
``e_color`` (``str`` or ``list``): The `color <https://matplotlib.org/stable/gallery/color/named_colors.html>`_ of hyperedges. Defaults to ``'gray'``.
|
|
``e_fill_color`` (``str`` or ``list``): The fill `color <https://matplotlib.org/stable/gallery/color/named_colors.html>`_ of hyperedges. Defaults to ``'whitesmoke'``.
|
|
``e_line_width`` (``float`` or ``list``): The line width of hyperedges. Defaults to ``1.0``.
|
|
``font_size`` (``float``): The font size of labels. Defaults to ``1.0``.
|
|
``font_family`` (``str``): The font family of labels. Defaults to ``'sans-serif'``.
|
|
``push_v_strength`` (``float``): The strength of pushing vertices. Defaults to ``1.0``.
|
|
``push_e_strength`` (``float``): The strength of pushing hyperedges. Defaults to ``1.0``.
|
|
``pull_e_strength`` (``float``): The strength of pulling hyperedges. Defaults to ``1.0``.
|
|
``pull_center_strength`` (``float``): The strength of pulling vertices to the center. Defaults to ``1.0``.
|
|
"""
|
|
import matplotlib.pyplot as plt
|
|
|
|
assert isinstance(
|
|
hg, eg.Hypergraph
|
|
), "The input object must be a EasyGraph's hypergraph object."
|
|
assert e_style in ["circle"], "e_style must be 'circle'"
|
|
assert hg.num_e > 0, "g must be a non-empty structure"
|
|
fig, ax = plt.subplots(figsize=(6, 6))
|
|
|
|
num_v, e_list = hg.num_v, deepcopy(hg.e[0])
|
|
# default configures
|
|
v_color, e_color, e_fill_color = default_hypergraph_style(
|
|
hg.num_v, hg.num_e, v_color, e_color, e_fill_color
|
|
)
|
|
v_size, v_line_width, e_line_width, font_size = default_size(
|
|
num_v, e_list, v_size, v_line_width, e_line_width
|
|
)
|
|
(
|
|
push_v_strength,
|
|
push_e_strength,
|
|
pull_e_strength,
|
|
pull_center_strength,
|
|
) = default_hypergraph_strength(
|
|
num_v,
|
|
e_list,
|
|
push_v_strength,
|
|
push_e_strength,
|
|
pull_e_strength,
|
|
pull_center_strength,
|
|
)
|
|
# layout
|
|
v_coor = force_layout(
|
|
num_v,
|
|
e_list,
|
|
push_v_strength,
|
|
push_e_strength,
|
|
pull_e_strength,
|
|
pull_center_strength,
|
|
)
|
|
if e_style == "circle":
|
|
draw_circle_edge(
|
|
ax,
|
|
v_coor,
|
|
v_size,
|
|
e_list,
|
|
e_color,
|
|
e_fill_color,
|
|
e_line_width,
|
|
)
|
|
else:
|
|
raise ValueError("e_style must be 'circle'")
|
|
|
|
draw_vertex(
|
|
ax,
|
|
v_coor,
|
|
v_label,
|
|
font_size,
|
|
font_family,
|
|
v_size,
|
|
v_color,
|
|
e_color,
|
|
v_line_width,
|
|
)
|
|
|
|
plt.xlim((0, 1.0))
|
|
plt.ylim((0, 1.0))
|
|
plt.axis("off")
|
|
fig.tight_layout()
|
|
plt.show()
|
|
|
|
|
|
def _draw_single_dynamic_hypergraph(
|
|
hg: "eg.Hypergraph",
|
|
ax,
|
|
title_font_size=4,
|
|
group_name: str = "main",
|
|
e_style: str = "circle",
|
|
v_label: Optional[List[str]] = None,
|
|
v_size: Union[float, list] = 2.0,
|
|
v_color: Union[str, list] = "r",
|
|
v_line_width: Union[str, list] = 1.0,
|
|
e_color: Union[str, list] = "gray",
|
|
e_fill_color: Union[str, list] = "whitesmoke",
|
|
e_line_width: Union[str, list] = 1.0,
|
|
font_size: float = 1.0,
|
|
font_family: str = "sans-serif",
|
|
push_v_strength: float = 1.0,
|
|
push_e_strength: float = 1.0,
|
|
pull_e_strength: float = 1.0,
|
|
pull_center_strength: float = 1.0,
|
|
):
|
|
import matplotlib.pyplot as plt
|
|
|
|
assert isinstance(
|
|
hg, eg.Hypergraph
|
|
), "The input object must be a EasyGraph's hypergraph object."
|
|
assert e_style in ["circle"], "e_style must be 'circle'"
|
|
assert hg.num_e > 0, "g must be a non-empty structure"
|
|
|
|
num_v, e_list = hg.num_v, deepcopy(hg.e_of_group(group_name)[0])
|
|
# default configures
|
|
v_color, e_color, e_fill_color = default_hypergraph_style(
|
|
hg.num_v, hg.num_e, v_color, e_color, e_fill_color
|
|
)
|
|
v_size, v_line_width, e_line_width, font_size = default_size(
|
|
num_v, e_list, v_size, v_line_width, e_line_width, font_size
|
|
)
|
|
|
|
(
|
|
push_v_strength,
|
|
push_e_strength,
|
|
pull_e_strength,
|
|
pull_center_strength,
|
|
) = default_hypergraph_strength(
|
|
num_v,
|
|
e_list,
|
|
push_v_strength,
|
|
push_e_strength,
|
|
pull_e_strength,
|
|
pull_center_strength,
|
|
)
|
|
# layout
|
|
v_coor = force_layout(
|
|
num_v,
|
|
e_list,
|
|
push_v_strength,
|
|
push_e_strength,
|
|
pull_e_strength,
|
|
pull_center_strength,
|
|
)
|
|
if e_style == "circle":
|
|
draw_circle_edge(
|
|
ax,
|
|
v_coor,
|
|
v_size,
|
|
e_list,
|
|
e_color,
|
|
e_fill_color,
|
|
e_line_width,
|
|
)
|
|
else:
|
|
raise ValueError("e_style must be 'circle'")
|
|
|
|
draw_vertex(
|
|
ax,
|
|
v_coor,
|
|
v_label,
|
|
font_size,
|
|
font_family,
|
|
v_size,
|
|
v_color,
|
|
v_color,
|
|
v_line_width,
|
|
)
|
|
plt.title(group_name, fontsize=title_font_size)
|
|
plt.xlim((0, 1.0))
|
|
plt.ylim((0, 1.0))
|
|
plt.axis("off")
|
|
|
|
|
|
def draw_dynamic_hypergraph(
|
|
G,
|
|
group_name_list=None,
|
|
column_size=None,
|
|
save_path=None,
|
|
title_font_size=4,
|
|
e_style: str = "circle",
|
|
v_label: Optional[List[str]] = None,
|
|
v_size: Union[float, list] = 2.0,
|
|
v_color: Union[str, list] = "r",
|
|
v_line_width: Union[str, list] = 1.0,
|
|
e_color: Union[str, list] = "gray",
|
|
e_fill_color: Union[str, list] = "whitesmoke",
|
|
e_line_width: Union[str, list] = 1.0,
|
|
font_size: float = 1.0,
|
|
font_family: str = "sans-serif",
|
|
push_v_strength: float = 1.0,
|
|
push_e_strength: float = 1.0,
|
|
pull_e_strength: float = 1.0,
|
|
pull_center_strength: float = 1.0,
|
|
):
|
|
"""
|
|
|
|
Parameters
|
|
----------
|
|
G eg.Hypergraph
|
|
group_name_list The groups to visualize
|
|
column_size The number of subplots placed in each row
|
|
save_path path to save visualization
|
|
title_font_size The font size of tilte of each subplot
|
|
|
|
"""
|
|
import math
|
|
|
|
import matplotlib.pyplot as plt
|
|
|
|
# if group_name_list == None:
|
|
# group_name_list = G.group_names
|
|
COLUMN_SIZE = 3 if column_size == None else column_size
|
|
ROW_SIZE = math.ceil(len(group_name_list) / COLUMN_SIZE)
|
|
fig = plt.figure()
|
|
|
|
sub = 1
|
|
for gn in group_name_list:
|
|
if sub > len(group_name_list):
|
|
break
|
|
tmp_ax = fig.add_subplot(ROW_SIZE, COLUMN_SIZE, sub)
|
|
_draw_single_dynamic_hypergraph(
|
|
G,
|
|
ax=tmp_ax,
|
|
group_name=gn,
|
|
title_font_size=title_font_size,
|
|
e_style=e_style,
|
|
v_label=v_label,
|
|
v_size=v_size,
|
|
v_color=v_color,
|
|
v_line_width=v_line_width,
|
|
e_color=e_color,
|
|
e_fill_color=e_fill_color,
|
|
e_line_width=e_line_width,
|
|
font_size=font_size,
|
|
font_family=font_family,
|
|
push_v_strength=push_v_strength,
|
|
push_e_strength=push_e_strength,
|
|
pull_e_strength=pull_e_strength,
|
|
pull_center_strength=pull_center_strength,
|
|
)
|
|
sub += 1
|
|
fig.tight_layout()
|
|
if save_path is not None:
|
|
plt.savefig(save_path)
|
|
plt.show()
|
|
|
|
|
|
def draw_easygraph_nodes(
|
|
G,
|
|
pos,
|
|
nodelist=None,
|
|
node_size=300,
|
|
node_color="#1f78b4",
|
|
node_shape="o",
|
|
alpha=None,
|
|
cmap=None,
|
|
vmin=None,
|
|
vmax=None,
|
|
ax=None,
|
|
linewidths=None,
|
|
edgecolors=None,
|
|
label=None,
|
|
margins=None,
|
|
):
|
|
"""Draw the nodes of the graph G.
|
|
|
|
This draws only the nodes of the graph G.
|
|
|
|
Parameters
|
|
----------
|
|
G : graph
|
|
A EasyGraph graph
|
|
|
|
pos : dictionary
|
|
A dictionary with nodes as keys and positions as values.
|
|
Positions should be sequences of length 2.
|
|
|
|
ax : Matplotlib Axes object, optional
|
|
Draw the graph in the specified Matplotlib axes.
|
|
|
|
nodelist : list (default list(G))
|
|
Draw only specified nodes
|
|
|
|
node_size : scalar or array (default=300)
|
|
Size of nodes. If an array it must be the same length as nodelist.
|
|
|
|
node_color : color or array of colors (default='#1f78b4')
|
|
Node color. Can be a single color or a sequence of colors with the same
|
|
length as nodelist. Color can be string or rgb (or rgba) tuple of
|
|
floats from 0-1. If numeric values are specified they will be
|
|
mapped to colors using the cmap and vmin,vmax parameters. See
|
|
matplotlib.scatter for more details.
|
|
|
|
node_shape : string (default='o')
|
|
The shape of the node. Specification is as matplotlib.scatter
|
|
marker, one of 'so^>v<dph8'.
|
|
|
|
alpha : float or array of floats (default=None)
|
|
The node transparency. This can be a single alpha value,
|
|
in which case it will be applied to all the nodes of color. Otherwise,
|
|
if it is an array, the elements of alpha will be applied to the colors
|
|
in order (cycling through alpha multiple times if necessary).
|
|
|
|
cmap : Matplotlib colormap (default=None)
|
|
Colormap for mapping intensities of nodes
|
|
|
|
vmin,vmax : floats or None (default=None)
|
|
Minimum and maximum for node colormap scaling
|
|
|
|
linewidths : [None | scalar | sequence] (default=1.0)
|
|
Line width of symbol border
|
|
|
|
edgecolors : [None | scalar | sequence] (default = node_color)
|
|
Colors of node borders. Can be a single color or a sequence of colors with the
|
|
same length as nodelist. Color can be string or rgb (or rgba) tuple of floats
|
|
from 0-1. If numeric values are specified they will be mapped to colors
|
|
using the cmap and vmin,vmax parameters. See `~matplotlib.pyplot.scatter` for more details.
|
|
|
|
label : [None | string]
|
|
Label for legend
|
|
|
|
margins : float or 2-tuple, optional
|
|
Sets the padding for axis autoscaling. Increase margin to prevent
|
|
clipping for nodes that are near the edges of an image. Values should
|
|
be in the range ``[0, 1]``. See :meth:`matplotlib.axes.Axes.margins`
|
|
for details. The default is `None`, which uses the Matplotlib default.
|
|
|
|
Returns
|
|
-------
|
|
matplotlib.collections.PathCollection
|
|
`PathCollection` of the nodes.
|
|
|
|
Examples
|
|
--------
|
|
>>> G = eg.dodecahedral_graph()
|
|
>>> nodes = eg.draw_easygraph_nodes(G, pos=eg.spring_layout(G))
|
|
|
|
|
|
|
|
"""
|
|
from collections.abc import Iterable
|
|
|
|
import matplotlib as mpl
|
|
import matplotlib.collections # call as mpl.collections
|
|
import matplotlib.pyplot as plt
|
|
import numpy as np
|
|
|
|
if ax is None:
|
|
ax = plt.gca()
|
|
|
|
if nodelist is None:
|
|
nodelist = list(G)
|
|
|
|
if len(nodelist) == 0: # empty nodelist, no drawing
|
|
return mpl.collections.PathCollection(None)
|
|
|
|
try:
|
|
xy = np.asarray([pos[v] for v in nodelist])
|
|
except KeyError as err:
|
|
raise eg.EasygraphError(f"Node {err} has no position.") from err
|
|
|
|
if isinstance(alpha, Iterable):
|
|
node_color = apply_alpha(node_color, alpha, nodelist, cmap, vmin, vmax)
|
|
alpha = None
|
|
|
|
node_collection = ax.scatter(
|
|
xy[:, 0],
|
|
xy[:, 1],
|
|
s=node_size,
|
|
c=node_color,
|
|
marker=node_shape,
|
|
cmap=cmap,
|
|
vmin=vmin,
|
|
vmax=vmax,
|
|
alpha=alpha,
|
|
linewidths=linewidths,
|
|
edgecolors=edgecolors,
|
|
label=label,
|
|
)
|
|
ax.tick_params(
|
|
axis="both",
|
|
which="both",
|
|
bottom=False,
|
|
left=False,
|
|
labelbottom=False,
|
|
labelleft=False,
|
|
)
|
|
|
|
if margins is not None:
|
|
if isinstance(margins, Iterable):
|
|
ax.margins(*margins)
|
|
else:
|
|
ax.margins(margins)
|
|
|
|
node_collection.set_zorder(2)
|
|
return node_collection
|
|
|
|
|
|
def draw_easygraph_edges(
|
|
G,
|
|
pos,
|
|
edgelist=None,
|
|
width=1.0,
|
|
edge_color="k",
|
|
style="solid",
|
|
alpha=None,
|
|
arrowstyle=None,
|
|
arrowsize=10,
|
|
edge_cmap=None,
|
|
edge_vmin=None,
|
|
edge_vmax=None,
|
|
ax=None,
|
|
arrows=None,
|
|
label=None,
|
|
node_size=300,
|
|
nodelist=None,
|
|
node_shape="o",
|
|
connectionstyle="arc3",
|
|
min_source_margin=0,
|
|
min_target_margin=0,
|
|
):
|
|
r"""Draw the edges of the graph G.
|
|
|
|
This draws only the edges of the graph G.
|
|
|
|
Parameters
|
|
----------
|
|
G : graph
|
|
A easygraph graph
|
|
|
|
pos : dictionary
|
|
A dictionary with nodes as keys and positions as values.
|
|
Positions should be sequences of length 2.
|
|
|
|
edgelist : collection of edge tuples (default=G.edges())
|
|
Draw only specified edges
|
|
|
|
width : float or array of floats (default=1.0)
|
|
Line width of edges
|
|
|
|
edge_color : color or array of colors (default='k')
|
|
Edge color. Can be a single color or a sequence of colors with the same
|
|
length as edgelist. Color can be string or rgb (or rgba) tuple of
|
|
floats from 0-1. If numeric values are specified they will be
|
|
mapped to colors using the edge_cmap and edge_vmin,edge_vmax parameters.
|
|
|
|
style : string or array of strings (default='solid')
|
|
Edge line style e.g.: '-', '--', '-.', ':'
|
|
or words like 'solid' or 'dashed'.
|
|
Can be a single style or a sequence of styles with the same
|
|
length as the edge list.
|
|
If less styles than edges are given the styles will cycle.
|
|
If more styles than edges are given the styles will be used sequentially
|
|
and not be exhausted.
|
|
Also, `(offset, onoffseq)` tuples can be used as style instead of a strings.
|
|
(See `matplotlib.patches.FancyArrowPatch`: `linestyle`)
|
|
|
|
alpha : float or array of floats (default=None)
|
|
The edge transparency. This can be a single alpha value,
|
|
in which case it will be applied to all specified edges. Otherwise,
|
|
if it is an array, the elements of alpha will be applied to the colors
|
|
in order (cycling through alpha multiple times if necessary).
|
|
|
|
edge_cmap : Matplotlib colormap, optional
|
|
Colormap for mapping intensities of edges
|
|
|
|
edge_vmin,edge_vmax : floats, optional
|
|
Minimum and maximum for edge colormap scaling
|
|
|
|
ax : Matplotlib Axes object, optional
|
|
Draw the graph in the specified Matplotlib axes.
|
|
|
|
arrows : bool or None, optional (default=None)
|
|
If `None`, directed graphs draw arrowheads with
|
|
`~matplotlib.patches.FancyArrowPatch`, while undirected graphs draw edges
|
|
via `~matplotlib.collections.LineCollection` for speed.
|
|
If `True`, draw arrowheads with FancyArrowPatches (bendable and stylish).
|
|
If `False`, draw edges using LineCollection (linear and fast).
|
|
|
|
Note: Arrowheads will be the same color as edges.
|
|
|
|
arrowstyle : str (default='-\|>' for directed graphs)
|
|
For directed graphs and `arrows==True` defaults to '-\|>',
|
|
For undirected graphs default to '-'.
|
|
|
|
See `matplotlib.patches.ArrowStyle` for more options.
|
|
|
|
arrowsize : int (default=10)
|
|
For directed graphs, choose the size of the arrow head's length and
|
|
width. See `matplotlib.patches.FancyArrowPatch` for attribute
|
|
`mutation_scale` for more info.
|
|
|
|
connectionstyle : string (default="arc3")
|
|
Pass the connectionstyle parameter to create curved arc of rounding
|
|
radius rad. For example, connectionstyle='arc3,rad=0.2'.
|
|
See `matplotlib.patches.ConnectionStyle` and
|
|
`matplotlib.patches.FancyArrowPatch` for more info.
|
|
|
|
node_size : scalar or array (default=300)
|
|
Size of nodes. Though the nodes are not drawn with this function, the
|
|
node size is used in determining edge positioning.
|
|
|
|
nodelist : list, optional (default=G.nodes())
|
|
This provides the node order for the `node_size` array (if it is an array).
|
|
|
|
node_shape : string (default='o')
|
|
The marker used for nodes, used in determining edge positioning.
|
|
Specification is as a `matplotlib.markers` marker, e.g. one of 'so^>v<dph8'.
|
|
|
|
label : None or string
|
|
Label for legend
|
|
|
|
min_source_margin : int (default=0)
|
|
The minimum margin (gap) at the beginning of the edge at the source.
|
|
|
|
min_target_margin : int (default=0)
|
|
The minimum margin (gap) at the end of the edge at the target.
|
|
|
|
Returns
|
|
-------
|
|
matplotlib.collections.LineCollection or a list of matplotlib.patches.FancyArrowPatch
|
|
If ``arrows=True``, a list of FancyArrowPatches is returned.
|
|
If ``arrows=False``, a LineCollection is returned.
|
|
If ``arrows=None`` (the default), then a LineCollection is returned if
|
|
`G` is undirected, otherwise returns a list of FancyArrowPatches.
|
|
|
|
Notes
|
|
-----
|
|
For directed graphs, arrows are drawn at the head end. Arrows can be
|
|
turned off with keyword arrows=False or by passing an arrowstyle without
|
|
an arrow on the end.
|
|
|
|
Be sure to include `node_size` as a keyword argument; arrows are
|
|
drawn considering the size of nodes.
|
|
|
|
Self-loops are always drawn with `~matplotlib.patches.FancyArrowPatch`
|
|
regardless of the value of `arrows` or whether `G` is directed.
|
|
When ``arrows=False`` or ``arrows=None`` and `G` is undirected, the
|
|
FancyArrowPatches corresponding to the self-loops are not explicitly
|
|
returned. They should instead be accessed via the ``Axes.patches``
|
|
attribute (see examples).
|
|
|
|
"""
|
|
import matplotlib as mpl
|
|
import matplotlib.collections # call as mpl.collections
|
|
import matplotlib.colors # call as mpl.colors
|
|
import matplotlib.patches # call as mpl.patches
|
|
import matplotlib.path # call as mpl.path
|
|
import matplotlib.pyplot as plt
|
|
import numpy as np
|
|
|
|
# The default behavior is to use LineCollection to draw edges for
|
|
# undirected graphs (for performance reasons) and use FancyArrowPatches
|
|
# for directed graphs.
|
|
# The `arrows` keyword can be used to override the default behavior
|
|
use_linecollection = not G.is_directed()
|
|
if arrows in (True, False):
|
|
use_linecollection = not arrows
|
|
|
|
# Some kwargs only apply to FancyArrowPatches. Warn users when they use
|
|
# non-default values for these kwargs when LineCollection is being used
|
|
# instead of silently ignoring the specified option
|
|
if use_linecollection and any(
|
|
[
|
|
arrowstyle is not None,
|
|
arrowsize != 10,
|
|
connectionstyle != "arc3",
|
|
min_source_margin != 0,
|
|
min_target_margin != 0,
|
|
]
|
|
):
|
|
import warnings
|
|
|
|
msg = (
|
|
"\n\nThe {0} keyword argument is not applicable when drawing edges\n"
|
|
"with LineCollection.\n\n"
|
|
"To make this warning go away, either specify `arrows=True` to\n"
|
|
"force FancyArrowPatches or use the default value for {0}.\n"
|
|
"Note that using FancyArrowPatches may be slow for large graphs.\n"
|
|
)
|
|
if arrowstyle is not None:
|
|
msg = msg.format("arrowstyle")
|
|
if arrowsize != 10:
|
|
msg = msg.format("arrowsize")
|
|
if connectionstyle != "arc3":
|
|
msg = msg.format("connectionstyle")
|
|
if min_source_margin != 0:
|
|
msg = msg.format("min_source_margin")
|
|
if min_target_margin != 0:
|
|
msg = msg.format("min_target_margin")
|
|
warnings.warn(msg, category=UserWarning, stacklevel=2)
|
|
|
|
if arrowstyle == None:
|
|
if G.is_directed():
|
|
arrowstyle = "-|>"
|
|
else:
|
|
arrowstyle = "-"
|
|
|
|
if ax is None:
|
|
ax = plt.gca()
|
|
|
|
if edgelist is None:
|
|
edgelist = list(G.edges)
|
|
|
|
if len(edgelist) == 0: # no edges!
|
|
return []
|
|
|
|
if nodelist is None:
|
|
nodelist = list(G.nodes)
|
|
|
|
# FancyArrowPatch handles color=None different from LineCollection
|
|
if edge_color is None:
|
|
edge_color = "k"
|
|
edgelist_tuple = list(map(tuple, edgelist))
|
|
|
|
# set edge positions
|
|
edge_pos = np.asarray([(pos[e[0]], pos[e[1]]) for e in edgelist])
|
|
|
|
# Check if edge_color is an array of floats and map to edge_cmap.
|
|
# This is the only case handled differently from matplotlib
|
|
if (
|
|
np.iterable(edge_color)
|
|
and (len(edge_color) == len(edge_pos))
|
|
and np.all([isinstance(c, Number) for c in edge_color])
|
|
):
|
|
if edge_cmap is not None:
|
|
assert isinstance(edge_cmap, mpl.colors.Colormap)
|
|
else:
|
|
edge_cmap = plt.get_cmap()
|
|
if edge_vmin is None:
|
|
edge_vmin = min(edge_color)
|
|
if edge_vmax is None:
|
|
edge_vmax = max(edge_color)
|
|
color_normal = mpl.colors.Normalize(vmin=edge_vmin, vmax=edge_vmax)
|
|
edge_color = [edge_cmap(color_normal(e)) for e in edge_color]
|
|
|
|
def _draw_networkx_edges_line_collection():
|
|
edge_collection = mpl.collections.LineCollection(
|
|
edge_pos,
|
|
colors=edge_color,
|
|
linewidths=width,
|
|
antialiaseds=(1,),
|
|
linestyle=style,
|
|
alpha=alpha,
|
|
)
|
|
edge_collection.set_cmap(edge_cmap)
|
|
edge_collection.set_clim(edge_vmin, edge_vmax)
|
|
edge_collection.set_zorder(1) # edges go behind nodes
|
|
edge_collection.set_label(label)
|
|
ax.add_collection(edge_collection)
|
|
|
|
return edge_collection
|
|
|
|
def _draw_networkx_edges_fancy_arrow_patch():
|
|
# Note: Waiting for someone to implement arrow to intersection with
|
|
# marker. Meanwhile, this works well for polygons with more than 4
|
|
# sides and circle.
|
|
|
|
def to_marker_edge(marker_size, marker):
|
|
if marker in "s^>v<d": # `large` markers need extra space
|
|
return np.sqrt(2 * marker_size) / 2
|
|
else:
|
|
return np.sqrt(marker_size) / 2
|
|
|
|
# Draw arrows with `matplotlib.patches.FancyarrowPatch`
|
|
arrow_collection = []
|
|
|
|
if isinstance(arrowsize, list):
|
|
if len(arrowsize) != len(edge_pos):
|
|
raise ValueError("arrowsize should have the same length as edgelist")
|
|
else:
|
|
mutation_scale = arrowsize # scale factor of arrow head
|
|
|
|
base_connection_style = mpl.patches.ConnectionStyle(connectionstyle)
|
|
|
|
# Fallback for self-loop scale. Left outside of _connectionstyle so it is
|
|
# only computed once
|
|
max_nodesize = np.array(node_size).max()
|
|
|
|
def _connectionstyle(posA, posB, *args, **kwargs):
|
|
# check if we need to do a self-loop
|
|
if np.all(posA == posB):
|
|
# Self-loops are scaled by view extent, except in cases the extent
|
|
# is 0, e.g. for a single node. In this case, fall back to scaling
|
|
# by the maximum node size
|
|
selfloop_ht = 0.005 * max_nodesize if h == 0 else h
|
|
# this is called with _screen space_ values so convert back
|
|
# to data space
|
|
data_loc = ax.transData.inverted().transform(posA)
|
|
v_shift = 0.1 * selfloop_ht
|
|
h_shift = v_shift * 0.5
|
|
# put the top of the loop first so arrow is not hidden by node
|
|
path = [
|
|
# 1
|
|
data_loc + np.asarray([0, v_shift]),
|
|
# 4 4 4
|
|
data_loc + np.asarray([h_shift, v_shift]),
|
|
data_loc + np.asarray([h_shift, 0]),
|
|
data_loc,
|
|
# 4 4 4
|
|
data_loc + np.asarray([-h_shift, 0]),
|
|
data_loc + np.asarray([-h_shift, v_shift]),
|
|
data_loc + np.asarray([0, v_shift]),
|
|
]
|
|
|
|
ret = mpl.path.Path(ax.transData.transform(path), [1, 4, 4, 4, 4, 4, 4])
|
|
# if not, fall back to the user specified behavior
|
|
else:
|
|
ret = base_connection_style(posA, posB, *args, **kwargs)
|
|
|
|
return ret
|
|
|
|
# FancyArrowPatch doesn't handle color strings
|
|
arrow_colors = mpl.colors.colorConverter.to_rgba_array(edge_color, alpha)
|
|
for i, (src, dst) in zip(fancy_edges_indices, edge_pos):
|
|
x1, y1 = src
|
|
x2, y2 = dst
|
|
shrink_source = 0 # space from source to tail
|
|
shrink_target = 0 # space from head to target
|
|
|
|
if isinstance(arrowsize, list):
|
|
# Scale each factor of each arrow based on arrowsize list
|
|
mutation_scale = arrowsize[i]
|
|
|
|
if np.iterable(node_size): # many node sizes
|
|
source, target = edgelist[i][:2]
|
|
source_node_size = node_size[nodelist.index(source)]
|
|
target_node_size = node_size[nodelist.index(target)]
|
|
shrink_source = to_marker_edge(source_node_size, node_shape)
|
|
shrink_target = to_marker_edge(target_node_size, node_shape)
|
|
else:
|
|
shrink_source = shrink_target = to_marker_edge(node_size, node_shape)
|
|
|
|
if shrink_source < min_source_margin:
|
|
shrink_source = min_source_margin
|
|
|
|
if shrink_target < min_target_margin:
|
|
shrink_target = min_target_margin
|
|
|
|
if len(arrow_colors) > i:
|
|
arrow_color = arrow_colors[i]
|
|
elif len(arrow_colors) == 1:
|
|
arrow_color = arrow_colors[0]
|
|
else: # Cycle through colors
|
|
arrow_color = arrow_colors[i % len(arrow_colors)]
|
|
|
|
if np.iterable(width):
|
|
if len(width) > i:
|
|
line_width = width[i]
|
|
else:
|
|
line_width = width[i % len(width)]
|
|
else:
|
|
line_width = width
|
|
|
|
if (
|
|
np.iterable(style)
|
|
and not isinstance(style, str)
|
|
and not isinstance(style, tuple)
|
|
):
|
|
if len(style) > i:
|
|
linestyle = style[i]
|
|
else: # Cycle through styles
|
|
linestyle = style[i % len(style)]
|
|
else:
|
|
linestyle = style
|
|
|
|
arrow = mpl.patches.FancyArrowPatch(
|
|
(x1, y1),
|
|
(x2, y2),
|
|
arrowstyle=arrowstyle,
|
|
shrinkA=shrink_source,
|
|
shrinkB=shrink_target,
|
|
mutation_scale=mutation_scale,
|
|
color=arrow_color,
|
|
linewidth=line_width,
|
|
connectionstyle=_connectionstyle,
|
|
linestyle=linestyle,
|
|
zorder=1,
|
|
) # arrows go behind nodes
|
|
|
|
arrow_collection.append(arrow)
|
|
ax.add_patch(arrow)
|
|
|
|
return arrow_collection
|
|
|
|
# compute initial view
|
|
minx = np.amin(np.ravel(edge_pos[:, :, 0]))
|
|
maxx = np.amax(np.ravel(edge_pos[:, :, 0]))
|
|
miny = np.amin(np.ravel(edge_pos[:, :, 1]))
|
|
maxy = np.amax(np.ravel(edge_pos[:, :, 1]))
|
|
w = maxx - minx
|
|
h = maxy - miny
|
|
|
|
# Draw the edges
|
|
if use_linecollection:
|
|
edge_viz_obj = _draw_networkx_edges_line_collection()
|
|
# Make sure selfloop edges are also drawn
|
|
selfloops_to_draw = [loop for loop in eg.selfloop_edges(G) if loop in edgelist]
|
|
if selfloops_to_draw:
|
|
fancy_edges_indices = [
|
|
edgelist_tuple.index(loop) for loop in selfloops_to_draw
|
|
]
|
|
edge_pos = np.asarray([(pos[e[0]], pos[e[1]]) for e in selfloops_to_draw])
|
|
arrowstyle = "-"
|
|
_draw_networkx_edges_fancy_arrow_patch()
|
|
else:
|
|
fancy_edges_indices = range(len(edgelist))
|
|
edge_viz_obj = _draw_networkx_edges_fancy_arrow_patch()
|
|
|
|
# update view after drawing
|
|
padx, pady = 0.05 * w, 0.05 * h
|
|
corners = (minx - padx, miny - pady), (maxx + padx, maxy + pady)
|
|
ax.update_datalim(corners)
|
|
ax.autoscale_view()
|
|
|
|
ax.tick_params(
|
|
axis="both",
|
|
which="both",
|
|
bottom=False,
|
|
left=False,
|
|
labelbottom=False,
|
|
labelleft=False,
|
|
)
|
|
|
|
return edge_viz_obj
|
|
|
|
|
|
def draw_SHS_center(G, SHS, rate=1, style="center"):
|
|
"""
|
|
Draw the graph whose the SH Spanners are in the center, with random layout.
|
|
|
|
Parameters
|
|
----------
|
|
G : graph
|
|
A easygraph graph.
|
|
|
|
SHS : list
|
|
The SH Spanners in graph G.
|
|
|
|
rate : float
|
|
The proportion of visible points and edges to the total
|
|
|
|
style : string
|
|
"side"- the label is next to the dot
|
|
"center"- the label is in the center of the dot
|
|
|
|
Returns
|
|
-------
|
|
graph : network
|
|
the graph whose the SH Spanners are in the center.
|
|
"""
|
|
import matplotlib.pyplot as plt
|
|
import numpy as np
|
|
|
|
plt.figure(figsize=(8, 8))
|
|
pos = eg.random_position(G)
|
|
center = np.zeros((len(SHS), 2), float)
|
|
node = np.zeros((len(pos) - len(SHS), 2), float)
|
|
m, n = 0, 0
|
|
if rate == 1:
|
|
for i in pos:
|
|
if i in SHS:
|
|
center[n][0] = 0.5 + (-1) ** random.randint(1, 2) * pos[i][0] / 5
|
|
center[n][1] = 0.5 + (-1) ** random.randint(1, 2) * pos[i][1] / 5
|
|
pos[i][0] = center[n][0]
|
|
pos[i][1] = center[n][1]
|
|
n += 1
|
|
else:
|
|
node[m][0] = pos[i][0]
|
|
node[m][1] = pos[i][1]
|
|
m += 1
|
|
if style == "side":
|
|
plt.scatter(node[:, 0], node[:, 1], marker=".", color="b", s=10)
|
|
plt.scatter(center[:, 0], center[:, 1], marker="*", color="r", s=20)
|
|
elif style == "center":
|
|
plt.scatter(
|
|
node[:, 0],
|
|
node[:, 1],
|
|
marker="o",
|
|
color="skyblue",
|
|
edgecolors="skyblue",
|
|
s=300,
|
|
linewidth=0.5,
|
|
)
|
|
plt.scatter(
|
|
center[:, 0],
|
|
center[:, 1],
|
|
marker="o",
|
|
color="tomato",
|
|
edgecolors="tomato",
|
|
s=500,
|
|
linewidth=0.5,
|
|
zorder=2,
|
|
)
|
|
k = 0
|
|
for i in pos:
|
|
if style == "side":
|
|
plt.text(
|
|
pos[i][0],
|
|
pos[i][1],
|
|
i,
|
|
fontsize=5,
|
|
verticalalignment="top",
|
|
horizontalalignment="right",
|
|
)
|
|
elif style == "center":
|
|
plt.text(
|
|
pos[i][0],
|
|
pos[i][1],
|
|
i,
|
|
fontsize=10,
|
|
verticalalignment="center",
|
|
horizontalalignment="center",
|
|
)
|
|
k += 1
|
|
for i in G.edges:
|
|
p1 = [pos[i[0]][0], pos[i[1]][0]]
|
|
p2 = [pos[i[0]][1], pos[i[1]][1]]
|
|
plt.plot(
|
|
p1,
|
|
p2,
|
|
color="skyblue",
|
|
linestyle="-",
|
|
alpha=0.3,
|
|
linewidth=1.8,
|
|
zorder=1,
|
|
)
|
|
plt.show()
|
|
|
|
else:
|
|
degree = G.degree()
|
|
sorted_degree = sorted(degree.items(), key=lambda d: d[1], reverse=True)
|
|
l = int(rate * len(G))
|
|
s = []
|
|
for i in sorted_degree:
|
|
if len(s) < l:
|
|
s.append(i[0])
|
|
for i in pos:
|
|
if i in SHS and i in s:
|
|
center[n][0] = 0.5 + (-1) ** random.randint(1, 2) * pos[i][0] / 5
|
|
center[n][1] = 0.5 + (-1) ** random.randint(1, 2) * pos[i][1] / 5
|
|
pos[i][0] = center[n][0]
|
|
pos[i][1] = center[n][1]
|
|
n += 1
|
|
elif i in s:
|
|
node[m][0] = pos[i][0]
|
|
node[m][1] = pos[i][1]
|
|
m += 1
|
|
node = node[0:m, :]
|
|
center = center[0:n, :]
|
|
if style == "side":
|
|
plt.scatter(node[:, 0], node[:, 1], marker=".", color="b", s=10)
|
|
plt.scatter(center[:, 0], center[:, 1], marker="*", color="r", s=20)
|
|
elif style == "center":
|
|
plt.scatter(
|
|
node[:, 0],
|
|
node[:, 1],
|
|
marker="o",
|
|
color="None",
|
|
edgecolors="b",
|
|
s=50,
|
|
linewidth=0.5,
|
|
)
|
|
plt.scatter(
|
|
center[:, 0],
|
|
center[:, 1],
|
|
marker="o",
|
|
color="None",
|
|
edgecolors="r",
|
|
s=50,
|
|
linewidth=0.5,
|
|
)
|
|
k = 0
|
|
for i in pos:
|
|
if i in s:
|
|
if style == "side":
|
|
plt.text(
|
|
pos[i][0],
|
|
pos[i][1],
|
|
i,
|
|
fontsize=5,
|
|
verticalalignment="top",
|
|
horizontalalignment="right",
|
|
)
|
|
elif style == "center":
|
|
plt.text(
|
|
pos[i][0],
|
|
pos[i][1],
|
|
i,
|
|
fontsize=5,
|
|
verticalalignment="center",
|
|
horizontalalignment="center",
|
|
)
|
|
k += 1
|
|
for i in G.edges:
|
|
(u, v, t) = i
|
|
if u in s and v in s:
|
|
p1 = [pos[i[0]][0], pos[i[1]][0]]
|
|
p2 = [pos[i[0]][1], pos[i[1]][1]]
|
|
plt.plot(p1, p2, color="skyblue", linestyle="-", alpha=0.3, linewidth=3)
|
|
plt.show()
|
|
return
|
|
|
|
|
|
def draw_SHS_center_kk(G, SHS, rate=1, style="center"):
|
|
"""
|
|
Draw the graph whose the SH Spanners are in the center, with a Kamada-Kawai force-directed layout.
|
|
|
|
Parameters
|
|
----------
|
|
G : graph
|
|
A easygraph graph.
|
|
|
|
SHS : list
|
|
The SH Spanners in graph G.
|
|
|
|
rate : float
|
|
The proportion of visible points and edges to the total
|
|
|
|
style : string
|
|
"side"- the label is next to the dot
|
|
"center"- the label is in the center of the dot
|
|
|
|
Returns
|
|
-------
|
|
graph : network
|
|
the graph whose the SH Spanners are in the center.
|
|
"""
|
|
import matplotlib.pyplot as plt
|
|
import numpy as np
|
|
|
|
pos = eg.kamada_kawai_layout(G)
|
|
center = np.zeros((len(SHS), 2), float)
|
|
node = np.zeros((len(pos) - len(SHS), 2), float)
|
|
m, n = 0, 0
|
|
if rate == 1:
|
|
for i in pos:
|
|
if i in SHS:
|
|
center[n][0] = pos[i][0] / 5
|
|
center[n][1] = pos[i][1] / 5
|
|
pos[i][0] = center[n][0]
|
|
pos[i][1] = center[n][1]
|
|
n += 1
|
|
else:
|
|
node[m][0] = pos[i][0]
|
|
node[m][1] = pos[i][1]
|
|
m += 1
|
|
if style == "side":
|
|
plt.scatter(node[:, 0], node[:, 1], marker=".", color="b", s=50)
|
|
plt.scatter(center[:, 0], center[:, 1], marker="*", color="r", s=100)
|
|
elif style == "center":
|
|
plt.scatter(
|
|
node[:, 0],
|
|
node[:, 1],
|
|
marker="o",
|
|
color="skyblue",
|
|
edgecolors="skyblue",
|
|
s=300,
|
|
linewidth=0.5,
|
|
)
|
|
plt.scatter(
|
|
center[:, 0],
|
|
center[:, 1],
|
|
marker="o",
|
|
color="skyblue",
|
|
edgecolors="skyblue",
|
|
s=300,
|
|
linewidth=0.5,
|
|
)
|
|
plt.scatter(
|
|
center[:, 0],
|
|
center[:, 1],
|
|
marker="*",
|
|
color="None",
|
|
edgecolors="r",
|
|
s=1000,
|
|
linewidth=2,
|
|
)
|
|
k = 0
|
|
for i in pos:
|
|
if style == "side":
|
|
plt.text(
|
|
pos[i][0],
|
|
pos[i][1],
|
|
i,
|
|
fontsize=5,
|
|
verticalalignment="top",
|
|
horizontalalignment="right",
|
|
)
|
|
elif style == "center":
|
|
plt.text(
|
|
pos[i][0],
|
|
pos[i][1],
|
|
i,
|
|
fontsize=10,
|
|
verticalalignment="center",
|
|
horizontalalignment="center",
|
|
)
|
|
k += 1
|
|
for i in G.edges:
|
|
p1 = [pos[i[0]][0], pos[i[1]][0]]
|
|
p2 = [pos[i[0]][1], pos[i[1]][1]]
|
|
plt.plot(p1, p2, color="skyblue", linestyle="-", alpha=0.3, linewidth=3)
|
|
plt.show()
|
|
else:
|
|
degree = G.degree()
|
|
sorted_degree = sorted(degree.items(), key=lambda d: d[1], reverse=True)
|
|
l = int(rate * len(G))
|
|
s = []
|
|
for i in sorted_degree:
|
|
if len(s) < l:
|
|
s.append(i[0])
|
|
for i in pos:
|
|
if i in SHS and i in s:
|
|
center[n][0] = pos[i][0] / 5
|
|
center[n][1] = pos[i][1] / 5
|
|
pos[i][0] = center[n][0]
|
|
pos[i][1] = center[n][1]
|
|
n += 1
|
|
elif i in s:
|
|
node[m][0] = pos[i][0]
|
|
node[m][1] = pos[i][1]
|
|
m += 1
|
|
node = node[0:m, :]
|
|
center = center[0:n, :]
|
|
if style == "side":
|
|
plt.scatter(node[:, 0], node[:, 1], marker=".", color="b", s=10)
|
|
plt.scatter(center[:, 0], center[:, 1], marker="*", color="r", s=20)
|
|
elif style == "center":
|
|
plt.scatter(
|
|
node[:, 0],
|
|
node[:, 1],
|
|
marker="o",
|
|
color="None",
|
|
edgecolors="b",
|
|
s=50,
|
|
linewidth=0.5,
|
|
)
|
|
plt.scatter(
|
|
center[:, 0],
|
|
center[:, 1],
|
|
marker="o",
|
|
color="None",
|
|
edgecolors="r",
|
|
s=50,
|
|
linewidth=0.5,
|
|
)
|
|
k = 0
|
|
for i in pos:
|
|
if i in s:
|
|
if style == "side":
|
|
plt.text(
|
|
pos[i][0],
|
|
pos[i][1],
|
|
i,
|
|
fontsize=5,
|
|
verticalalignment="top",
|
|
horizontalalignment="right",
|
|
)
|
|
elif style == "center":
|
|
plt.text(
|
|
pos[i][0],
|
|
pos[i][1],
|
|
i,
|
|
fontsize=5,
|
|
verticalalignment="center",
|
|
horizontalalignment="center",
|
|
)
|
|
k += 1
|
|
for i in G.edges:
|
|
(u, v, t) = i
|
|
if u in s and v in s:
|
|
p1 = [pos[i[0]][0], pos[i[1]][0]]
|
|
p2 = [pos[i[0]][1], pos[i[1]][1]]
|
|
plt.plot(p1, p2, color="skyblue", linestyle="-", alpha=0.3, linewidth=3)
|
|
plt.show()
|
|
return
|
|
|
|
|
|
def draw_kamada_kawai(G, rate=1, style="side"):
|
|
"""Draw the graph G with a Kamada-Kawai force-directed layout.
|
|
|
|
Parameters
|
|
----------
|
|
G : graph
|
|
A easygraph graph
|
|
|
|
rate : float
|
|
The proportion of visible points and edges to the total
|
|
|
|
style : string
|
|
"side"- the label is next to the dot
|
|
"center"- the label is in the center of the dot
|
|
|
|
"""
|
|
import matplotlib.pyplot as plt
|
|
import numpy as np
|
|
|
|
pos = eg.kamada_kawai_layout(G)
|
|
node = np.zeros((len(pos), 2), float)
|
|
m, n = 0, 0
|
|
if rate == 1:
|
|
for i in pos:
|
|
node[m][0] = pos[i][0]
|
|
node[m][1] = pos[i][1]
|
|
m += 1
|
|
if style == "side":
|
|
plt.scatter(node[:, 0], node[:, 1], marker=".", color="b", s=10)
|
|
elif style == "center":
|
|
plt.scatter(
|
|
node[:, 0],
|
|
node[:, 1],
|
|
marker="o",
|
|
color="None",
|
|
edgecolors="b",
|
|
s=50,
|
|
linewidth=0.5,
|
|
)
|
|
k = 0
|
|
for i in pos:
|
|
if style == "side":
|
|
plt.text(
|
|
pos[i][0],
|
|
pos[i][1],
|
|
i,
|
|
fontsize=5,
|
|
verticalalignment="top",
|
|
horizontalalignment="right",
|
|
)
|
|
elif style == "center":
|
|
plt.text(
|
|
pos[i][0],
|
|
pos[i][1],
|
|
i,
|
|
fontsize=5,
|
|
verticalalignment="center",
|
|
horizontalalignment="center",
|
|
)
|
|
k += 1
|
|
for i in G.edges:
|
|
p1 = [pos[i[0]][0], pos[i[1]][0]]
|
|
p2 = [pos[i[0]][1], pos[i[1]][1]]
|
|
plt.plot(p1, p2, "k-", alpha=0.3, linewidth=0.5)
|
|
plt.show()
|
|
else:
|
|
degree = G.degree()
|
|
sorted_degree = sorted(degree.items(), key=lambda d: d[1], reverse=True)
|
|
l = int(rate * len(G))
|
|
s = []
|
|
for i in sorted_degree:
|
|
if len(s) < l:
|
|
s.append(i[0])
|
|
for i in pos:
|
|
if i in s:
|
|
node[m][0] = pos[i][0]
|
|
node[m][1] = pos[i][1]
|
|
m += 1
|
|
node = node[0:m, :]
|
|
if style == "side":
|
|
plt.scatter(node[:, 0], node[:, 1], marker=".", color="b", s=10)
|
|
elif style == "center":
|
|
plt.scatter(
|
|
node[:, 0],
|
|
node[:, 1],
|
|
marker="o",
|
|
color="None",
|
|
edgecolors="b",
|
|
s=50,
|
|
linewidth=0.5,
|
|
)
|
|
k = 0
|
|
for i in pos:
|
|
if i in s:
|
|
if style == "side":
|
|
plt.text(
|
|
pos[i][0],
|
|
pos[i][1],
|
|
i,
|
|
fontsize=5,
|
|
verticalalignment="top",
|
|
horizontalalignment="right",
|
|
)
|
|
elif style == "center":
|
|
plt.text(
|
|
pos[i][0],
|
|
pos[i][1],
|
|
i,
|
|
fontsize=5,
|
|
verticalalignment="center",
|
|
horizontalalignment="center",
|
|
)
|
|
k += 1
|
|
for i in G.edges:
|
|
(u, v, t) = i
|
|
if u in s and v in s:
|
|
p1 = [pos[i[0]][0], pos[i[1]][0]]
|
|
p2 = [pos[i[0]][1], pos[i[1]][1]]
|
|
plt.plot(p1, p2, "k-", alpha=0.3, linewidth=0.5)
|
|
plt.show()
|
|
return
|
|
|
|
|
|
def draw_louvain_com(G, l_com):
|
|
"""
|
|
Draw the graph and show the communities
|
|
|
|
Parameters
|
|
----------
|
|
G : graph
|
|
l_com : communities created by louvain algorithm
|
|
"""
|
|
import matplotlib.pyplot as plt
|
|
import numpy as np
|
|
|
|
plt.figure(figsize=(8, 8))
|
|
n = len(l_com)
|
|
colors = get_n_colors(n + 1)
|
|
com_pos = community_pos(n)
|
|
node = np.zeros((len(G.nodes), 2), float)
|
|
node_idx = np.zeros(len(G.nodes) + 1)
|
|
edge_label = edge_partition(G, l_com)
|
|
k = 0
|
|
|
|
for i in range(n):
|
|
n_pos = node_pos(len(l_com[i]))
|
|
com_list = list(l_com[i])
|
|
m = len(com_list)
|
|
start = k
|
|
for j in range(m):
|
|
node[k][0] = com_pos[i][0] + n_pos[j][0]
|
|
node[k][1] = com_pos[i][1] + n_pos[j][1]
|
|
node_idx[com_list[j]] = k
|
|
k += 1
|
|
plt.scatter(
|
|
node[start:k, 0],
|
|
node[start:k, 1],
|
|
marker="o",
|
|
color=colors[i],
|
|
edgecolors=colors[i],
|
|
s=300,
|
|
linewidth=0.5,
|
|
zorder=2,
|
|
)
|
|
for j in range(m):
|
|
x = int(node_idx[com_list[j]])
|
|
plt.text(
|
|
node[x][0],
|
|
node[x][1],
|
|
com_list[j],
|
|
fontsize=10,
|
|
verticalalignment="center",
|
|
horizontalalignment="center",
|
|
color="white",
|
|
)
|
|
for i in G.edges:
|
|
x = int(node_idx[int(i[0])])
|
|
y = int(node_idx[int(i[1])])
|
|
p1 = [node[x][0], node[y][0]]
|
|
p2 = [node[x][1], node[y][1]]
|
|
plt.plot(
|
|
p1,
|
|
p2,
|
|
color=colors[edge_label[(i[0], i[1])]],
|
|
linestyle="-",
|
|
alpha=0.3,
|
|
linewidth=1.5,
|
|
zorder=1,
|
|
)
|
|
plt.show()
|
|
return
|
|
|
|
|
|
def draw_lpa_com(G, lpa_com):
|
|
"""
|
|
Draw the graph and show the communities
|
|
|
|
Parameters
|
|
----------
|
|
G : graph
|
|
lpa_com : communities created by LPA
|
|
"""
|
|
import matplotlib.pyplot as plt
|
|
import numpy as np
|
|
|
|
plt.figure(figsize=(8, 8))
|
|
list_lpa_com = list(lpa_com.values())
|
|
n = len(list_lpa_com)
|
|
colors = get_n_colors(n + 1)
|
|
com_pos = community_pos(n)
|
|
node = np.zeros((len(G.nodes), 2), float)
|
|
node_idx = np.zeros(len(G.nodes) + 1)
|
|
edge_label = edge_partition(G, list_lpa_com)
|
|
k = 0
|
|
|
|
for i in range(n):
|
|
cur_com = list_lpa_com[i]
|
|
m = len(cur_com)
|
|
n_pos = node_pos(m)
|
|
start = k
|
|
for j in range(m):
|
|
node[k][0] = com_pos[i][0] + n_pos[j][0]
|
|
node[k][1] = com_pos[i][1] + n_pos[j][1]
|
|
node_idx[cur_com[j]] = k
|
|
k += 1
|
|
plt.scatter(
|
|
node[start:k, 0],
|
|
node[start:k, 1],
|
|
marker="o",
|
|
color=colors[i],
|
|
edgecolors=colors[i],
|
|
s=300,
|
|
linewidth=0.5,
|
|
zorder=2,
|
|
)
|
|
for j in range(m):
|
|
x = int(node_idx[cur_com[j]])
|
|
plt.text(
|
|
node[x][0],
|
|
node[x][1],
|
|
cur_com[j],
|
|
fontsize=10,
|
|
verticalalignment="center",
|
|
horizontalalignment="center",
|
|
color="white",
|
|
)
|
|
for i in G.edges:
|
|
x = int(node_idx[int(i[0])])
|
|
y = int(node_idx[int(i[1])])
|
|
p1 = [node[x][0], node[y][0]]
|
|
p2 = [node[x][1], node[y][1]]
|
|
plt.plot(
|
|
p1,
|
|
p2,
|
|
color=colors[edge_label[(i[0], i[1])]],
|
|
linestyle="-",
|
|
alpha=0.3,
|
|
linewidth=1.5,
|
|
zorder=1,
|
|
)
|
|
plt.show()
|
|
return
|
|
|
|
|
|
def draw_gm_com(G, gm_com):
|
|
"""
|
|
Draw the graph and show the communities
|
|
|
|
Parameters
|
|
----------
|
|
G : graph
|
|
gm_com : communities created by greedy modularity
|
|
"""
|
|
import matplotlib.pyplot as plt
|
|
import numpy as np
|
|
|
|
plt.figure(figsize=(8, 8))
|
|
list_gm_com = [list(i) for i in gm_com]
|
|
n = len(list_gm_com)
|
|
colors = get_n_colors(n + 1)
|
|
com_pos = community_pos(n)
|
|
node = np.zeros((len(G.nodes), 2), float)
|
|
node_idx = np.zeros(len(G.nodes) + 1)
|
|
edge_label = edge_partition(G, list_gm_com)
|
|
k = 0
|
|
|
|
for i in range(n):
|
|
cur_com = list_gm_com[i]
|
|
m = len(cur_com)
|
|
n_pos = node_pos(m)
|
|
start = k
|
|
for j in range(m):
|
|
node[k][0] = com_pos[i][0] + n_pos[j][0]
|
|
node[k][1] = com_pos[i][1] + n_pos[j][1]
|
|
node_idx[cur_com[j]] = k
|
|
k += 1
|
|
plt.scatter(
|
|
node[start:k, 0],
|
|
node[start:k, 1],
|
|
marker="o",
|
|
color=colors[i],
|
|
edgecolors=colors[i],
|
|
s=300,
|
|
linewidth=0.5,
|
|
zorder=2,
|
|
)
|
|
for j in range(m):
|
|
x = int(node_idx[cur_com[j]])
|
|
plt.text(
|
|
node[x][0],
|
|
node[x][1],
|
|
cur_com[j],
|
|
fontsize=10,
|
|
verticalalignment="center",
|
|
horizontalalignment="center",
|
|
color="white",
|
|
)
|
|
for i in G.edges:
|
|
x = int(node_idx[int(i[0])])
|
|
y = int(node_idx[int(i[1])])
|
|
p1 = [node[x][0], node[y][0]]
|
|
p2 = [node[x][1], node[y][1]]
|
|
plt.plot(
|
|
p1,
|
|
p2,
|
|
color=colors[edge_label[(i[0], i[1])]],
|
|
linestyle="-",
|
|
alpha=0.3,
|
|
linewidth=1.5,
|
|
zorder=1,
|
|
)
|
|
plt.show()
|
|
return
|
|
|
|
|
|
def get_n_colors(n):
|
|
import numpy as np
|
|
|
|
from matplotlib import cm
|
|
|
|
viridis = cm.get_cmap("viridis", n)
|
|
colors = viridis(np.linspace(0, 1, n))
|
|
return colors
|
|
|
|
|
|
def community_pos(n, scale=10):
|
|
"""
|
|
Set position for every community.
|
|
|
|
Parameters
|
|
----------
|
|
n : number of communities
|
|
scale : parameter for sprint_layout
|
|
"""
|
|
graph = eg.Graph()
|
|
graph.add_nodes(range(n))
|
|
pos = eg.spring_layout(graph, scale=scale)
|
|
return pos
|
|
|
|
|
|
def node_pos(n, scale=2):
|
|
"""
|
|
Set position for every node in a community
|
|
|
|
Parameters
|
|
----------
|
|
n : number of nodes
|
|
scale : parameter for sprint_layout
|
|
"""
|
|
graph = eg.Graph()
|
|
graph.add_nodes(range(n))
|
|
pos = eg.spring_layout(graph, scale=scale)
|
|
return pos
|
|
|
|
|
|
def edge_partition(G, community):
|
|
"""
|
|
Label every edge with the community it belongs to.
|
|
|
|
Parameters
|
|
----------
|
|
G : the graph
|
|
community : communities of the graph
|
|
"""
|
|
edge_label = {}
|
|
n = len(community)
|
|
for edge in G.edges:
|
|
for i in range(n):
|
|
if edge[0] in community[i] and edge[1] in community[i]:
|
|
edge_label[(edge[0], edge[1])] = i
|
|
break
|
|
elif edge[0] in community[i] or edge[1] in community[i]:
|
|
edge_label[(edge[0], edge[1])] = n
|
|
break
|
|
return edge_label
|
|
|
|
|
|
def draw_ego_graph(G, ego_graph):
|
|
import matplotlib.pyplot as plt
|
|
import numpy as np
|
|
|
|
plt.figure(figsize=(10, 10))
|
|
pos = eg.random_position(G)
|
|
center = np.zeros((len(ego_graph), 2), float)
|
|
node = np.zeros((len(pos) - len(ego_graph), 2), float)
|
|
m, n = 0, 0
|
|
for i in pos:
|
|
if i in list(ego_graph.nodes.keys()):
|
|
center[n][0] = 0.5 + (-1) ** np.random.randint(1, 2) * pos[i][0] / 3
|
|
center[n][1] = 0.5 + (-1) ** np.random.randint(1, 2) * pos[i][1] / 3
|
|
pos[i][0] = center[n][0]
|
|
pos[i][1] = center[n][1]
|
|
n += 1
|
|
else:
|
|
node[m][0] = pos[i][0]
|
|
node[m][1] = pos[i][1]
|
|
m += 1
|
|
plt.scatter(
|
|
node[:, 0],
|
|
node[:, 1],
|
|
marker="o",
|
|
color="skyblue",
|
|
edgecolors="skyblue",
|
|
s=100,
|
|
linewidth=0.5,
|
|
)
|
|
plt.scatter(
|
|
center[:, 0],
|
|
center[:, 1],
|
|
marker="o",
|
|
color="tomato",
|
|
edgecolors="tomato",
|
|
s=200,
|
|
linewidth=0.5,
|
|
zorder=2,
|
|
)
|
|
k = 0
|
|
for i in pos:
|
|
plt.text(
|
|
pos[i][0],
|
|
pos[i][1],
|
|
i,
|
|
fontsize=10,
|
|
verticalalignment="center",
|
|
horizontalalignment="center",
|
|
)
|
|
k += 1
|
|
for i in G.edges:
|
|
p1 = [pos[i[0]][0], pos[i[1]][0]]
|
|
p2 = [pos[i[0]][1], pos[i[1]][1]]
|
|
if i not in ego_graph.edges:
|
|
plt.plot(
|
|
p1,
|
|
p2,
|
|
color="skyblue",
|
|
linestyle="-",
|
|
alpha=0.3,
|
|
linewidth=1.8,
|
|
zorder=1,
|
|
)
|
|
else:
|
|
plt.plot(
|
|
p1,
|
|
p2,
|
|
color="tomato",
|
|
linestyle="-",
|
|
alpha=0.3,
|
|
linewidth=1.8,
|
|
zorder=1,
|
|
)
|
|
plt.show()
|
|
return
|
|
|
|
|
|
if __name__ == "__main__":
|
|
G = eg.datasets.get_graph_karateclub()
|
|
draw_SHS_center(G, [1, 33, 34], style="side")
|
|
draw_SHS_center(G, [1, 33, 34], style="center")
|
|
draw_SHS_center_kk(G, [1, 33, 34], style="side")
|
|
draw_SHS_center_kk(G, [1, 33, 34], style="center")
|
|
draw_kamada_kawai(G, style="side")
|
|
draw_kamada_kawai(G, style="center")
|
|
draw_SHS_center(G, [1, 33, 34], rate=0.8, style="side")
|
|
draw_SHS_center(G, [1, 33, 34], rate=0.8, style="center")
|
|
draw_SHS_center_kk(G, [1, 33, 34], rate=0.8, style="side")
|
|
draw_SHS_center_kk(G, [1, 33, 34], rate=0.8, style="center")
|
|
draw_kamada_kawai(G, rate=0.8, style="side")
|
|
draw_kamada_kawai(G, rate=0.8, style="center")
|