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 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",