segmentation / graph_gui

Commit 17e4b25a127e9bb5b3f69616f8d0a5649894954e

Authored by Pavel Govyadinov
1 parent 4407a915

Bug fixes, Dual version, histograms, cluster exploration, vertex exploration, to… 

… do: path exploration and hover-over
Showing 13 changed files with 1493 additions and 235 deletions   Show diff stats
Inline Side-by-side
GraphCanvas.py
  Show/Hide comments   View file @17e4b25
... ... @@ -13,6 +13,18 @@ from vispy.gloo import set_viewport, set_state, clear, set_blend_color, context
13 13 from vispy.util.transforms import perspective, translate, rotate, scale
14 14 import vispy.gloo.gl as glcore
15 15 from vispy import app
  16 +#from shapely.geometry import Polygon
  17 +#from shapely.geometry import Point
  18 +#from shapely.geometry import MultiPoint
  19 +from scipy.spatial import ConvexHull
  20 +from scipy.spatial import Delaunay
  21 +#import scipy.spatial.ConvexHull
  22 +
  23 +from vispy.scene.visuals import Text
  24 +from vispy.scene.visuals import ColorBar
  25 +
  26 +
  27 +
16 28 import copy
17 29  
18 30 import numpy as np
... ... @@ -211,6 +223,10 @@ class GraphCanvas(scene.SceneCanvas):
211 223 self.timer = app.Timer('auto', connect=self.on_timer, start=False)
212 224 #self.constant = app.Timer('auto', connect=self.update, start=True)
213 225 self.num=0
  226 + self.current_color = ""
  227 + self.update_text(self.current_color)
  228 + self.update_color_bar(self.current_color)
  229 +
214 230 print(self.context.config)
215 231  
216 232 def on_timer(self, event):
... ... @@ -251,42 +267,42 @@ class GraphCanvas(scene.SceneCanvas):
251 267 self.vbo_line = gloo.VertexBuffer(self.line_data)
252 268 self.program_e.bind(self.vbo_line)
253 269  
254   -
255   - self.update_clusters(self.old_pos)
256   - edges = self.G_cluster.get_edges()
257   -# #generate the vertex buffer and the connections buffer.
258   - for e in range(edges.shape[0]):
259   - idx = int(4*edges[e][2])
260   - p0 = self.cluster_pos[int(edges[e][0])]
261   - p1 = self.cluster_pos[int(edges[e][1])]
262   - #p0 = self.G_cluster.vertex_properties["pos"][self.G_cluster.vertex(edges[e][0])]
263   - #p1 = self.G_cluster.vertex_properties["pos"][self.G_cluster.vertex(edges[e][1])]
264   - d = np.subtract(p1, p0)
265   - #d_norm = np.multiply(d, 1/np.sqrt(np.power(d[0],2) + np.power(d[1],2)))
266   - d_norm = d[0:2]
267   - d_norm = d_norm / np.sqrt(np.power(d_norm[0],2) + np.power(d_norm[1],2))
268   - norm = np.zeros((2,), dtype=np.float32)
269   - norm[0] = d_norm[1]
270   - norm[1] = d_norm[0]*-1
271   - #print(np.sqrt(norm[0]*norm[0] + norm[1]*norm[1]))
272   - #thickness = G.edge_properties["thickness"][e]
273   - #self.cluster_dict[int(edges[e][0]), int(edges[e][1])] = int(edges[e][2])
274   - self.cluster_line_data['a_position'][idx] = p0
275   - self.cluster_line_data['a_normal'][idx] = norm
276   -
277   - self.cluster_line_data['a_position'][idx+1] = p1
278   - self.cluster_line_data['a_normal'][idx+1] = norm
279   -
280   - self.cluster_line_data['a_position'][idx+2] = p0
281   - self.cluster_line_data['a_normal'][idx+2] = -norm
282   -
283   - self.cluster_line_data['a_position'][idx+3] = p1
284   - self.cluster_line_data['a_normal'][idx+3] = -norm
285   -
286   - self.vbo_cluster_lines.set_data(self.cluster_line_data)
287   - self.vbo_s.set_data(self.clusters)
288   - self.program_s.bind(self.vbo_s)
289   - self.program_e_s.bind(self.vbo_cluster_lines)
  270 + if(self.subgraphs):
  271 + self.update_clusters(self.old_pos)
  272 + edges = self.G_cluster.get_edges()
  273 + # #generate the vertex buffer and the connections buffer.
  274 + for e in range(edges.shape[0]):
  275 + idx = int(4*edges[e][2])
  276 + p0 = self.cluster_pos[int(edges[e][0])]
  277 + p1 = self.cluster_pos[int(edges[e][1])]
  278 + #p0 = self.G_cluster.vertex_properties["pos"][self.G_cluster.vertex(edges[e][0])]
  279 + #p1 = self.G_cluster.vertex_properties["pos"][self.G_cluster.vertex(edges[e][1])]
  280 + d = np.subtract(p1, p0)
  281 + #d_norm = np.multiply(d, 1/np.sqrt(np.power(d[0],2) + np.power(d[1],2)))
  282 + d_norm = d[0:2]
  283 + d_norm = d_norm / np.sqrt(np.power(d_norm[0],2) + np.power(d_norm[1],2))
  284 + norm = np.zeros((2,), dtype=np.float32)
  285 + norm[0] = d_norm[1]
  286 + norm[1] = d_norm[0]*-1
  287 + #print(np.sqrt(norm[0]*norm[0] + norm[1]*norm[1]))
  288 + #thickness = G.edge_properties["thickness"][e]
  289 + #self.cluster_dict[int(edges[e][0]), int(edges[e][1])] = int(edges[e][2])
  290 + self.cluster_line_data['a_position'][idx] = p0
  291 + self.cluster_line_data['a_normal'][idx] = norm
  292 +
  293 + self.cluster_line_data['a_position'][idx+1] = p1
  294 + self.cluster_line_data['a_normal'][idx+1] = norm
  295 +
  296 + self.cluster_line_data['a_position'][idx+2] = p0
  297 + self.cluster_line_data['a_normal'][idx+2] = -norm
  298 +
  299 + self.cluster_line_data['a_position'][idx+3] = p1
  300 + self.cluster_line_data['a_normal'][idx+3] = -norm
  301 +
  302 + self.vbo_cluster_lines.set_data(self.cluster_line_data)
  303 + self.vbo_s.set_data(self.clusters)
  304 + self.program_s.bind(self.vbo_s)
  305 + self.program_e_s.bind(self.vbo_cluster_lines)
290 306  
291 307 self.refresh()
292 308  
... ... @@ -309,6 +325,8 @@ class GraphCanvas(scene.SceneCanvas):
309 325 self.vbo = gloo.VertexBuffer(self.data)
310 326 self.program.bind(self.vbo)
311 327 #self.program_e.bind(self.vbo)
  328 + self.update_text(self.current_color)
  329 + self.update_color_bar(self.current_color)
312 330 self.refresh()
313 331  
314 332 def update_color_buffers(self):
... ... @@ -622,7 +640,7 @@ class GraphCanvas(scene.SceneCanvas):
622 640 two.
623 641 """
624 642 def gen_cluster_line_vbo(self, G):
625   - #create a graph that stores the edges of between the clusters
  643 +
626 644 self.G_cluster = nwt.gt.Graph(directed=False)
627 645 self.G_cluster.vertex_properties["pos"] = self.G_cluster.new_vertex_property("vector<double>", val=np.zeros((3,1), dtype=np.float32))
628 646 self.G_cluster.vertex_properties["RGBA"] = self.G_cluster.new_vertex_property("vector<double>", val=np.zeros((4,1), dtype=np.float32))
... ... @@ -630,22 +648,73 @@ class GraphCanvas(scene.SceneCanvas):
630 648 self.G_cluster.add_vertex()
631 649 self.G_cluster.vertex_properties["pos"][self.G_cluster.vertex(v)] = np.asarray(self.cluster_pos[v], dtype=np.float32)
632 650 self.G_cluster.edge_properties["weight"] = self.G_cluster.new_edge_property("int", val = 0)
  651 + self.G_cluster.edge_properties["volume"] = self.G_cluster.new_edge_property("float", val = 0.0)
633 652 #for each edge in the original graph, generate appropriate subgraph edges without repretiions
634 653 #i.e. controls the thichness of the edges in the subgraph view.
635 654 for e in G.edges():
636 655 #if the source and target cluster is not equal to each other
637 656 #add an inter subgraph edge.
638 657 if(G.vertex_properties["clusters"][e.source()] != G.vertex_properties["clusters"][e.target()]):
  658 + t0 = e.source()
  659 + t1 = e.target()
  660 + ct0 = self.G_cluster.vertex(G.vertex_properties["clusters"][t0])
  661 + ct1 = self.G_cluster.vertex(G.vertex_properties["clusters"][t1])
  662 + if(self.G_cluster.edge(ct0, ct1) == None):
  663 + if(self.G_cluster.edge(ct1, ct0) == None):
639 664 #temp_e.append([G.vertex_properties["clusters"][e.source()], G.vertex_properties["clusters"][e.target()]])
640   - self.G_cluster.add_edge(self.G_cluster.vertex(G.vertex_properties["clusters"][e.source()]), \
641   - self.G_cluster.vertex(G.vertex_properties["clusters"][e.target()]))
642   - self.G_cluster.edge_properties["weight"][self.G_cluster.edge(self.G_cluster.vertex(G.vertex_properties["clusters"][e.source()]), \
643   - self.G_cluster.vertex(G.vertex_properties["clusters"][e.target()]))] += 1
644   - self.G_cluster.vertex_properties["RGBA"][self.G_cluster.vertex(G.vertex_properties["clusters"][e.source()])] \
645   - = G.vertex_properties["RGBA"][e.source()]
646   - self.G_cluster.vertex_properties["RGBA"][self.G_cluster.vertex(G.vertex_properties["clusters"][e.target()])] \
647   - = G.vertex_properties["RGBA"][e.target()]
648   -
  665 + self.G_cluster.add_edge(self.G_cluster.vertex(G.vertex_properties["clusters"][t0]), \
  666 + self.G_cluster.vertex(G.vertex_properties["clusters"][t1]))
  667 + self.G_cluster.edge_properties["weight"][self.G_cluster.edge(self.G_cluster.vertex(G.vertex_properties["clusters"][t0]), \
  668 + self.G_cluster.vertex(G.vertex_properties["clusters"][t1]))] += 1
  669 + self.G_cluster.edge_properties["volume"][self.G_cluster.edge(self.G_cluster.vertex(G.vertex_properties["clusters"][t0]), \
  670 + self.G_cluster.vertex(G.vertex_properties["clusters"][t1]))] += G.edge_properties["volume"][e]
  671 + self.G_cluster.vertex_properties["RGBA"][self.G_cluster.vertex(G.vertex_properties["clusters"][t0])] \
  672 + = G.vertex_properties["RGBA"][t0]
  673 + self.G_cluster.vertex_properties["RGBA"][self.G_cluster.vertex(G.vertex_properties["clusters"][t1])] \
  674 + = G.vertex_properties["RGBA"][t1]
  675 + else:
  676 + self.G_cluster.edge_properties["weight"][self.G_cluster.edge(self.G_cluster.vertex(G.vertex_properties["clusters"][t1]), \
  677 + self.G_cluster.vertex(G.vertex_properties["clusters"][t0]))] += 1
  678 + self.G_cluster.edge_properties["volume"][self.G_cluster.edge(self.G_cluster.vertex(G.vertex_properties["clusters"][t1]), \
  679 + self.G_cluster.vertex(G.vertex_properties["clusters"][t0]))] += G.edge_properties["volume"][e]
  680 + self.G_cluster.vertex_properties["RGBA"][self.G_cluster.vertex(G.vertex_properties["clusters"][t1])] \
  681 + = G.vertex_properties["RGBA"][t1]
  682 + self.G_cluster.vertex_properties["RGBA"][self.G_cluster.vertex(G.vertex_properties["clusters"][t0])] \
  683 + = G.vertex_properties["RGBA"][t0]
  684 + else:
  685 + self.G_cluster.edge_properties["weight"][self.G_cluster.edge(self.G_cluster.vertex(G.vertex_properties["clusters"][t0]), \
  686 + self.G_cluster.vertex(G.vertex_properties["clusters"][t1]))] += 1
  687 + self.G_cluster.edge_properties["volume"][self.G_cluster.edge(self.G_cluster.vertex(G.vertex_properties["clusters"][t0]), \
  688 + self.G_cluster.vertex(G.vertex_properties["clusters"][t1]))] += G.edge_properties["volume"][e]
  689 + self.G_cluster.vertex_properties["RGBA"][self.G_cluster.vertex(G.vertex_properties["clusters"][t0])] \
  690 + = G.vertex_properties["RGBA"][t0]
  691 + self.G_cluster.vertex_properties["RGBA"][self.G_cluster.vertex(G.vertex_properties["clusters"][t1])] \
  692 + = G.vertex_properties["RGBA"][t1]
  693 + #create a graph that stores the edges of between the clusters
  694 +# self.G_cluster = nwt.gt.Graph(directed=False)
  695 +# self.G_cluster.vertex_properties["pos"] = self.G_cluster.new_vertex_property("vector<double>", val=np.zeros((3,1), dtype=np.float32))
  696 +# self.G_cluster.vertex_properties["RGBA"] = self.G_cluster.new_vertex_property("vector<double>", val=np.zeros((4,1), dtype=np.float32))
  697 +# for v in range(len(self.cluster_pos)):
  698 +# self.G_cluster.add_vertex()
  699 +# self.G_cluster.vertex_properties["pos"][self.G_cluster.vertex(v)] = np.asarray(self.cluster_pos[v], dtype=np.float32)
  700 +# self.G_cluster.edge_properties["weight"] = self.G_cluster.new_edge_property("int", val = 0)
  701 +# #for each edge in the original graph, generate appropriate subgraph edges without repretiions
  702 +# #i.e. controls the thichness of the edges in the subgraph view.
  703 +# for e in G.edges():
  704 +# #if the source and target cluster is not equal to each other
  705 +# #add an inter subgraph edge.
  706 +# if(G.vertex_properties["clusters"][e.source()] != G.vertex_properties["clusters"][e.target()]):
  707 +# #temp_e.append([G.vertex_properties["clusters"][e.source()], G.vertex_properties["clusters"][e.target()]])
  708 +# self.G_cluster.add_edge(self.G_cluster.vertex(G.vertex_properties["clusters"][e.source()]), \
  709 +# self.G_cluster.vertex(G.vertex_properties["clusters"][e.target()]))
  710 +# self.G_cluster.edge_properties["weight"][self.G_cluster.edge(self.G_cluster.vertex(G.vertex_properties["clusters"][e.source()]), \
  711 +# self.G_cluster.vertex(G.vertex_properties["clusters"][e.target()]))] += 1
  712 +# self.G_cluster.vertex_properties["RGBA"][self.G_cluster.vertex(G.vertex_properties["clusters"][e.source()])] \
  713 +# = G.vertex_properties["RGBA"][e.source()]
  714 +# self.G_cluster.vertex_properties["RGBA"][self.G_cluster.vertex(G.vertex_properties["clusters"][e.target()])] \
  715 +# = G.vertex_properties["RGBA"][e.target()]
  716 +
  717 + self.G_cluster.vertex_properties["degree"] = self.G_cluster.degree_property_map("total")
649 718 self.cluster_line_data = np.zeros(self.G_cluster.num_edges()*4, dtype=[('a_position', np.float32, 3),
650 719 ('a_normal', np.float32, 2),
651 720 ('a_fg_color', np.float32, 4),
... ... @@ -824,6 +893,62 @@ class GraphCanvas(scene.SceneCanvas):
824 893  
825 894  
826 895 """
  896 + Generates a hierarchical layout based on the cluster graph (spdf) and subclusters
  897 + """
  898 + def voronoi_layout(self, G = None, n_c = None, G_c = None):
  899 +
  900 + def gen_subclusters(G, G_cluster, i, reposition = False):
  901 + vfilt = np.zeros([G.num_vertices(), 1], dtype='bool')
  902 + labels = G.vertex_properties["clusters"].get_array()
  903 + num_v_in_cluster = len(np.argwhere(labels == i))
  904 + vfilt[np.argwhere(labels == i)] = 1
  905 + vfilt_prop = G.new_vertex_property("bool", vals = vfilt)
  906 + G.set_vertex_filter(vfilt_prop)
  907 +
  908 + g = nwt.gt.Graph(G, prune=True, directed=False)
  909 +
  910 +
  911 + if reposition == True:
  912 + vbetweeness_centrality = g.new_vertex_property("double")
  913 + ebetweeness_centrality = g.new_edge_property("double")
  914 + nwt.gt.graph_tool.centrality.betweenness(g, vprop=vbetweeness_centrality, eprop=ebetweeness_centrality, norm=True)
  915 + g.vertex_properties["bc"] = vbetweeness_centrality
  916 + g.edge_properties["bc"] = ebetweeness_centrality
  917 + g.vertex_properties["pos"] = nwt.gt.sfdp_layout(g, eweight = ebetweeness_centrality)
  918 +
  919 + positions = g.vertex_properties["pos"].get_2d_array(range(2)).T
  920 + center = np.sum(positions, 0)/num_v_in_cluster
  921 + G.clear_filters()
  922 + return g, center
  923 +
  924 + if G_c == None:
  925 + G_c = self.G_cluster
  926 + G_c.vertex_properties["pos"] = nwt.gt.sfdp_layout(G_c, eweight=G_c.edge_properties["volume"], vweight=G_c.vertex_properties["degree"], C = 1.0, K = 10)
  927 + if(G == None):
  928 + G = self.G
  929 + if(n_c == None):
  930 + n_c = self.n_c
  931 + else:
  932 + if(G == None):
  933 + G = self.G
  934 + if(n_c == None):
  935 + n_c = self.n_c
  936 + if self.n_c == G_c.num_vertices():
  937 + for i in range(n_c):
  938 + self.G_cluster.vertex_properties["pos"][self.G_cluster.vertex(i)] = G_c.vertex_properties["pos"][G_c.vertex(i)]
  939 +
  940 +
  941 + for i in range(n_c):
  942 + g, center = gen_subclusters(G, G_c, i, reposition=True)
  943 + d = G_c.vertex_properties["pos"][i] - center
  944 + for v in g.vertices():
  945 + G.vertex_properties["pos"][g.vertex_properties["idx"][v]] = g.vertex_properties["pos"][v] + d
  946 + g.vertex_properties["pos"][v] = g.vertex_properties["pos"][v] + d
  947 + #print("stuff")
  948 +
  949 +
  950 +
  951 + """
827 952 Layout algorithm that expands the cluster based on the location of the of the clusters
828 953 """
829 954 def expand_based_on_clusters(self, G, n):
... ... @@ -920,73 +1045,14 @@ class GraphCanvas(scene.SceneCanvas):
920 1045 self.clusters['a_value'][index:index+4] = np.asarray(v, dtype=np.float32)
921 1046 self.G_cluster.vertex_properties["pos"][self.G_cluster.vertex(i)] = self.cluster_pos[i]
922 1047  
923   -
924   -
925   -
926 1048 """
927   - Function that generates the clusters for an unclustered graph
928   - These are to be represented by the arcs
929   - """
930   - def gen_clusters(self, G, bbl, bbu, n_c = None, edge_metric = 'volume', vertex_metric = 'degree'):
931   -
932   - #Generate the clusters
933   - self.labels = nwt.Network.spectral_clustering(G,'length', n_clusters = n_c)
934   - bb = nwt.AABB(G)
935   - #print("FLJKKHDFLKJFDLKJFDLKJ ", m)
936   - pts = []
937   - x, y, z = bb.project_grid(3)
938   - for i in range(3):
939   - for j in range(3):
940   - for k in range(3):
941   - pts.append(np.array([x[i], y[j], z[k]]))
942   -
943   - #self.labels = nwt.Network.spectral_clustering(G,'length')
  1049 + Function that creates the clusters, assuming that all the data is set already.
944 1050  
945   - #Add clusters as a vertex property
946   - G.vertex_properties["clusters"] = G.new_vertex_property("int", vals=self.labels)
947   - num_clusters = len(np.unique(self.labels))
948   - self.n_c = n_c
949   - new_indices = []
950   - pos = G.vertex_properties["p"].get_2d_array(range(3)).T
951   -
952   - #for each cluster find the average vertex position and match to closest point
953   - #in the unique grid.
954   - for i in range(n_c):
955   - point = np.sum(pos[np.argwhere(self.labels == i)], axis=0)/len(np.argwhere(self.labels == i))
956   - d = 100000000.0
957   - idx = -1
958   - for j in range(len(pts)):
959   - dist = np.sqrt(np.power(pts[j][0]-point[0,0],2) + np.power(pts[j][1]-point[0,1],2) + np.power(pts[j][2]-point[0,2],2))
960   - if dist < d:
961   - d = dist
962   - idx = j
963   - new_indices.append(idx)
964   - pts[idx] = np.array([100000000.0, 1000000000.0, 100000000.0])
965   - #since there are more points than clusters, we need to make the indices range from
966   - #[0, n_c)
967   - j=0
968   - unique_indices = np.array(new_indices)
969   - for i in range(n_c):
970   - idx = np.argmin(new_indices)
971   - unique_indices[idx] = j
972   - j += 1
973   - new_indices[idx] = 100
974   -
975   - lbl = np.zeros(self.labels.shape)
976   - for i in range(n_c):
977   - idxs = np.argwhere(self.labels == i)
978   - new_idx = np.argwhere(unique_indices == i)
979   - lbl[idxs] = unique_indices[i]
980   -
981   - self.labels = lbl
982   - G.vertex_properties["clusters"] = G.new_vertex_property("int", vals=self.labels)
983   -
984   -
985   -
986   -
987   -
988   - #add colormap
989   - G.vertex_properties["RGBA"] = nwt.Network.map_property_to_color(G, G.vertex_properties["clusters"])
  1051 + """
  1052 + def gen_cluster_vbo(self, G, bbl, bbu, num_clusters, edge_metric = 'volume', vertex_metric = 'degree', update_color = True):
  1053 + #add colormap
  1054 + if(update_color == True):
  1055 + G.vertex_properties["RGBA"] = nwt.Network.map_property_to_color(G, G.vertex_properties["clusters"])
990 1056  
991 1057 #generate an empty property set for the clusters.
992 1058 self.clusters = np.zeros(num_clusters*4, dtype=[('a_position', np.float32, 3),
... ... @@ -1105,6 +1171,66 @@ class GraphCanvas(scene.SceneCanvas):
1105 1171 # self.edges_s = []
1106 1172 #print(self.edges_s)
1107 1173  
  1174 + """
  1175 + Function that generates the clusters for an unclustered graph
  1176 + These are to be represented by the arcs
  1177 + """
  1178 + def gen_clusters(self, G, bbl, bbu, n_c = None, edge_metric = 'volume', vertex_metric = 'degree'):
  1179 +
  1180 + #Generate the clusters
  1181 + self.labels = nwt.Network.spectral_clustering(G,'length', n_clusters = n_c)
  1182 + bb = nwt.AABB(G)
  1183 + #print("FLJKKHDFLKJFDLKJFDLKJ ", m)
  1184 + pts = []
  1185 + x, y, z = bb.project_grid(3)
  1186 + for i in range(3):
  1187 + for j in range(3):
  1188 + for k in range(3):
  1189 + pts.append(np.array([x[i], y[j], z[k]]))
  1190 +
  1191 +
  1192 + #self.labels = nwt.Network.spectral_clustering(G,'length')
  1193 + #Add clusters as a vertex property
  1194 + G.vertex_properties["clusters"] = G.new_vertex_property("int", vals=self.labels)
  1195 + num_clusters = len(np.unique(self.labels))
  1196 + self.n_c = n_c
  1197 + new_indices = []
  1198 + pos = G.vertex_properties["p"].get_2d_array(range(3)).T
  1199 +
  1200 + #for each cluster find the average vertex position and match to closest point
  1201 + #in the unique grid.
  1202 + for i in range(n_c):
  1203 + point = np.sum(pos[np.argwhere(self.labels == i)], axis=0)/len(np.argwhere(self.labels == i))
  1204 + d = 100000000.0
  1205 + idx = -1
  1206 + for j in range(len(pts)):
  1207 + dist = np.sqrt(np.power(pts[j][0]-point[0,0],2) + np.power(pts[j][1]-point[0,1],2) + np.power(pts[j][2]-point[0,2],2))
  1208 + if dist < d:
  1209 + d = dist
  1210 + idx = j
  1211 + new_indices.append(idx)
  1212 + pts[idx] = np.array([100000000.0, 1000000000.0, 100000000.0])
  1213 + #since there are more points than clusters, we need to make the indices range from
  1214 + #[0, n_c)
  1215 + j=0
  1216 + unique_indices = np.array(new_indices)
  1217 + for i in range(n_c):
  1218 + idx = np.argmin(new_indices)
  1219 + unique_indices[idx] = j
  1220 + j += 1
  1221 + new_indices[idx] = 100
  1222 +
  1223 + lbl = np.zeros(self.labels.shape)
  1224 + for i in range(n_c):
  1225 + idxs = np.argwhere(self.labels == i)
  1226 + new_idx = np.argwhere(unique_indices == i)
  1227 + lbl[idxs] = unique_indices[i]
  1228 +
  1229 + self.labels = lbl
  1230 + G.vertex_properties["clusters"] = G.new_vertex_property("int", vals=self.labels)
  1231 + self.gen_cluster_vbo(self.G, bbl, bbu, num_clusters, edge_metric, vertex_metric)
  1232 +
  1233 +
1108 1234  
1109 1235 """
1110 1236 Function that expands that generates the layout and updates the buffer
... ... @@ -1124,11 +1250,288 @@ class GraphCanvas(scene.SceneCanvas):
1124 1250 print(self.view)
1125 1251 self.refresh()
1126 1252  
  1253 +
  1254 + """
  1255 + Function for generating a distance field based on the clusters in the
  1256 + clustered 3D network.
  1257 + """
  1258 + def distancefield(self, G):
  1259 +
  1260 + import scipy as sp
  1261 + #generate a meshgrid of the appropriate size and resolution to surround the network
  1262 + #get the space occupied by the network
  1263 + lower = self.bbl
  1264 + upper = self.bbu
  1265 + R = np.asarray(np.floor(abs(lower-upper)), dtype=np.int)
  1266 +
  1267 + x = np.linspace(lower[0], upper[0], R[0]) #get the grid points for uniform sampling of this space
  1268 + y = np.linspace(lower[1], upper[1], R[1])
  1269 + z = np.linspace(lower[2], upper[2], R[2])
  1270 + X, Y, Z = np.meshgrid(x, y, z, indexing='ij')
  1271 +
  1272 + Q = np.stack((X, Y, Z), 3)
  1273 + #get a list of all node positions in the network
  1274 + P = []
  1275 + #get a mirrored list of all the point labels
  1276 + L = []
  1277 +
  1278 + for e in G.edges():
  1279 + X_p = G.edge_properties["x"][e]
  1280 + Y_p = G.edge_properties["y"][e]
  1281 + Z_p = G.edge_properties["z"][e]
  1282 + l = list(np.array([X_p,Y_p,Z_p]).T)
  1283 + #generate points list foe each edge
  1284 +
  1285 + P = P + l
  1286 + #generate labels list for each edge
  1287 + if G.vertex_properties["clusters"][e.source()] == G.vertex_properties["clusters"][e.target()]:
  1288 + c = G.vertex_properties["clusters"][e.source()]
  1289 + for i in range(len(l)):
  1290 + L.append(c)
  1291 + #if source and target have the same label, all points have that label
  1292 + else:
  1293 + #if source != target label, then point takes on the closest label
  1294 + source = []
  1295 + source.append(0.0)
  1296 + target = []
  1297 + for i in range(1, len(l)):
  1298 + dist = math.sqrt(pow(l[i][0]-l[i-1][0],2) + pow(l[i][1]-l[i-1][1],2) + pow(l[i][2]-l[i-1][2],2))
  1299 + source.append(dist + source[len(source)-1])
  1300 + target = source[::-1]
  1301 + for i in range(len(l)):
  1302 + if source[i] > target[i]:
  1303 + L.append(G.vertex_properties["clusters"][e.source()])
  1304 + else:
  1305 + L.append(G.vertex_properties["clusters"][e.target()])
  1306 +
  1307 + #turn that list into a Numpy array so that we can create a KD tree
  1308 + P = np.array(P)
  1309 +
  1310 + #generate a KD-Tree out of the network point array
  1311 + tree = sp.spatial.cKDTree(P)
  1312 +
  1313 + D, I = tree.query(Q)
  1314 + C = np.zeros(I.shape, dtype=np.int)
  1315 + for i in range(I.shape[0]):
  1316 + for j in range(I.shape[1]):
  1317 + for k in range(I.shape[2]):
  1318 + C[i,j,k] = L[I[i,j,k]]
  1319 +
  1320 + self.write_VTK_R(G, "./test_field.vtk", Q, C, X, Y, Z)
  1321 + return D, x, y, z, C
  1322 +
  1323 + """
  1324 + Function for saving the distance field based on the clusters in the
  1325 + clustered 3D network.
  1326 + """
  1327 + def write_VTK_R(self, G, filepath, Q, C, X, Y, Z):\
  1328 +
  1329 + from pyevtk.hl import gridToVTK
  1330 + from pyevtk.hl import imageToVTK
  1331 + from pyevtk.vtk import VtkFile, VtkImageData
  1332 + import vtk
  1333 + #T = C.reshape(C.shape[0]*C.shape[1]*C.shape[2])
  1334 + #C = T.reshape((C.shape[0], C.shape[1], C.shape[2]), order = 'C')
  1335 + ColorR = np.zeros((C.shape[0], C.shape[1], C.shape[2]))
  1336 + ColorG = np.zeros((C.shape[0], C.shape[1], C.shape[2]))
  1337 + ColorB = np.zeros((C.shape[0], C.shape[1], C.shape[2]))
  1338 + ColorA = np.zeros((C.shape[0], C.shape[1], C.shape[2]))
  1339 + #ColorR = ColorG = ColorB = ColorA = np.chararray((P.shape[0], P.shape[1], P.shape[2]))
  1340 + G.vertex_properties["RGBA"] = nwt.Network.map_property_to_color(G, G.vertex_properties["clusters"])
  1341 + self.color_edges(G)
  1342 + thisdict = {}
  1343 + otherdict = {}
  1344 + for v in G.vertices():
  1345 + thisdict[G.vertex_properties["clusters"][v]] = G.vertex_properties["RGBA"][v]
  1346 + color = G.vertex_properties["RGBA"][v].get_array()
  1347 + c = '#%02x%02x%02x%02x' % (int(color[0]*255), int(color[1]*255), int(color[2]*255), int(color[3]*255*0.3))
  1348 + otherdict[G.vertex_properties["clusters"][v]] = c
  1349 +
  1350 + print(thisdict, file=open('myfile.txt', 'w'))
  1351 + i = 0
  1352 + for i in range(C.shape[0]):
  1353 + for j in range(C.shape[1]):
  1354 + for k in range(C.shape[2]):
  1355 + c = thisdict[C[i,j,k]]
  1356 + ColorR[i,j,k] = c[0]
  1357 + ColorG[i,j,k] = c[1]
  1358 + ColorB[i,j,k] = c[2]
  1359 + ColorA[i,j,k] = c[3]
  1360 +
  1361 +
  1362 + # fig = plt.figure()
  1363 + # ax = fig.gca(projection='3d')
  1364 + # for e in G.edges():
  1365 + # X = G.edge_properties["x"][e]
  1366 + # Y = G.edge_properties["y"][e]
  1367 + # Z = G.edge_properties["z"][e]
  1368 + # color = G.edge_properties['RGBA'][e].get_array()
  1369 + # c = '#%02x%02x%02x' % (int(color[0]*255), int(color[1]*255), int(color[2]*255))
  1370 + # ax.plot(X,Y,Z, color=c)
  1371 + # print("plotting line")
  1372 + #
  1373 + #
  1374 + # print("generating cells")
  1375 + # x, y, z = np.indices(np.array(C.shape) + 1).astype(float)
  1376 + # filled = np.ones(C.shape)
  1377 + # print("replacing dict")
  1378 + # vox = replace_with_dict(C, otherdict)
  1379 + #
  1380 + # print("plotting voxels")
  1381 + # ax.voxels(x, y, z, filled, facecolors=vox)
  1382 +
  1383 +
  1384 + #ax.imshow(np.stack((ColorR[:,:,0], ColorG[:,:,0], ColorB[:,:,0]), axis = 2))
  1385 +
  1386 + #plt.show()
  1387 +
  1388 +
  1389 +
  1390 +
  1391 +
  1392 + filename = "./image_fixed.vti"
  1393 + imageData = vtk.vtkImageData()
  1394 + imageData.SetDimensions(C.shape[0], C.shape[1], C.shape[2])
  1395 + imageData.SetOrigin(0.0, 0.0, 0.0)
  1396 + imageData.SetSpacing(1.0, 1.0, 1.0)
  1397 + if vtk.VTK_MAJOR_VERSION <= 5:
  1398 + imageData.SetNumberOfScalarComponents(4)
  1399 + imageData.SetScalarTypeToDouble()
  1400 + else:
  1401 + imageData.AllocateScalars(vtk.VTK_DOUBLE, 4)
  1402 +
  1403 + for z in range(C.shape[2]):
  1404 + for y in range(C.shape[1]):
  1405 + for x in range(C.shape[0]):
  1406 + imageData.SetScalarComponentFromDouble(x, y, z, 0, ColorR[x,y,z])
  1407 + imageData.SetScalarComponentFromDouble(x, y, z, 1, ColorG[x,y,z])
  1408 + imageData.SetScalarComponentFromDouble(x, y, z, 2, ColorB[x,y,z])
  1409 + imageData.SetScalarComponentFromDouble(x, y, z, 3, ColorA[x,y,z])
  1410 +
  1411 +
  1412 + writer = vtk.vtkXMLImageDataWriter()
  1413 + writer.SetFileName(filename)
  1414 + if vtk.VTK_MAJOR_VERSION <= 5:
  1415 + writer.SetInputConnection(imageData.GetProducerPort())
  1416 + else:
  1417 + writer.SetInputData(imageData)
  1418 +
  1419 + writer.Write()
  1420 + nwt.Network.write_vtk(G, "./vessels_fixed.vtk", binning = False)
  1421 +
  1422 + def set_graph(self, G, bbl, bbu, subgraph = False):
  1423 + self.G = G
  1424 + self.bbl = bbl
  1425 + self.bbu = bbu
  1426 + clear(color=True, depth=True)
  1427 + self.subgraphs = subgraph
  1428 + self.current_color = "clusters"
  1429 + self.color_edges(G)
  1430 + print(self.G)
  1431 + color = G.vertex_properties["RGBA"].get_2d_array(range(4)).T
  1432 + size = nwt.Network.map_vertices_to_range(G, [30*self.pixel_scale, 8*self.pixel_scale], 'degree').get_array()
  1433 +
  1434 + position = G.vertex_properties["pos"].get_2d_array(range(3)).T
  1435 + #for p in range(position.shape[0]):
  1436 + # position[p][0] = position[p][0] + self.clusters["a_position"][G.vertex_properties["clusters"][G.vertex(p)]][0]
  1437 + # position[p][1] = position[p][1] + self.clusters["a_position"][G.vertex_properties["clusters"][G.vertex(p)]][1]
  1438 + # position[p][2] = position[p][2] + self.clusters["a_position"][G.vertex_properties["clusters"][G.vertex(p)]][2]
  1439 + #G.vertex_properties["pos"] = G.new_vertex_property("vector<double>", vals = position)
  1440 + edges = G.get_edges();
  1441 + edges = edges[:, 0:2]
  1442 + #width = nwt.Network.map_edges_to_range(G, [1*self.pixel_scale, 5*self.pixel_scale], 'volume').get_array()
  1443 + #ecolor = G.edge_properties["RGBA"].get_2d_array(range(4)).T
  1444 +
  1445 + self.data = np.zeros(G.num_vertices(), dtype=[('a_position', np.float32, 3),
  1446 + ('a_fg_color', np.float32, 4),
  1447 + ('a_bg_color', np.float32, 4),
  1448 + ('a_size', np.float32, 1),
  1449 + ('a_linewidth', np.float32, 1),
  1450 + ('a_unique_id', np.float32, 4),
  1451 + ('a_selection', np.float32, 1),
  1452 + ])
  1453 +
  1454 + #self.edges = edges.astype(np.uint32)
  1455 + self.data['a_position'] = position
  1456 + #fg color is the color of the ring
  1457 + self.data['a_fg_color'] = 0, 0, 0, 1
  1458 + self.data['a_bg_color'] = color
  1459 + self.data['a_size'] = size
  1460 + self.data['a_linewidth'] = 4.*self.pixel_scale
  1461 + self.data['a_unique_id'] = self.gen_vertex_id(G)
  1462 + self.data['a_selection'] = G.vertex_properties["selection"].get_array()
  1463 + #self.data['a_graph_size'] = [bbu-bbl]
  1464 +
  1465 + #self.program['u_graph_size'] = [bbu-bbl]
  1466 +
  1467 + self.vbo = gloo.VertexBuffer(self.data)
  1468 + self.gen_line_vbo(G)
  1469 + #self.gen_cylinder_vbo(G)
  1470 + if(self.subgraphs):
  1471 + self.labels = self.G.vp["clusters"].get_array()
  1472 + self.gen_cluster_vbo(self.G, bbl, bbu, self.n_c)
  1473 + self.vbo_s = gloo.VertexBuffer(self.clusters)
  1474 + self.index_s = gloo.IndexBuffer(self.edges_s)
  1475 + #self.index = gloo.IndexBuffer(self.edges)
  1476 + self.program_e.bind(self.vbo_line)
  1477 + self.program.bind(self.vbo)
  1478 + if(self.subgraphs):
  1479 + #self.program_e_s.bind(self.vbo_s)
  1480 + self.program_s.bind(self.vbo_s)
  1481 + if DEBUG:
  1482 + print(self.view)
  1483 + self.update_text(self.current_color)
  1484 + self.update_color_bar(self.current_color)
  1485 + self.refresh()
  1486 +
  1487 +
  1488 + def update_text(self, text):
  1489 + self.t1 = Text(text, parent=self.scene, color = 'black', method='gpu', anchor_x = 'right', anchor_y='top')
  1490 + self.t1.font_size = 24
  1491 + #self.t1.anchor_y = 'top'
  1492 + #self.t1.anchor_x = 'right'
  1493 +# print(self.t1.bounds(0), self.t1.bounds(1))
  1494 + self.t1.pos = self.size[0]-10, self.size[1] // 24
  1495 + self.refresh()
  1496 +
  1497 + def update_color_bar(self, color_property):
  1498 + if color_property != "":
  1499 + prop = self.G.vp[color_property].get_array().T
  1500 + mx = max(prop)
  1501 + mn = min(prop)
  1502 + else:
  1503 + mx = 1.0
  1504 + mn = 0.0
  1505 + if(color_property=="clusters"):
  1506 + cm = 'tab20'
  1507 + else:
  1508 + cm = 'plasma'
  1509 + self.c_bar = ColorBar(cmap=cm, orientation = 'bottom',
  1510 + size = (self.size[0] // 3, self.size[1] // 24), clim = (mn, mx),
  1511 + border_width = 10.0,border_color = 'white',
  1512 + parent=self.scene,
  1513 + pos=(self.size[0] // 3 // 2 + 20, self.size[1] // 24),
  1514 + padding = (100, 100)
  1515 + )
  1516 + self.refresh()
  1517 +
1127 1518 """
1128 1519 Loads the data G and generates all the buffers necessary as well as performs
1129 1520 spectral clustering on the graph passed if the subgraph is set to true.
1130 1521 """
1131   - def set_data(self, G, bbl, bbu, subgraph=True):
  1522 + def set_data(self, G, bbl, bbu, subgraph=True, G_other = None):
  1523 +
  1524 + def in_hull(point, hull, tolerance=1e-6):
  1525 + return all(
  1526 + (np.dot(eq[:-1], point) + eq[-1] <= tolerance)
  1527 + for eq in hull.equations)
  1528 +
  1529 +# def in_hull(p, hull):
  1530 +# if not isinstance(hull,Delaunay):
  1531 +# hull = Delaunay(hull)
  1532 +#
  1533 +# return hull.find_simplex(p)>=0
  1534 +
1132 1535 if DEBUG:
1133 1536 print("Setting data")
1134 1537 self.G = G
... ... @@ -1137,11 +1540,115 @@ class GraphCanvas(scene.SceneCanvas):
1137 1540 clear(color=True, depth=True)
1138 1541 self.subgraphs = True
1139 1542 self.current_color = "clusters"
1140   - if(subgraph==True):
1141   - self.gen_clusters(G, bbl, bbu, n_c=19)
1142 1543  
  1544 + if(subgraph==True and G_other == None):
  1545 + self.gen_clusters(G, bbl, bbu, n_c=19)
  1546 + self.G.vertex_properties["idx"] = self.G.vertex_index
1143 1547 #color based on clusters
1144 1548 self.color_edges(G)
  1549 + else:
  1550 + #polygons = []
  1551 + self.G.vertex_properties["idx"] = self.G.vertex_index
  1552 + self.G.vertex_properties["clusters"] = self.G.new_vertex_property("int", vals=np.full(self.G.num_vertices(), -1, dtype="int"))
  1553 + num_clusters = len(np.unique(G_other.vertex_properties["clusters"].get_array().T))
  1554 + color_lookup = []
  1555 + lbls = G_other.vertex_properties["clusters"].get_array().T
  1556 + for i in range(num_clusters):
  1557 + idx = np.where(lbls == i)[0][0]
  1558 + color_lookup.append(G_other.vertex_properties["RGBA"][G_other.vertex(idx)])
  1559 +
  1560 +
  1561 + self.n_c = num_clusters
  1562 + D, x, y, z, C = self.distancefield(G_other)
  1563 + print(len(x), len(y), len(z))
  1564 + for v in self.G.vertices():
  1565 + p = self.G.vertex_properties["p"][v]
  1566 + x_temp = np.fabs(x - p[0])
  1567 + idx_x = x_temp.argmin()
  1568 + y_temp = np.fabs(y - p[1])
  1569 + idx_y = y_temp.argmin()
  1570 + z_temp = np.fabs(z - p[2])
  1571 + idx_z = z_temp.argmin()
  1572 + cluster = C[idx_x][idx_y][idx_z]
  1573 + self.G.vertex_properties["clusters"][v] = cluster
  1574 + self.G.vertex_properties["RGBA"][v] = color_lookup[cluster]
  1575 +
  1576 +
  1577 +
  1578 + ###############OLD Comparison mechanic########################
  1579 +# polygons = []
  1580 +# for i in range(num_clusters):
  1581 +# #num_v_in_cluster = len(np.argwhere(self.labels == i))
  1582 +# vfilt = np.zeros([G_other.num_vertices(), 1], dtype="bool")
  1583 +# vfilt[np.argwhere(G_other.vertex_properties["clusters"].get_array().T == i)] = 1
  1584 +# vfilt_prop = G_other.new_vertex_property("bool", vals = vfilt)
  1585 +# G_other.set_vertex_filter(vfilt_prop)
  1586 +#
  1587 +# #get the filtered properties
  1588 +# g = nwt.gt.Graph(G_other, prune=True, directed=False)
  1589 +# color = g.vertex_properties["RGBA"][g.vertex(0)]
  1590 +# positions = g.vertex_properties["p"].get_2d_array(range(3)).T
  1591 +# hull = ConvexHull(positions)
  1592 +# #hull = Delaunay(positions)
  1593 +# #hull = multipoint.convex_hull
  1594 +# polygons.append(hull)
  1595 +# G_other.clear_filters()
  1596 +# for v in self.G.vertices():
  1597 +# if in_hull(self.G.vertex_properties["p"][v], hull) and self.G.vertex_properties["clusters"][v] == -1:
  1598 +# self.G.vertex_properties["clusters"][v] = i
  1599 +# self.G.vertex_properties["RGBA"][v] = color
  1600 +## if hull.contains(Point(self.G.vertex_properties["p"][v])):
  1601 +## self.G.vertex_properties["clusters"][v] = i
  1602 +## self.G.vertex_properties["RGBA"][v] = color
  1603 +#
  1604 +# unassigned = np.argwhere(self.G.vertex_properties["clusters"].get_array().T == -1)
  1605 +# while len(unassigned > 0):
  1606 +# for i in range(len(unassigned)):
  1607 +# gen = self.G.vertex(unassigned[i]).all_neighbors()
  1608 +# neighbors = []
  1609 +# neighbors_clusters = []
  1610 +# for j in gen:
  1611 +# neighbors.append(j)
  1612 +# neighbors_clusters.append(self.G.vertex_properties["clusters"][j])
  1613 +# if len(np.unique(neighbors_clusters)) == 1 and np.unique(neighbors_clusters[0]) != -1:
  1614 +# self.G.vertex_properties["clusters"][self.G.vertex(unassigned[i])] = \
  1615 +# self.G.vertex_properties["clusters"][neighbors[0]]
  1616 +# self.G.vertex_properties["RGBA"][self.G.vertex(unassigned[i])] = \
  1617 +# self.G.vertex_properties["RGBA"][neighbors[0]]
  1618 +# else:
  1619 +# c, count = np.unique(neighbors_clusters, return_counts=True)
  1620 +# for k in range(len(c)):
  1621 +# if c[k] == -1:
  1622 +# c = np.delete(c, k)
  1623 +# count = np.delete(count, k)
  1624 +# break
  1625 +# if len(c) > 0:
  1626 +# cluster = np.argwhere(count == max(count))[0]
  1627 +# self.G.vertex_properties["clusters"][self.G.vertex(unassigned[i])] = c[cluster[0]]
  1628 +# for v in range(len(neighbors)):
  1629 +# if self.G.vertex_properties["clusters"][self.G.vertex(unassigned[i])] == c[cluster[0]]:
  1630 +# self.G.vertex_properties["RGBA"][self.G.vertex(unassigned[i])] = \
  1631 +# self.G.vertex_properties["RGBA"][neighbors[v]]
  1632 +# unassigned = np.argwhere(self.G.vertex_properties["clusters"].get_array().T == -1)
  1633 +# #print("stuff")
  1634 +# #for j in range(len(neighbors_clusters)):
  1635 +#
  1636 +# #self.G.vertex_properties["RGBA"] = nwt.Network.map_property_to_color(self.G, self.G.vertex_properties["clusters"])
  1637 + temp = self.G.vertex_properties["clusters"].get_array().T
  1638 + print(np.unique(temp))
  1639 + self.labels = copy.copy(temp)
  1640 +# c = np.unique(temp)
  1641 +# idx = 0
  1642 +# for i in range(len(c)):
  1643 +# self.labels[np.argwhere(temp == c[i])] = idx
  1644 +# idx += 1
  1645 +#
  1646 + ###############/OLD Comparison mechanic########################
  1647 + self.G.vertex_properties["clusters"] = self.G.new_vertex_property("int", vals = self.labels)
  1648 + self.n_c = len(np.unique(self.labels))
  1649 + self.gen_cluster_vbo(self.G, bbl, bbu, self.n_c, update_color = False)
  1650 + self.color_edges(self.G)
  1651 +
1145 1652  
1146 1653 color = G.vertex_properties["RGBA"].get_2d_array(range(4)).T
1147 1654 size = nwt.Network.map_vertices_to_range(G, [30*self.pixel_scale, 8*self.pixel_scale], 'degree').get_array()
... ... @@ -1193,6 +1700,8 @@ class GraphCanvas(scene.SceneCanvas):
1193 1700 self.program_s.bind(self.vbo_s)
1194 1701 if DEBUG:
1195 1702 print(self.view)
  1703 + self.update_text(self.current_color)
  1704 + self.update_color_bar(self.current_color)
1196 1705 self.refresh()
1197 1706  
1198 1707 """
... ... @@ -1201,7 +1710,10 @@ class GraphCanvas(scene.SceneCanvas):
1201 1710 def on_resize(self, event):
1202 1711 set_viewport(0, 0, *event.physical_size)
1203 1712 self.fbo = gloo.FrameBuffer(color=gloo.RenderBuffer(self.size[::-1]), depth=gloo.RenderBuffer(self.size[::-1]))
1204   -
  1713 + self.update_text(self.current_color)
  1714 + self.update_color_bar(self.current_color)
  1715 + self.refresh()
  1716 + app.Canvas.update(self)
1205 1717  
1206 1718 """
1207 1719 Overloaded function that is called during every self.update() call
... ... @@ -1215,8 +1727,10 @@ class GraphCanvas(scene.SceneCanvas):
1215 1727 if(self.subgraphs):
1216 1728 self.program_e_s.draw('triangles', indices=self.index_clusters_s)
1217 1729 self.program_s.draw('triangles', indices=self.index_s)
1218   - print("updated ", self.num)
1219   - self.num += 1
  1730 + #print("updated ", self.num)
  1731 + #self.num += 1
  1732 + self.t1.draw()
  1733 + self.c_bar.draw()
1220 1734 #self._u
1221 1735 #self._update_pending = True
1222 1736 #app.Canvas.update(self)
... ... @@ -1227,6 +1741,7 @@ class GraphCanvas(scene.SceneCanvas):
1227 1741 vispy 0.6.3
1228 1742 """
1229 1743 def refresh(self):
  1744 + self.update_view_global()
1230 1745 self.update()
1231 1746 app.Canvas.update(self)
1232 1747  
... ... @@ -1289,6 +1804,7 @@ class GraphCanvas(scene.SceneCanvas):
1289 1804 #imsave("test_ori.png", buff)
1290 1805 self.fbo.activate()
1291 1806 if clusters == False:
  1807 + self.refresh()
1292 1808 self.program['u_picking'] = True
1293 1809 clear(color='white', depth=True)
1294 1810 self.program.draw('points')
... ... @@ -1336,6 +1852,12 @@ class GraphCanvas(scene.SceneCanvas):
1336 1852 else:
1337 1853 return self.cluster_dict[tuple(color)]
1338 1854  
  1855 + def update_view_global(self):
  1856 + self.program['u_view'] = self.view
  1857 + self.program_e['u_view'] = self.view
  1858 + self.program_s['u_view'] = self.view
  1859 + self.program_e_s['u_view'] = self.view
  1860 +
1339 1861  
1340 1862 """
1341 1863 Top level handle-mouse presee event for either left or right click
... ... @@ -1361,8 +1883,10 @@ class GraphCanvas(scene.SceneCanvas):
1361 1883 # #if menu.exec_(event.globalPos()):
1362 1884 # # print(item.text())
1363 1885 if(event.button == 1):
1364   - if(self.view[0][0] > 0.0010):
  1886 + if(self.view[0][0] > 0.0024):
  1887 + self.refresh()
1365 1888 c_id = self.get_clicked_id(event)
  1889 + self.refresh()
1366 1890 if(c_id != None):
1367 1891 self.original_point = self.G.vertex_properties["pos"][self.G.vertex(c_id)]
1368 1892 self.location = event.pos
... ... @@ -1373,7 +1897,10 @@ class GraphCanvas(scene.SceneCanvas):
1373 1897 update_view()
1374 1898 #print("Clicked on:", event.pos)
1375 1899 else:
  1900 +# c_id = None
  1901 + self.refresh()
1376 1902 c_id = self.get_clicked_id(event, True)
  1903 + self.refresh()
1377 1904 if DEBUG:
1378 1905 print(c_id)
1379 1906 if(c_id != None):
... ... @@ -1390,6 +1917,27 @@ class GraphCanvas(scene.SceneCanvas):
1390 1917 Gets the path and formats it in terms of vertex-to-vertex
1391 1918 instead of source(obj)-to-source(obj)
1392 1919 """
  1920 +
  1921 + def get_cluster(self, cluster_id):
  1922 + p = []
  1923 + num_v_in_cluster = len(np.argwhere(self.labels == cluster_id))
  1924 + vfilt = np.zeros([self.G.num_vertices(), 1], dtype="bool")
  1925 + vfilt[np.argwhere(self.labels == cluster_id)] = 1
  1926 + vfilt_prop = self.G.new_vertex_property("bool", vals = vfilt)
  1927 + self.G.set_vertex_filter(vfilt_prop)
  1928 +
  1929 + #get the filtered properties
  1930 + g = nwt.gt.Graph(self.G, prune=True, directed=False)
  1931 + self.G.clear_filters()
  1932 + for e in g.edges():
  1933 + source = g.vp["idx"][e.source()]
  1934 + target = g.vp["idx"][e.target()]
  1935 + temp = (int(source), int(target))
  1936 + p.append(temp)
  1937 +
  1938 + return p
  1939 +
  1940 +
1393 1941 def get_path(self):
1394 1942 p = []
1395 1943 for s in self.path:
... ... @@ -1422,12 +1970,14 @@ class GraphCanvas(scene.SceneCanvas):
1422 1970 self.G.vertex_properties["selection"][vl[v]] = 2.0
1423 1971 update_vertex_alpha(self, self.G.vertex(vl[v]), 1.0)
1424 1972 self.data['a_selection'][int(vl[v])] = 2.0
  1973 + self.G.vp["exclude"][self.G.vertex(vl[v])] = True
1425 1974 source.v_path.append(int(vl[v]))
1426 1975 for e in el:
1427 1976 source.e_path.append(e)
1428 1977 temp = self.G.edge_properties["RGBA"][e]
1429 1978 temp[3] = 1.0
1430 1979 self.G.edge_properties["RGBA"][e] = temp
  1980 + self.G.edge_properties["exclude"][e] = True
1431 1981  
1432 1982  
1433 1983 def remove_from_path(self, source):
... ... @@ -1435,15 +1985,19 @@ class GraphCanvas(scene.SceneCanvas):
1435 1985 self.G.vertex_properties["selection"][self.G.vertex(v)] = 0.0
1436 1986 update_vertex_alpha(self,self.G.vertex(v), 0.5)
1437 1987 self.data['a_selection'][v] = 0.0
  1988 + self.G.vertex_properties["exclude"][v] = False
1438 1989 for e in source.e_path:
1439 1990 temp = self.G.edge_properties["RGBA"][e]
1440 1991 temp[3] = 0.0
1441 1992 self.G.edge_properties["RGBA"][e] = temp
  1993 + self.G.edge_properties["exclude"][e] = False
1442 1994 source.clear_path()
1443 1995  
1444 1996 if (event.button == 1):
1445   - if(self.view[0][0] > 0.0010):
  1997 + if(self.view[0][0] > 0.0024):
  1998 + self.refresh()
1446 1999 c_id = self.get_clicked_id(event)
  2000 + self.refresh()
1447 2001 if(c_id != None):
1448 2002 #check whether this is the first node to be selected
1449 2003 if(self.pathing == False):
... ... @@ -1496,6 +2050,7 @@ class GraphCanvas(scene.SceneCanvas):
1496 2050 self.pathing = False
1497 2051 self.make_all_transparent(1.0)
1498 2052 self.update_color_buffers()
  2053 + self.refresh()
1499 2054  
1500 2055  
1501 2056  
... ... @@ -1725,6 +2280,43 @@ class GraphCanvas(scene.SceneCanvas):
1725 2280 self.location = event.pos
1726 2281 self.refresh()
1727 2282  
  2283 + def set_view_matrix(self, matrix):
  2284 + self.view = matrix
  2285 + self.program['u_view'] = self.view
  2286 + self.program_e['u_view'] = self.view
  2287 + self.program_s['u_view'] = self.view
  2288 + self.program_e_s['u_view'] = self.view
  2289 + self.refresh()
  2290 +
  2291 +
  2292 + def center_camera_on(self, camera):
  2293 + self.translate[0] += (0.0 - camera[0])/self.view[0][0]
  2294 + self.translate[1] += (0.0 - camera[1])/self.view[1][1]
  2295 + #self.view[3][0] = self.view[3][0]-(self.location[0]-event.pos[0])/10000.0
  2296 + #self.view[3][1] = self.view[3][1]+(self.location[1]-event.pos[1])/10000.0
  2297 +
  2298 + self.view = np.matmul(translate((self.translate[0], self.translate[1], 0)), scale((self.scale[0], self.scale[1], 0)))
  2299 +
  2300 + self.program['u_view'] = self.view
  2301 + self.program_e['u_view'] = self.view
  2302 + self.program_s['u_view'] = self.view
  2303 + self.program_e_s['u_view'] = self.view
  2304 + self.refresh()
  2305 +
  2306 + def zoom_camera_on(self, zoom):
  2307 + self.scale[0] = zoom[0]
  2308 + self.scale[1] = zoom[1]
  2309 +
  2310 + self.view = np.matmul(translate((self.translate[0], self.translate[1], 0)),
  2311 + scale((self.scale[0], self.scale[1], 0)))
  2312 +
  2313 + self.program['u_view'] = self.view
  2314 + self.program_e['u_view'] = self.view
  2315 + self.program_s['u_view'] = self.view
  2316 + self.program_e_s['u_view'] = self.view
  2317 + #print(event.delta[1])
  2318 + self.refresh()
  2319 +
1728 2320 """
1729 2321 Handles the mouse wheel zoom event.
1730 2322 """
... ...
GraphWidget.py
  Show/Hide comments   View file @17e4b25
... ... @@ -5,15 +5,79 @@ Created on Mon Aug 5 15:42:19 2019
5 5  
6 6 @author: pavel
7 7 """
8   -
9 8 from GraphCanvas import GraphCanvas
  9 +from HistogramWidget import HistogramWidget
  10 +#from NodeInformationWidget import NodeInfoWidget
10 11 from PyQt5 import QtCore, QtGui, QtWidgets
  12 +from PyQt5.Qt import QRect
11 13 import network_dep as nwt
  14 +from TubeWidget import TubeWidget
  15 +from vispy.scene.visuals import Text
12 16  
13 17 import numpy as np
14 18  
15 19 DEBUG = False
16 20  
  21 +
  22 +
  23 +class NodeInfoWidget(QtWidgets.QWidget):
  24 + def __init__(self, *args, **kwargs):
  25 + QtWidgets.QWidget.__init__(self)
  26 + self.layout = QtWidgets.QGridLayout()
  27 + self.resize(900, 300)
  28 + self.bar = None
  29 + print("stuff 22")
  30 + if 'hist' in kwargs:
  31 + print("stuff")
  32 + self.bar = HistogramWidget()
  33 + self.bar.canvas.create_native()
  34 + self.fibers_mini = TubeWidget()
  35 + self.fibers_mini.canvas.create_native()
  36 +
  37 + self.graph_mini1 = GraphWidget()
  38 + self.graph_mini1.canvas.create_native()
  39 + self.graph_mini2 = GraphWidget()
  40 + self.graph_mini2.canvas.create_native()
  41 + self.graph_mini3 = GraphWidget()
  42 + self.graph_mini3.canvas.create_native()
  43 + self.graph_mini4 = GraphWidget()
  44 + self.graph_mini4.canvas.create_native()
  45 +
  46 +
  47 +
  48 + self.graph_mini1.connect(self.fibers_mini)
  49 + self.fibers_mini.connect(self.graph_mini1)
  50 + self.fibers_mini.connect(self.graph_mini2)
  51 + self.fibers_mini.connect(self.graph_mini3)
  52 + self.fibers_mini.connect(self.graph_mini4)
  53 +
  54 +
  55 + self.layout.addWidget(self.graph_mini1.canvas.native, 0, 0, 1, 1)
  56 + self.layout.addWidget(self.graph_mini2.canvas.native, 0, 1, 1, 1)
  57 + self.layout.addWidget(self.graph_mini3.canvas.native, 1, 0, 1, 1)
  58 + self.layout.addWidget(self.graph_mini4.canvas.native, 1, 1, 1, 1)
  59 + #layout.addItem(vspacer, 0, 2, 2, 1)
  60 + if self.bar == None:
  61 + self.layout.addWidget(self.fibers_mini.canvas.native, 0, 2, 2, 2)
  62 + else:
  63 + self.layout.addWidget(self.fibers_mini.canvas.native, 0, 2, 1, 1)
  64 + self.layout.addWidget(self.bar.canvas.native, 1, 2, 1, 1)
  65 + #layout.setColumnStretch(0, 2)
  66 + #layout.setRowStretch(0, 2)
  67 + #layout.setColumnStretch(2, 1)
  68 + #layout.setRowStretch(0, 1)
  69 +
  70 + self.setLayout(self.layout)
  71 + #print(layout.getContentsMargins())
  72 + #top.show()
  73 +
  74 +
  75 +# def paintEvent(self, e):
  76 +# dc = QPainter(self)
  77 +
  78 + def bye(self):
  79 + self.exit(0)
  80 +
17 81 """
18 82 Initializes the entire QTlayout and sets the mouse press events.
19 83 These are connected to the slots such that each is processes by this class
... ... @@ -34,11 +98,13 @@ class GraphWidget(QtWidgets.QWidget):
34 98 self.color = True
35 99 self.use_3D = False
36 100 self.camera = [0,0,0]
  101 + self.other = None
37 102  
38 103 self.canvas.events.mouse_press.connect(self.on_mouse_press)
39 104 self.canvas.events.mouse_release.connect(self.on_mouse_release)
40 105 self.canvas.events.mouse_move.connect(self.on_mouse_move)
41 106 self.canvas.events.mouse_double_click.connect(self.on_mouse_double_click)
  107 + self.w = None
42 108 #self.canvas.events.
43 109 #self.show()
44 110 #self.repaint()
... ... @@ -55,18 +121,19 @@ class GraphWidget(QtWidgets.QWidget):
55 121 self.canvas.set_current(event)
56 122 if event.button == 2:
57 123 if self.canvas.view[0][0] >= 0.0010:
58   - self.canvas.update()
  124 + self.canvas.refresh()
59 125 c_id = self.canvas.get_clicked_id(event)
60   - self.canvas.update()
  126 + self.canvas.refresh()
61 127 else:
62   - self.canvas.update()
  128 + self.canvas.refresh()
63 129 c_id = self.canvas.get_clicked_id(event, clusters=True)
64   - self.canvas.update()
  130 + self.canvas.refresh()
65 131 #right click
66 132 if(c_id == None):
67 133 menu = QtWidgets.QMenu(self)
68 134 NS = menu.addAction('Node Size')
69   -
  135 + if (self.canvas.path != []):
  136 + FNP = menu.addAction("Filter Network Path")
70 137 #tmp = menu.addAction('temp')
71 138 tmp = menu.addMenu('Node Color')
72 139 vertex_props = self.canvas.G.vertex_properties.keys()
... ... @@ -76,12 +143,14 @@ class GraphWidget(QtWidgets.QWidget):
76 143 vertex_actions.append(tmp.addAction(vertex_props[i]))
77 144 #tmp.addAction("Cluster")
78 145 #NC = menu.addAction('Node Color')
79   - #EXP = menu.addAction('Export VTK')
  146 + EXP = menu.addAction('Export VTK')
80 147 #EXP_adv = menu.addAction('Export VTK Advanced')
81 148 NL = menu.addAction('New Layout')
82 149 NSL = menu.addAction('New Spring-Onion Layout (sum)')
83 150 NSLMI = menu.addAction('New Spring-Onion Layout(max)')
84 151 EXPAND = menu.addAction('Expand')
  152 + CL = menu.addAction('Cluster_Layout')
  153 +
85 154 action = menu.exec_(event.native.globalPos())
86 155 if DEBUG:
87 156 print(action)
... ... @@ -101,11 +170,22 @@ class GraphWidget(QtWidgets.QWidget):
101 170 self.use_3D = False
102 171 self.canvas.size_vertices(self.canvas.G, 'degree' )
103 172 self.canvas.color_vertices(self.canvas.G, 'degree')
  173 + if (self.canvas.path != []):
  174 + if action == FNP:
  175 + net = nwt.Network()
  176 + G1 = net.filterBorder(self.canvas.G)
  177 + BB = nwt.AABB(G1)
  178 + self.canvas.set_graph(G1, BB.A, BB.B, subgraph=True)
  179 + self.test.canvas.set_data(G1, BB.A, BB.B, 16)
  180 + self.canvas.refresh()
  181 + self.test.canvas.refresh()
  182 + #self.canvas.set_data()
  183 +
104 184 #if action == NC:
105 185 # self.canvas.color_vertices(self.canvas.G, not self.color)
106 186 # self.color = not self.color
107   -# if action == EXP:
108   -# nwt.Network.write_vtk(self.canvas.G, "./nwt.vtk")
  187 + if action == EXP:
  188 + nwt.Network.write_vtk(self.canvas.G, "./nwt_small.vtk")
109 189 # if action == EXP_adv:
110 190 # nwt.Network.write_vtk(self.canvas.G, "./nwt_median_binned.vtk")
111 191 # nwt.Network.write_vtk(self.canvas.G, "./nwt_median_non_binned.vtk", binning=False)
... ... @@ -158,36 +238,221 @@ class GraphWidget(QtWidgets.QWidget):
158 238 #self.canvas.expand_clusters(self.canvas.G, self.canvas.n_c)
159 239  
160 240 self.canvas.animate(old_pos, new_pos)
  241 + if action == CL:
  242 + old_pos = self.canvas.G.vertex_properties["pos"].get_2d_array(range(3)).T
  243 + self.canvas.voronoi_layout()
  244 + new_pos = self.canvas.G.vertex_properties["pos"].get_2d_array(range(3)).T
  245 + if self.other != None:
  246 + other_old_pos = self.other.canvas.G.vertex_properties["pos"].get_2d_array(range(3)).T
  247 + self.other.canvas.voronoi_layout(G_c = self.canvas.G_cluster)
  248 + other_new_pos = self.other.canvas.G.vertex_properties["pos"].get_2d_array(range(3)).T
  249 + self.other.canvas.animate(other_old_pos, other_new_pos)
  250 + self.canvas.animate(old_pos, new_pos)
161 251 #self.canvas.size_vertices(self.canvas.G, 'degree_volume')
162 252 else:
163 253 if self.canvas.view[0][0] >= 0.0010:
164 254 menu = QtWidgets.QMenu(self)
165   - NS = menu.addAction('Display Node Info')
  255 + MnOC = menu.addAction('Minimize Other Clusters')
  256 + RA = menu.addAction('Reset Alpha')
  257 + NI = menu.addAction('Display Node Info')
  258 + CI = menu.addAction('Display Cluster Info')
166 259 action = menu.exec_(event.native.globalPos())
167   - if action == NS:
  260 + if action == MnOC:
  261 + self.canvas.set_current(event)
  262 + self.canvas.refresh()
  263 + c_id = self.canvas.get_clicked_id(event)
  264 +
  265 + cluster_id = self.canvas.G.vp["clusters"][self.canvas.G.vertex(c_id)]
  266 + self.select.emit(self.canvas.get_cluster(cluster_id))
  267 + if action == RA:
  268 + t = []
  269 + self.select.emit(self.canvas.get_cluster(t))
  270 + if action == NI:
  271 + self.canvas.set_current(event)
  272 + self.canvas.refresh()
  273 + c_id = self.canvas.get_clicked_id(event)
  274 + self.canvas.refresh()
168 275 print("Display Node Info")
  276 + self.w = NodeInfoWidget()
  277 +
  278 + #generate the subgraph around the node
  279 + vfilt = np.zeros([self.canvas.G.num_vertices(), 1], dtype="bool")
  280 + center = self.canvas.G.vp["pos"][self.canvas.G.vertex(c_id)]
  281 + for v in self.canvas.G.vertex(c_id).all_neighbors():
  282 + vfilt[int(v)] = 1
  283 + vfilt[int(c_id)] = 1
  284 + vfilt_prop = self.canvas.G.new_vertex_property("bool", vals = vfilt)
  285 + self.canvas.G.set_vertex_filter(vfilt_prop)
  286 +
  287 + #get the filtered properties
  288 + g = nwt.gt.Graph(self.canvas.G, prune=True, directed=False)
  289 + BB = nwt.AABB(g)
  290 + #print(BB.A)
  291 + #print(BB.B)
  292 + self.canvas.G.clear_filters()
  293 + self.w.setGeometry(QRect(100, 100, 900, 800))
  294 + self.w.graph_mini1.canvas.set_graph(g, BB.A, BB.B)
  295 + self.w.graph_mini1.canvas.center_camera_on(center)
  296 + self.w.graph_mini1.canvas.zoom_camera_on(self.canvas.scale)
  297 + self.w.graph_mini1.canvas.color_vertices(g, "clusters")
  298 +
  299 + self.w.graph_mini2.canvas.set_graph(g, BB.A, BB.B)
  300 + self.w.graph_mini2.canvas.center_camera_on(center)
  301 + self.w.graph_mini2.canvas.zoom_camera_on(self.canvas.scale)
  302 + self.w.graph_mini2.canvas.color_vertices(g, "degree")
  303 +
  304 + self.w.graph_mini3.canvas.set_graph(g, BB.A, BB.B)
  305 + #self.w.graph_mini3.canvas.set_view_matrix(self.canvas.view)
  306 + self.w.graph_mini3.canvas.center_camera_on(center)
  307 + self.w.graph_mini3.canvas.zoom_camera_on(self.canvas.scale)
  308 + self.w.graph_mini3.canvas.color_vertices(g, "bc")
  309 +
  310 + self.w.graph_mini4.canvas.set_graph(g, BB.A, BB.B)
  311 + #self.w.graph_mini4.canvas.set_view_matrix(self.canvas.view)
  312 + self.w.graph_mini4.canvas.center_camera_on(center)
  313 + self.w.graph_mini4.canvas.zoom_camera_on(self.canvas.scale)
  314 + self.w.graph_mini4.canvas.color_vertices(g, "degree_volume")
  315 +
  316 + self.w.fibers_mini.canvas.set_data(g, BB.A, BB.B, 16)
  317 + self.w.show()
  318 + if action == CI:
  319 + self.canvas.set_current(event)
  320 + self.canvas.refresh()
  321 + c_id = self.canvas.get_clicked_id(event)
  322 + #self.canvas.refresh()
  323 + self.w = NodeInfoWidget(hist=True)
  324 + #self.w = NodeInfoWidget()
  325 +
  326 + cluster_id = self.canvas.G.vp["clusters"][self.canvas.G.vertex(c_id)]
  327 + num_v_in_cluster = len(np.argwhere(self.canvas.labels == cluster_id))
  328 + vfilt = np.zeros([self.canvas.G.num_vertices(), 1], dtype="bool")
  329 + vfilt[np.argwhere(self.canvas.labels == cluster_id)] = 1
  330 + vfilt_prop = self.canvas.G.new_vertex_property("bool", vals = vfilt)
  331 + self.canvas.G.set_vertex_filter(vfilt_prop)
  332 +
  333 + #get the filtered properties
  334 + g = nwt.gt.Graph(self.canvas.G, prune=True, directed=False)
  335 + positions = g.vertex_properties["pos"].get_2d_array(range(3)).T
  336 + center = np.sum(positions, 0)/num_v_in_cluster
  337 + self.canvas.G.clear_filters()
  338 +
  339 + BB = nwt.AABB(g)
  340 + self.canvas.G.clear_filters()
  341 + self.w.setGeometry(QRect(100, 100, 900, 800))
  342 + self.w.graph_mini1.canvas.set_graph(g, BB.A, BB.B)
  343 + self.w.graph_mini1.canvas.center_camera_on(center)
  344 + self.w.graph_mini1.canvas.zoom_camera_on(self.canvas.scale)
  345 +
  346 + self.w.graph_mini2.canvas.set_graph(g, BB.A, BB.B)
  347 + self.w.graph_mini2.canvas.center_camera_on(center)
  348 + self.w.graph_mini2.canvas.zoom_camera_on(self.canvas.scale)
  349 + self.w.graph_mini2.canvas.color_vertices(g, "degree")
  350 +
  351 + self.w.graph_mini3.canvas.set_graph(g, BB.A, BB.B)
  352 + #self.w.graph_mini3.canvas.set_view_matrix(self.canvas.view)
  353 + self.w.graph_mini3.canvas.center_camera_on(center)
  354 + self.w.graph_mini3.canvas.zoom_camera_on(self.canvas.scale)
  355 + self.w.graph_mini3.canvas.color_vertices(g, "bc")
  356 +
  357 + self.w.graph_mini4.canvas.set_graph(g, BB.A, BB.B)
  358 + #self.w.graph_mini4.canvas.set_view_matrix(self.canvas.view)
  359 + self.w.graph_mini4.canvas.center_camera_on(center)
  360 + self.w.graph_mini4.canvas.zoom_camera_on(self.canvas.scale)
  361 + self.w.graph_mini4.canvas.color_vertices(g, "degree_volume")
  362 +
  363 + self.w.fibers_mini.canvas.set_data(g, BB.A, BB.B, 16)
  364 +
  365 + self.w.bar.set_Graph(g)
  366 +
  367 + self.w.show()
  368 +
  369 + print("Display Cluster Info")
169 370 else:
170 371 menu = QtWidgets.QMenu(self)
171 372 MnOC = menu.addAction('Minimize Other Clusters')
  373 + CI = menu.addAction('Display Cluster Info')
172 374 RA = menu.addAction('Reset Alpha')
173 375 action = menu.exec_(event.native.globalPos())
174 376 if action == MnOC:
175   - new_Graph = self.canvas.focus_on_cluster(self.canvas.G, c_id)
176   - self.test.draw_new(new_Graph)
  377 + self.canvas.set_current(event)
  378 + self.canvas.refresh()
  379 + c_id = self.canvas.get_clicked_id(event, clusters=True)
  380 + self.canvas.refresh()
  381 +
  382 + cluster_id = self.canvas.G.vp["clusters"][c_id]
  383 + self.select.emit(self.canvas.get_path(cluster_id))
177 384 if action == RA:
178   - self.canvas.reset_alpha(c_id[0])
  385 + t = []
  386 + self.select.emit(self.canvas.get_cluster(t))
  387 + if action == CI:
  388 + self.canvas.set_current(event)
  389 + self.canvas.refresh()
  390 + c_id = self.canvas.get_clicked_id(event, clusters=True)
  391 + self.canvas.refresh()
  392 +
  393 + self.w = NodeInfoWidget(hist=True)
  394 + #self.w = NodeInfoWidget()
  395 +
  396 + cluster_id = self.canvas.G.vp["clusters"][c_id]
  397 + num_v_in_cluster = len(np.argwhere(self.canvas.labels == c_id))
  398 + vfilt = np.zeros([self.canvas.G.num_vertices(), 1], dtype="bool")
  399 + vfilt[np.argwhere(self.canvas.labels == c_id)] = 1
  400 + vfilt_prop = self.canvas.G.new_vertex_property("bool", vals = vfilt)
  401 + self.canvas.G.set_vertex_filter(vfilt_prop)
  402 +
  403 + #get the filtered properties
  404 + g = nwt.gt.Graph(self.canvas.G, prune=True, directed=False)
  405 + positions = g.vertex_properties["pos"].get_2d_array(range(3)).T
  406 + center = np.sum(positions, 0)/num_v_in_cluster
  407 + self.canvas.G.clear_filters()
  408 +
  409 + BB = nwt.AABB(g)
  410 + self.canvas.G.clear_filters()
  411 + self.w.setGeometry(QRect(100, 100, 900, 800))
  412 + self.w.graph_mini1.canvas.set_graph(g, BB.A, BB.B)
  413 + self.w.graph_mini1.canvas.center_camera_on(center)
  414 + self.w.graph_mini1.canvas.zoom_camera_on(self.canvas.scale)
  415 +
  416 + self.w.graph_mini2.canvas.set_graph(g, BB.A, BB.B)
  417 + self.w.graph_mini2.canvas.center_camera_on(center)
  418 + self.w.graph_mini2.canvas.zoom_camera_on(self.canvas.scale)
  419 + self.w.graph_mini2.canvas.color_vertices(g, "degree")
  420 +
  421 + self.w.graph_mini3.canvas.set_graph(g, BB.A, BB.B)
  422 + #self.w.graph_mini3.canvas.set_view_matrix(self.canvas.view)
  423 + self.w.graph_mini3.canvas.center_camera_on(center)
  424 + self.w.graph_mini3.canvas.zoom_camera_on(self.canvas.scale)
  425 + self.w.graph_mini3.canvas.color_vertices(g, "bc")
  426 +
  427 + self.w.graph_mini4.canvas.set_graph(g, BB.A, BB.B)
  428 + #self.w.graph_mini4.canvas.set_view_matrix(self.canvas.view)
  429 + self.w.graph_mini4.canvas.center_camera_on(center)
  430 + self.w.graph_mini4.canvas.zoom_camera_on(self.canvas.scale)
  431 + self.w.graph_mini4.canvas.color_vertices(g, "degree_volume")
  432 +
  433 + self.w.fibers_mini.canvas.set_data(g, BB.A, BB.B, 16)
  434 +
  435 + self.w.bar.set_Graph(g)
  436 + self.w.show()
  437 +
  438 + print("Display Cluster Info")
  439 +
179 440  
180 441  
181 442 # def selection_change(self, i):
182 443 # self.canvas.size_vertices(self.canvas.G, self.cb.currentText())
183 444  
184 445  
  446 + def set_other(self, other):
  447 + self.other = other
  448 +
185 449 """
186 450 Handles the mouse double click event.
187 451 Pass-through function.
188 452 """
189 453  
190 454 def on_mouse_double_click(self, event):
  455 + self.canvas.set_current(event)
191 456 self.canvas.update_path(event)
192 457 self.select.emit(self.canvas.get_path())
193 458 # old_pos = self.canvas.G.vertex_properties["pos"].get_2d_array(range(3)).T
... ... @@ -209,7 +474,11 @@ class GraphWidget(QtWidgets.QWidget):
209 474 Pass-through function.
210 475 """
211 476 def on_mouse_move(self, event):
212   - n = 2
  477 + self.canvas.set_current(event)
  478 + self.canvas.refresh()
  479 + c_id = self.canvas.get_clicked_id(event)
  480 + self.canvas.refresh()
  481 + print(c_id)
213 482  
214 483 """
215 484 Internal function that interacts with the tube visualization.
... ...
GuiVisPy_tube.py
  Show/Hide comments   View file @17e4b25
... ... @@ -57,23 +57,28 @@ graph.canvas.create_native()
57 57 graph.connect(fibers)
58 58 fibers.connect(graph)
59 59  
60   -#initialize the layout
61   -layout.addWidget(graph.canvas.native, 0, 0, 2, 3)
62   -layout.addWidget(fibers.canvas.native, 0, 2, 2, 3)
63   -layout.setColumnStretch(0, 2)
64   -layout.setRowStretch(0, 2)
65   -layout.setColumnStretch(2, 1)
66   -layout.setRowStretch(0, 1)
  60 +#vspacer = QtWidgets.QSpacerItem(10,10, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum)
67 61  
68   -top.setLayout(layout)
  62 +#initialize the layoutddddddddddd
69 63  
70   -top.show()
  64 +#addLayout(QLayout *layout, int row, int column, int rowSpan, int columnSpan
  65 +#, Qt::Alignment alignment = Qt::Alignment())
  66 +#layout.addWidget(graph.canvas.native, 0, 0, 2, 3)
  67 +#layout.addItem(vspacer, 0, 1, 2, 3)
  68 +#layout.addWidget(fibers.canvas.native, 0, 2, 2, 3)
  69 +
  70 +layout.addWidget(graph.canvas.native, 0, 0, 2, 3)
  71 +#layout.addItem(vspacer, 0, 2, 2, 1)
  72 +layout.addWidget(fibers.canvas.native, 0, 4, 2, 3)
71 73  
  74 +#layout.setColumnStretch(0, 2)
  75 +#layout.setRowStretch(0, 2)
  76 +#layout.setColumnStretch(2, 1)
  77 +#layout.setRowStretch(0, 1)
72 78  
73   -#def draw_histogram(G, value):
74   -# vals = G.edge_properties[value].get_array()
75   -# y, x = np.histogram(vals,40)
76   -# hist.plot(x,y, stepMode=True, fillLevel=0, brush=(0,0,255,150))
  79 +top.setLayout(layout)
  80 +print(layout.getContentsMargins())
  81 +top.show()
77 82  
78 83 def load_nwt(filepath):
79 84 net = nwt.Network(filepath)
... ... @@ -115,6 +120,12 @@ fibers.canvas.set_data(G, bbl, bbu, 16)
115 120 #fibers.draw_all(G, center, fibers, graph, node_tex)
116 121 graph.set_g_view(fibers)
117 122  
  123 +graph.label = QtWidgets.QLabel(graph)
  124 +graph.label.setFrameStyle(QtWidgets.QFrame.Panel | QtWidgets.QFrame.Sunken)
  125 +graph.label.setText("STUFF")
  126 +graph.label.setAlignment(QtCore.Qt.AlignTop | QtCore.Qt.AlignRight)
  127 +graph.label.raise_()
  128 +
118 129 ## Start Qt event loop unless running in interactive mode.
119 130 if __name__ == '__main__':
120 131 #import sys
... ...
GuiVisPy_tube_dual.py 0 → 100644
  Show/Hide comments   View file @17e4b25
  1 +#!/usr/bin/env python3
  2 +# -*- coding: utf-8 -*-
  3 +"""
  4 +Created on Thu Jan 31 15:29:40 2019
  5 +
  6 +@author: pavel
  7 +`"""
  8 +
  9 +from vispy import app
  10 +import vispy
  11 +
  12 +import network_dep as nwt
  13 +
  14 +#from pyqtgraph.Qt import QtCore, QtGui, QtWidgets
  15 +from PyQt5 import QtCore, QtGui, QtWidgets
  16 +#import pyqtgraph as pg
  17 +import numpy as np
  18 +import math
  19 +
  20 +from mpl_toolkits.mplot3d import Axes3D
  21 +#import matplotlib
  22 +#import matplotlib.pyplot as plt
  23 +#matplotlib.use('Qt5Agg')
  24 +
  25 +from GraphWidget import GraphWidget
  26 +from TubeWidget import TubeWidget
  27 +#vispy.use(app='egl')
  28 +
  29 +
  30 +DEBUG = False
  31 +
  32 +#set the backend. for different versions of PyQt
  33 +app.use_app(backend_name='PyQt5')
  34 +
  35 +app.set_interactive(True)
  36 +
  37 +#Define a top level application
  38 +appMain = QtWidgets.QApplication([])
  39 +#QtWidgets.QApplication.setAttribute(QtCore.Qt.AA_ShareOpenGLContexts, True)
  40 +
  41 +##Define a toplevel Widget
  42 +top = QtWidgets.QWidget()
  43 +top.resize(900, 900)
  44 +
  45 +
  46 +#fibers = FiberView()
  47 +fibers = TubeWidget()
  48 +fibers.canvas.create_native()
  49 +#fibers = gl.GLViewWidget()
  50 +
  51 +#plt = hist.addPlot()
  52 +
  53 +layout = QtWidgets.QGridLayout()
  54 +graph = GraphWidget()
  55 +graph.canvas.create_native()
  56 +
  57 +
  58 +fibers2 = TubeWidget()
  59 +fibers2.canvas.create_native()
  60 +
  61 +graph2 = GraphWidget()
  62 +graph2.canvas.create_native()
  63 +
  64 +graph.connect(fibers)
  65 +fibers.connect(graph)
  66 +
  67 +graph2.connect(fibers2)
  68 +fibers2.connect(graph2)
  69 +
  70 +#vspacer = QtWidgets.QSpacerItem(10,10, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum)
  71 +
  72 +#initialize the layoutddddddddddd
  73 +
  74 +#addLayout(QLayout *layout, int row, int column, int rowSpan, int columnSpan
  75 +#, Qt::Alignment alignment = Qt::Alignment())
  76 +#layout.addWidget(graph.canvas.native, 0, 0, 2, 3)
  77 +#layout.addItem(vspacer, 0, 1, 2, 3)
  78 +#layout.addWidget(fibers.canvas.native, 0, 2, 2, 3)
  79 +
  80 +layout.addWidget(graph.canvas.native, 0, 0, 1, 3)
  81 +#layout.addItem(vspacer, 0, 2, 2, 1)
  82 +layout.addWidget(fibers.canvas.native, 0, 4, 1, 3)
  83 +
  84 +layout.addWidget(graph2.canvas.native, 1, 0, 1, 3)
  85 +#layout.addItem(vspacer, 0, 2, 2, 1)
  86 +layout.addWidget(fibers2.canvas.native, 1, 4, 1, 3)
  87 +
  88 +#layout.setColumnStretch(0, 2)
  89 +#layout.setRowStretch(0, 2)
  90 +#layout.setColumnStretch(2, 1)
  91 +#layout.setRowStretch(0, 1)
  92 +
  93 +top.setLayout(layout)
  94 +print(layout.getContentsMargins())
  95 +top.show()
  96 +
  97 +def load_nwt(filepath):
  98 + net = nwt.Network(filepath)
  99 + G = net.createFullGraph_gt()
  100 + G = net.filterDisconnected(G)
  101 + #G = net.gen_spring_onion_layout(G, 'degree', 1.0, 1000, 0.01, 1.0)
  102 + #G = net.filterFullGraph_gt(G, erode=True)
  103 + #G = net.filterFullGraph_gt(G, erode=True)
  104 + #G = net.gen_new_fd_layout(G)
  105 + #G = net.filterBorder(G)
  106 + #nwt.Network.saveGraph_gt(nwt, G, "FilteredNetwork_JACK_3.nwt")
  107 + color = np.zeros(4, dtype = np.double)
  108 + color = [0.0, 1.0, 0.0, 1.0]
  109 + G.edge_properties["RGBA"] = G.new_edge_property("vector<double>", val=color)
  110 + color = [1.0, 0.0, 0.0, 0.9]
  111 + G.vertex_properties["RGBA"] = G.new_vertex_property("vector<double>", val=color)
  112 + bbl, bbu = net.aabb()
  113 +
  114 +
  115 + return G, bbl, bbu
  116 +
  117 +G, bbl, bbu = load_nwt("/home/pavel/Documents/Python/GraphGuiQt/network_4.nwt")
  118 +
  119 +G2, bbl2, bbu2 = load_nwt("/home/pavel/Documents/Python/GraphGuiQt/network_4.nwt")
  120 +#G2, bbl2, bbu2 = load_nwt("/home/pavel/Documents/Python/GraphGuiQt/network_4.nwt")
  121 +#nwt.Network.write_vtk(G)
  122 +
  123 +#G, bbl, bbu = load_nwt("/home/pavel/Documents/Python/GraphGuiQt/net`````````work_test_251_1kx3_short_NEW.nwt")
  124 +#ret = nwt.Network.get_affinity_matrix(G, "length")
  125 +#node_image = QtGui.QImage("/home/pavel/Documents/Python/GraphGuiQt/node_tex.jpg")
  126 +#node_tex = QtGui.QBitmap.fromImage(node_image)
  127 +
  128 +if DEBUG:
  129 + print(node_tex.depth())
  130 +#fibers.opts['distance'] = 5
  131 +# item = NodeItem(G)
  132 +# graph.addItem(item)
  133 +#draw_histogram(G, "length")
  134 +
  135 + #self.canvas.events.mouse_press.connect(o_canvas.on_mouse_press)
  136 + #self.canvas.events.mouse_release.connect(o_canvas.on_mouse_release)
  137 + #self.canvas.events.mouse_move.connect(o_canvas.on_mouse_move)
  138 + #self.canvas.events.mouse_wheel.connect(o_canvas.on_mouse_wheel)
  139 +#fibers.canvas.events.mouse_press.connect(fibers2.mouse_press)
  140 +#fibers.canvas.events.mouse_release.connect(fibers2.mouse_release)
  141 +#fibers.canvas.events.on_mouse_wheel.connect(fibers2.canvas.on_mouse_wheel)
  142 +
  143 +graph.canvas.set_data(G, bbl, bbu)
  144 +fibers.canvas.set_data(G, bbl, bbu, 16)
  145 +fibers.set_other(fibers2)
  146 +fibers2.set_other(fibers)
  147 +graph.set_other(graph2)
  148 +graph2.set_other(graph)
  149 +
  150 +graph2.canvas.set_data(G2, bbl2, bbu2, G_other=graph.canvas.G)
  151 +fibers2.canvas.set_data(G2, bbl2, bbu2, 16)
  152 +#fibers.draw_all(G, center, fibers, graph, node_tex)
  153 +graph.set_g_view(fibers)
  154 +graph2.set_g_view(fibers2)
  155 +
  156 +
  157 +#fibers.link_cameras(fibers2)
  158 +#fibers2.link_cameras(fibers)
  159 +
  160 +## Start Qt event loop unless running in interactive mode.
  161 +if __name__ == '__main__':
  162 + #import sys
  163 + #if (sys.flags.interactive != 1) or not hasattr(QtCore, 'PYQT_VERSION'):
  164 + #QtGui.QApplication.instance().exec_()
  165 + app.set_interactive(enabled=True)
  166 + app.run()
  167 +
... ...
HistogramWidget.py 0 → 100644
  Show/Hide comments   View file @17e4b25
  1 +#!/usr/bin/env python3
  2 +# -*- coding: utf-8 -*-
  3 +"""
  4 +Created on Tue Mar 3 13:47:39 2020
  5 +
  6 +@author: pavel
  7 +"""
  8 +
  9 +from PyQt5 import QtCore, QtGui, QtWidgets
  10 +import network_dep as nwt
  11 +import vispy.plot as vp
  12 +#import vispy.scene.visuals. as Histogram
  13 +from vispy.scene.visuals import Histogram as Histogram
  14 +
  15 +import numpy as np
  16 +
  17 +DEBUG = False
  18 +
  19 +
  20 +class HistogramWidget(QtWidgets.QWidget):
  21 + def __init__(self):
  22 + super(HistogramWidget, self).__init__()
  23 + box = QtWidgets.QVBoxLayout(self)
  24 + self.resize(500,500)
  25 + self.setLayout(box)
  26 + self.canvas = vp.Fig(show=False)
  27 + self.hist = self.canvas[0, 0].histogram(np.random.rand(100))
  28 +
  29 + #data = np.random.rand(100)
  30 + #self.canvas[0, 0].histogram(data)
  31 + #self.canvas = Histogram()
  32 + self.setUpdatesEnabled(True)
  33 + box.addWidget(self.canvas.native)
  34 + self.G = None
  35 +
  36 + self.canvas.events.mouse_press.connect(self.on_mouse_press)
  37 + #self.canvas.events.mouse_release.connect(self.on_mouse_release)
  38 + #self.canvas.events.mouse_move.connect(self.on_mouse_move)
  39 + #self.canvas.events.mouse_double_click.connect(self.on_mouse_double_click)
  40 + self.current_color = 'clusters'
  41 +
  42 + def on_mouse_press(self, event):
  43 + print("mouse_press")
  44 + if event.button == 2:
  45 + menu = QtWidgets.QMenu(self)
  46 + tmp = menu.addMenu('Histogram Metric')
  47 + edge_properties = self.G.edge_properties.keys()
  48 + edge_actions = []
  49 + for i in range(len(edge_properties)):
  50 + if(edge_properties[i] != "map" or edge_properties[i] != "RGBA"):
  51 + edge_actions.append(tmp.addAction(edge_properties[i]))
  52 +
  53 + action = menu.exec_(event.native.globalPos())
  54 + for i in range(len(edge_actions)):
  55 + if action == edge_actions[i]:
  56 + self.set_data(prop=edge_properties[i])
  57 +
  58 + print("mouse_press")
  59 +
  60 + def on_mouse_double_click(self, event):
  61 + print("mouse_double")
  62 +
  63 + def on_mouse_release(self, event):
  64 + print("mouse_release")
  65 +
  66 + def on_mouse_move(self, event):
  67 + print("mouse_move")
  68 +
  69 + def set_Graph(self, G):
  70 + self.G = G
  71 + #self.canvas[0, 0].histogram(np.random.rand(10))
  72 + self.set_data()
  73 +
  74 + def gen_mesh(self, data, bins=10, orientation='h'):
  75 +
  76 + data = np.asarray(data)
  77 + if data.ndim != 1:
  78 + raise ValueError('Only 1D data currently supported')
  79 + X, Y = (0, 1) if orientation == 'h' else (1, 0)
  80 +
  81 + # do the histogramming
  82 + data, bin_edges = np.histogram(data, bins)
  83 + # construct our vertices
  84 + rr = np.zeros((3 * len(bin_edges) - 2, 3), np.float32)
  85 + rr[:, X] = np.repeat(bin_edges, 3)[1:-1]
  86 + rr[1::3, Y] = data
  87 + rr[2::3, Y] = data
  88 + bin_edges.astype(np.float32)
  89 + # and now our tris
  90 + tris = np.zeros((2 * len(bin_edges) - 2, 3), np.uint32)
  91 + offsets = 3 * np.arange(len(bin_edges) - 1,
  92 + dtype=np.uint32)[:, np.newaxis]
  93 + tri_1 = np.array([0, 2, 1])
  94 + tri_2 = np.array([2, 0, 3])
  95 + tris[::2] = tri_1 + offsets
  96 + tris[1::2] = tri_2 + offsets
  97 +
  98 + return rr, tris
  99 +
  100 +
  101 + def set_data(self, prop = 'length'):
  102 + #self.canvas = vp.Fig(show=False)
  103 + #, xlabel=prop, ylabel='#'
  104 + #self.canvas.clear()
  105 + #self.canvas[0, 0]._configured = False
  106 + p = self.G.ep[prop].get_array().T
  107 + self.canvas.bgcolor = 'w'
  108 + rr, tris = self.gen_mesh(p)
  109 + self.hist.set_data(rr, tris, color = 'b')
  110 + #self.canvas.context.clear(color='w', depth=True)
  111 + #self.canvas.central_widget().context.clear(color='w', depth=True)
  112 +
  113 + self.canvas[0, 0].xlabel.text = prop
  114 + self.canvas[0, 0].ylabel.text = '# of occurances'
  115 + self.canvas[0, 0].title.text = 'edge property distribution'
  116 + for hist, pwidget in zip([self.hist], self.canvas.plot_widgets):
  117 + #x_data = hist._line.pos[:, 0]
  118 + #y_data = hist._line.pos[:, 1]
  119 + #print(hist._bounds, hist._bounds[:, 0], hist._bounds[:, 1])
  120 + x_range = hist._bounds[0][0], hist._bounds[0][1]
  121 + y_range = hist._bounds[1][0], hist._bounds[1][1]
  122 +
  123 +
  124 + pwidget.view.camera.set_range(x=x_range, y=y_range)
  125 + #self.canvas[0, 0]._configured = False
  126 + #self.canvas[0, 0].histogram(p, color = 'b')
  127 + self.canvas.update()
  128 + self.canvas.show()
  129 +
  130 +
  131 +
0 132 \ No newline at end of file
... ...
TubeCanvas.py
  Show/Hide comments   View file @17e4b25
... ... @@ -95,7 +95,7 @@ class TubeDraw(scene.SceneCanvas):
95 95 self.bbu = bbu
96 96 self.bbl = bbl
97 97 bb = nwt.AABB(G).resample_sides(3)
98   -
  98 + print(self.bbu, self.bbl, self.camera)
99 99  
100 100 #create program
101 101 self.gen_cylinder_vbo(self.G, self.num_sides)
... ... @@ -115,8 +115,10 @@ class TubeDraw(scene.SceneCanvas):
115 115 self.program['u_projection'] = self.projection
116 116 self.program.bind(self.vbo)
117 117  
  118 + print(self.bbu, self.bbl, self.camera)
118 119 gloo.set_clear_color('white')
119 120 self.center = (bbu-bbl)/2.0
  121 + print(self.bbu, self.bbl, self.camera)
120 122 self.translate = [-self.center[0], -self.center[1], -self.center[2]]
121 123  
122 124 self.bb = np.ones((26, 3), dtype=np.float32)
... ... @@ -132,6 +134,7 @@ class TubeDraw(scene.SceneCanvas):
132 134  
133 135 ##### prototype #####
134 136 self.camera = self.camera - self.translate
  137 + print(self.camera)
135 138 self.program['u_eye'] = self.camera
136 139 self.up = np.cross((np.asarray(self.center, dtype=np.float32)-np.asarray(self.camera, dtype=np.float32)), np.asarray(self.up))
137 140 self.program['u_up'] = self.up
... ... @@ -466,19 +469,17 @@ class TubeDraw(scene.SceneCanvas):
466 469 #print(event.delta[1])
467 470 self.refresh()
468 471  
469   -
  472 + def update_view(self, event):
  473 + self.location = event.pos
  474 + #self.program['u_view'] = self.view
  475 + self.down = True
470 476  
471 477  
472 478 #Handles the mouse press event to rotate the camera if the left mouse button
473 479 #if clicked down.
474 480 def on_mouse_press(self, event):
475   - def update_view():
476   - self.location = event.pos
477   - #self.program['u_view'] = self.view
478   - self.down = True
479   -
480 481 if(event.button == 1):
481   - update_view()
  482 + self.update_view(event)
482 483  
483 484  
484 485 #Handles the rotation of the camera using a quaternion centered around the
... ...
TubeWidget.py
  Show/Hide comments   View file @17e4b25
... ... @@ -32,7 +32,9 @@ class TubeWidget(QtWidgets.QWidget):
32 32 box.addWidget(self.canvas.native)
33 33 self.camera = [0,0,0]
34 34 self.down = False
  35 + self.other = None
35 36  
  37 + self.canvas.location = self.geometry().center()
36 38 self.canvas.events.mouse_press.connect(self.on_mouse_press)
37 39 self.canvas.events.mouse_release.connect(self.on_mouse_release)
38 40 self.canvas.events.mouse_move.connect(self.on_mouse_move)
... ... @@ -40,15 +42,41 @@ class TubeWidget(QtWidgets.QWidget):
40 42  
41 43 #self.show()
42 44  
  45 +
  46 + def link_cameras(self, o_canvas):
  47 + self.canvas.events.mouse_press.connect(o_canvas.on_mouse_press)
  48 + self.canvas.events.mouse_release.connect(o_canvas.on_mouse_release)
  49 + self.canvas.events.mouse_move.connect(o_canvas.on_mouse_move)
  50 + self.canvas.events.mouse_wheel.connect(o_canvas.on_mouse_wheel)
  51 +
  52 + def set_other(self, other):
  53 + self.other = other
  54 +
  55 + def pass_event(self, event, case):
  56 + if self.other != None:
  57 + if case == 0:
  58 + self.other.canvas.on_mouse_wheel(event)
  59 + if case == 1:
  60 + self.other.canvas.on_mouse_press(event)
  61 + if case == 2:
  62 + self.other.canvas.on_mouse_move(event)
  63 + if case == 3:
  64 + self.other.canvas.on_mouse_release(event)
  65 + #if case == 4:
  66 + # self.other.sendCameraInfo()
  67 +
  68 +
43 69 #Handles the mouse release event
44 70 def on_mouse_release(self, event):
45 71 self.down=False
46 72 self.sendCameraInfo()
  73 + self.pass_event(event, 3)
47 74  
48 75 #Handles the mouse move event
49 76 def on_mouse_move(self, event):
50 77 if self.down:
51 78 self.sendCameraInfo()
  79 + self.pass_event(event, 2)
52 80  
53 81 #Handles the mouse press events
54 82 def on_mouse_press(self, event):
... ... @@ -59,11 +87,14 @@ class TubeWidget(QtWidgets.QWidget):
59 87 action = menu.exec_(event.native.globalPos())
60 88 if action == NS:
61 89 self.save_stl_mesh()
  90 + else:
  91 + self.pass_event(event, 1)
62 92  
63 93  
64 94 #Handles the mouse wheel event
65 95 def on_mouse_wheel(self, event):
66 96 self.sendCameraInfo()
  97 + self.pass_event(event, 0)
67 98  
68 99 #controls the emit function of the QT class to send a signal to the slot
69 100 #located in the other window.
... ... @@ -73,6 +104,7 @@ class TubeWidget(QtWidgets.QWidget):
73 104 #print("stuff", self.view[3, 0], self.view[3, 1], self.view[3, 2])
74 105 if DEBUG:
75 106 print("stuff", self.camera[0], self.camera[1], self.camera[2])
  107 + #self.pass_event(None, 4)
76 108 self.sigUpdate.emit(self.camera[0], self.camera[1], self.camera[2])
77 109  
78 110 """
... ...
graph_shaders.py
  Show/Hide comments   View file @17e4b25
... ... @@ -100,7 +100,7 @@ void main()
100 100 }
101 101 else if( d < 0.0 )
102 102 {
103   - if(v_zoom_level < 0.0010)
  103 + if(v_zoom_level < 0.0024)
104 104 {
105 105 float alpha = d/v_antialias;
106 106 alpha = new_alpha(v_zoom_level);
... ... @@ -119,27 +119,28 @@ void main()
119 119 else
120 120 {
121 121 float alpha = d/v_antialias;
122   - if(v_zoom_level < 0.0010)
  122 + if(v_zoom_level < 0.0024)
123 123 alpha = new_alpha(v_zoom_level);
124 124 else
125 125 alpha = exp(-alpha*alpha);
126 126  
127   - if (r > 0 && v_zoom_level >= 0.0010)
  127 + if (r > 0 && v_zoom_level >= 0.0024)
128 128 gl_FragColor = vec4(v_fg_color.rgb, alpha*v_fg_color.a);
129 129 else
130   - if(v_zoom_level < 0.0010)
  130 + if(v_zoom_level < 0.0024)
131 131 if(vec3(gl_Color.rgb) != vec3(v_bg_color.rgb))
132 132 gl_FragColor = mix(vec4(1,1,1,0.9), v_bg_color, max(1.0-alpha, 0.3));
133 133 else
134 134 gl_FragColor = vec4(gl_Color.rgb, max(1.0-alpha, 0.1));
135 135 else
136 136 {
137   - //gl_FragColor = mix(v_bg_color, v_fg_color, alpha); vec3 color = vec3(1.0, 0.0, 0.0);
138   - vec3 normal = normalize(vec3(p.xy, d));
139   - vec3 direction = normalize(vec3(1.0, 1.0, 5.0));
140   - float diffuse = max(0.0, dot(direction, normal));
141   - float specular = pow(diffuse, 24.0);
142   - gl_FragColor = mix(vec4(max(diffuse*v_bg_color.rgb, specular*vec3(0.7)), 1.0), v_fg_color, alpha);
  137 + gl_FragColor = mix(v_bg_color, v_fg_color, alpha);
  138 + //vec3 color = vec3(1.0, 0.0, 0.0);
  139 + //vec3 normal = normalize(vec3(p.xy, d));
  140 + //vec3 direction = normalize(vec3(1.0, 1.0, 1.0));
  141 + //float diffuse = max(0.0, dot(direction, normal));
  142 + //float specular = pow(diffuse, 24.0);
  143 + //gl_FragColor = mix(vec4(max(diffuse*v_bg_color.rgb, specular*vec3(1.0)), 1.0), v_fg_color, alpha);
143 144 }
144 145 }
145 146  
... ... @@ -151,7 +152,7 @@ void main()
151 152 float r = marker(gl_PointCoord, size);
152 153 float d = abs(r) - t;
153 154 float alpha = d/v_antialias;
154   - if(v_zoom_level < 0.0010)
  155 + if(v_zoom_level < 0.0024)
155 156 alpha = new_alpha(v_zoom_level);
156 157 else
157 158 alpha = exp(-alpha*alpha);
... ... @@ -172,7 +173,7 @@ float marker(vec2 P, float size)
172 173  
173 174 float new_alpha(float zoom_level)
174 175 {
175   - float val = (zoom_level - 0.0010)/(0.00075-0.0010);
  176 + float val = (zoom_level - 0.0024)/(0.00075-0.0024);
176 177 if(val < 0)
177 178 {
178 179 val = 0;
... ... @@ -243,14 +244,14 @@ void main()
243 244 else
244 245 alpha = 0.5;
245 246  
246   - if(v_zoom_level < 0.0010)
  247 + if(v_zoom_level < 0.0024)
247 248 alpha = new_alpha(v_zoom_level);
248 249 gl_FragColor = vec4(v_fg_color.rgb, alpha);
249 250 }
250 251  
251 252 float new_alpha(float zoom_level)
252 253 {
253   - float val = (zoom_level-0.00075)/(0.0010-0.00075);
  254 + float val = (zoom_level-0.00075)/(0.0024-0.00075);
254 255 if(val < 0.)
255 256 {
256 257 val = 0.;
... ...
network_4.nwt 0 → 100755
View file @17e4b25
No preview for this file type
network_dep.py
  Show/Hide comments   View file @17e4b25
... ... @@ -254,9 +254,9 @@ class AABB():
254 254 # or a normal graph.
255 255 self.is_dual = is_dual
256 256 #minimum vertex
257   - self.A = np.full((3,1), 1000000.0, dtype=float)
  257 + self.A = np.full(3, 1000000.0, dtype=float)
258 258 #maximum vertex
259   - self.B = np.full((3,1), -1000000.0, dtype=float)
  259 + self.B = np.full(3, -1000000.0, dtype=float)
260 260 if(is_dual == False):
261 261 #find the minumum and the maximum of the graph.
262 262 for v in G.vertices():
... ... @@ -507,26 +507,26 @@ class VisitorClassPartition(gt.BFSVisitor):
507 507 self.dist[e.target()] = self.dist[e.source()] + 1
508 508  
509 509 class Network:
510   - def __init__(self, filename, clock=False):
  510 + def __init__(self, filename=None, clock=False):
511 511 if clock:
512 512 start_time = time.time()
513   -
514   - with open(filename, "rb") as file:
515   - header = file.read(72)
516   - bytes = file.read(4)
517   - numVertex = int.from_bytes(bytes, byteorder='little')
518   - bytes = file.read(4)
519   - numEdges = int.from_bytes(bytes, byteorder='little')
520   -
521   - self.N = []
522   - self.F = []
523   - for i in range(numVertex):
524   - node = NWT.readVertex(file)
525   - self.N.append(node)
526   -
527   - for i in range(numEdges):
528   - edge = NWT.readFiber(file)
529   - self.F.append(edge)
  513 + if filename!=None:
  514 + with open(filename, "rb") as file:
  515 + header = file.read(72)
  516 + bytes = file.read(4)
  517 + numVertex = int.from_bytes(bytes, byteorder='little')
  518 + bytes = file.read(4)
  519 + numEdges = int.from_bytes(bytes, byteorder='little')
  520 +
  521 + self.N = []
  522 + self.F = []
  523 + for i in range(numVertex):
  524 + node = NWT.readVertex(file)
  525 + self.N.append(node)
  526 +
  527 + for i in range(numEdges):
  528 + edge = NWT.readFiber(file)
  529 + self.F.append(edge)
530 530 if clock:
531 531 print("Network initialization: " + str(time.time() - start_time) + "s")
532 532 '''
... ... @@ -821,9 +821,10 @@ class Network:
821 821 for v in G.vertices():
822 822 pt = np.array([G.vertex_properties["p"][v][0], G.vertex_properties["p"][v][1], G.vertex_properties["p"][v][2]])
823 823 if G.vertex_properties["degree"][v] == 1 and bb.distance(pt) < 5.0:
824   - TFv[v] = False
825   - for e in v.all_edges():
826   - TFe[G.edge(e.source(), e.target())] = False
  824 + if G.vp["exclude"][v] == False:
  825 + TFv[v] = False
  826 + for e in v.all_edges():
  827 + TFe[G.edge(e.source(), e.target())] = False
827 828 else:
828 829 #print("I have entered this method")
829 830 for v in G.vertices():
... ... @@ -1144,14 +1145,14 @@ class Network:
1144 1145 #find all 2 neighbors
1145 1146 for i in one_n:
1146 1147 for j in G.vertex(i).all_neighbors():
1147   - if(int(j) not in one_n):
1148   - two_n.append(int(j))
  1148 +# if(int(j) not in one_n):
  1149 + two_n.append(int(j))
1149 1150  
1150 1151 #find all 3 neighbors
1151 1152 for i in two_n:
1152 1153 for j in G.vertex(i).all_neighbors():
1153   - if(int(j) not in one_n and int(j) not in two_n):
1154   - three_n.append(int(j))
  1154 +# if(int(j) not in one_n and int(j) not in two_n):
  1155 + three_n.append(int(j))
1155 1156  
1156 1157 #we do not keep ones that have already counted, i.e. a vertex
1157 1158 #appears in all 3 arrays only once.
... ... @@ -1209,32 +1210,50 @@ class Network:
1209 1210 start = time.time()
1210 1211  
1211 1212 pos = G.vertex_properties["pos"].get_2d_array(range(3)).T
  1213 + #x = np.zeros(3, dtype=float)
  1214 +
1212 1215 weight = G.vertex_properties[v_property].get_array().T
1213 1216  
1214 1217 for n in range(n_steps+1):
1215 1218 forces = np.zeros([G.num_vertices(), 3])
  1219 + center = np.sum(pos, 0)/G.num_vertices()
1216 1220 #pos = G.vertex_properties["pos"].get_2d_array(range(2)).T
1217 1221 if Sum:
1218 1222 for v in G.vertices():
1219 1223 for i in o1_n[int(v)]:
1220 1224 x = pos[int(i), :] - pos[int(v), :]
1221   - forces[int(v), 0] += -k*(x[0])
1222   - forces[int(v), 1] += -k*(x[1])
  1225 + l = np.sqrt(x[0]*x[0] + x[1]*x[1])
  1226 + forces[int(v), 0] += -k*(l-1.0)*(x[0])
  1227 + forces[int(v), 1] += -k*(l-1.0)*(x[1])
1223 1228 for i in o2_n[int(v)]:
1224   - x = pos[int(i)] - pos[int(v)]
1225   - forces[int(v), 0] += -k*(x[0])/2.0
1226   - forces[int(v), 1] += -k*(x[1])/2.0
  1229 + x = pos[int(i), :] - pos[int(v), :]
  1230 + l = np.sqrt(x[0]*x[0] + x[1]*x[1])
  1231 + forces[int(v), 0] += -k*(l-2.0)*(x[0])/2.0
  1232 + forces[int(v), 1] += -k*(l-2.0)*(x[1])/2.0
1227 1233 for i in o3_n[int(v)]:
1228   - x = pos[int(i)] - pos[int(v)]
1229   - forces[int(v), 0] += -k*(x[0])/4.0
1230   - forces[int(v), 1] += -k*(x[1])/4.0
  1234 + x = pos[int(i), :] - pos[int(v), :]
  1235 + l = np.sqrt(x[0]*x[0] + x[1]*x[1])
  1236 + forces[int(v), 0] += -k*(l-3.0)*(x[0])/4.0
  1237 + forces[int(v), 1] += -k*(l-3.0)*(x[1])/4.0
  1238 + x = -center[:] + pos[int(v), :]
  1239 + l = np.sqrt(x[0]*x[0] + x[1]*x[1])
  1240 + forces[int(v), 0] += -k/l*(x[0])
  1241 + forces[int(v), 1] += -k/l*(x[1])
  1242 +
1231 1243 else:
1232 1244 for v in G.vertices():
1233 1245 for i in o3_n[int(v)]:
1234 1246 x = pos[int(i)] - pos[int(v)]
1235   - forces[int(v), 0] = -k*(x[0])/4.0
1236   - forces[int(v), 1] = -k*(x[1])/4.0
1237   -
  1247 + if np.sqrt(np.power(-k*(x[0])/4.0, 2) + np.sqrt(np.power(-k*(x[1])/4.0, 2))) > \
  1248 + np.sqrt(np.power(forces[int(v), 0], 2) + np.sqrt(np.power(forces[int(v), 0], 2))):
  1249 +
  1250 + forces[int(v), 0] = -k*(x[0])/4.0
  1251 + forces[int(v), 1] = -k*(x[1])/4.0
  1252 +
  1253 + x = pos[int(v), :] - center[:]
  1254 + forces[int(v), 0] += -k*(x[0])/100.0
  1255 + forces[int(v), 1] += -k*(x[1])/100.0
  1256 +#
1238 1257 forces[:, 0] = forces[:, 0]/weight[:]
1239 1258 forces[:, 1] = forces[:, 1]/weight[:]
1240 1259 # if n < 1:
... ... @@ -1248,6 +1267,7 @@ class Network:
1248 1267 for v in G.vertices():
1249 1268 if n < 1:
1250 1269 velocities = forces * time_step
  1270 + #pos[int(v), :] = pos[int(v), :] + velocities[int(v), :] * time_step
1251 1271 #G.vertex_properties["pos"][v] = pos[int(v), :] + forces[int(v), :] * time_step
1252 1272 else:
1253 1273 pos[int(v), :] = pos[int(v), :] + velocities[int(v), :] * time_step
... ... @@ -1448,7 +1468,7 @@ class Network:
1448 1468 degree = G.new_vertex_property("int") #degree
1449 1469 degree_volume = G.new_vertex_property("double") #degree scaled by the volume of all in fibers
1450 1470 degree_tortuosity = G.new_vertex_property("double") #degree scaled by the tortuosity of all in fibers.
1451   -
  1471 +
1452 1472  
1453 1473 #add all the required edge properties
1454 1474 #G.properties[("x,y,z,r")] = G.new_edge_property("vector<double")
... ... @@ -1465,7 +1485,7 @@ class Network:
1465 1485 ebetweeness_centrality = G.new_edge_property("double") #betweeness centrality of the edge
1466 1486 ebc_length = G.new_edge_property("double") #betweeneness centrality scaled by the length
1467 1487 mst = G.new_edge_property("bool") #Boolean value deligating belongance to the minimum spanning tree.
1468   -
  1488 + exclude = G.new_edge_property("bool", val = False)
1469 1489  
1470 1490 #This map gets updated.
1471 1491 gaussian = G.new_edge_property("double") #empty property map for gaussian values downstream
... ... @@ -1516,6 +1536,8 @@ class Network:
1516 1536 degree_tortuosity = G.degree_property_map("total", weight=t_edge)
1517 1537  
1518 1538  
  1539 +
  1540 +
1519 1541 #print(clusters.get_array()[:], clusters.get_array()[:])
1520 1542 pos = gt.sfdp_layout(G, C = 1.0, K = 10)
1521 1543 rpos = gt.radial_tree_layout(G, root=G.vertex(np.argmax(vbetweeness_centrality.get_array())))
... ... @@ -1534,6 +1556,7 @@ class Network:
1534 1556 G.vertex_properties["degree_volume"] = degree_volume
1535 1557 G.vertex_properties["degree_tortuosity"] = degree_tortuosity
1536 1558 G.vertex_properties["selection"] = G.new_vertex_property("bool", val=False)
  1559 + G.vertex_properties["exclude"] = G.new_vertex_property("bool", val=False)
1537 1560  
1538 1561 #set property maps for the edges
1539 1562 G.edge_properties["x"] = x_edge
... ... @@ -1551,6 +1574,7 @@ class Network:
1551 1574 G.edge_properties["inverted_volume"] = iv_edge
1552 1575 G.edge_properties["gaussian"] = gaussian
1553 1576 G.edge_properties["selection"] = G.new_edge_property("double", val=0.0)
  1577 + G.edge_properties["exclude"] = exclude
1554 1578  
1555 1579 #set graph properies
1556 1580 G.graph_properties["mst_ratio"] = mst_ratio
... ... @@ -1711,10 +1735,13 @@ class Network:
1711 1735 def map_vertices_to_range(G, rng, propertymap):
1712 1736 def func(maximum, minimum, new_maximum, new_minimum, value):
1713 1737 return ((value-minimum)/(maximum-minimum)*(new_maximum-new_minimum)+new_minimum)
1714   -
  1738 +
1715 1739 mx = max(G.vertex_properties[propertymap].get_array())
1716 1740 mn = min(G.vertex_properties[propertymap].get_array())
  1741 + if mx == mn:
  1742 + mn = 0
1717 1743 G.vertex_properties["map"] = G.new_vertex_property("float")
  1744 + print("stuff ", mx, mn, propertymap)
1718 1745 gt.map_property_values(G.vertex_properties[propertymap], G.vertex_properties["map"], lambda x: func(mx, mn, rng[0], rng[1], x))
1719 1746  
1720 1747 return G.vertex_properties["map"]
... ...
subgraph_shaders.py
  Show/Hide comments   View file @17e4b25
... ... @@ -80,12 +80,13 @@ void main()
80 80 float R = 0.55;
81 81 float R2 = 0.3;
82 82 float dist = sqrt(dot(v_value, v_value));
83   - float sm = smoothstep(R, R-0.0010, dist);
84   - float sm2 = smoothstep(R2, R2+0.0010, dist);
  83 + float sm = smoothstep(R, R-0.0024, dist);
  84 + float sm2 = smoothstep(R2, R2+0.0024, dist);
85 85 float alpha = sm*sm2;
  86 + float epsilon = 0.005;
86 87  
87 88 float n_alpha = 1.0;
88   - if(v_zoom_level < 0.0010)
  89 + if(v_zoom_level < 0.0024)
89 90 {
90 91 n_alpha = new_alpha(v_zoom_level);
91 92 }
... ... @@ -97,13 +98,22 @@ void main()
97 98 if(dist < 0.25)
98 99 {
99 100 //gl_FragColor = v_cluster_color;
100   -// vec2 p = (gl_FragCoord.xy - v_value);
101   -// vec3 normal = normalize(vec3(p.xy, dist));
102   -// vec3 direction = normalize(vec3(1.0, 1.0, 5.0));
103   -// float diffuse = max(0.0, dot(direction, normal));
104   -// float specular = pow(diffuse, 24.0);
105   -// gl_FragColor = vec4(max(diffuse*v_cluster_color.rgb, specular*vec3(1.0)), 1.0);
106   - gl_FragColor = vec4(v_cluster_color.rgb, n_alpha);
  101 + vec2 p = (v_value.xy);
  102 + vec3 normal = normalize(vec3(p.xy, 0.25));
  103 + vec3 direction = normalize(vec3(0.0, 0.0, 5.0));
  104 + float diffuse = max(0.0, dot(direction, normal));
  105 + float specular = pow(diffuse, 24.0);
  106 + gl_FragColor = vec4(max(diffuse*v_cluster_color.rgb, specular*vec3(0.6)), n_alpha);
  107 +// gl_FragColor = vec4(v_cluster_color.rgb, n_alpha);
  108 + }
  109 + if(dist < 0.25+epsilon && dist > 0.25)
  110 + {
  111 + vec2 p = (v_value.xy);
  112 + vec3 normal = normalize(vec3(p.xy, 0.25));
  113 + vec3 direction = normalize(vec3(0.0, 0.0, 5.0));
  114 + float diffuse = max(0.0, dot(direction, normal));
  115 + float specular = pow(diffuse, 24.0);
  116 + gl_FragColor = vec4(max(diffuse*v_cluster_color.rgb, specular*vec3(0.6)), exp(-n_alpha*n_alpha));
107 117 }
108 118 if(dist > 0.3 && 0.55 > dist)
109 119 {
... ... @@ -114,7 +124,12 @@ void main()
114 124 }
115 125 else
116 126 {
117   - gl_FragColor = vec4(v_bg_color.rgb, n_alpha*alpha);
  127 + vec3 normal = normalize(vec3(v_value.xy, 1.0));
  128 + vec3 direction = normalize(vec3(0.0, 0.0, 5.0));
  129 + float diffuse = max(0.0, dot(direction, normal));
  130 + float specular = pow(diffuse, 24.0);
  131 + //gl_FragColor = vec4(v_bg_color.rgb, n_alpha);
  132 + gl_FragColor = vec4(max(diffuse*v_bg_color.rgb, specular*vec3(1.0)), n_alpha);
118 133 }
119 134 }
120 135 angle = atan(v_value[1]/dist, v_value[0]/dist);
... ... @@ -123,24 +138,36 @@ void main()
123 138 //THIS NEED TO BE FIXED
124 139 if(dist > 0.61 && 0.9 > dist)
125 140 {
  141 + vec3 normal = normalize(vec3(v_value.xy, 1.0));
  142 + vec3 direction = normalize(vec3(0.0, 0.0, 5.0));
  143 + float diffuse = max(0.0, dot(direction, normal));
  144 + float specular = pow(diffuse, 24.0);
126 145 if(angle < v_outer_arc_length[1])
127 146 {
128   - gl_FragColor = vec4(0.32, 0.61, 0.93, n_alpha);
  147 + vec3 color = vec3(0.32, 0.61, 0.93);
  148 + // gl_FragColor = vec4(0.32, 0.61, 0.93, n_alpha);
  149 + gl_FragColor = vec4(max(diffuse*color, specular*vec3(1.0)), n_alpha);
129 150 //gl_FragColor = vec4(1.0, 0.0, 0.0, n_alpha);
130 151 }
131 152 else if(angle > v_outer_arc_length[1] && angle < v_outer_arc_length[2])
132 153 {
133   - gl_FragColor = vec4(0.337, 0.866, 0.415, n_alpha);
  154 + vec3 color = vec3(0.337, 0.866, 0.415);
  155 + gl_FragColor = vec4(max(diffuse*color, specular*vec3(1.0)), n_alpha);
  156 + //gl_FragColor = vec4(0.337, 0.866, 0.415, n_alpha);
134 157 //gl_FragColor = vec4(0.0, 1.0, 0.0, n_alpha);
135 158 }
136 159 else if(angle > v_outer_arc_length[2] && angle < v_outer_arc_length[3])
137 160 {
138   - gl_FragColor = vec4(0.988, 0.631, 0.058, n_alpha);
  161 + vec3 color = vec3(0.988, 0.631, 0.058);
  162 + gl_FragColor = vec4(max(diffuse*color, specular*vec3(1.0)), n_alpha);
  163 + //gl_FragColor = vec4(0.988, 0.631, 0.058, n_alpha);
139 164 //gl_FragColor = vec4(0.0, 0.0, 1.0, n_alpha);
140 165 }
141 166 else //if(angle > v_outer_arc_length[3] && angle < pi)
142 167 {
143   - gl_FragColor = vec4(0.93, 0.949, 0.329, n_alpha);
  168 + vec3 color = vec3(0.93, 0.949, 0.329);
  169 + gl_FragColor = vec4(max(diffuse*color, specular*vec3(1.0)), n_alpha);
  170 + //gl_FragColor = vec4(0.93, 0.949, 0.329, n_alpha);
144 171 //gl_FragColor = vec4(1.0, 1.0, 0.0, n_alpha);
145 172 }
146 173 }
... ... @@ -172,7 +199,7 @@ float atan2(float y, float x)
172 199  
173 200 float new_alpha(float zoom_level)
174 201 {
175   - float val = 1 - (zoom_level - 0.00075)/(0.0010-0.00075);
  202 + float val = 1 - (zoom_level - 0.0015)/(0.0024-0.0015);
176 203 if(val > 1.0)
177 204 {
178 205 val = 1.0;
... ... @@ -238,14 +265,14 @@ void main()
238 265 else
239 266 alpha = 0.0;
240 267  
241   - if(v_zoom_level < 0.0010)
  268 + if(v_zoom_level < 0.0024)
242 269 alpha = new_alpha(v_zoom_level);
243 270 gl_FragColor = vec4(v_fg_color.rgb, alpha);
244 271 }
245 272  
246 273 float new_alpha(float zoom_level)
247 274 {
248   - float val = 1 - (zoom_level - 0.00075)/(0.0010-0.00075);
  275 + float val = 1 - (zoom_level - 0.0015)/(0.0024-0.0015);
249 276 if(val > 1.0)
250 277 {
251 278 val = 1.0;
... ...
tube_shaders.py
  Show/Hide comments   View file @17e4b25
... ... @@ -10,7 +10,7 @@ Created on Mon Aug 5 15:58:30 2019
10 10 VERT_SHADER = """
11 11 // Uniforms
12 12 // ------------------------------------
13   -uniform vec4 u_bb[26];
  13 +uniform vec3 u_bb[26];
14 14 uniform mat4 u_model;
15 15 //uniform mat4 u_view;
16 16 uniform mat4 u_projection;
... ...
voronoi_test.py
  Show/Hide comments   View file @17e4b25
... ... @@ -162,7 +162,7 @@ class Polygon_mass:
162 162 def plot_graph(self, D, x, y):
163 163 plt.figure()
164 164 ext = [self.a[0], self.b[0], self.a[1], self.b[1]]
165   - #plt.imshow(D, origin = 'lower', extent=ext)
  165 + plt.imshow(D, origin = 'lower', extent=ext)
166 166 p = self.G.vertex_properties["pos"].get_2d_array(range(2)).T
167 167 plt.scatter(p[:,0], p[:,1], color='r')
168 168 plt.scatter(self.CoM[0], self.CoM[1], marker='*')
... ... @@ -180,8 +180,8 @@ class Polygon_mass:
180 180 # plt.plot((pts[segs[i][0]][0], pts[segs[i][1]][0]), (pts[segs[i][0]][1], pts[segs[i][1]][1]), color='b')
181 181 plt.gca().set_title(str(self.polygon.area))
182 182  
183   - for e in self.torque:
184   - plt.quiver(e[2][0], e[2][1], e[1][0], e[1][1], color='r')
  183 +# for e in self.torque:
  184 +# plt.quiver(e[2][0], e[2][1], e[1][0], e[1][1], color='r')
185 185 #tri = Delaunay(np.asarray(self.polygon.exterior.coords.xy).T)
186 186 #tri = triangulate(mesh, 'pq20a' + str(self.polygon.area/100.0)+'D')
187 187 #delaunay_plot_2d(tri)
... ... @@ -259,7 +259,7 @@ class Polygon_mass:
259 259 # #nlist = c.trace(level, level, 0)
260 260 # #segs = nlist[:len(nlist)//2]
261 261 #self.polygon = Polygon(pts)
262   - #self.plot_graph(D, x, y)
  262 + self.plot_graph(D, x, y)
263 263  
264 264  
265 265  
... ... @@ -684,8 +684,8 @@ def gen_Eades(G, masses, M = 10):
684 684 for j in masses:
685 685 j.translate(0.001)
686 686  
687   -def onion_springs(G, masses, min_length):
688   - for v in G.vertices():
  687 +#def onion_springs(G, masses, min_length):
  688 +# for v in G.vertices():
689 689  
690 690  
691 691  
... ...