def detect_spn():
degree_map = calculate_degree_map()
source_map = dict()
for eid in graphiti.get_link_ids():
src = graphiti.get_link_node1(eid)
if src not in degree_map:
continue
if degree_map[src]["in"] == 0 and degree_map[src]["out"] >= 0:
dst = graphiti.get_link_node2(eid)
if src not in source_map:
source_map[src] = [(dst, eid)]
elif dst not in source_map[src]:
source_map[src].append((dst, eid))
for nid in graphiti.get_node_ids():
graphiti.set_node_attribute(nid, "graphiti:space:lod", "float", "0.0")
for eid in graphiti.get_link_ids():
graphiti.set_link_attribute(eid, "graphiti:space:lod", "float", "0.0")
for source in source_map.keys():
graphiti.set_node_attribute(source, "graphiti:space:lod", "float", "1.0")
for successor in source_map[source]:
graphiti.set_node_attribute(successor[0], "graphiti:space:lod", "float", "1.0")
graphiti.set_link_attribute(successor[1], "graphiti:space:lod", "float", "1.0")
print("SPN detection results :")
print(source_map)
def color_diff():
global colors
for n in graphiti.get_node_ids():
s = graphiti.get_node_attribute(n, 'diffstatus')
graphiti.set_node_attribute(n, "graphiti:space:color", "vec3", colors[s])
for e in graphiti.get_link_ids():
s = graphiti.get_link_attribute(e, 'diffstatus')
try:
graphiti.set_link_attribute(e, "graphiti:space:color", "vec3", colors[s])
except KeyError:
print("link: {}".format(e))
print("diffstatus: {}".format(s))
sys.exit(-1)
def multiply_colors(v, node_flag, edge_flag):
def f(c, v):
return [c[0] * v[0], c[1] * v[1], c[2] * v[2], c[3] * v[3]]
if node_flag:
for id in graphiti.get_node_ids():
c = graphiti.get_node_attribute(id, "graphiti:space:color")
graphiti.set_node_attribute(id, "graphiti:space:color", "vec4", std.vec4_to_str(f(c, v)))
if edge_flag:
for id in graphiti.get_link_ids():
c = graphiti.get_link_attribute(id, "graphiti:space:color1")
graphiti.set_link_attribute(id, "graphiti:space:color1", "vec4", std.vec4_to_str(f(c, v)))
c = graphiti.get_link_attribute(id, "graphiti:space:color2")
graphiti.set_link_attribute(id, "graphiti:space:color2", "vec4", std.vec4_to_str(f(c, v)))
def on_started():
global cities
dico = {}
for city in cities:
nid = graphiti.add_node(city["name"])
graphiti.set_node_attribute(nid, "og:world:geolocation", "vec2",
std.vec2_to_str(city["geolocation"]))
graphiti.set_node_attribute(nid, "og:world:color", "vec4",
std.vec4_to_str(city["color"]))
graphiti.set_node_attribute(nid, "og:world:size", "float",
str(city["size"]))
dico[city['name']] = nid
eid = graphiti.add_link(dico['Paris'], dico['San Francisco'])
graphiti.set_link_attribute(eid, "og:world:color", "vec4",
"0.0 1.0 0.0 1.0")
def color_edges_by_type():
graphiti.set_attribute("graphiti:space:linkmode", "string", "edge_color")
ids = graphiti.get_link_ids()
colors = dict()
for id in ids:
type = graphiti.get_link_attribute(id, "type")
if type == None:
print("Edge " + str(id) + " has no type attribute !")
color = None
if type in colors:
color = colors[type]
else:
r = random.random()
g = random.random()
b = random.random()
color = str(r) + " " + str(g) + " " + str(b)
colors[type] = color
graphiti.set_link_attribute(id, "graphiti:space:color", "vec3", color)
def add_random_graph():
node_count = int(raw_input("Number of nodes : "))
edge_count = int(raw_input("Number of edges : "))
nodes = []
for i in range(node_count):
id = graphiti.add_node(str(i))
graphiti.set_node_attribute(id, "type", "string", str(i % 3))
size = 1 + abs(math.sin(float(i)))
graphiti.set_node_attribute(id, "og:space:size", "float", str(size))
nodes.append(id)
for j in range(edge_count):
loop = True
while loop:
src = random.choice(nodes)
dst = random.choice(nodes)
if src != dst:
loop = False
id = graphiti.add_link(src, dst)
graphiti.set_link_attribute(id, "type", "string", str(j % 3))
def attribute_to_lod(attribute, fun = lambda x : x):
min = float("inf")
max = float("-inf")
min_value = None
max_value = None
n_values = dict()
for nid in graphiti.get_node_ids():
value = graphiti.get_node_attribute(nid, attribute)
if value is None:
graphiti.set_node_attribute(nid, "graphiti:space:lod", "float", "-1000")
continue
fun_value = fun(value)
if fun_value is None:
graphiti.set_node_attribute(nid, "graphiti:space:lod", "float", "-1000")
continue
fvalue = float(fun_value)
if fvalue > max:
max = fvalue
max_value = value
if fvalue < min:
min = fvalue
min_value = value
n_values[nid] = fvalue
e_values = dict()
for eid in graphiti.get_link_ids():
value = graphiti.get_link_attribute(eid, attribute)
if value is None:
graphiti.set_link_attribute(eid, "graphiti:space:lod", "float", "-1000")
continue
fun_value = fun(value)
if fun_value is None:
graphiti.set_link_attribute(eid, "graphiti:space:lod", "float", "-1000")
continue
fvalue = float(fun_value)
if fvalue > max:
max = fvalue
max_value = value
if fvalue < min:
min = fvalue
min_value = value
e_values[eid] = fvalue
for nid in n_values.keys():
svalue = (n_values[nid] - min) / (max - min)
print(attribute + " : " + str(n_values[nid]) + " --> lod : " + str(svalue))
graphiti.set_node_attribute(nid, "graphiti:space:lod", "float", str(svalue))
for eid in e_values.keys():
svalue = (e_values[eid] - min) / (max - min)
print(attribute + " : " + str(e_values[eid]) + " --> lod : " + str(svalue))
graphiti.set_link_attribute(eid, "graphiti:space:lod", "float", str(svalue))
print("LOD range : " + str(min_value) + " to " + str(max_value))
def randomize_edge_width():
for id in graphiti.get_link_ids():
width = random.uniform(0.0, 5.0)
graphiti.set_link_attribute(id, "graphiti:space:width", "float", str(width))
def randomize_edge_activity():
for id in graphiti.get_link_ids():
activity = random.uniform(0.0, 2.0)
graphiti.set_link_attribute(id, "graphiti:space:activity", "float", str(activity))
def f(t, id, match):
if not match:
if t == "node":
graphiti.set_node_attribute(id, "graphiti:space:lod", "float", "0.0")
elif t == "edge":
graphiti.set_link_attribute(id, "graphiti:space:lod", "float", "0.0")
def set_lod(value):
for id in graphiti.get_node_ids():
graphiti.set_node_attribute(id, "graphiti:space:lod", "float", str(value))
for id in graphiti.get_link_ids():
graphiti.set_link_attribute(id, "graphiti:space:lod", "float", str(value))
def show_edge_direction():
for id in graphiti.get_link_ids():
graphiti.set_link_attribute(id, "og:space:icon", "string", "styles/triangles")
def randomize_lod():
for id in graphiti.get_node_ids():
graphiti.set_node_attribute(id, "og:space:lod", "float", str(random.random()))
for id in graphiti.get_link_ids():
graphiti.set_link_attribute(id, "og:space:lod", "float", str(random.random()))
def randomize_edge_icons():
icons = glob.glob("./Resources/SpaceView/EdgeStyles/*.png")
print(icons)
for id in graphiti.get_link_ids():
icon = "styles/" + random.choice(icons).split("/")[-1][:-4].lower()
graphiti.set_link_attribute(id, "graphiti:space:icon", "string", icon)
def load_json(json_filename):
nodes = {}
links = {}
global node_attributes
global edge_attributes
print("Loading \"" + json_filename + "\" ...")
import json
with open(json_filename, "r") as infile:
data = json.load(infile)
print("Loading meta information ...")
# TODO : Find a more generic way of doing this
if "meta" in data:
if "title" in data["meta"].keys():
if data["meta"]["title"] is not None:
graphiti.set_attribute("raindance:space:title", "string",
data["meta"]["title"])
if "attributes" in data:
for key in data["attributes"].keys():
if key in reserved_attributes:
continue
att_info = get_attribute_info(data["attributes"][key])
if att_info is None:
print("Error: Couldn't parse key '" + key + "' with value '" +
str(n[key]) + "'!")
continue
graphiti.set_attribute(key, att_info[0], att_info[1])
print(". Loading nodes ...")
for n in data["nodes"]:
label = ""
if "label" in n:
label = n["label"].encode("utf-8")
nid = graphiti.add_node(label)
nodes[n["id"]] = nid
for key in n.keys():
if key in reserved_attributes:
continue
att_info = get_attribute_info(n[key])
if att_info is None:
print("Error: Couldn't parse key '" + key + "' with value '" +
str(n[key]) + "'!")
continue
graphiti.set_node_attribute(nid, key, att_info[0], att_info[1])
print(". Loading edges ...")
for e in data["edges"]:
if "src" in e:
eid = graphiti.add_link(nodes[e["src"]], nodes[e["dst"]])
else:
eid = graphiti.add_link(nodes[e['source']], nodes[e['target']])
links[e["id"]] = eid
for key in e.keys():
if key in reserved_attributes:
continue
att_info = get_attribute_info(e[key])
if att_info is None:
print("Error: Couldn't parse key '" + key + "' with value '" +
str(n[key]) + "'!")
continue
graphiti.set_link_attribute(eid, key, att_info[0], att_info[1])
if "timeline" in data:
print(". Loading timeline ...")
for c in data["timeline"]:
# TODO : Get rid of this translation phase when possible.
if c[1].startswith("graph:"):
if c[1] in ["graph:remove_node", "graph:set_node_attribute"]:
c[2]["id"] = nodes[c[2]["id"]]
elif c[1] in ["graph:remove_link", "graph:set_link_attribute"]:
c[2]["id"] = links[c[2]["id"]]
elif c[1] in ["graph:add_link"]:
c[2]["src"] = nodes[c[2]["src"]]
c[2]["dst"] = nodes[c[2]["dst"]]
graphiti.send_command(c[0], c[1], c[2])
print("Done.")