igraph¶

#Import libraries
import matplotlib as mpl
import matplotlib.pyplot as plt
import networkx as nx
import numpy as np

#Import Test_Dataset.txt, which is created by hand, 
#as a directed network by using the argument: nx.DiGraph()
with open('Test_Dataset.txt', 'rb') as file:
    #next(file, '')   # skip a line if the data has a header
    test = nx.read_edgelist(file, create_using=nx.DiGraph(), delimiter=' ', nodetype=int)

#Add up to 10 nodes
H = nx.path_graph(10)
test.add_nodes_from(H)


#List all the edges
list(test.edges)


#Add edges by hand 
test.add_edges_from([(7, 1), (9, 7), (9, 6), (2, 4), (1, 8), (0, 8), (6, 7)])

#Another way to add Weights
test.add_weighted_edges_from([(0, 1, 0.6), (0, 2, 0.2), (0, 8, 0.1), (1, 3, 0.7),
                              (1, 8, 0.8), (2, 1, 0.3), (2, 4, 0.2), (3, 0, 0.1),
                              (3, 4, 0.5), (3, 3, 0.2), (5, 4, 0.3), (5, 6, 0.6),
                              (6, 4, 0.2), (6, 7, 0.1), (7, 1, 0.7), (9, 7, 0.9), 
                              (9, 6, 0.3), (4, 3, 0.6)])

#Print the number of nodes and edges of the network
nx.number_of_nodes(test)
test.number_of_edges()
#Check the degree
test.degree()
print('\nTest Dataset:')
print(nx.info(test))

#Another way to change nodes' color by grouping the degree of the nodes
#Store the degree for each node in a list
dg_test = [d[1] for d in test.degree]


#Create a list that comtains the color choices for different degrees:
#dgree >= 5: crimson; degree < 5: teal
color_map_2 = []
for i in range(len(dg_test)):
    if dg_test[i] >= 5:
        color_map_2.append(('crimson'))
    else: 
        color_map_2.append('teal')  



#Create a list that comtains the node size choices for different degrees:
size_map = []
for i in range(len(dg_test)):
    size_map.append(test.degree[i]*100)

#Reset label
#Change nodes label
labeldict = {}
labeldict[0] = "Point 0"
labeldict[1] = "Point 1"
labeldict[2] = "Point 2"
labeldict[3] = "Point 3"
labeldict[4] = "Point 4"
labeldict[5] = "Point 5"
labeldict[6] = "Point 6"
labeldict[7] = "Point 7"
labeldict[8] = "Point 8"
labeldict[9] = "Point 9"


plt.figure(1)

plt.figure(1)

#Set plot size
#plt.figure(figsize=(8, 8))
#Set the layout of the group, here is set to draw a circular graph
pos = nx.circular_layout(test)

#Nodes arguments used, set node_size = size_map(based on degree), node_color = dg_test(based on degree),
#Method 1: The node_color can use an list, such as the degree, then use cmap to match the colors in mathplotlib
nx.draw_networkx_nodes(test, pos, node_size = size_map, node_color = dg_test, cmap = plt.cm.Reds_r)


#Method2: Use the color_map list that was stored previously
#nx.draw_networkx_nodes(test, pos, node_size = size_map, node_color = color_map_2)

#Group edges into two levels by weight > 0.5 and weight <= 0.5,
#The two groups can be used later when ploting the edges
elarge = [(u, v) for (u, v, d) in test.edges(data=True) if d['weight'] > 0.5]
esmall = [(u, v) for (u, v, d) in test.edges(data=True) if d['weight'] <= 0.5]


#Draw edges based on the two weight levels
nx.draw_networkx_edges(test, pos, edgelist=elarge,
                       width=3, edge_color = 'darkred')
nx.draw_networkx_edges(test, pos, edgelist=esmall,
                       width=1.5, alpha=0.5, edge_color = 'teal', style = 'dashed')


#Get and print the edge weights 
edg_label = nx.get_edge_attributes(test,'weight')
nx.draw_networkx_edge_labels(test, pos, edge_labels = edg_label)


#Assign the labels to the plot
nx.draw_networkx_labels(test, pos, labels=labeldict, with_labels = True, font_size = 10, font_family = 'sans-serif')



#Show the plot
#plt.axis('off') #Hide the axis
plt.show()

with open('stormofswords.txt', 'rb') as test:
    #next(test, '')   # skip a line
    got = nx.read_edgelist(test, create_using=nx.DiGraph(), data=(('weight',int),), delimiter=' ')


#Print the number of nodes and edges of the network
got.number_of_nodes()
got.number_of_edges()
#Check the degree
got.degree()
#Print the info of the network, which includes the number of nodes, edges, 
#average in dgree and avg out degree
print('\nGame of Thrones:')
print(nx.info(got))


#Store the degree for each node in a list
got_dgr = [d[1] for d in got.degree]
dict((x,got_dgr.count(x)) for x in set(got_dgr))

#Create a list that comtains the color choices for different degrees:
color_map = []
for i in range(len(got_dgr)):
    
    if got_dgr[i] >= 20:
        color_map.append('red')
    
    elif got_dgr[i] >= 10 and got_dgr[i] < 20:
        color_map.append('darkorange')
    
    elif got_dgr[i] >= 5 and got_dgr[i] < 10:
        color_map.append('yellow')
    
    else:
        color_map.append('steelblue')

    
#Create size argument
size = []
for i in range(len(got_dgr)):
    size.append(got_dgr[i]*20)    

plt.figure(2)
#Set plot layout, k = 1 which means the nodes are somehow apart from each other 
pos = nx.spring_layout(got, k =1)


#Set nodes size based on degree
nx.draw_networkx_nodes(got, pos, node_size = size, node_color = color_map)


elarge_got = [(u, v) for (u, v, d) in got.edges(data=True) if d['weight'] > 30]
esmall_got = [(u, v) for (u, v, d) in got.edges(data=True) if d['weight'] <= 30]



#Draw edges based on the two weight levels
nx.draw_networkx_edges(got, pos, edgelist=elarge_got, width=2, edge_color = 'darkred')
nx.draw_networkx_edges(got, pos, edgelist=esmall_got, width=1.5, alpha=0.5, edge_color = 'lightblue', style = 'dashed')

#Get and print the edge weights
#edg_label_got = nx.get_edge_attributes(got,'weight')
#nx.draw_networkx_edge_labels(got, pos, edge_labels = edg_label_got)



#nx.draw(got, pos, with_labels = True)
nx.draw_networkx_labels(got, pos, with_labels = True, font_size=8, font_color='k', font_family='sans-serif')


plt.axis('off') #Hide the axis
plt.show()

dolphins = nx.read_gml("dolphins.gml")
#Find the clustering coefficient of the nodes
nx.clustering(dolphins) # for undirect type


#Extract the coefficients out from the clustering dictionary
clustering = list(nx.clustering(dolphins).values())

print("\nDolphins_gml:")
print(nx.info(dolphins))

#Create a list that comtains the color choices for different degrees:
color_map = []
for i in range(len(clustering)):
    
    if clustering[i] >= 0.5:
        color_map.append('steelblue')
    
    elif clustering[i] >= 0.3 and clustering[i] < 0.5:
        color_map.append('skyblue')
    
    else:
        color_map.append('paleturquoise')

    
#Create size argument
size = []
for i in range(len(clustering)):
    size.append(clustering[i]*1000)    

plt.figure(3)
#Set plot layout, k = 1 which means the nodes are somehow apart from each other 
pos = nx.circular_layout(dolphins)


#Set nodes size based on degree
nx.draw_networkx_nodes(dolphins, pos, node_size = size, node_color = color_map)



#Draw edges based on the two weight levels
nx.draw_networkx_edges(dolphins, pos, width=1.5, alpha=0.5, edge_color = 'peachpuff')



#nx.draw(got, pos, with_labels = True)
nx.draw_networkx_labels(dolphins, pos, with_labels = True, font_size=8, font_color='k', font_family='sans-serif')


plt.axis('off') #Hide the axis
plt.show()

#Create adjacency matrix
#The following codes are adapted and changed from the following example:
#https://networkx.github.io/documentation/stable/auto_examples/drawing/
#plot_directed.html#sphx-glr-auto-examples-drawing-plot-directed-py

#Create a numpy matrix
A = np.matrix([[0,4,0,2],[0,0,1,3],[3,0,0,2],[2,0,1,0]])
#Read the numpu matrix as network
G = nx.from_numpy_matrix(A, create_using=nx.DiGraph())

#Print information about the adjacency matrix network
print("\nAdjacency Matrix:")
print(nx.info(G))

plt.figure(4)

#Set the plot layout
pos = nx.spring_layout(G)



#Store the degree for each node in a list
G_dgr = [d[1] for d in G.degree]
dict((x,got_dgr.count(x)) for x in set(got_dgr))

#Get and print the edge weights
edg_label_G = nx.get_edge_attributes(G,'weight')
nx.draw_networkx_edge_labels(G, pos, edge_labels = edg_label_G, label_pos = .5, 
                             font_size = 7, font_color = 'salmon')

#Change the node sizeand color for different nodes based on degree
node_sizes = [i * 100 for i in G_dgr]
node_colors = [i/10 for i in G_dgr]

#Change edge colors based on weight
M = G.number_of_edges()

edge_colors = list(edg_label_G.values())
#Set the transparency level of the edge
edge_alphas = [(5 + i) / (M + 4) for i in range(M)]


#Draw node and change color
nodes = nx.draw_networkx_nodes(G, pos, node_size = node_sizes, node_color='firebrick')
                               #node_color = node_colors, node_cmap = plt.cm.Reds)

                               
edges = nx.draw_networkx_edges(G, pos, node_size = node_sizes, arrowstyle = '->',
                               arrowsize = 10, edge_color = edge_colors,
                               edge_cmap = plt.cm.Reds, width = 2)

# set alpha value for each edge
for i in range(M):
    edges[i].set_alpha(edge_alphas[i])



pc = mpl.collections.PatchCollection(edges, cmap = plt.cm.Reds)
pc.set_array(edge_colors)
plt.colorbar(pc)

nx.draw_networkx_labels(G, pos, with_labels = True)
                        
ax = plt.gca()
ax.set_axis_off()
plt.show()