def test_multipartite_layout(self):
sizes = (0, 5, 7, 2, 8)
G = nx.complete_multipartite_graph(*sizes)
vpos = nx.multipartite_layout(G)
assert len(vpos) == len(G)
start = 0
for n in sizes:
end = start + n
assert all(vpos[start][0] == vpos[i][0]
for i in range(start + 1, end))
start += n
vpos = nx.multipartite_layout(G,
align="horizontal",
scale=2,
center=(2, 2))
assert len(vpos) == len(G)
start = 0
for n in sizes:
end = start + n
assert all(vpos[start][1] == vpos[i][1]
for i in range(start + 1, end))
start += n
pytest.raises(ValueError, nx.multipartite_layout, G, align="foo")
def test_smoke_empty_graph(self):
G = []
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.bipartite_layout(G, G)
nx.spiral_layout(G)
nx.multipartite_layout(G)
nx.kamada_kawai_layout(G)
def display_pos(G, layout='shortest'):
''' Display Position of the Nodes:
# spiral
# 1. general layout that works well for lots of nodes
# pos = nx.spiral_layout(G)
# "variable-type":
multiplartitle_layout using subsets of (output, intermediatory, input). it works well for small number of nodes, but not for a bigger set of nodes
# "shortest" by default
multiplartitle_layout using shortest distance to the source.
'''
if layout == 'shortest':
var_id = list(G.nodes)[0]
shortest_length = single_source_shortest_path_length(G, var_id)
for node in shortest_length.keys():
G.nodes[node]['shortest'] = shortest_length[node]
pos = nx.multipartite_layout(G,
subset_key="shortest",
align='horizontal')
elif layout == "variable-type":
for node, varType in G.nodes(data=True):
if varType['type'] == 'input':
G.nodes[node]['subset'] = 2
elif varType['type'] == 'output':
G.nodes[node]['subset'] = 0
elif varType['type'] == 'intermediary':
G.nodes[node]['subset'] = 1
else:
G.nodes[node]['subset'] = -1
pos = nx.multipartite_layout(G,
subset_key="subset",
align='horizontal')
elif layout == "planar":
pos = nx.planar_layout(G)
elif layout == "spring":
pos = nx.spring_layout(G)
elif layout == "shell":
pos = nx.shell_layout(G)
elif layout == "spiral":
pos = nx.spiral_layout(G)
else:
pos = nx.spiral_layout(G)
return pos
def print_graph_pretty(self, filename):
# make a networkx graph and draw it to file
NG = nx.DiGraph()
label_dict = {}
# G.n = maximal number of nodes
for i in range(self.G.n):
if i not in NG:
NG.add_node(i,depth = 0)
try:
label_dict[i]=self.instructions[i]
except:
pass
depth = NG.nodes[i]['depth']
# G[i] is a list of the neighbors of the ith node.
for j in self.G[i]:
NG.add_node(j,depth = depth+1)
try:
label_dict[j]=self.instructions[j]
except:
pass
# print("out of range j=%d, istrutions = %s "%(j,self.instructions))
# exit()
NG.add_edge(i,j)
nx.draw_networkx(NG,pos = nx.multipartite_layout(NG, subset_key = 'depth', align='horizontal') ,with_labels=True, labels=label_dict)
plt.savefig(filename)
def image(self,
with_labels=True,
font_weight='bold',
position_nodes=None,
input_qubits=[]):
"""
Produces a matplotlib image of the graph associated to the graph state.
"""
pos_nodes = position_nodes
if pos_nodes is None:
# checks if all nodes have attribute "layer", and, if they do, plot the graph using multilayer_layout
if all([
"layer" in this_node[1]
for this_node in self.graph.nodes(data=True)
]):
pos_nodes = nx.multipartite_layout(self.graph,
subset_key="layer")
else:
pos_nodes = nx.spring_layout(self.graph)
color_map = [
'red' if this_node in input_qubits else 'blue'
for this_node in self.graph.nodes
]
nx.draw(self.graph,
pos_nodes,
node_color=color_map,
with_labels=with_labels,
font_weight=font_weight)
def visualize_flow_network(flow_network: np.ndarray, layers: List[list], max_flow: np.ndarray = None):
""" Visualize flow network with or without max flow in network
Parameters
----------
flow_network : np.ndarray
flow network as adjacency matrix
layers : List[list]
structure of flow network
max_flow : np.ndarray
max flow in flow network as adjacency matrix
"""
G = nx.from_numpy_array(flow_network, create_using=nx.MultiDiGraph)
for layer_index, layer in enumerate(layers):
for node in layer:
G.nodes(data=True)[node]['layer'] = layer_index
pos = nx.multipartite_layout(G, subset_key='layer')
nx.draw(G, pos, with_labels=True, font_weight='bold')
if max_flow is None:
edge_labels = dict([((n1, n2), f'{flow_network[n1][n2]}')
for n1, n2, d in G.edges])
else:
edge_labels = dict([((n1, n2), f'{max_flow[n1][n2]}/{flow_network[n1][n2]}')
for n1, n2, d in G.edges])
nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_size=8, label_pos=0.6)
plt.show()
def create_bowtie(self):
threats_bars = dict(
zip(self.threats, [bar.split(",") for bar in self.barriers]))
consequences_mits = dict(
zip(self.consequences,
[mit.split(",") for mit in self.mitigations]))
width = len(sum([bar.split(",") for bar in self.barriers], [])) + len(self.threats) + \
len(sum([mit.split(",") for mit in self.mitigations], [])) + len(self.consequences)
hazards_ue = [self.hazard, self.undesired_event, self.bowtie_id]
Bowtie.connect_nodes(branch=threats_bars,
master=hazards_ue,
labels=["threat", "barrier"],
width=width)
Bowtie.connect_nodes(branch=consequences_mits,
master=hazards_ue,
labels=["consequence", "mitigation"],
width=width)
pos = nx.multipartite_layout(Bowtie.graph, subset_key="layer")
nx.draw_networkx_nodes(Bowtie.graph, pos, node_size=750)
nx.draw_networkx_edges(Bowtie.graph,
pos,
edgelist=Bowtie.graph.edges(),
edge_color="grey")
nx.draw_networkx_labels(Bowtie.graph,
pos,
font_size=12,
verticalalignment="top")
plt.show()
def draw_cell_graph(plot_title, cell_G, from_nodes_cells, to_nodes_cells):
# not plotting on main graph as we need to show synapses with both electric and chemical together
G = build_cell_graph_combining_multi_edges(cell_G=cell_G)
if len(G.nodes()) < 100:
pos = nx.multipartite_layout(G, subset_key="layer")
else:
pos = nx.spring_layout(G)
node_color_values = color_nodes(G=G,
src_nodes=from_nodes_cells,
target_nodes=to_nodes_cells)
edge_colors = nx.get_edge_attributes(G, 'color').values()
edge_weights = nx.get_edge_attributes(G, 'weight').values()
plotter.figure(plot_title)
plotter.title(plot_title)
nx.draw(G,
pos,
node_size=1000,
node_color=node_color_values,
edge_color=edge_colors,
with_labels=True)
def draw_class_graph(plot_title, class_G, from_nodes_class, to_nodes_class,
cell_pathways_count):
if len(class_G.nodes()) < 100:
pos = nx.multipartite_layout(class_G, subset_key="layer")
else:
pos = nx.spring_layout(class_G)
node_color_values = color_nodes(G=class_G,
src_nodes=from_nodes_class,
target_nodes=to_nodes_class)
edge_attr = nx.get_edge_attributes(class_G, 'attr_dict').values()
edge_colors = nx.get_edge_attributes(class_G, 'color').values()
# edge_colors = [edge['color'] for edge in edge_attr]
# edge_colors = nx.get_edge_attributes(class_G,'color').values()
# edge_weights = nx.get_edge_attributes(class_G,'weight').values()
plotter.figure(plot_title)
plotter.title(plot_title)
nx.draw(class_G,
pos,
node_size=1000,
node_color=node_color_values,
edge_color=edge_colors,
with_labels=True)
exclude_nodes = []
exclude_nodes.extend(from_nodes_class)
exclude_nodes.extend(to_nodes_class)
interneurons_list, pathways_list = get_graph_details(
G=class_G, exclude_nodes=exclude_nodes)
write_plot_legend(G=class_G,
pathways_count=cell_pathways_count,
interneurons_count=len(interneurons_list))
def display_flow_network(graph: nx.DiGraph, filename: str = ""):
pos = nx.multipartite_layout(graph, subset_key="layer")
colors = nx.get_edge_attributes(graph, 'color').values()
plt.figure(figsize=(8, 8))
nx.draw(graph, pos, edge_color=colors, with_labels=True)
plt.axis("equal")
if filename:
plt.savefig(filename)
plt.show()
def test_multipartite_layout_nonnumeric_partition_labels():
"""See gh-5123."""
G = nx.Graph()
G.add_node(0, subset="s0")
G.add_node(1, subset="s0")
G.add_node(2, subset="s1")
G.add_node(3, subset="s1")
G.add_edges_from([(0, 2), (0, 3), (1, 2)])
pos = nx.multipartite_layout(G)
assert len(pos) == len(G)
def print(self):
""" The print function displays a graphical model of the neural network, representing the neurons as nodes and displaying the weights between the connections. This uses the NetworkX library. """
G = nx.Graph()
self.nodes = []
# connecting the input to the first deep layer
nodes = []
for idx, i in enumerate(self.inputs.neurons):
for j in self.layers_deep[0].neurons:
G.add_edge(i, j, weight=round(j.prev_weight[idx], 5))
nodes.append(i)
self.nodes.append(nodes)
# connecting the deep layers together
for i in range(self.n_layers - 1):
for idx, neuron1 in enumerate(self.layers_deep[i].neurons):
for neuron2 in self.layers_deep[i + 1].neurons:
G.add_edge(neuron1,
neuron2,
weight=round(neuron2.prev_weight[idx], 5))
for layer in self.layers_deep:
nodes = []
for neuron in layer.neurons:
nodes.append(neuron)
self.nodes.append(nodes)
# connecting the final deep layer to the output layer
nodes = []
for idx, neuron in enumerate(self.layers_deep[self.n_layers -
1].neurons):
for outputNeuron in self.outputs.neurons:
G.add_edge(neuron,
outputNeuron,
weight=round(outputNeuron.prev_weight[idx], 5))
for outputNeuron in self.outputs.neurons:
nodes.append(outputNeuron)
self.nodes.append(nodes)
# stores the graph inside the object
self.graph = G
# defines each layer in the network by a priority number (count). This is to maintain the order of the layers when displaying the graph.
nx.set_node_attributes(self.graph, 0, "layer")
count = 0
for layer in self.nodes:
count += 1
for neuron in layer:
self.graph.nodes[neuron]["layer"] = count
pos = nx.multipartite_layout(self.graph, subset_key="layer")
nx.draw(self.graph, pos, with_labels=False)
labels = nx.get_edge_attributes(self.graph, "weight")
nx.draw_networkx_edge_labels(self.graph, pos, labels)
def showMultipartite(_df):
print("Graph generation started...")
G = nx.MultiGraph()
relation = mappedRelation(_df)
listOfNodes1 = [seq[0] for seq in mappedRelation(_df)]
listOfNodes2 = [seq[1] for seq in mappedRelation(_df)]
G.add_nodes_from(listOfNodes1, layer=0)
G.add_nodes_from(listOfNodes2, layer=1)
G.add_edges_from(relation)
pos = nx.multipartite_layout(G, subset_key="layer")
nx.draw(G, pos, with_labels=True, edge_color="grey")
print("Graph generated.")
plt.show()
def showMultipartiteProdCat(DFs):
G = nx.MultiGraph()
DFsWithoutItems = []
for x in range(0, 7):
df = DFs[x][DFs[x].Object != 'item']
DFsWithoutItems.append(df)
listOfNodes = []
for x in range(0, 6): #predicates
temp = []
for y1, y2 in DFs[x].iterrows():
temp.append(y2[0])
listOfNodes.append(temp)
# Don't forget bout the products
temp = []
for y1, y2 in DFs[6].iterrows():
temp.append(y2[2])
listOfNodes.append(temp)
print(listOfNodes)
## Not possible to add same node few times, so we can do it like this
for it, x in enumerate(listOfNodes):
G.add_nodes_from(x, layer=it)
for x in range(0, 6):
rels = retMappedRelation(DFsWithoutItems[x])
G.add_edges_from(rels)
pos = nx.multipartite_layout(G, subset_key="layer")
nx.draw(G, pos, with_labels=True, width=0.5, font_size=5, edge_color='r')
#Relation also here so i could colour them
rels = retMappedRelation(DFsWithoutItems[6])
nx.draw_networkx_edges(
G,
pos,
edgelist=rels,
width=0.5,
alpha=0.5,
edge_color="g",
)
plt.show()
def get_tripartite_graph(self, df_party_weights: DataFrame,
df_media_weights: DataFrame):
"""
Creates a tripartite graph fom the term-weight-tuples which were previously calculated.
:param df_party_weights: The term-weight-tuples dataframe of the parties.
:param df_media_weights: The term-weight-tuples dataframe of the media.
:return: The tripartite graph as figure.
"""
graph = nx.Graph()
graph.add_nodes_from(df_party_weights["party"], bipartite=0)
graph.add_nodes_from(df_party_weights["term"], bipartite=1)
graph.add_nodes_from(df_media_weights["media"], bipartite=2)
df_party_weights["normalized_weight"] = df_party_weights[
"weight"].apply(
lambda row: row / df_party_weights["weight"].max() * 4)
df_media_weights["normalized_weight"] = df_media_weights[
"weight"].apply(
lambda row: row / df_media_weights["weight"].max() * 4)
graph.add_weighted_edges_from(
[(row["party"], row["term"], row["normalized_weight"])
for idx, row in df_party_weights.iterrows()],
weight="weight",
)
graph.add_weighted_edges_from(
[(row["media"], row["term"], row["normalized_weight"])
for idx, row in df_media_weights.iterrows()],
weight="weight",
)
plt.close()
fig = plt.figure(1, figsize=(10, 9))
nx.draw(
graph,
pos=nx.multipartite_layout(graph, subset_key="bipartite"),
width=list(nx.get_edge_attributes(graph, "weight").values()),
with_labels=True,
)
return fig
def show_Multipartite(df):
G = nx.MultiGraph()
nodes = assign_IDs(df)
relations = make_relation_list(df)
nodes_layer1 = [] # predicates list
for n in nodes[0]:
nodes_layer1.append(n)
nodes_layer2 = [] # objects list
for n in nodes[1]:
nodes_layer2.append(n)
G.add_nodes_from(nodes_layer1, layer=0)
G.add_nodes_from(nodes_layer2, layer=1)
print(nodes_layer2)
G.add_edges_from(relations)
pos = nx.multipartite_layout(G, subset_key="layer")
return nx.draw(G, pos, with_labels=True, edge_color='green')
def main(new):
global data, bigdata
num_nodes = len(data)
print('num of nodes:', num_nodes)
G = nx.path_graph(num_nodes)
# networkxでノードに座標を追加
new.update(nx.multipartite_layout(G, scale=500))
# 追加した座標をノードデータに書き込み
for i in range(len(data)):
try:
if data[i]['data']['id']:
data[i]["position"]={
"x": pos[i][0],
"y": pos[i][1]
}
except Exception as e:
raise e
print("position added")
for i in range(20000):
data.append(bigdata[i])
def showUniversalMultipartite(df):
G = nx.MultiGraph()
rels = retMappedRelation(df)
nodes = retIDs(df)
listOfNodes1 = []
for x in nodes[0]: #predicates
listOfNodes1.append(x)
listOfNodes2 = []
for x in nodes[1]: #objects
listOfNodes2.append(x)
G.add_nodes_from(listOfNodes1, layer=0)
G.add_nodes_from(listOfNodes2, layer=1)
print(listOfNodes2)
G.add_edges_from(rels)
pos = nx.multipartite_layout(G, subset_key="layer")
nx.draw(G, pos, with_labels=True, edge_color='grey') #node_color=color,
plt.show()
def draw_flow_network(graph, title, flow_dict=None):
plt.figure(num=title)
positions = nx.multipartite_layout(graph, subset_key='layer')
nx.draw(graph,
pos=positions,
node_color="green",
node_size=600,
labels={node: node
for node in graph})
# Draw with flow amounts
if flow_dict:
edge_labels = {}
for tile_id, flow in flow_dict.items():
for end_edge, flow_amount in flow.items():
edge_labels[(tile_id, end_edge)] = flow_amount
# Draw with capacities
else:
edge_labels = nx.get_edge_attributes(graph, 'capacity')
nx.draw_networkx_edge_labels(graph, pos=positions, edge_labels=edge_labels)
def test_empty_graph(self):
G = nx.empty_graph()
vpos = nx.random_layout(G, center=(1, 1))
assert vpos == {}
vpos = nx.circular_layout(G, center=(1, 1))
assert vpos == {}
vpos = nx.planar_layout(G, center=(1, 1))
assert vpos == {}
vpos = nx.bipartite_layout(G, G)
assert vpos == {}
vpos = nx.spring_layout(G, center=(1, 1))
assert vpos == {}
vpos = nx.fruchterman_reingold_layout(G, center=(1, 1))
assert vpos == {}
vpos = nx.spectral_layout(G, center=(1, 1))
assert vpos == {}
vpos = nx.shell_layout(G, center=(1, 1))
assert vpos == {}
vpos = nx.spiral_layout(G, center=(1, 1))
assert vpos == {}
vpos = nx.multipartite_layout(G, center=(1, 1))
assert vpos == {}
vpos = nx.kamada_kawai_layout(G, center=(1, 1))
assert vpos == {}
from CommonServerUserPython import *
import networkx as nx
import math
LAYOUT = demisto.args().get('layout')
layout_to_functions = {
'shell':
lambda G: nx.shell_layout(G, scale=200),
'spring':
lambda G: nx.spring_layout(G, scale=400),
'kamada_kawai':
lambda G: nx.kamada_kawai_layout(G, scale=400),
'circular':
lambda G: nx.circular_layout(G, scale=600),
'multipartite':
lambda G: nx.multipartite_layout(
G, scale=500, subset_key="layer", align='horizontal')
}
def convert_position(_id, _type, xy_arr):
return {
'id': _id,
'type': _type,
'position': {
'x': xy_arr[0],
'y': xy_arr[1]
}
}
def generate_layout(current_incident_id, incident_ids, indicator_ids,
circuit.add_edge(9, 15)
circuit.add_edge(10, 13)
circuit.add_edge(11, 13)
circuit.add_edge(11, 14)
circuit.add_edge(12, 14)
circuit.add_edge(13, 15)
# Convert the circuit to an equivalent formula.
formula = circuit_to_formula(circuit)
print(formula_to_string(formula))
labels = nx.get_node_attributes(circuit, "label")
options = {
"node_size": 600,
"alpha": 0.5,
"node_color": "blue",
"labels": labels,
"font_size": 22,
}
plt.figure(figsize=(8, 8))
pos = nx.multipartite_layout(circuit, subset_key="layer")
nx.draw_networkx(circuit, pos, **options)
plt.title(formula_to_string(formula))
plt.axis("equal")
plt.show()
subset_color = [
"gold",
"violet",
"violet",
"violet",
"violet",
"limegreen",
"limegreen",
"darkorange",
]
def multilayered_graph(*subset_sizes):
extents = pairwise(itertools.accumulate((0, ) + subset_sizes))
layers = [range(start, end) for start, end in extents]
G = nx.Graph()
for (i, layer) in enumerate(layers):
G.add_nodes_from(layer, layer=i)
for layer1, layer2 in pairwise(layers):
G.add_edges_from(itertools.product(layer1, layer2))
return G
G = multilayered_graph(*subset_sizes)
color = [subset_color[data["layer"]] for v, data in G.nodes(data=True)]
pos = nx.multipartite_layout(G, subset_key="layer")
plt.figure(figsize=(8, 8))
nx.draw(G, pos, node_color=color, with_labels=False)
plt.axis("equal")
plt.show()
for k,v in nodesDict.items():
for node in v:
G.add_node(node, role=k)
# Cell
for i in nodesDict[0]:
for j in nodesDict[1]:
if random() <= 0.25:
G.add_edge(i,j, relation='tableInput')
for i in nodesDict[1]:
for j in nodesDict[2]:
if random() <= 0.4:
G.add_edge(i,j, relation='modelConsumer')
# Cell
nx.draw_networkx(G, with_labels=True)
# Cell
pos = nx.multipartite_layout(G, subset_key="role")
color = list(itertools.chain(itertools.repeat('gold', len(datasourceNodes)),
itertools.repeat('violet', len(modelNodes)),
itertools.repeat('limegreen', len(stakeholderNodes)),
))
# Cell
plt.figure(figsize=(8, 8))
nx.draw(G, pos, node_color=color,with_labels=True)
plt.axis("equal")
plt.show()
def buildGraph(self):
self.publishers = []
self.subscribers = []
pubs_list = []
subs_list = []
font_size = 8
max = 1
y_offset = 0
new_nodetoplot = []
old_nodetoplot = []
good_chantoplot = []
old_chantoplot = []
edgestoplot = []
self.g.clear()
size_of_node = 266.66666
self.g.add_node("Publishers", layer=0)
self.g.add_node("Channels", layer=1, node_color="white")
self.g.add_node("Subscribers", layer=2, node_color="white")
self.g.add_edge("Publishers", "Channels")
self.g.add_edge("Channels", "Subscribers")
label_list = {}
width = self.canvas.width
height = self.canvas.height
for chan in self.channels:
self.g.add_node(str(chan), layer=1)
for pubs in self.channels[chan]["publishers"]:
ip_port = "IP:" + str(pubs[0]) + "\nPort:" + str(pubs[1])
self.g.add_node(str(ip_port), layer=0)
self.g.add_edge(str(ip_port), str(chan))
edgestoplot.append([str(ip_port), str(chan)])
if pubs not in self.g:
self.publishers.append(pubs)
pubs_list.append(str(ip_port))
for subs in self.channels[chan]["subscribers"]:
ip_port = "IP:" + str(subs[0]) + "\nPort:" + str(subs[1])
self.g.add_node(str(ip_port), layer=2)
self.g.add_edge(str(chan), str(ip_port))
edgestoplot.append([str(chan), str(ip_port)])
if subs not in self.g:
self.subscribers.append(subs)
subs_list.append(str(ip_port))
if (len(self.channels) > 1):
max = len(self.channels)
if (len(self.subscribers) > max):
max = len(self.subscribers)
if (len(self.publishers) > max):
max = len(self.publishers)
plt.clf()
pos = nx.multipartite_layout(self.g, subset_key="layer")
nx.draw_networkx_nodes(
self.g,
pos,
nodelist=["Publishers", "Channels", "Subscribers"],
node_color="w")
if ((1.0 / max) * height * .1) > 8:
font_size = 8
else:
font_size = ((1.0 / max) * height * .1)
if max < 3:
y_offset = ((1.0 / 4) / 2)
else:
y_offset = ((1.0 / max) / 2)
for node in pos:
x, y = pos[node]
text = str(node)
if (text != "Publishers" and text != "Channels"
and text != "Subscribers"):
if (text in pubs_list):
plt.text(x,
y + y_offset,
text,
horizontalalignment='right',
fontsize=font_size)
lookup = node.replace("IP:", "")
lookup = lookup.replace("\nPort", "")
if (self.parent.host.checkPub(lookup)):
new_nodetoplot.append(str(node))
else:
old_nodetoplot.append(str(node))
if (text in subs_list):
plt.text(x,
y + y_offset,
text,
horizontalalignment='left',
fontsize=font_size)
lookup = node.replace("IP:", "")
lookup = lookup.replace("\nPort", "")
if (self.parent.host.checkSub(lookup)):
new_nodetoplot.append(str(node))
else:
old_nodetoplot.append(str(node))
if (text in self.channels):
plt.text(x,
y + y_offset,
text,
horizontalalignment='center',
fontsize=font_size)
if (self.parent.host.checkChan(node)):
good_chantoplot.append(str(node))
else:
old_chantoplot.append(str(node))
else:
if (max == 0):
plt.text(x,
0.0,
text,
horizontalalignment='center',
fontsize=8)
elif (max == 1):
plt.text(x,
0.4166666666666666666666,
text,
horizontalalignment='center',
fontsize=8)
elif (max == 2):
plt.text(x,
0.7777777777777777777777,
text,
horizontalalignment='center',
fontsize=8)
else:
plt.text(x,
1.0,
text,
horizontalalignment='center',
fontsize=8)
if (((1.0 / max) * height) < size_of_node):
size_of_node = ((1.0 / max) * height)
nx.draw_networkx_nodes(self.g,
pos,
nodelist=new_nodetoplot,
node_size=size_of_node)
nx.draw_networkx_nodes(self.g,
pos,
nodelist=old_nodetoplot,
node_size=size_of_node,
node_color="grey")
nx.draw_networkx_nodes(self.g,
pos,
nodelist=good_chantoplot,
node_size=size_of_node,
node_shape='s')
nx.draw_networkx_nodes(self.g,
pos,
nodelist=old_chantoplot,
node_size=size_of_node,
node_shape='s',
node_color="grey")
nx.draw_networkx_edges(self.g,
pos,
edgelist=edgestoplot,
arrowstyle="-")
plt.axis('off')
plt.savefig('figure.png')
image = Image.open('figure.png')
img_width, img_height = image.size
rel_width = img_width / width
rel_height = img_height / height
image = image.resize(
(int((rel_width + .4) * width), int((rel_height + .4) * height)),
Image.ANTIALIAS) ## The (250, 250) is (height, width)
img = ImageTk.PhotoImage(image)
self.parent.one = img
self.canvas.create_image(width / 2,
height / 2,
anchor='center',
image=img)
image.close()
os.remove('figure.png')
def get_feasibility_tree_graph(model, building_element_index):
G = nx.Graph()
element = model.building_element_list[building_element_index]
print(
f"Considered building element | id: {element.id}, name: {element.name}"
)
G.add_node(element.id,
name=element.name,
color='lightgray',
label=element.id,
subset=0)
all_activities = element.reference_process.activities
activities = []
for activity in all_activities:
if activity.state == 'IDLE':
activities.append(activity)
# Building Element Nodes
for activity in activities:
G.add_node(activity.id,
name=activity.name,
color='bisque',
label=remove_prefix(activity.id, element.id),
subset=1)
G.add_edge(element.id, activity.id)
for capability in activity.capabilities:
G.add_node(capability.id,
name=capability.name,
color='bisque',
label=remove_prefix(capability.id, activity.id),
subset=2)
G.add_edge(activity.id, capability.id)
for parameter in capability.parameters:
G.add_node(
(capability.id + "/" + parameter.id),
name=parameter.name,
color='bisque',
label="/" + parameter.id + ": " + str(parameter.value) +
" " + str(parameter.dimensionUnit),
subset=3)
G.add_edge(capability.id, (capability.id + "/" + parameter.id))
#Resources nodes
for resource in model.resource_list:
G.add_node(resource.id,
name=resource.name,
color='lightskyblue',
label=resource.id,
subset=8)
for setup in resource.setups:
G.add_node((resource.id + "/" + setup.name),
name=setup.name,
color='lightskyblue',
label='/' + setup.name,
subset=7)
G.add_edge((resource.id + "/" + setup.name), resource.id)
for offered_capability in setup.capabilities:
G.add_node((resource.id + "/" + offered_capability.id),
name=offered_capability.name,
color='lightskyblue',
label=offered_capability.id[4:],
subset=6)
G.add_edge((resource.id + "/" + offered_capability.id),
(resource.id + "/" + setup.name))
for offered_parameter in offered_capability.parameters:
try:
offered_parameter_label = offered_parameter.id + ": " + str(
offered_parameter.value_range) + " " + str(
offered_parameter.dimensionUnit)
except:
offered_parameter_label = offered_parameter.id + ": " + str(
offered_parameter.value) + " " + str(
offered_parameter.dimensionUnit)
G.add_node(resource.id + "/" + offered_capability.id +
"/" + offered_parameter.id,
name=offered_parameter.name,
color='lightskyblue',
label=offered_parameter_label,
subset=5)
G.add_edge((resource.id + "/" + offered_capability.id +
"/" + offered_parameter.id),
(resource.id + "/" + offered_capability.id))
# Connections
for activity in activities:
for capability in activity.capabilities:
possible_resources = get_possible_resources_by_capability(
model.resource_list, capability)
for needed_parameter in capability.parameters:
for resource in possible_resources:
for offered_parameter in resource[2].parameters:
if (resource[0].id + "/" + resource[2].id + "/" +
offered_parameter.id) in G:
if (offered_parameter.id) == (needed_parameter.id):
G.add_edge(
(capability.id + "/" +
needed_parameter.id),
(resource[0].id + "/" + resource[2].id +
"/" + offered_parameter.id))
else:
print("Node not existing: ")
print((resource[0].id + "/" + resource[2].id +
"/" + offered_parameter.id))
att_labels = nx.get_node_attributes(G, 'label')
att_colors = list(nx.get_node_attributes(G, 'color').values())
#pos = hierarchy_pos(G, root=element.id)
pos = nx.multipartite_layout(G, scale=1.2)
#pos = nx.kamada_kawai_layout(G)
nx.draw_networkx(G, pos=pos, with_labels=False, node_color=att_colors)
text = nx.draw_networkx_labels(G, pos, font_size=8, labels=att_labels)
for _, t in text.items():
t.set_rotation(45)
plt.show()
def segmentation(self, c0, max_iter = None, visualize=False, show_graphs=False):
# make graph for image
self.image_to_graph()
if(visualize and show_graphs):
plt.imshow(self.A)
plt.title("adjacency matrix for graph G")
plt.show()
# subset attribute allows for better visualization of graph as grid
for n in list(self.G.nodes):
self.G.nodes[n]['subset'] = n % self.m # row number
nx.draw(self.G, with_labels=True, pos=nx.multipartite_layout(self.G))
plt.show()
i = 0
contour_list = [c0]
cp = c0
ci = c0
while True:
if(visualize):
print("ITERATION %d" % i)
# 1. Dilate current contour ci into its contour neighborhood CN(ci) with an inner contour ICi and an outer contour OCi.
dilated, contours = self.dilation(cp)
if(len(contours) == 1):
ci_image = np.zeros(cp.shape, dtype=np.uint8)
xs = [x[0][0] for x in contours[0]]
ys = [x[0][1] for x in contours[0]]
for j in range(len(xs)):
ci_image[xs[j], ys[j]] = 1
if(visualize):
plt.imshow(ci_image, cmap='gray')
plt.show()
return ci_image
if(visualize):
plt.subplot(1,2,1)
plt.imshow(dilated, cmap = 'gray')
plt.title("dilated contour")
xs = [x[0][0] for x in contours[0]]
ys = [x[0][1] for x in contours[0]]
plt.subplot(1,2,2)
plt.imshow(dilated, cmap = 'gray')
plt.plot(xs, ys)
xs = [x[0][0] for x in contours[1]]
ys = [x[0][1] for x in contours[1]]
plt.plot(xs, ys)
plt.title("inner and outer contour")
plt.show()
# 2. Identify all the vertices corresponding to the inner contour as a single source si and identify all the vertices corresponding to the outer contour as a single sink ti to obtain a new graph Gi.
Gi, Ai = self.vertex_identification(contours[0], contours[1])
if(visualize and show_graphs):
plt.imshow(Ai)
plt.title("adjacency matrix for new graph Gi")
plt.show()
# subset attribute allows for better visualization of graph as grid
for n in list(Gi.nodes):
if n != 's' and n != 't':
Gi.nodes[n]['subset'] = n % self.m + 1 # row number
Gi.nodes['s']['subset'] = int(0)
Gi.nodes['t']['subset'] = int(self.n+1)
pos=nx.multipartite_layout(Gi)
nx.draw(Gi, with_labels=True, pos=pos)
edge_labels = nx.get_edge_attributes(Gi,'capacity') # key is edge, pls check for your case
nx.draw_networkx_edge_labels(Gi,pos,edge_labels=edge_labels,font_color='red')
plt.show()
# 3. Compute the s–t minimum cut MC(Gi,si,ti) to obtain a new contour ci+1
ci = self.min_cut(Gi)
ci_image = np.zeros(cp.shape, dtype=np.uint8)
# xs = [x[0][0] for x in ci]
# ys = [x[0][1] for x in ci]
xs = [x[0] for x in ci]
ys = [x[1] for x in ci]
for j in range(len(xs)):
ci_image[xs[j], ys[j]] = 1
if(visualize):
# plt.subplot(1,3,1)
# plt.imshow(self.image, cmap = 'gray')
# plt.plot(xs, ys)
plt.title("new contour")
plt.subplot(1,2,1)
plt.imshow(ci_image, cmap='gray')
plt.title("new contour")
plt.subplot(1,2,2)
plt.imshow(cp, cmap='gray')
plt.title("previous contour")
plt.show()
# 4. Terminate the algorithm if a resulting contour reoccurs, otherwise set i=i+1 and return to step 1.
if np.linalg.norm(cp-ci_image) < 1e-5:
break
else:
contour_list.append(ci_image)
cp = ci_image
if max_iter is not None and i >= max_iter:
break
i = i + 1
return ci_image
def drawGraph(self):
graph = self.getGraph
nx.draw(graph, nx.multipartite_layout(graph, "vertex", "horizontal"))
def draw_bipartite(
weights=None,
weight_max=None,
):
# if weights is None:
# weights = np.array([[1, 19], [10, 10]])
n_node = len(weights)
if weight_max is None:
weight_max = np.mean(np.sum(weights, 1)) * 2
# weight_max = 20
node_sizes = np.concatenate([np.sum(weights, 1), np.sum(weights, 0)])
G = nx.DiGraph()
for i in range(n_node):
G.add_node(i, layer=0, count=node_sizes[i])
G.add_node(i + n_node, layer=1, count=node_sizes[i + n_node])
for src in range(n_node):
for dst in range(n_node):
G.add_weighted_edges_from([(src, dst + n_node, weights[src, dst])])
c_max = 255
cmap = plt.get_cmap('coolwarm', c_max)
pos = nx.multipartite_layout(G, subset_key="layer")
# plt.figure(figsize=(3, 3))
nx.draw_networkx_nodes(G,
pos,
nodelist=np.arange(n_node**2),
node_size=300 * node_sizes / weight_max,
node_color=cmap(node_sizes / weight_max),
cmap=cmap,
alpha=0.5)
wmax = np.amax(weights)
for edge, v in G.edges.items():
w = v['weight']
nx.draw_networkx_edges(
G,
pos,
edgelist=[edge],
edge_color=cmap(w / weight_max * n_node),
width=0,
arrowstyle=ArrowStyle.Simple(
head_length=w / weight_max * 2.1,
head_width=w / weight_max * 1.4,
tail_width=w / weight_max * 0.5,
),
min_source_margin=wmax / 2 + weight_max * 0.2,
min_target_margin=wmax / 2 + weight_max * 0.2,
)
edge_weights = {k: '%g' % v['weight'] for k, v in G.edges.items()}
nx.draw_networkx_edge_labels(G,
pos,
edge_labels=edge_weights,
label_pos=0.33)
node_labels = {k: '%g' % v['count'] for k, v in G.nodes.items()}
nx.draw_networkx_labels(G, pos, labels=node_labels)
plt.axis("equal")
plt.box(False)
# plt.show()
# print('--')
return G, pos
def get_person_relations(externalUid: str):
if not graph_conn:
test()
result = {}
try:
relations_query_result = graph_conn.query_data(family_tree_query,
{'$xuid': externalUid})
except Exception as e:
logging.error('At fetching family relations of %s' % extrenalUid)
logging.error(e)
if "details" in dir(e):
details = e.details()
else:
details = str(e)
raise GraphException(details)
if len(relations_query_result['relations']) == 0:
raise NotAvailableException("Realtions: " + str(externalUid))
result['person'] = {
"name":
relations_query_result['relations'][0]['name'],
"link":
"%s/names/relations?externalUid=%s" %
(base_URL,
urllib.parse.quote(
relations_query_result['relations'][0]['externalUid']))
}
result['siblings'] = []
if "father" in relations_query_result['relations'][0]:
result['father'] = {
"name":
relations_query_result['relations'][0]['father'][0]['name'],
"link":
"%s/names/relations?externalUid=%s" %
(base_URL,
urllib.parse.quote(relations_query_result['relations'][0]
['father'][0]['externalUid']))
}
if 'sibling' in relations_query_result['relations'][0]['father'][0]:
for sibling in relations_query_result['relations'][0]['father'][0][
'sibling']:
if sibling['externalUid'] != externalUid:
result['siblings'].append({
"name":
sibling['name'],
"link":
"%s/names/relations?externalUid=%s" %
(base_URL, urllib.parse.quote(sibling['externalUid']))
})
elif "sameAs" in relations_query_result['relations'][0]:
for otherName in relations_query_result['relations'][0]['sameAs']:
if 'father' in otherName:
if 'father' not in result:
result['father'] = {
"name":
otherName['father'][0]['name'],
"link":
"%s/names/relations?externalUid=%s" %
(base_URL,
urllib.parse.quote(
otherName['father'][0]['externalUid']))
}
if 'sibling' in otherName['father'][0]:
for sibling in otherName['father'][0]['sibling']:
result['siblings'].append({
"name":
sibling['name'],
"link":
"%s/names/relations?externalUid=%s" %
(base_URL,
urllib.parse.quote(sibling['externalUid']))
})
break
if "mother" in relations_query_result['relations'][0]:
result['mother'] = {
"name":
relations_query_result['relations'][0]['mother'][0]['name'],
"link":
"%s/names/relations?externalUid=%s" %
(base_URL,
urllib.parse.quote(relations_query_result['relations'][0]
['mother'][0]['externalUid']))
}
if 'sibling' in relations_query_result['relations'][0]['mother'][0]:
for sibling in relations_query_result['relations'][0]['mother'][0][
'sibling']:
sib = {
"name":
sibling['name'],
"link":
"%s/names/relations?externalUid=%s" %
(base_URL, urllib.parse.quote(sibling['externalUid']))
}
if sibling['externalUid'] != externalUid and sib not in result[
'siblings']:
result['siblings'].append()
elif "sameAs" in relations_query_result['relations'][0]:
for otherName in relations_query_result['relations'][0]['sameAs']:
if 'mother' in otherName:
if 'mother' not in result:
result['mother'] = {
"name":
otherName['mother'][0]['name'],
"link":
"%s/names/relations?externalUid=%s" %
(base_URL,
urllib.parse.quote(
otherName['mother'][0]['externalUid']))
}
if 'sibling' in otherName['mother'][0]:
for sibling in otherName['mother'][0]['sibling']:
sib = {
"name":
sibling['name'],
"link":
"%s/names/relations?externalUid=%s" %
(base_URL,
urllib.parse.quote(sibling['externalUid']))
}
if sibling[
'externalUid'] != externalUid and sib not in result[
'siblings']:
result['siblings'].append({
"name":
sibling['name'],
"link":
"%s/names/relations?externalUid=%s" %
(base_URL,
urllib.parse.quote(sibling['externalUid']))
})
break
result['spouses'] = []
if "spouse" in relations_query_result['relations'][0]:
for spouse in relations_query_result['relations'][0]['spouse']:
sps = {
"name":
spouse['name'],
"link":
"%s/names/relations?externalUid=%s" %
(base_URL, urllib.parse.quote(spouse['externalUid']))
}
if sps not in result['spouses']:
result['spouses'].append(sps)
elif "sameAs" in relations_query_result['relations'][0]:
for otherName in relations_query_result['relations'][0]['sameAs']:
if "spouse" in otherName:
for spouse in otherName['spouse']:
sps = {
"name":
spouse['name'],
"link":
"%s/names/relations?externalUid=%s" %
(base_URL, urllib.parse.quote(spouse['externalUid']))
}
if sps not in result['spouses']:
result['spouses'].append(sps)
result['children'] = []
if "children1" in relations_query_result['relations'][0]:
for child in relations_query_result['relations'][0]['children1']:
ch = {
"name":
child['name'],
"link":
"%s/names/relations?externalUid=%s" %
(base_URL, urllib.parse.quote(child['externalUid']))
}
if ch not in result['children']:
result['children'].append(ch)
elif "children2" in relations_query_result['relations'][0]:
for child in relations_query_result['relations'][0]['children2']:
ch = {
"name":
child['name'],
"link":
"%s/names/relations?externalUid=%s" %
(base_URL, urllib.parse.quote(child['externalUid']))
}
if ch not in result['children']:
result['children'].append(ch)
elif "sameAs" in relations_query_result['relations'][0]:
for otherName in relations_query_result['relations'][0]['sameAs']:
if 'children1' in otherName:
for child in otherName['children1']:
ch = {
"name":
child['name'],
"link":
"%s/names/relations?externalUid=%s" %
(base_URL, urllib.parse.quote(child['externalUid']))
}
if ch not in result['children']:
result['children'].append(ch)
elif 'children2' in otherName:
for child in otherName['children2']:
ch = {
"name":
child['name'],
"link":
"%s/names/relations?externalUid=%s" %
(base_URL, urllib.parse.quote(child['externalUid']))
}
if ch not in result['children']:
result['children'].append(ch)
if len(result['spouses']) == 0:
del result['spouses']
if len(result['siblings']) == 0:
del result['siblings']
if len(result['children']) == 0:
del result['children']
fig = plt.figure(figsize=(12, 12))
ax = plt.subplot(111)
ax.set_title('Graph - Shapes', fontsize=10)
G = nx.DiGraph()
G.add_node(result['person']['name'], level=3)
colour_list = ["blue"]
if 'father' in result:
G.add_node(result['father']['name'], level=4)
G.add_edge(result['person']['name'],
result['father']['name'],
label='father')
colour_list.append("green")
if 'mother' in result:
G.add_node(result['mother']['name'], level=4)
G.add_edge(result['person']['name'],
result['mother']['name'],
label='mother')
colour_list.append("green")
if 'siblings' in result:
for sib in result['siblings']:
G.add_node(sib['name'], level=2)
G.add_edge(result['person']['name'], sib['name'], label='sibling')
colour_list.append("purple")
if 'spouses' in result:
for sps in result['spouses']:
G.add_node(sps['name'], level=2)
G.add_edge(result['person']['name'], sps['name'], label='spouse')
colour_list.append("pink")
if 'children' in result:
for child in result['children']:
G.add_node(child['name'], level=1)
G.add_edge(result['person']['name'], child['name'], label='child')
colour_list.append("orange")
pos = nx.multipartite_layout(G, subset_key='level', align='horizontal')
nx.draw(G,
pos,
node_size=5000,
node_color=colour_list,
font_size=20,
font_weight='bold')
nx.draw_networkx_labels(G, pos)
nx.draw_networkx_edge_labels(G, pos)
plt.tight_layout()
plt.savefig("static/Family-tree.png")
rels_html = ""
for key in result:
if key in ['person', 'mother', 'father']:
rels_html += '%s:<a href="%s">%s</a><br>' % (
key.upper(), result[key]['link'], result[key]['name'])
else:
items = ", ".join([
'<a href="%s">%s</a>' % (it['link'], it['name'])
for it in result[key]
])
# items = ['<a href="%s">%s</a>'%(it['link'], it['name']) for it in result[key]]
rels_html += '%s:%s <br>' % (key.upper(), str(items))
html_file = open("Family-tree.html", "w")
html_content = '''
<html>
<body>
<div style="float:left" width="25%%">
%s
</div>
<div style="float:left" width="75%%">
<img src="/static/Family-tree.png" height="750px">
</div>
</body>
</html>
''' % rels_html
html_file.write(html_content)
html_file.close()
return FileResponse("Family-tree.html")
