def road(road_file_path, comments='#'):
G = nx.read_edgelist(road_file_path, comments=comments, nodetype=int)
nodes = []
start_node = random.choice(G.nodes())
queue = [start_node]
added_nodes = 1
seen = set()
while added_nodes < MAX_ROAD_NODES and len(queue) > 0:
curr = queue.pop()
if curr in seen:
continue
else:
nodes.append(curr)
queue += G.neighbors(curr)
seen.add(curr)
added_nodes += 1
G = G.subgraph(nodes)
mapping = {}
for i, node in enumerate(G.nodes()):
x = i / 12
y = i % 12
mapping[node] = (x, y)
#nx.relabel_nodes(G, mapping, copy=False)
mapping2 = {}
for i, node in enumerate(sorted(G.nodes())):
mapping2[node] = i
#nx.relabel_nodes(G, mapping2, copy=False)
G.graph['name'] = 'road'
pos = nx.kamada_kawai_layout(G, scale = graphscale)
for u in G.nodes():
G.node[u]['pos'] = pos[u]
done = False
for i in xrange(MAX_ROAD_ATTEMPTS):
n1, n2 = sample(G.nodes(), 2)
if not nx.has_path(G, n1, n2):
continue
sp = nx.shortest_path(G, n1, n2)
if len(sp) < 8 or len(sp) > 30:
continue
index = random.choice(range(len(sp) / 4, 3 * len(sp) / 4))
u, v = sp[index], sp[index + 1]
G.remove_edge(u, v)
if not nx.has_path(G, u, v):
G.add_edge(u, v)
continue
fp = nx.shortest_path(G, u, v)
if len(fp) > 8:
G.add_edge(u, v)
continue
#print n1, n2, u, v, sp, fp
G.add_edge(u, v)
set_init_road_path(G, n1, n2, u, v)
return G
def test_smoke_string(self):
G = self.Gs
vpos = nx.random_layout(G)
vpos = nx.circular_layout(G)
vpos = nx.spring_layout(G)
vpos = nx.fruchterman_reingold_layout(G)
vpos = nx.spectral_layout(G)
vpos = nx.shell_layout(G)
if self.scipy is not None:
vpos = nx.kamada_kawai_layout(G)
def test_smoke_empty_graph(self):
G = []
vpos = nx.random_layout(G)
vpos = nx.circular_layout(G)
vpos = nx.spring_layout(G)
vpos = nx.fruchterman_reingold_layout(G)
vpos = nx.spectral_layout(G)
vpos = nx.shell_layout(G)
vpos = nx.bipartite_layout(G, G)
if self.scipy is not None:
vpos = nx.kamada_kawai_layout(G)
def test_default_scale_and_center(self):
sc = self.check_scale_and_center
c = (0, 0)
G = nx.complete_graph(9)
G.add_node(9)
sc(nx.random_layout(G), scale=0.5, center=(0.5, 0.5))
sc(nx.spring_layout(G), scale=1, center=c)
sc(nx.spectral_layout(G), scale=1, center=c)
sc(nx.circular_layout(G), scale=1, center=c)
sc(nx.shell_layout(G), scale=1, center=c)
if self.scipy is not None:
sc(nx.kamada_kawai_layout(G), scale=1, center=c)
def test_scale_and_center_arg(self):
sc = self.check_scale_and_center
c = (4, 5)
G = nx.complete_graph(9)
G.add_node(9)
sc(nx.random_layout(G, center=c), scale=0.5, center=(4.5, 5.5))
# rest can have 2*scale length: [-scale, scale]
sc(nx.spring_layout(G, scale=2, center=c), scale=2, center=c)
sc(nx.spectral_layout(G, scale=2, center=c), scale=2, center=c)
sc(nx.circular_layout(G, scale=2, center=c), scale=2, center=c)
sc(nx.shell_layout(G, scale=2, center=c), scale=2, center=c)
if self.scipy is not None:
sc(nx.kamada_kawai_layout(G, scale=2, center=c), scale=2, center=c)
def test_smoke_int(self):
G = self.Gi
vpos = nx.random_layout(G)
vpos = nx.circular_layout(G)
vpos = nx.spring_layout(G)
vpos = nx.fruchterman_reingold_layout(G)
vpos = nx.fruchterman_reingold_layout(self.bigG)
vpos = nx.spectral_layout(G)
vpos = nx.spectral_layout(G.to_directed())
vpos = nx.spectral_layout(self.bigG)
vpos = nx.spectral_layout(self.bigG.to_directed())
vpos = nx.shell_layout(G)
if self.scipy is not None:
vpos = nx.kamada_kawai_layout(G)
def test_smoke_string(self):
G = self.Gs
nx.random_layout(G)
nx.circular_layout(G)
nx.planar_layout(G)
nx.spring_layout(G)
nx.fruchterman_reingold_layout(G)
nx.spectral_layout(G)
nx.shell_layout(G)
nx.spiral_layout(G)
nx.kamada_kawai_layout(G)
nx.kamada_kawai_layout(G, dim=1)
nx.kamada_kawai_layout(G, dim=3)
def show_ps_graph(case_name, save_fig=False):
bus = pd.read_csv("../datasets/ps/" + case_name + "/bus.csv", header=None)
branch = pd.read_csv("../datasets/ps/" + case_name + "/branch.csv", header=None)
gen = pd.read_csv("../datasets/ps/" + case_name + "/gen.csv", header=None)
# mac = pd.read_csv("../datasets/" + case_name + "/mac.csv", header=None)
# shunt = pd.read_csv("../datasets/" + case_name + "/shunt.csv", header=None)
# exc = pd.read_csv("../datasets/" + case_name + "/exc.csv", header=None)
# gov = pd.read_csv("../datasets/" + case_name + "/gov.csv", header=None)
bus_id = list(bus[0])
branch_from = list(branch[0])
branch_to = list(branch[1])
try:
branch_id = list(branch[23])
except KeyError:
branch_id = list(branch[22])
gen_bus = list(gen[0])
# gen_id = gen[-1]
# mac_bus = mac[0]
# shunt_bus = shunt[0]
# exc_bus = exc[0]
# gov_bus = gov[0]
print("> Red Node: Bus with Gen")
print("> Green Node: Bus without Gen")
node_list = []
color_map = []
G = nx.Graph()
for bus_i in bus_id:
node_list.append(bus_i)
if bus_i in gen_bus:
color_map.append("red")
else:
color_map.append("green")
G.add_nodes_from(node_list)
for f, t, i in zip(branch_from, branch_to, branch_id):
G.add_edge(f, t, key=i)
pos = nx.kamada_kawai_layout(G)
nx.draw_networkx(G, pos=pos, node_color=color_map)
if save_fig:
plt.savefig(case_name + ".png") # save as png
plt.show() # display
def plot(self, labels="candidate_counts"):
if not self._nxgraph:
self._nxgraph = nx.from_scipy_sparse_matrix(
self.composite_adj, create_using=nx.DiGraph())
self._pos = {}
subgraphs = list(
nx.weakly_connected_component_subgraphs(self._nxgraph))
for subfig_i, subgraph in enumerate(subgraphs):
df = pd.DataFrame(index=self._nxgraph.nodes(),
columns=self._nxgraph.nodes())
for row, data in nx.shortest_path_length(
subgraph.to_undirected()):
for col, dist in data.items():
df.loc[row, col] = dist
pos = nx.kamada_kawai_layout(subgraph,
dist=df.to_dict())
subfig_center = np.array([2.5 * subfig_i, 0])
pos = {
key: subfig_center + val
for key, val in pos.items()
}
self._pos.update(pos)
if labels == "candidate_counts":
labels = {
i: len(self.get_candidate_set(node))
for i, node in enumerate(self.nodes)
}
else:
labels = {i: node for i, node in enumerate(self.nodes)}
nx.draw(self._nxgraph,
node_size=1000,
edge_color="black",
node_color="#26FEFD",
labels=labels,
pos=self._pos)
def plot_graph(G, file_name, title, show):
edges, weights = zip(*nx.get_edge_attributes(G, "I").items())
layout = nx.kamada_kawai_layout(G)
edge_labels = nx.get_edge_attributes(G, 'I')
plt.title(title)
nx.draw(G,
pos=layout,
node_color='Grey',
edgelist=edges,
edge_color=weights,
with_labels=True,
edge_labels=edge_labels,
width=3,
arrowsize=20,
edge_cmap=plt.cm.get_cmap("Reds"))
plt.savefig(file_name + ".png")
if show == "show":
plt.show()
def plot_sentence(self,
graph,
nodelist,
words,
edgelist=None,
figname=None):
pos = nx.kamada_kawai_layout(graph)
words_dict = {i: words[i] for i in graph.nodes}
if nodelist is not None:
pos_coalition = {k: v for k, v in pos.items() if k in nodelist}
nx.draw_networkx_nodes(graph,
pos_coalition,
nodelist=nodelist,
node_color='yellow',
node_shape='o',
node_size=500)
if edgelist is None:
edgelist = [(n_frm, n_to) for (n_frm, n_to) in graph.edges()
if n_frm in nodelist and n_to in nodelist]
nx.draw_networkx_edges(graph,
pos=pos_coalition,
edgelist=edgelist,
width=5,
edge_color='yellow',
arrows=False)
nx.draw_networkx_nodes(graph,
pos,
nodelist=list(graph.nodes()),
node_size=300)
nx.draw_networkx_edges(graph,
pos,
width=2,
edge_color='grey',
arrows=False)
nx.draw_networkx_labels(graph, pos, words_dict)
plt.axis('off')
plt.title('\n'.join(wrap(' '.join(words), width=50)))
if figname is not None:
plt.savefig(figname)
plt.close('all')
def Network_GRNdb(w, ax):
"""
Given a w gene-gene interaction matrix and an axes object, draw and return the corresponding Networkx graph.
:param w: A matrix representing perturbation interactions with genes as columns and gene names as indices
:type w: DataFrame
:param ax: an axes object to determine where to plot in the figure
:type ax: Axes
:output G: Networkx weighted directed graph
:type G: DiGraph
"""
G = nx.DiGraph()
# add nodes and edges
for i in range(len(w)):
G.add_node(i, gene=w.columns[i])
add_edges_GRNdb(G, w)
# Remove isolated nodes
G.remove_nodes_from(list(nx.isolates(G)))
df = pd.DataFrame(index=G.nodes(), columns=G.nodes())
for row, data in nx.shortest_path_length(G):
for col, dist in data.items():
df.loc[row, col] = dist
df = df.fillna(df.max().max())
pos = nx.kamada_kawai_layout(G, dist=df.to_dict())
# draw the nodes, edges, labels and legend
set_nodes_GRNdb(G, pos, ax)
set_edges_GRNdb(G, pos, ax)
set_labels(G, pos, ax)
make_legend(G, ax)
# remove self-interacting loops
m = list(nx.simple_cycles(G))
for l in m:
if len(l) == 1:
G.remove_edges_from([(l[0], l[0])])
return G
def build_comm_network(comm_id, debug):
print(">>> Building community network.")
# make graph object
G = nx.Graph()
# obtain nodes for graph
def_nodes = get_pure_comm_nodes()
nodes_list = get_comm_nodes(def_nodes, comm_id)
# add nodes to graph
G.add_nodes_from([node[0] for node in nodes_list])
# obtain edges for graph
edges_list = get_edges_from_nodes(nodes_list)
# add edges to graph
G.add_edges_from([[edge[0], edge[1]] for edge in edges_list])
# obtain node attributes
max_emails = max([node[1] + node[2] for node in nodes_list])
max_emails_sent = max([node[1] for node in nodes_list])
max_emails_rec = max([node[2] for node in nodes_list])
node_colors = get_node_community_colors(nodes_list)
node_sizes = get_node_popularity_sizes(nodes_list, max_emails)
node_labels_dict = get_node_labels(nodes_list, 0.95, max_emails)
print("<<< Built community network with {} nodes.".format(len(G.nodes)))
# debug
print(nx.info(G))
# draw network
g_pos = nx.kamada_kawai_layout(G)
nx.draw(G,
pos=g_pos,
node_color=node_colors,
node_size=node_sizes,
width=0.05)
nx.draw_networkx_labels(G, g_pos, node_labels_dict, font_size=5)
if debug:
plt.show()
else:
plt.savefig("comm_{}.png".format(comm_id), format="PNG", dpi=1000)
return
def plotSymmetricDiff(g, figsize=None, pos=None, labels=None):
if not figsize:
figsize = (6, 6)
plt.figure(figsize=figsize)
plt.axis('off')
pos = pos if pos else nx.kamada_kawai_layout(g)
highlight_edges = [(u, v) for (u, v) in g.edges if {g.nodes[u][label],g.nodes[v][label]} == {INIT, FINAL}]
nx.draw_networkx_edges(g, pos, edgelist = highlight_edges, width=1.5)
nx.draw_networkx_edges(g, pos, [e for e in g.edges if e not in highlight_edges], width=0.5, style='dashed')
alpha = 0.5
nx.draw_networkx_nodes(g, pos, nodelist=[u for u in g if g.nodes[u][label]==INIT],
node_size=node_size, node_color='b')
nx.draw_networkx_nodes(g, pos, nodelist=[u for u in g if g.nodes[u][label]==FINAL],
node_size=node_size, node_color='r')
nx.draw_networkx_nodes(g, pos, nodelist=[u for u in g if g.nodes[u][label]==COMMON],
node_size=node_size, node_color='g')
nx.draw_networkx_nodes(g, pos, nodelist=[u for u in g if g.nodes[u][label]==NOTIN],
node_size=node_size, node_color='y', alpha=alpha)
nx.draw_networkx_labels(g, pos)
def network_draw(graph, saveFigPath):
plt.figure()
node_color = list()
for node in graph.nodes:
color = [30 / 255, 144 / 255, 255 / 255]
color[0] = graph.nodes[node]["viz"]["color"]["r"] / 255
color[1] = graph.nodes[node]["viz"]["color"]["g"] / 255
color[2] = graph.nodes[node]["viz"]["color"]["b"] / 255
node_color.append(color)
pos = nx.kamada_kawai_layout(graph)
nx.draw(graph,
pos=pos,
node_color=node_color,
node_size=60,
edge_color="gray",
with_labels=False)
plt.savefig(saveFigPath)
def layout_wrapper(S):
pos = position
if pos is None:
try:
# group bipartition if nodes are colored
dist = defaultdict(dict)
for u, v in product(nodelist, repeat=2):
if u == v: # node has no distance from itself
dist[u][v] = 0
elif (nodelist[u]["color"] == nodelist[v]["color"]
): # make same color nodes closer together
dist[u][v] = 1
else: # make different color nodes further apart
dist[u][v] = 2
pos = nx.kamada_kawai_layout(S, dist)
except KeyError:
# default to circular layout if nodes aren't colored
pos = nx.circular_layout(S)
return pos
def main():
pd.set_option('display.max_columns', None)
df = pd.read_csv('Urban.csv')
# df_top_one = get_top_percent(df, 0.01)
df_dict = get_relation(df, 2)
df_dict_clean = drop_empty(df_dict)
# print(df_rel)
g, sizeOfNodes = Dict2Graph(df_dict_clean)
pos = nx.kamada_kawai_layout(g, scale=4)
nx.draw(g, pos, with_labels=True, node_size=sizeOfNodes, font_size=6)
plt.draw()
plt.savefig("KG1.png", dpi=1000)
plt.show()
def grow_and_show_tree(filename,
pruning=False,
threshold=0.5,
notification=True):
training_data, data_header = load_csv(filename)
d_tree = grow_tree(training_data, columns_map=data_header)
plot(d_tree)
if pruning:
prune(d_tree, minGain=threshold, notification=notification)
plot(d_tree)
G, edge_dict, nodes_dict = draw_graph(get_neighborhood_list(d_tree))
plt.figure(figsize=(25, 25))
plt.subplot(111)
pos = nx.kamada_kawai_layout(G, scale=3)
nx.draw_networkx_edge_labels(G, pos, edge_dict, verticalalignment='center')
nx.draw_networkx_labels(G, pos, nodes_dict)
nx.draw(G, pos)
plt.show()
return d_tree
def main():
# Read interactions from file
with open("interactions.csv", "r") as f:
csvreader = csv.reader(f, delimiter=",")
g = nx.Graph()
for row in csvreader:
# Row in format: Creator 1,Creator2,The Interaction
g.add_edge(row[0], row[1], how=row[2])
# Create the plot
plt.figure(figsize=(24, 16))
labels = nx.get_edge_attributes(g, 'how')
pos = nx.kamada_kawai_layout(g)
nx.draw_networkx_edge_labels(g, pos=pos, edge_labels=labels, font_size=8)
nx.draw(g, pos=pos, with_labels=True)
plt.savefig("Graph.png", dpi=200)
def draw_graph_weighted_colored(self,
position='spring',
nsize='asset',
ncolor='community'):
"""
Draws graph with giver position, node size, and node color character
"""
plt.figure()
print("Size of G is:", self.G.number_of_nodes())
if nsize == 'asset':
size = [self.a_matrix[u].asset * 15 for u in self.G.nodes()]
if nsize == 'money':
size = [self.a_matrix[u].money * 30 for u in self.G.nodes()]
if nsize == 'approval':
size = [self.a_matrix[u].approval * 30 for u in self.G.nodes()]
if nsize == 'degree':
size = np.array(list(self.G.degree)) * 5
if ncolor == 'community':
color = list(self.best_parts.values())
if ncolor == 'situation':
color = [self.a_matrix[u].situation for u in self.G.nodes()]
if ncolor == 'worth_ratio':
color = [self.a_matrix[u].worth_ratio for u in self.G.nodes()]
if position == 'spring':
pos = nx.spring_layout(self.G)
if position == 'kamada_kawai':
pos = nx.kamada_kawai_layout(self.G)
nx.draw(self.G,
pos=pos,
with_labels=True,
node_size=size,
font_size=8,
node_color=color,
width=0.1)
plt.savefig(self.path + 'graph ' + position + ' fpoint=%d' %
(self.friendship_num) + ' s=' + nsize + ' c=' + ncolor)
plt.close()
return
def draw(self, color="country"):
"""
Draws current graph
"""
colors = ['r', 'g', 'c', 'm', 'y', 'b', 'w']
label_dict = {
v: k + ':\n' + str(v.num_armies)
for k, v in self.territories.items()
}
layout = nx.kamada_kawai_layout(self.graph, scale=50)
node_color = []
if color is "players":
node_color = [
node.owner.color if node.owner is not None else 'r'
for node in self.graph.nodes()
]
elif color is "country":
continent_color_dict = {
continent: colors[i]
for i, continent in enumerate(self.continents)
}
node_color = [
continent_color_dict[territory.continent]
for territory in self.graph.nodes()
]
# Lower alpha channels for colors
node_color = [
matplotlib.colors.to_hex(matplotlib.colors.to_rgba(c, alpha=0.1),
keep_alpha=True) for c in node_color
]
print(node_color)
nx.draw_networkx_nodes(self.graph,
pos=layout,
node_color=node_color,
alpha=0.5)
nx.draw_networkx_edges(self.graph, pos=layout)
nx.draw_networkx_labels(self.graph, pos=layout, labels=label_dict)
# plt.ion()
plt.show()
def visualize_subgraph(self, edge_index, edge_mask, num_nodes,
threshold=None, **kwargs):
assert edge_mask.size(0) == edge_index.size(1)
if threshold is not None:
edge_mask = (edge_mask >= threshold).to(torch.float)
print(edge_mask)
data = Data(edge_index=edge_index, att=edge_mask).to('cpu')
data.num_nodes = num_nodes
G = to_networkx(data, edge_attrs=['att'])
# kwargs['with_labels'] = kwargs.get('with_labels') or True
kwargs['font_size'] = kwargs.get('font_size') or 10
node_size = kwargs.get('node_size') or 800
# kwargs['cmap'] = kwargs.get('cmap') or 'cool'
SCALE = 2
pos = nx.rescale_layout_dict(nx.kamada_kawai_layout(G), scale=SCALE)
ax = plt.gca()
ax.set_xlim((-SCALE - 0.1, SCALE + 0.1))
ax.set_ylim((-SCALE - 0.1, SCALE + 0.1))
for source, target, data in G.to_undirected().edges(data=True):
ax.annotate(
'',
xy=pos[target],
xycoords='data',
xytext=pos[source],
textcoords='data', arrowprops=dict(
arrowstyle="-",
alpha=max(data['att'], 0.1),
shrinkA=sqrt(node_size) / 2.0,
shrinkB=sqrt(node_size) / 2.0,
connectionstyle="arc3,rad=0.00",
))
nx.draw_networkx_labels(G, pos, **kwargs)
return ax, G
def plot_subgraph(graph,
nodelist,
colors='#FFA500',
labels=None,
edge_color='gray',
edgelist=None,
subgraph_edge_color='black',
title_sentence=None,
figname=None):
if edgelist is None:
edgelist = [(n_frm, n_to) for (n_frm, n_to) in graph.edges()
if n_frm in nodelist and n_to in nodelist]
pos = nx.kamada_kawai_layout(graph)
pos_nodelist = {k: v for k, v in pos.items() if k in nodelist}
nx.draw_networkx_nodes(graph,
pos,
nodelist=list(graph.nodes()),
node_color=colors,
node_size=300)
nx.draw_networkx_edges(graph,
pos,
width=3,
edge_color=edge_color,
arrows=False)
nx.draw_networkx_edges(graph,
pos=pos_nodelist,
edgelist=edgelist,
width=6,
edge_color=subgraph_edge_color,
arrows=False)
if labels is not None:
nx.draw_networkx_labels(graph, pos, labels)
plt.axis('off')
if title_sentence is not None:
plt.title('\n'.join(wrap(title_sentence, width=60)))
plt.show()
def print_graph(graph, labels, edges=None, weights='red', layout=0):
if not edges:
edges = graph.edges()
if layout == 0:
pos = nx.circular_layout(G)
else:
pos = nx.kamada_kawai_layout(G)
nx.draw(G,
pos,
node_color='white',
node_size=50,
labels=labels,
width=1.0,
edgelist=edges,
edge_color=weights,
font_size=9,
edge_cmap=plt.cm.coolwarm,
font_color="black",
font_weight='bold')
plt.show()
def centV(self):
"""
Método que devuelve la centralidad de valor propio
Args:
Return:
centralidad de valor propio
"""
centv = nx.eigenvector_centrality(self.__G)
pesos = np.array(list(centv.values()))
pos = nx.kamada_kawai_layout(self.__G)
f = plt.figure(figsize=(12, 12))
nx.draw(self.__G,
pos,
with_labels=True,
node_size=pesos * 5000,
ax=f.add_subplot(111))
f.savefig(os.path.join(self.dir, 'centv.png'), format="PNG")
return centv
def paRa(self):
"""
Método que devuelve la centralidad de pagerank
Args:
Return:
centralidad de pagerank
"""
pr = nx.pagerank_numpy(self.__G, alpha=0.85)
pesos = np.array(list(pr.values()))
pos = nx.kamada_kawai_layout(self.__G)
f = plt.figure(figsize=(12, 12))
nx.draw(self.__G,
pos,
with_labels=True,
node_size=pesos * 10000,
ax=f.add_subplot(111))
f.savefig(os.path.join(self.dir, 'para.png'), format="PNG")
return pr
def centI(self):
"""
Método que devuelve la centralidad de intermediacion
Args:
Return:
centralidad de intermediacion
"""
centi = nx.betweenness_centrality(self.__G)
pesos = np.array(list(centi.values()))
pos = nx.kamada_kawai_layout(self.__G)
f = plt.figure(figsize=(12, 12))
nx.draw(self.__G,
pos,
with_labels=True,
node_size=pesos * 10000,
ax=f.add_subplot(111))
f.savefig(os.path.join(self.dir, 'centi.png'), format="PNG")
return centi
def ranWal(self):
"""
Método que devuelve la centralidad de intermediacion random walker
Args:
Return:
centralidad de intermediacion random walker
"""
ranwal = nx.current_flow_betweenness_centrality(self.__G)
pesos = np.array(list(ranwal.values()))
pos = nx.kamada_kawai_layout(self.__G)
f = plt.figure(figsize=(12, 12))
nx.draw(self.__G,
pos,
with_labels=True,
node_size=pesos * 10000,
ax=f.add_subplot(111))
f.savefig(os.path.join(self.dir, 'ranwal.png'), format="PNG")
return ranwal
def plot_save(self):
"""
Saves the plot of the NetworkX DiGraph.
See also
---------
crnt4sbml.CRNT.plot_save_c_graph
"""
pos = networkx.circular_layout(self.__g, scale=1.5)
pos = networkx.kamada_kawai_layout(self.__g, pos=pos, scale=1.5)
node_colors = [self.__g.nodes[n]['color'] for n in self.__g_nodes]
networkx.draw(self.__g, pos, node_color=node_colors)
node_labels = networkx.get_node_attributes(self.__g, 'label')
networkx.draw_networkx_labels(self.__g, pos, labels=node_labels)
edge_labels = networkx.get_edge_attributes(self.__g, 'label')
networkx.draw_networkx_edge_labels(self.__g,
pos,
edge_labels,
label_pos=0.3)
plt.savefig('network_cgraph.png')
def plot_graph(G, labels, threshold, ngram):
pos = nx.kamada_kawai_layout(G)
color_map = []
for node in G.nodes.keys():
if labels.loc[labels['name'] == node, 'partition'].values[0] == 0:
color_map.append('#ff9e4a')
if labels.loc[labels['name'] == node, 'partition'].values[0] == 1:
color_map.append('#ed665d')
if labels.loc[labels['name'] == node, 'partition'].values[0] == 2:
color_map.append('#ad8bc9')
if labels.loc[labels['name'] == node, 'partition'].values[0] == 3:
color_map.append('#a8786e')
plt.figure()
plt.title("Similarities greater than " + str(threshold) + " with ngram = " + str(ngram))
nx.draw(G, pos, with_labels=True, node_color=color_map, edge_color='grey', font_size=11, width=0.5)
plt.savefig('results/' + str(threshold) + 'sim_ngram' + str(ngram) + '.png', dpi=500)
plt.close()
def main():
# initial graph
graph = nx.Graph([(0, 1)])
fitness_coef = dict(graph.degree)
for new_node in range(graph.size() + 1, NUMBER_OF_NODES + 1):
node_neighbour, fitness_coef = find_neighbour(graph, fitness_coef)
graph.add_node(new_node)
graph.add_edge(new_node, node_neighbour)
degree_sequence = sorted(dict(graph.degree()).values(), reverse=True)
build_degree_frequency_plot(degree_sequence)
build_degree_rank_plot(degree_sequence)
# build graph
plt.figure(figsize=(20, 20))
nx.draw(graph, pos=nx.kamada_kawai_layout(graph))
plt.show()
def vsepr_layout(graph):
dist = dict(nx.shortest_path_length(graph, weight=None))
for source, dest_d in dist.items():
for dest, d in dest_d.items():
if d % 2 == 1: # odd
# sqrt(1 + (n*x)**2 + n*x**2)
n = (d - 1) // 2
dist[source][dest] = math.sqrt(1 + 3 * n**2 + 3 * n)
else: # even
dist[source][dest] = d // 2 * math.sqrt(3)
try:
p0 = nx.planar_layout(graph)
except nx.NetworkXException:
p0 = None
pos = nx.kamada_kawai_layout(graph,
pos=p0,
weight=None,
dist=dist,
scale=len(graph)**0.5)
return pos
def simulate(self, N):
"""
Simulate for N iterations
"""
pos = nx.kamada_kawai_layout(self.G)
plt.figure(figsize=(15, 5))
demon_hist = []
for i in range(N):
plt.clf()
# Simulated annealing #
if self.E_demon > 100:
self.E_demon = 100
#######################
self.calc_order_param()
demon_hist.append(self.E_demon)
self.plot_stuff(pos, demon_hist, N)
self.demon_move()
#plt.savefig('/home/michael/demon/gif/imgage_' + str(i))
plt.pause(0.01)
plt.show()
def shownet(self, network, name='default'): # 简单展示网络
plt.cla()
position = nx.kamada_kawai_layout(network)
edgelists = [(v0, v1) for (v0, v1) in network.edges if True]
nx.draw_networkx_nodes(network,
position,
node_color='green',
node_size=300)
nx.draw_networkx_labels(network,
position,
font_size=8,
font_color='white')
nx.draw_networkx_edges(network,
position,
edgelist=edgelists,
edge_color='black',
width=1.0)
direct = sup.ROOT + '/graphs/' + name + '.png'
plt.savefig(direct)
plt.close()
def selectLayout(G, layout_selected):
if layout_selected == 'circular_layout':
pos = nx.circular_layout(G)
if layout_selected == 'spring_layout':
pos = nx.spring_layout(G)
if layout_selected == 'kamada_kawai_layout':
pos = nx.kamada_kawai_layout(G)
if layout_selected == 'random_layout':
pos = nx.random_layout(G)
if layout_selected == 'shell_layout':
pos = nx.shell_layout(G)
if layout_selected == 'spectral_layout':
pos = nx.spectral_layout(G)
if layout_selected == 'planar_layout':
pos = nx.planar_layout(G)
if layout_selected == 'fruchterman_reingold_layout':
pos = nx.fruchterman_reingold_layout(G)
if layout_selected == 'spiral_layout':
pos = nx.spiral_layout(G)
return pos
def show_network(G, y=None, labels=None, pos=None, ax=None, figsize=(5,5)):
if ax is None:
plt.figure(figsize=figsize) # image is 8 x 8 inches
plt.axis('off')
ax = plt.gca()
if pos is None:
pos = nx.kamada_kawai_layout(G)
nx.draw_networkx_nodes(G, pos, node_size=500, alpha=0.8, cmap=plt.cm.RdYlGn, node_color=y, ax=ax)
nx.draw_networkx_edges(G, pos, ax=ax)
if labels is None:
nx.draw_networkx_labels(G, pos, font_color='w', font_weight='bold', font_size=15, ax=ax)
else:
labeldict = {}
for i, v in enumerate(G.nodes):
labeldict[v] = labels[i]
nx.draw_networkx_labels(G, pos, font_color='w', font_weight='bold', font_size=15, labels=labeldict, ax=ax)
def mapped_network(network):
G = read_network(network)
graphscale = 1
pos = nx.kamada_kawai_layout(G, scale = graphscale)
for u in G.nodes():
G.node[u]['pos'] = pos[u]
nest1, nest2 = G.graph['nests'][:2]
sp = nx.shortest_path(G, nest1, nest2)
G.graph['init path'] = []
break_edges = []
for i in xrange(len(sp) - 1):
u, v = sp[i], sp[i + 1]
G.graph['init path'].append((u, v))
if acceptable_break(G, u, v):
break_edges.append((u, v))
break_index = random.choice(range(len(break_edges)))
u, v = break_edges[break_index]
G.remove_edge(u, v)
G.graph['init path'].remove((u, v))
return G
