def sz_pos(self):
"""
Returns a **copy** of the sigma zed values
Note that no update is run.
"""
sigmas = self.graph.vertex_properties["sigmas"].copy()
zeds = self.graph.vertex_properties["zeds"].copy()
sigmazs = [sigmas, zeds]
return gt.group_vector_property(sigmazs, value_type='float')
def sz_pos(self):
"""
Returns a **copy** of the sigma zed values
Note that no update is run.
"""
sigmas = self.graph.vertex_properties["sigmas"].copy()
zeds = self.graph.vertex_properties["zeds"].copy()
sigmazs = [sigmas, zeds]
return gt.group_vector_property(sigmazs, value_type='float')
def rtz_pos(self):
"""
Returns a **copy** of the rho theta zed values
Note that no update is run.
"""
rhos = self.graph.vertex_properties["rhos"].copy()
thetas = self.graph.vertex_properties["thetas"].copy()
zeds = self.graph.vertex_properties["zeds"].copy()
rtzs = [rhos, thetas, zeds]
return gt.group_vector_property(rtzs, value_type='float')
def rtz_pos(self):
"""
Returns a **copy** of the rho theta zed values
Note that no update is run.
"""
rhos = self.graph.vertex_properties["rhos"].copy()
thetas = self.graph.vertex_properties["thetas"].copy()
zeds = self.graph.vertex_properties["zeds"].copy()
rtzs = [rhos, thetas, zeds]
return gt.group_vector_property(rtzs, value_type='float')
def pseudo3d_draw(graph, rtz, output="lattice_3d.pdf",
z_angle=0.12, theta_rot=0.1,
RGB=(0.8, 0.1, 0.), **kwargs):
'''
Deprecated
'''
rhos, thetas, zeds = rtz
thetas += theta_rot
output = os.path.join('saved_graph/pdf', output)
red, green, blue = RGB
pseudo_x = graph.new_vertex_property('float')
pseudo_y = graph.new_vertex_property('float')
vertex_red = graph.new_vertex_property('float')
vertex_green = graph.new_vertex_property('float')
vertex_blue = graph.new_vertex_property('float')
vertex_alpha = graph.new_vertex_property('float')
pseudo_x.a = zeds * np.cos(z_angle)\
- rhos * np.cos(thetas) * np.sin(z_angle)
pseudo_y.a = rhos * np.sin(thetas)
depth = rhos * np.cos(thetas)
normed_depth = (depth - depth.min()) / (depth.max() - depth.min())
vertex_alpha.a = normed_depth * 0.7 + 0.3
vertex_red.a = np.ones(rhos.shape, dtype=np.float) * red
vertex_green.a = np.ones(rhos.shape, dtype=np.float) * green
vertex_blue.a = np.ones(rhos.shape, dtype=np.float) * blue
rgba = [vertex_red, vertex_green, vertex_blue, vertex_alpha]
pseudo3d_color = gt.group_vector_property(rgba,
value_type='float')
xy = [pseudo_x, pseudo_y]
pseudo3d_pos = gt.group_vector_property(xy, value_type='float')
pmap = gt.graph_draw(graph, pseudo3d_pos,
vertex_fill_color=pseudo3d_color,
vertex_color=pseudo3d_color,
edge_pen_width=2.,
output=output, **kwargs)
del pmap
return pseudo3d_pos
def Stochastic():
import pandas as pd
import numpy as np
import pprint as pp
import locale
import matplotlib.pyplot as plt
import matplotlib.ticker as tkr
import graph_tool.all as gt
import math
# Need to drag this out into the real world
from GAC_Graph_Builder import findEdges
t = gt.Graph(directed=True)
tprop_label = t.new_vertex_property("string")
tprop_instType = t.new_vertex_property("string")
linkDict, instSet = findEdges()
# ingest our university checking lists [this is sloppy, TBI]
foreignUniTxt = open('Workaround txts/Foreign Unis.txt', 'r')
UKUniTxt = open('Workaround txts/UK Unis.txt', 'r')
forerignUniVals = foreignUniTxt.read().splitlines()
UKUniVals = UKUniTxt.read().splitlines()
# add vertices and label them based on their names.
######## FILTERING BASED ON CORDIS RESIDENCY ##########
dfCordisNames = pd.read_pickle('Pickles/CORDIS_Countries.pickle')
eligiblenames = dfCordisNames.name.values.tolist()
veryDirtyWorkaround = ['FOCUS', 'FLUOR', 'GE', 'NI', 'OTE', 'ROKE']
for inst in instSet:
nameCheck = inst.upper()
firstFound = next((x for x in eligiblenames if nameCheck in x), None)
if inst in forerignUniVals:
del (linkDict[inst])
elif nameCheck in veryDirtyWorkaround:
del (linkDict[inst])
elif firstFound is None:
del (linkDict[inst])
else:
vert = t.add_vertex()
tprop_label[vert] = str(inst)
del (linkDict[''])
# internalise property map
t.vertex_properties["label"] = tprop_label
# explicitly declare the hierarchy defining vertices and edges, the sequencing here matters.
for_uni = t.add_vertex()
UK_uni = t.add_vertex()
other = t.add_vertex()
root = t.add_vertex()
edgeList = [(root, for_uni), (root, UK_uni), (root, other)]
t.add_edge_list(edgeList)
# use label name to add edges to hierarchy
for i in range(t.num_vertices())[:-4]:
if tprop_label[i] in forerignUniVals:
t.add_edge(for_uni, t.vertex(i))
tprop_instType[i] = "Foreign Uni"
elif tprop_label[i] in UKUniVals:
t.add_edge(UK_uni, t.vertex(i))
tprop_instType[i] = "UK Uni"
else:
t.add_edge(other, t.vertex(i))
tprop_instType[i] = "Other Institution"
t.vertex_properties["instType"] = tprop_instType
tpos = gt.radial_tree_layout(t,
t.vertex(t.num_vertices() - 1),
rel_order_leaf=True)
######### MAIN GRAPH DRAWING ################
g = gt.Graph(directed=False)
# creates graph g, using the same nodes (with the same index!)
for v in t.vertices():
gv = g.add_vertex()
# we remove: root, for_uni, uk_uni or 'other' vertices
lower = g.num_vertices() - 5
current = g.num_vertices() - 1
while current > lower:
g.remove_vertex(current)
current -= 1
# Pull vertex properties from t
labelDict = t.vertex_properties["label"]
instTypeDict = t.vertex_properties["instType"]
# create properties for g vertices
gprop_label = g.new_vertex_property("string")
gprop_instType = g.new_vertex_property("string")
# match labels between g and t
for v in g.vertices():
gprop_label[v] = labelDict[v]
gprop_instType[v] = instTypeDict[v]
# make property map internal to graph g
g.vertex_properties["label"] = gprop_label
g.vertex_properties["instType"] = gprop_instType
###### COLOUR VERTICES #########
# Reclaim variable names because lazy
gprop_vcolour = g.new_vertex_property("string")
for v in g.vertices():
if gprop_instType[v] == "Foreign Uni":
gprop_vcolour[v] = "red"
elif gprop_instType[v] == "UK Uni":
gprop_vcolour[v] = "blue"
else:
gprop_vcolour[v] = "white"
g.vertex_properties["vcolour"] = gprop_vcolour
# create numLinks edge property for g edges
eprop_numLinks = g.new_edge_property("int")
# creates the edges between nodes
for i in linkDict:
for n in linkDict[i]:
#print(i)
vertex_i = gt.find_vertex(g, gprop_label, i)[0]
#print(n)
try:
vertex_n = gt.find_vertex(g, gprop_label, n)[0]
e = g.add_edge(vertex_i, vertex_n)
eprop_numLinks[e] = linkDict[i][n]
except:
IndexError
##### EXPERIMENTAL SIZE THINGS ######
#gvprop_size = g.new_vertex_property('float')
deleteList = []
for v in g.vertices():
# sum the num edges and the number of links they correspond to
# use this to find a ratio and scale size off of this.
numEdges = sum(1 for _ in v.all_edges())
numLinks = 0
for e in v.all_edges():
numLinks += eprop_numLinks[e]
#print(gprop_label[v])
print("NumEdges = " + str(numEdges) + " NumLinks = " + str(numLinks))
# create a delete list
try:
ratio = (numLinks / numEdges) * 5 * 2
except:
ZeroDivisionError
deleteList.append(v)
#gvprop_size[v] = ratio
#g.vertex_properties['size'] = gvprop_size
#### Delete linkless vertices #######
for v in reversed(sorted(deleteList)):
g.remove_vertex(v)
for v in reversed(sorted(deleteList)):
t.remove_vertex(v)
tpos = gt.radial_tree_layout(t,
t.vertex(t.num_vertices() - 1),
rel_order_leaf=True)
#######
############ stochastic BLOCK MODEL ####################
state = gt.minimize_nested_blockmodel_dl(g, deg_corr=True, verbose=True)
t = gt.get_hierarchy_tree(state)[0]
tpos = pos = gt.radial_tree_layout(t,
t.vertex(t.num_vertices() - 1),
weighted=True)
# in order to make sure labels fit in the image we have to manually adjust the
# co-ordinates of each vertex.
x, y = gt.ungroup_vector_property(tpos, [0, 1])
x.a = (x.a - x.a.min()) / (x.a.max() - x.a.min()) * 1400 + 400
y.a = (y.a - y.a.min()) / (y.a.max() - y.a.min()) * 1400 + 400
tpos = gt.group_vector_property([x, y])
# This draws the 'Bezier spline control points' for edges
# it draws the edges directed in graph g, but uses the hierarchy / positioning of graph t.
cts = gt.get_hierarchy_control_points(g, t, tpos)
pos = g.own_property(tpos)
gt.graph_draw(
g,
vertex_text_position="centered",
vertex_text=g.vertex_properties["label"],
vertex_font_size=14,
vertex_anchor=0,
vertex_aspect=1,
vertex_shape="square",
vertex_fill_color=g.vertex_properties["vcolour"],
vertex_size=10,
fit_view=False,
# edge_color=g.edge_properties["colour"],
# edge_pen_width=g.edge_properties["thickness"],
edge_end_marker="none",
edge_pen_width=0.2,
edge_color="white",
bg_color=[0, 0, 0, 1],
output_size=[2000, 2000],
output='UK_ONLY_RELATIONSHIPS_stochastic.png',
pos=pos,
edge_control_points=cts)
if __name__ == '__main__':
pyjd.setup("Hello.html")
split = line.strip().split(' ')
if split != []:
split = [int(split[1]), int(split[2])]
v = g.add_vertex()
g.vp.position[v] = split
lines.append(split)
else:
count+=1
lines = np.array(lines)
num_vertices = len(lines)
tree = spatial.KDTree(lines)
distances, hoods_arr = tree.query(lines, num_vertices)
distances = [dist[1:] for dist in distances]
hoods_arr = [nbhd[1:] for nbhd in hoods_arr]
g.properties[("e", "neighborhoods")] = g.new_edge_property("boolean")
neighborhoods_array = [
nl.NeighborLists(g, vertex, distances[index], hoods_arr[index]).neighborhood \
for index, vertex in enumerate(g.vertices())]
gt.graph_draw(g, pos=g.vp.position)
property_map = gt.group_vector_property(neighborhoods_array)
g.properties[("e", "neighborhoods")] = property_map
g.save("dsj1000.gt")
def epithelium_draw(eptm, z_angle=0.15, d_theta=4*np.pi/5,
output3d="tissue_3d.pdf",
output2d='tissue_sz.pdf', verbose=False,
vfilt=None,
efilt=None,
**kwargs):
kwargs['inline'] = False
eptm.graph.set_directed(False)
vertex_red = eptm.graph.new_vertex_property('float')
vertex_green = eptm.graph.new_vertex_property('float')
vertex_blue = eptm.graph.new_vertex_property('float')
vertex_alpha = eptm.graph.new_vertex_property('float')
vertex_size = eptm.graph.new_vertex_property('int')
edge_red = eptm.graph.new_edge_property('float')
edge_green = eptm.graph.new_edge_property('float')
edge_blue = eptm.graph.new_edge_property('float')
edge_alpha = eptm.graph.new_edge_property('float')
edge_width = eptm.graph.new_edge_property('float')
edge_height = eptm.graph.new_edge_property('float')
eptm.update_rhotheta()
rhos, thetas, zeds = eptm.rhos, eptm.thetas, eptm.zeds
pseudo_x = eptm.graph.new_vertex_property('float')
pseudo_y = eptm.graph.new_vertex_property('float')
pseudo_x.a = zeds.a * np.cos(z_angle) - rhos.a * np.cos(
thetas.a + d_theta) * np.sin(z_angle)
pseudo_y.a = rhos.a * np.sin(thetas.a + d_theta)
depth = vertex_alpha.copy()
depth.a = rhos.a * (1 - np.cos(thetas.a + d_theta))
depth.a = (depth.a - depth.a.min()) / (depth.a.max() - depth.a.min())
vertex_alpha.a = (depth.a * 0.8 + 0.2) * eptm.is_alive.a
for edge in eptm.graph.edges():
edge_alpha[edge] = vertex_alpha[edge.source()]
edge_height[edge] = (depth[edge.source()]
+ depth[edge.target()]) * 0.5
vertex_alpha.a *= (1 - eptm.is_cell_vert.a)
vorder = eptm.graph.new_vertex_property('float')
vorder.a = np.argsort(vertex_alpha.a)
### Junction vertices
j_filt = eptm.is_cell_vert.copy()
#j_filt.a *= (1 - eptm.is_alive.a)
eptm.graph.set_vertex_filter(j_filt,
inverted=True)
if verbose: print(eptm.graph.num_vertices())
vertex_red.fa = 105/256.
vertex_green.fa = 182/256.
vertex_blue.fa = 40/256.
vertex_size.fa = 1.
eptm.graph.set_vertex_filter(None)
### Junction edges
eptm.graph.set_edge_filter(eptm.is_junction_edge,
inverted=False)
cmap = plt.cm.jet(edge_height.fa)
edge_red.fa = cmap[:, 0] #105/256.
edge_green.fa = cmap[:, 1] #201/256.
edge_blue.fa = cmap[:, 2] #40/256.
#edge_width.fa[:] = 1.
edge_width.fa = 2. * (eptm.junctions.line_tensions.fa /
eptm.junctions.line_tensions.fa.mean())**0.5
eptm.graph.set_edge_filter(None)
### Cell vertices
cell_filt = eptm.is_cell_vert.copy()
cell_filt.a *= eptm.is_alive.a
eptm.graph.set_vertex_filter(cell_filt,
inverted=False)
vertex_red.fa = 105 / 256.
vertex_green.fa = 201 / 256.
vertex_blue.fa = 237 / 256.
vertex_size.fa = 0.
eptm.graph.set_vertex_filter(None)
### Cell to junction edges
eptm.graph.set_edge_filter(eptm.is_ctoj_edge,
inverted=False)
edge_red.fa = 105 / 256.
edge_green.fa = 201 / 256.
edge_blue.fa = 237 / 256.
edge_width.fa = 0.
eptm.graph.set_edge_filter(None)
eorder = eptm.graph.new_edge_property('float')
eorder.a = np.argsort(edge_alpha.a)
vertex_rgba = [vertex_red, vertex_green, vertex_blue, vertex_alpha]
vertex_color = gt.group_vector_property(vertex_rgba, value_type='float')
edge_rgba = [edge_red, edge_green, edge_blue, edge_alpha]
edge_color = gt.group_vector_property(edge_rgba, value_type='float')
xy = [pseudo_x, pseudo_y]
pseudo3d_pos = gt.group_vector_property(xy, value_type='float')
eptm.graph.set_vertex_filter(vfilt)
eptm.graph.set_edge_filter(efilt)
pmap = gt.graph_draw(eptm.graph, pseudo3d_pos,
vertex_fill_color=vertex_color,
vertex_color=vertex_color,
edge_pen_width=edge_width,
edge_color=edge_color,
vertex_size=vertex_size,
vorder=vorder, eorder=eorder,
output=output3d, **kwargs)
if verbose: print('saved tissue to %s' % output3d)
eptm.graph.set_vertex_filter(None)
eptm.graph.set_edge_filter(None)
#### 2D view
eptm.rotate(-np.pi / 2)
### Junction edges
eptm.graph.set_edge_filter(eptm.is_junction_edge,
inverted=False)
depth.a = rhos.a
depth.a = (depth.a - depth.a.min()) / (depth.a.max() - depth.a.min())
vertex_alpha.a = (depth.a * 0.8 + 0.2) * eptm.is_alive.a
for edge in eptm.graph.edges():
edge_alpha[edge] = vertex_alpha[edge.source()]
edge_height[edge] = (depth[edge.source()]
+ depth[edge.target()]) * 0.5
cmap = plt.cm.jet(edge_height.fa)
edge_red.fa = cmap[:, 0] #105/256.
edge_green.fa = cmap[:, 1] #201/256.
edge_blue.fa = cmap[:, 2] #40/256.
#edge_width.fa[:] = 1.
edge_width.fa = 2. * (eptm.junctions.line_tensions.fa /
eptm.junctions.line_tensions.fa.mean())**0.5
eptm.graph.set_edge_filter(None)
sigma = eptm.proj_sigma()
zs = [zeds, sigma]
zs_pos = gt.group_vector_property(zs, value_type='float')
eptm.update_dsigmas()
edge_alpha.a = 1.
edge_alpha.a *= (1 - eptm.at_boundary.a)
edge_alpha.a *= eptm.is_junction_edge.a
edge_rgba = [edge_red, edge_green, edge_blue, edge_alpha]
edge_color = gt.group_vector_property(edge_rgba, value_type='float')
eptm.graph.set_vertex_filter(vfilt)
eptm.graph.set_edge_filter(efilt)
pmap2 = gt.graph_draw(eptm.graph, zs_pos,
vertex_fill_color=vertex_color,
vertex_color=vertex_color,
edge_pen_width=edge_width,
edge_color=edge_color,
vertex_size=vertex_size,
vorder=vorder, eorder=eorder,
output=output2d, **kwargs)
if verbose: print('saved tissue to %s' % output2d)
eptm.graph.set_vertex_filter(None)
eptm.graph.set_edge_filter(None)
del pmap, pmap2
eptm.graph.set_directed(True)
eptm.rotate(np.pi / 2)
for v in reversed(sorted(deleteList)):
t.remove_vertex(v)
tpos = gt.radial_tree_layout(t, t.vertex(t.num_vertices() -1), rel_order_leaf = True)
#######
#g.vertex_properties['size'] = gvprop_size
#
# in order to make sure labels fit in the image we have to manually adjust the
# co-ordinates of each vertex.
x, y = gt.ungroup_vector_property(tpos, [0, 1])
x.a = (x.a - x.a.min()) / (x.a.max() - x.a.min()) * 400 + 100
y.a = (y.a - y.a.min()) / (y.a.max() - y.a.min()) * 400 + 100
tpos = gt.group_vector_property([x, y])
# This draws the 'Bezier spline control points' for edges
# it draws the edges directed in graph g, but uses the hierarchy / positioning of graph t.
cts = gt.get_hierarchy_control_points(g, t, tpos)
pos = g.own_property(tpos)
###### Create interactive window #####
win = gt.GraphWindow(g,
geometry =(500,400),
vertex_text_position="centered",
vertex_text=g.vertex_properties["label"],
vertex_text_color = "white",
