def to_networkxs(self):
"""Returns a networkx graph that contains the stored data.
The node and edge features are placed in the networkx graph's nodes and edges attribute dictionaries
under the "features" key. Edges are added in the order they are stored in the `self.edges` tensor.
The global features are placed under the key "features" of the the networkx graph's property.
:returns: An instance of `networkx.OrderedMultiDiGraph`.
"""
output_graphs_nx = []
for g in self.batch_iterator():
graph_nx = nx.OrderedMultiDiGraph()
graph_nx.graph[GRAPH_NX_FEATURES_KEY] = g.globals.numpy()[0]
nodes_list = _unstack(g.nodes)
for i, x in enumerate(nodes_list):
graph_nx.add_node(i, **{GRAPH_NX_FEATURES_KEY: x})
edges_features = [{
"index": i,
GRAPH_NX_FEATURES_KEY: x
} for i, x in enumerate(_unstack(g.edges))]
edges_data = zip(g.senders.numpy(), g.receivers.numpy(),
edges_features)
graph_nx.add_edges_from(edges_data)
output_graphs_nx.append(graph_nx)
return output_graphs_nx
def __init__(self, region_id, label=''):
self.region_id = region_id
# self.node_data = node_data
# self.edge_data = edge_data
self.label = Label(label)
self.graph = nx.OrderedMultiDiGraph()
self.path_node_ids = None
def generate_graph(raw_graph, edge_permutations, target_graph):
num_nodes = len(raw_graph[1])
num_edges = len(raw_graph[2])
graph_nx = nx.OrderedMultiDiGraph()
# Globals
graph_nx.graph['features'] = raw_graph[0]
# Nodes
for node_id in range(num_nodes):
graph_nx.add_node(raw_graph[1][node_id][0],
features=raw_graph[1][node_id][1])
# Edges
for edge_id in range(num_edges):
graph_nx.add_edge(raw_graph[2][edge_id][0],
raw_graph[2][edge_id][1],
features=raw_graph[2][edge_id][2])
if target_graph:
graph_nx.add_edge(raw_graph[2][edge_id][1],
raw_graph[2][edge_id][0],
features=raw_graph[2][edge_id][2])
else:
graph_nx.add_edge(
raw_graph[2][edge_id][1],
raw_graph[2][edge_id][0],
features=raw_graph[2][edge_id][2][edge_permutations])
return graph_nx
def test_global_access_with_key():
g = nx.OrderedMultiDiGraph()
g.data = {}
assert g.get_global("data") == {}
g.get_global("data")["k"] = 1
g.get_global("data").update({"u": 2})
assert g.get_global("data") == {"k": 1, "u": 2}
def test_from_networkx_no_edge(self, keys):
kwargs = {"feature_key": "features", "global_attr_key": "data"}
feature_key, global_attr_key = keys
if feature_key is not None:
kwargs["feature_key"] = feature_key
else:
del kwargs["feature_key"]
if global_attr_key is not None:
kwargs["global_attr_key"] = global_attr_key
else:
del kwargs["global_attr_key"]
fkey = kwargs.get("feature_key", "features")
gkey = kwargs.get("global_attr_key", None)
g = nx.OrderedMultiDiGraph()
g.add_node("node1", **{fkey: np.random.randn(5)})
g.add_node("node2", **{fkey: np.random.randn(5)})
g.ordered_edges = []
# g.add_edge('node1', 'node2', **{fkey: torch.randn(4)})
g.set_global({fkey: np.random.randn(3)}, gkey)
data = GraphData.from_networkx(g, **kwargs)
Comparator.data_to_nx(data, g, fkey, gkey)
def __init__(self, model):
super().__init__()
self.nx_graph = nx.OrderedMultiDiGraph()
self._input_names = inputs = model.get('inputs', 'input')
self._output_names = outputs = model.get('outputs', 'output')
self._add_module(inputs, outputs, model['name'], model, [])
self._optimize()
self._validate()
def __init__(self, nodes, edges, regions, dimensions):
self.nodes = nodes
self.edges = edges
self.regions = regions
self.dimensions = dimensions
self.node_counts = {node_name: 0 for node_name in self.nodes}
self.graph = nx.OrderedMultiDiGraph()
self.graph_contains_loops = False
def as_networkx_graph(self):
import networkx as nx
graph = nx.OrderedMultiDiGraph()
# Not sure if we could just insert edges and have the nodes be inserted
# automatically, not sure if order is properly preserved then
graph.add_nodes_from(self.graph.keys())
graph.add_edges_from(((u, v, { 'action': a }) \
for u, edges in self.graph.items() \
for a, v in edges.items()))
return graph
def deal_image(self, image):
graph_nx = nx.OrderedMultiDiGraph()
# Globals.
graph_nx.graph["features"] = np.random.randn(36)
# Nodes.
for i in range(self.block_height):
for j in range(self.block_width):
graph_nx.add_node(
i * self.block_width + j,
features=image[i * self.stride:(i + 1) * self.stride,
j * self.stride:(j + 1) *
self.stride].flatten())
# Edges.
for i in range(self.block_height):
for j in range(self.block_width):
if i - 1 >= 0 and j >= 0:
graph_nx.add_edge(i * self.block_width + j,
(i - 1) * self.block_width + j,
features=np.random.randn(10))
graph_nx.add_edge((i - 1) * self.block_width + j,
i * self.block_width + j,
features=np.random.randn(10))
if i + 1 >= 0 and j >= 0 and i + 1 <= self.block_height - 1:
graph_nx.add_edge(i * self.block_width + j,
(i + 1) * self.block_width + j,
features=np.random.randn(10))
graph_nx.add_edge((i + 1) * self.block_width + j,
i * self.block_width + j,
features=np.random.randn(10))
if i >= 0 and j - 1 >= 0:
graph_nx.add_edge(i * self.block_width + j,
i * self.block_width + j - 1,
features=np.random.randn(10))
graph_nx.add_edge(i * self.block_width + j - 1,
i * self.block_width + j,
features=np.random.randn(10))
if i >= 0 and j + 1 >= 0 and j + 1 <= self.block_width - 1:
graph_nx.add_edge(i * self.block_width + j,
i * self.block_width + j + 1,
features=np.random.randn(10))
graph_nx.add_edge(i * self.block_width + j + 1,
i * self.block_width + j,
features=np.random.randn(10))
return graph_nx
def generate_example_nn(positions, properties, k=1, plot=False):
"""
Generate a k-nn graph from positions.
Args:
positions: [num_points, 3] positions used for graph constrution.
properties: [num_points, F0,...,Fd] each node will have these properties of shape [F0,...,Fd]
k: int, k nearest neighbours are connected.
plot: whether to plot graph.
Returns: GraphTuple
"""
graph = nx.OrderedMultiDiGraph()
kdtree = cKDTree(positions)
dist, idx = kdtree.query(positions, k=k + 1)
receivers = idx[:, 1:] #N,k
senders = np.arange(positions.shape[0]) #N
senders = np.tile(senders[:, None], [1, k]) #N,k
receivers = receivers.flatten()
senders = senders.flatten()
n_nodes = positions.shape[0]
pos = dict() # for plotting node positions.
edgelist = []
for node, feature, position in zip(np.arange(n_nodes), properties,
positions):
graph.add_node(node, features=feature)
pos[node] = position[:2]
# edges = np.stack([senders, receivers], axis=-1) + sibling_node_offset
for u, v in zip(senders, receivers):
graph.add_edge(u, v, features=None)
graph.add_edge(v, u, features=None)
edgelist.append((u, v))
edgelist.append((v, u))
graph.graph['features'] = None
# plotting
if plot:
fig, ax = plt.subplots(1, 1, figsize=(12, 12))
draw(graph, ax=ax, pos=pos, node_color='green', edge_color='red')
plt.show()
return networkxs_to_graphs_tuple(
[graph], node_shape_hint=[positions.shape[1] + properties.shape[1]])
def _single_data_dict_to_networkx(data_dict):
graph_nx = nx.OrderedMultiDiGraph()
if data_dict["nodes"].size > 0:
for i, x in enumerate(data_dict["nodes"]):
graph_nx.add_node(i, features=x)
if data_dict["edges"].size > 0:
edge_data = zip(data_dict["senders"], data_dict["receivers"], [{
"features": x
} for x in data_dict["edges"]])
graph_nx.add_edges_from(edge_data)
graph_nx.graph["features"] = data_dict["globals"]
return graph_nx
def generate_singulation_graph(config, n_manipulable_objects):
gripper_as_global = config.gripper_as_global
#graph_nx = nx.DiGraph()
graph_nx = nx.OrderedMultiDiGraph()
if not gripper_as_global:
offset = 1
else:
offset = 0
""" adding features to nodes """
# 120*160*4(seg+rgb)
#graph_nx.add_node(0, type_name='container')
#graph_nx.add_node(0, features=np.zeros(shape=(config.node_output_size,), dtype=np.float32))
if not gripper_as_global:
""" if gripper should be a global attribute, include its data in global features """
# 120*160*4(seg+rgb)+3(pos)
graph_nx.add_node(0, type_name='gripper')
graph_nx.add_node(0,
features=np.zeros(shape=(config.node_output_size, ),
dtype=np.float32))
for i in range(offset, n_manipulable_objects):
''' no multiple features -> flatten and concatenate everything '''
# 120*160*4(seg+rgb)+3(vel)+3(pos)
object_str = str(i)
graph_nx.add_node(i, type_name='manipulable_object_' + object_str)
graph_nx.add_node(i,
features=np.zeros(shape=(config.node_output_size, ),
dtype=np.float32))
""" adding edges and features, the container does not have edges due to missing objpos """
edge_tuples = [(a, b)
for a, b in product(range(0, graph_nx.number_of_nodes()),
range(0, graph_nx.number_of_nodes()))
if a != b]
for edge in edge_tuples:
graph_nx.add_edge(*edge,
key=0,
features=np.zeros(shape=(config.edge_output_size, ),
dtype=np.float32))
""" adding global features """
# 120*160*3(rgb)+120*160(seg)+120*160*3(depth)+1(timestep)+1(gravity)
graph_nx.graph["features"] = np.zeros(shape=(config.global_output_size, ),
dtype=np.float32)
return graph_nx
def test_networkxs_to_data_dict_raises_node_key_error(self):
"""If the nodes have keys not consistent with the order they were added."""
graph_nx = nx.OrderedMultiDiGraph()
graph_nx.add_node(0, features=None)
graph_nx.add_node(1, features=None)
graph_nx.add_node(3, features=None)
with self.assertRaisesRegexp(
ValueError, "found node with index 2 and key 3"):
utils_np.networkx_to_data_dict(graph_nx)
# Check that it is still raised even if there is a node with each key,
# and only the order is wrong.
graph_nx.add_node(2, features=None)
with self.assertRaisesRegexp(
ValueError, "found node with index 2 and key 3"):
utils_np.networkx_to_data_dict(graph_nx)
def make_digraph(s,t,w=None):
'''
Makes a digraph with potential weights w
It takes in two required arguments:
s: A list indicating start nodes of all edges
t: A list indicating end nodes of all edges
'''
# Set up a NetworkX graph
G = nx.OrderedMultiDiGraph()
# If weights are not specified, make the graph without weights
if w is None:
edge_list = list(zip(s,t))
G.add_edges_from(edge_list)
# Else make weighted edges
else:
edge_list = list(zip(s,t,w))
G.add_weighted_edges_from(edge_list)
return G
def __init__(self, term: Term):
# Our DAG is an ordered graph because the edges are directional
# It is considered a MultiGraph due to our structured sharing.
# It is a digraph since the edges are directed
# One of the consequences is that finding the parent of a node is ambiguous
self.dag = nx.OrderedMultiDiGraph()
self.term = term
self.edge_labels: Dict[Tuple[Term, Term], str] = {}
self.node_labels: Dict[Term, Union[Variable, Function]] = {}
self.dag.add_node(term)
# If the term we're starting out from is just a variable or constant,
# then we just make a single node graph.
# Otherwise, we'll need to start recursing down the arguments and add edges to each one...
if isinstance(term, FuncTerm):
self.node_labels[term] = term.function
# Go through each of the arguments and add it to the graph
for index, t in enumerate(term.arguments):
self._appendTermDAG(term, t, edge_label=str(index))
else:
self.node_labels[term] = term
def test_networkxs_to_graphs_tuple_with_none_fields(self):
graph_nx = nx.OrderedMultiDiGraph()
data_dict = utils_np.networkx_to_data_dict(graph_nx,
node_shape_hint=None,
edge_shape_hint=None)
self.assertEqual(None, data_dict["edges"])
self.assertEqual(None, data_dict["globals"])
self.assertEqual(None, data_dict["nodes"])
graph_nx.add_node(0, features=None)
data_dict = utils_np.networkx_to_data_dict(graph_nx,
node_shape_hint=1,
edge_shape_hint=None)
self.assertEqual(None, data_dict["nodes"])
graph_nx.add_edge(0, 0, features=None)
data_dict = utils_np.networkx_to_data_dict(graph_nx,
node_shape_hint=[1],
edge_shape_hint=[1])
self.assertEqual(None, data_dict["edges"])
graph_nx.graph["features"] = None
utils_np.networkx_to_data_dict(graph_nx)
self.assertEqual(None, data_dict["globals"])
def draw_graph(edgeList, user_id, file_name):
lis = []
for i in edgeList:
reshaped_text = arabic_reshaper.reshape(i[0])
artext = get_display(reshaped_text)
reshaped_text1 = arabic_reshaper.reshape(i[1])
artext1 = get_display(reshaped_text1)
lis.append((artext, artext1))
G = nx.OrderedMultiDiGraph()
G.add_edges_from(lis)
pos = nx.spring_layout(G, k=0.99, iterations=50)
nx.draw_networkx_nodes(G, pos, node_color='#AED6F1', node_size=2500)
nx.draw_networkx_edges(G, pos, edgelist=G.edges(), edge_color='#95A5A6', arrows=True)
nx.draw_networkx_labels(G, pos, font_size=20, font_family='Times New Roman')
graph_path = os.path.join(os.path.join(BASE_DIR, 'static/media'), 'graph')
user_path = os.path.join(graph_path, str(user_id))
if not os.path.isdir(graph_path):
os.mkdir(graph_path)
if not os.path.isdir(user_path):
os.mkdir(user_path)
path = os.path.join(user_path, file_name)
plt.tight_layout()
plt.savefig(path+'.png', format="PNG")
plt.show()
def show(self):
G = nx.OrderedMultiDiGraph()
G.add_nodes_from(x.name for x in self.list_node)
labels = {}
for node in self.list_node:
for edge in node.edges:
# Fazer o graico ser aceito pra edges do mesmo ponto
labels[(node.name, edge.node.name)] = edge.name
G.add_edge(node.name, edge.node.name, length=5)
print("Nodes do Grafo Inicial: ")
print(self.node_init.name)
print("Nodes do Grafo Finais: ")
[print(node) for node in self.node_finals]
print("Nodes do Grafo: ")
print(G.nodes())
print("Edges do Grafo: ")
print(G.edges())
print("Labels do Grafo: ")
print(labels)
# labels={}
pos = nx.layout.spring_layout(G)
plt.figure(figsize=(20, 20))
nx.draw(G, pos, with_labels=True, edge_color='black', width=2,
linewidths=1, node_size=250, node_color='green', alpha=0.9,)
nx.draw_networkx_edge_labels(G, pos, edge_labels=labels)
plt.savefig("../graph.png") # save as png
plt.show() # display
def data_dict_to_networkx(data_dict):
"""Returns a networkx graph that contains the stored data.
Depending on the content of `data_dict`, the returned `networkx` instance has
the following properties:
- The nodes feature are placed in the nodes attribute dictionary under the
"features" key. If the `NODES` fields is `None`, a `None` value is placed
here;
- If the `RECEIVERS` field is `None`, no edges are added to the graph.
Otherwise, edges are added with the order in which they appeared in
`data_dict` stored in the "index" field of their attributes dictionary;
- The edges features are placed in the edges attribute dictionary under the
"features" key. If the `EDGES` field is `None`, a `None` value is placed;
- The global feature are placed under the key "features" of the graph
property of the returned instance. If the `GLOBALS` field is `None`, a
`None` global property is created.
Args:
data_dict: A graph `dict` of Numpy data.
Returns:
The `networkx.OrderedMultiDiGraph`.
Raises:
ValueError: If the `NODES` field of `data_dict` contains `None`, and
`data_dict` does not have a `N_NODE` field.
"""
graph_nx = nx.OrderedMultiDiGraph()
data_dict = _populate_number_fields(data_dict)
graph_nx.graph[GRAPH_NX_FEATURES_KEY] = data_dict[GLOBALS]
if data_dict[NODES] is not None:
if data_dict[NODES].shape[0] > 0:
nodes_list = _unstack(data_dict[NODES])
for i, x in enumerate(nodes_list):
graph_nx.add_node(i, **{GRAPH_NX_FEATURES_KEY: x})
elif data_dict[N_NODE] is not None:
for i in range(data_dict[N_NODE]):
graph_nx.add_node(i, **{GRAPH_NX_FEATURES_KEY: None})
else:
raise ValueError(
"Cannot create a graph with unspecified number of nodes")
if data_dict[EDGES] is not None and data_dict[EDGES].shape[0] > 0:
edges_features = [
{ # pylint: disable=g-complex-comprehension
"index": i,
GRAPH_NX_FEATURES_KEY: x
} for i, x in enumerate(_unstack(data_dict[EDGES]))
]
edges_data = zip(data_dict[SENDERS], data_dict[RECEIVERS],
edges_features)
graph_nx.add_edges_from(edges_data)
elif data_dict[RECEIVERS] is not None and data_dict[RECEIVERS].shape[0] > 0:
edges_features = [
{ # pylint: disable=g-complex-comprehension
"index": i,
GRAPH_NX_FEATURES_KEY: None
} for i in range(data_dict[RECEIVERS].shape[0])
]
edges_data = zip(data_dict[SENDERS], data_dict[RECEIVERS],
edges_features)
graph_nx.add_edges_from(edges_data)
return graph_nx
def graphs_from_nodes_edges_and_globals(graph_nodes, graph_edges,
graph_globals, only_edge, target_graph,
graph_nx_format):
num_nodes = graph_nodes.shape[0]
num_edges = graph_edges.shape[0]
graph_nx = nx.OrderedMultiDiGraph()
graph_no_nx = [0, [], []]
# Exclude columns from features - either because they are no features or
# because they are categorical
exclude_cols = [
'molecule_name', 'atom_index', 'atom_index_0', 'atom_index_1', 'atom',
'atom_0', 'atom_1', 'type', 'bond_type', 'interm_0_atom',
'interm_1_atom'
]
# Target columns (they may not all be present)
main_target_col = 'scalar_coupling_constant'
target_cols = [main_target_col, 'fc', 'sd', 'pso', 'dso']
target_cols = list(set(target_cols).intersection(set(graph_edges.columns)))
# Make sure that scalar_coupling_constant is the first in the list
if target_cols:
scc_id = np.where(np.array(target_cols) == main_target_col)[0][0]
if scc_id > 0:
target_cols[scc_id] = target_cols[0]
target_cols[0] = main_target_col
# Globals
if target_graph:
global_features = np.array([])
else:
global_numeric = graph_globals.drop(exclude_cols, errors='ignore')
global_features = global_numeric.values
global_features = global_features.astype(np.float)
if graph_nx_format:
graph_nx.graph['features'] = global_features
else:
graph_no_nx[0] = global_features
# Nodes
assert (np.all(graph_nodes.atom_index.values == np.arange(num_nodes)))
graph_node_numeric = graph_nodes.drop(exclude_cols,
axis=1,
errors='ignore')
for node_id in range(num_nodes):
if target_graph:
node_features = np.array([])
else:
atom_onehot = ATOM_ONEHOTS[graph_nodes.atom.values[node_id]]
node_numeric = graph_node_numeric.iloc[node_id].values
node_features = np.hstack([atom_onehot, node_numeric])
node_features = node_features.astype(np.float)
if graph_nx_format:
graph_nx.add_node(node_id, features=node_features)
else:
graph_no_nx[1].append((node_id, node_features))
# Edges
no_edge_cols = exclude_cols + target_cols
graph_edge_numeric = graph_edges.drop(no_edge_cols,
axis=1,
errors='ignore')
for edge_id in range(num_edges):
first_node = graph_edges.atom_index_0.values[edge_id]
second_node = graph_edges.atom_index_1.values[edge_id]
if target_graph:
binding_onehot = BINDING_ONEHOTS[
graph_edges.bond_type.values[edge_id]]
edge_type_id = np.where(binding_onehot == 1)[0][0]
if edge_type_id < 8:
target_values = graph_edges[target_cols].values[edge_id]
else:
target_values = np.empty((len(target_cols)))
target_values[:] = np.nan
edge_features = np.hstack([target_values, edge_type_id])
other_edge_permutation = np.zeros(())
else:
atom_onehot_0 = ATOM_ONEHOTS[graph_edges.atom_0.values[edge_id]]
atom_onehot_1 = ATOM_ONEHOTS[graph_edges.atom_1.values[edge_id]]
binding_onehot = BINDING_ONEHOTS[
graph_edges.bond_type.values[edge_id]]
connect_0_3J_onehot = ATOM_3J_ONEHOTS[
graph_edges.interm_0_atom.values[edge_id]]
connect_1_3J_onehot = ATOM_3J_ONEHOTS[
graph_edges.interm_1_atom.values[edge_id]]
edge_numeric = graph_edge_numeric.iloc[edge_id].values
edge_features = np.hstack([
binding_onehot, atom_onehot_0, atom_onehot_1,
connect_0_3J_onehot, connect_1_3J_onehot, edge_numeric
])
if edge_id == 0:
other_edge_permutation = get_other_edge_ids(([
binding_onehot.size, atom_onehot_0.size,
atom_onehot_1.size, connect_0_3J_onehot.size,
connect_1_3J_onehot.size
], [(1, 2), (3, 4)]), graph_edge_numeric.columns)
edge_features = edge_features.astype(np.float)
if graph_nx_format:
graph_nx.add_edge(first_node, second_node, features=edge_features)
graph_nx.add_edge(second_node, first_node, features=edge_features)
else:
# Make sure to create a bidirectional edge at graph construction time!!!
graph_no_nx[2].append((first_node, second_node, edge_features))
return_graph = graph_nx if graph_nx_format else graph_no_nx
if only_edge:
return_graph = convert_to_edge_features(return_graph)
return (return_graph, other_edge_permutation)
def test_multidigraph(self):
G = nx.OrderedMultiDiGraph()
def test_global_access():
g = nx.OrderedMultiDiGraph()
assert g.get_global() == {}
g.get_global().update({"u": 2})
g.get_global()["x"] = 1
assert g.get_global()["x"] == 1
def constructGraph(logEntries):
'''
Constructs a directed graph from the supplied list of log entries
'''
# Create a new directed graph with support for parallel edges
graph = nx.OrderedMultiDiGraph()
# Maintain a list of function calls for which we've not yet seen a return value
pending = []
# Gather all LdrLoadDll() calls and process them last
loadDllEntries = list(
[e for e in logEntries if e['function'] == 'LdrLoadDll'])
logEntries = list([
e for e in logEntries if e['function'] != 'LdrLoadDll'
]) + loadDllEntries
# Process each log entry in turn
for entry in logEntries:
# Determine if the log entry is for the start of a function call or its return value
if entry['type'] == 'enter':
# Add the entry to our stack of pending function calls
pending.append(entry)
elif entry['type'] == 'return':
# Identify which pending function call this entry represents the return value for
match = GraphHelpers.findMatch(pending, entry)
if match is None:
OutputFormatting.printWarning(
'encountered a return value before the function call!')
continue
# If this is a LdrLoadDll() call then examine the stack trace to determine the appropriate module to treat as the caller
# (Note that we filter out the resolved module in addition to KERNELBASE.DLL and NTDLL.DLL, to help prevent self-loops that provide little valuable information)
if entry['function'] == 'LdrLoadDll':
candidates = [
m for m in entry['stack']
if m != entry['result'] and m.upper() not in [
'C:\\WINDOWS\\SYSTEM32\\KERNELBASE.DLL',
'C:\\WINDOWS\\SYSTEM32\\NTDLL.DLL'
]
]
if len(candidates) > 0:
entry['module'] = candidates[0]
# Create a vertex for the calling module if we don't already have one
if entry['module'] not in graph:
graph.add_node(entry['module'], non_loadlibrary_calls=[])
# Determine if this is a LoadLibrary function call
if entry['function'].startswith(
'LoadLibrary') or entry['function'] == 'LdrLoadDll':
# Create a vertex for the module resolved by the LoadLibrary() call if we don't already have one
# (Note that this will create a vertex called "NULL" that all failed calls will have outbound edges pointing to)
if entry['result'] not in graph:
graph.add_node(entry['result'],
non_loadlibrary_calls=[])
# Create an edge between the calling module vertex and the resolved module vertex, annotated with the call details
graph.add_edge(entry['module'],
entry['result'],
details=entry)
else:
# For all other function calls, just add an entry to the list in the metadata for the vertex
nx.get_node_attributes(
graph,
'non_loadlibrary_calls')[entry['module']].append(entry)
else:
raise RuntimeError('unsupported log entry type "{}"!'.format(
entry['type']))
# Print a warning if there were any function calls for which we did not encounter a return value
if len(pending) > 0:
for entry in pending:
OutputFormatting.printWarning(
'return value not found for function call: {}'.format(
entry))
return graph
def graph_img_plotting(plotting, virtual_properties, senders, receivers,
xray_image, positions, hot_gas_positions, base_data_dir,
center, vprime, dataset, sphere):
max_pos = np.max(positions.T, axis=1)
min_pos = np.min(positions.T, axis=1)
box_size = max_pos - min_pos
if plotting == 1:
print('Plotting xray...')
fig, ax = plt.subplots(1, 3, figsize=(18, 6))
ax[0].scatter(center[0] + hot_gas_positions[:, 0],
center[1] + hot_gas_positions[:, 1],
s=10**(2.5 - np.log10(positions.shape[0])))
ax[0].set_xlim(center[0] - 0.5 * box_size[0],
center[0] + 0.5 * box_size[0])
ax[0].set_ylim(center[1] - 0.5 * box_size[1],
center[1] + 0.5 * box_size[1])
ax[0].set_title('Hot gas particles')
ax[1].imshow(xray_image)
# fig.colorbar(xray_plot, ax=ax[1])
ax[1].set_title('Xray')
ax[2].scatter(center[0] + positions.T[0],
center[1] + positions.T[1],
s=10**(2.5 - np.log10(positions.shape[0])))
ax[2].set_xlim(center[0] - 0.5 * box_size[0],
center[0] + 0.5 * box_size[0])
ax[2].set_ylim(center[1] - 0.5 * box_size[1],
center[1] + 0.5 * box_size[1])
ax[2].set_title('Gas particles')
plt.savefig(os.path.join(base_data_dir, 'images/xray.png'))
plt.show()
if plotting > 1:
graph = nx.OrderedMultiDiGraph()
n_nodes = virtual_properties.shape[
0] # number of nodes is the number of positions
virtual_box_size = (np.min(virtual_properties[:, :3]),
np.max(virtual_properties[:, :3]))
pos = dict() # for plotting node positions.
edgelist = []
# Now put the data in the directed graph: first the nodes with their positions and properties
# pos just takes the x and y coordinates of the position so a 2D plot can be made
for node, feature, position in zip(np.arange(n_nodes),
virtual_properties,
virtual_properties[:, :3]):
graph.add_node(node, features=feature)
pos[node] = (position[:2] - virtual_box_size[0]) / (
virtual_box_size[1] - virtual_box_size[0])
# Next add the edges using the receivers and senders arrays we just created
# Note that an edge is added for both directions
# The features of the edge are dummy arrays at the moment
# The edgelist is for the plotting
# edges = np.stack([senders, receivers], axis=-1) + sibling_node_offset
for u, v in zip(senders, receivers):
graph.add_edge(u, v, features=np.array([1., 0.]))
edgelist.append((u, v))
print(f'Particle graph nodes : {graph.number_of_nodes()}')
print(f'Particle graph edges : {graph.number_of_edges()}')
dens_list = []
for n in list(graph.nodes.data('features')):
dens_list.append(n[1][6])
if plotting == 2:
# Plotting
fig, ax = plt.subplots(2, 2, figsize=(12, 12))
print('Plotting multiplot...')
draw(graph,
ax=ax[0, 0],
pos=pos,
edge_color='red',
node_size=10**(4 - np.log10(len(dens_list))),
width=0.1,
arrowstyle='-',
node_color=dens_list,
cmap='viridis')
# draw(graph, ax=ax[0, 0], pos=pos, node_color='blue', edge_color='red', node_size=10, width=0.1)
ax[0, 1].scatter(center[0] + hot_gas_positions[:, 0],
center[1] + hot_gas_positions[:, 1],
s=10**(2.5 - np.log10(positions.shape[0])))
ax[0, 1].set_xlim(center[0] - 0.5 * box_size[0],
center[0] + 0.5 * box_size[0])
ax[0, 1].set_ylim(center[1] - 0.5 * box_size[1],
center[1] + 0.5 * box_size[1])
ax[0, 1].set_title('Hot gas particles')
ax[1, 0].imshow(xray_image)
# fig.colorbar(xray_plot, ax=ax[1])
# ax[1].set_title('Xray')
ax[1, 1].scatter(center[0] + positions.T[0],
center[1] + positions.T[1],
s=10**(2.5 - np.log10(positions.shape[0])))
ax[1, 1].set_xlim(center[0] - 0.5 * box_size[0],
center[0] + 0.5 * box_size[0])
ax[1, 1].set_ylim(center[1] - 0.5 * box_size[1],
center[1] + 0.5 * box_size[1])
ax[1, 1].set_title('Gas particles')
print('Multiplot done, showing...')
plt.savefig(os.path.join(base_data_dir, 'images/multiplot.png'))
plt.show()
if plotting == 3:
interp_virtual_positions = virtual_properties[:, :3] / 1e4
fig, ax = plt.subplots(figsize=(8, 8))
_x = np.linspace(np.min(interp_virtual_positions[:, 0]),
np.max(interp_virtual_positions[:, 0]), 300)
_y = np.linspace(np.min(interp_virtual_positions[:, 1]),
np.max(interp_virtual_positions[:, 1]), 300)
_z = np.linspace(np.min(interp_virtual_positions[:, 2]),
np.max(interp_virtual_positions[:, 2]), 300)
x, y, z = np.meshgrid(_x, _y, _z, indexing='ij')
interp = interpolate.griddata(
(interp_virtual_positions[:, 0],
interp_virtual_positions[:, 1], interp_virtual_positions[:,
2]),
dens_list,
xi=(x, y, z),
fill_value=0.0)
im = np.mean(interp, axis=2).T[::-1, ]
im = np.log10(
np.where(im / np.max(im) < 1e-3, 1e-3, im / np.max(im)))
ax.imshow(im)
plt.savefig(os.path.join(base_data_dir, 'images/interp.png'))
plt.show()
if plotting == 4:
print('Plotting off-axis projection...')
east_vector = vprime[:, 0]
north_vector = vprime[:, 1]
viewing_vec = vprime[:, 2]
fig, ax = plt.subplots(figsize=(8, 8))
off_axis_image = yt.off_axis_projection(data_source=dataset,
center=sphere.center,
normal_vector=viewing_vec,
width=0.01 *
dataset.domain_width,
item='Density',
resolution=[400, 400],
north_vector=east_vector)
off_axis_image = np.log10(
np.where(off_axis_image < 1e17, 1e17, off_axis_image))
# off_axis_image = off_axis_image.to_ndarray() / np.max(off_axis_image.to_ndarray())
# off_axis_image = np.log10(np.where(off_axis_image < 1e-5, 1e-5, off_axis_image))
# print(f'Maximum : {np.max(off_axis_image)}')
off_axis_image = ax.imshow(off_axis_image)
fig.colorbar(off_axis_image, ax=ax)
plt.savefig(os.path.join(base_data_dir,
'images/off_axis_proj.png'))
plt.show()
# yt.write_image(np.log10(off_axis_image), os.path.join(base_data_dir, 'images/off_axis_proj.png'))
if plotting == 5:
print('Plotting 3D image...')
mlab.points3d(virtual_properties.T[0],
virtual_properties.T[1],
virtual_properties.T[2],
dens_list,
resolution=8,
scale_factor=0.15,
scale_mode='none',
colormap='viridis')
for u, v in zip(senders, receivers):
mlab.plot3d(
[virtual_properties[u][0], virtual_properties[v][0]],
[virtual_properties[u][1], virtual_properties[v][1]],
[virtual_properties[u][2], virtual_properties[v][2]],
tube_radius=None,
tube_sides=3,
opacity=0.1)
mlab.show()
for quest, prereqs in quests.items():
if prereqs:
for prereq in prereqs:
graph_data.append((quest, prereq))
else:
graph_data.append((quest, quest))
# Creating Graph
connections_are_quest_color = True # or required quest color
plt.figure(figsize=(60, 80))
plt.title("Old School Runescape Quest Tree\n" +
("(colored by quest)"
if connections_are_quest_color else "(colored by requirement)"),
fontsize=150,
fontweight="bold")
g = nx.OrderedMultiDiGraph()
colors = [
'brown', 'orange', 'olive', 'green', 'cyan', 'blue', 'sienna', 'red',
'black', 'black'
]
# Edge colors
edge_colors = []
for d in graph_data:
q1, q2 = d
# Broken, temporary fix!
q1 = q1.replace("recipe for disaster/", "")
q2 = q2.replace("recipe for disaster/", "")
g.add_edge(q1, q2)
