segmentation / graph_gui

  #!/usr/bin/env python3
  # -*- coding: utf-8 -*-
  """
  Created on Mon Aug  5 15:43:59 2019
  
  @author: pavel
      The GraphCanvas class that extends the scene class in vispy in order to draw
      the graph object. This class is wrapped in a QTcanvas.
  """
  
  from vispy import gloo, scene
  from vispy.gloo import set_viewport, set_state, clear, set_blend_color
  from vispy.util.transforms import perspective, translate, rotate, scale
  import vispy.gloo.gl as glcore
  
  import numpy as np
  import math
  import network_dep as nwt
  
  #import the graph shaders.
  from graph_shaders import vert, frag, vs, fs
  from subgraph_shaders import vert_s, frag_s, vs_s, fs_s
  

  DEBUG = False
  

  #The graph canvas class that 
  class GraphCanvas(scene.SceneCanvas):
      
      """
          Initialization method.
          Generates the 512x512 canvas, makes it available for drawing the fills all
          the GLSL shaders with dummy data.
      """
      def __init__(self, **kwargs):
          # Initialize the canvas for real
          scene.SceneCanvas.__init__(self, size=(512, 512), **kwargs)
          #Unfreeze the canvas to make dynamic interaction possible
          self.unfreeze()
          
          #initialize all the boolean and dictionary variables.
          ps = self.pixel_scale
          self.subgraphs = False
          self.position = 50, 50
          self.down=False;
          
          #Dictionaries to store the unique color ID, cluster ID, and edge-to-ID
          #dictionaries.
          self.color_dict = {}
          self.cluster_dict = {}
          self.edge_dict = {}
  
          #Booleans the storage for the current "Path", i.e. edges the user selected.
          self.pathing = False
          self.path = []
          self.full_path = []
  
          #utility variables used for storing the cluster being moved and all the
          #nodes and edges that belong to that cluster and move along with it.
          self.moving = False
          self.moving_cluster = False
          self.selection = False
  
          n = 10
          ne = 10
          #Init dummy structures
          self.uniforms = [('u_graph_size', np.float32, 3)]
          self.data = np.zeros(n, dtype=[('a_position', np.float32, 3),
                                    ('a_fg_color', np.float32, 4),
                                    ('a_bg_color', np.float32, 4),
                                    ('a_size', np.float32, 1),
                                    ('a_linewidth', np.float32, 1),
                                    ('a_unique_id', np.float32, 4),
                                    ])
  
          self.clusters = np.zeros(n, dtype=[('a_position', np.float32, 3),
                ('a_bg_color', np.float32, 4),
                ('a_value', np.float32, 2),
                ('a_unique_id', np.float32, 4),
                ])
  
          self.edges = np.random.randint(size=(ne, 2), low=0,
                                    high=n-1).astype(np.uint32)
          self.edges_s = np.random.randint(size=(ne, 4), low=0,
                                    high=n-1).astype(np.uint32)
          self.data['a_position'] = np.hstack((0.25 * np.random.randn(n, 2),
                                         np.zeros((n, 1))))
          self.data['a_fg_color'] = 0, 0, 0, 1.0
          color = np.random.uniform(0.5, 1., (n, 3))
          self.data['a_bg_color'] = np.hstack((color, np.zeros((n, 1))))
          self.data['a_size'] = np.random.randint(size=n, low=8*ps, high=20*ps)
          self.data['a_linewidth'] = 8.*ps
          self.data['a_unique_id'] = np.hstack((color, np.ones((n, 1))))
          #self.uniforms['u_graph_size'] = [1.0, 1.0, 1.0]
          self.translate = [0,0,0]
          self.scale = [1,1,1]
          #color = np.random.uniform(0.5, 1., (ne, 3))
          #self.linecolor = np.hstack((color, np.ones((ne, 1))))
          #color = np.random.uniform(0.5, 1., (ne, 3))
          #self.linecolor = np.hstack((color, np.ones((ne, 1))))
          self.u_antialias = 1
  
          #init dummy vertex and index buffers.
          self.vbo = gloo.VertexBuffer(self.data)
          self.vbo_s = gloo.VertexBuffer(self.clusters)
  
          #Need to initialize thick lines.
          self.index = gloo.IndexBuffer(self.edges)
          self.index_s = gloo.IndexBuffer(self.edges_s)
  
          #Set the view matrices.
          self.view = np.eye(4, dtype=np.float32)
          self.model = np.eye(4, dtype=np.float32)
          self.projection = np.eye(4, dtype=np.float32)
  
          #init shaders used for vertices of the full graph.
          self.program = gloo.Program(vert, frag)
          self.program.bind(self.vbo)
          self.program['u_size'] = 1
          self.program['u_antialias'] = self.u_antialias
          self.program['u_model'] = self.model
          self.program['u_view'] = self.view
          self.program['u_projection'] = self.projection
          self.program['u_graph_size'] = [1.0, 1.0, 1.0]
          self.program['u_picking'] = False
  
          #init shades used for the edges in the graph
          self.program_e = gloo.Program(vs, fs)
          self.program_e['u_size'] = 1
          self.program_e['u_model'] = self.model
          self.program_e['u_view'] = self.view
          self.program_e['u_projection'] = self.projection
          #self.program_e['l_color'] = self.linecolor.astype(np.float32)
          self.program_e.bind(self.vbo)
  
          #init shaders used to the vertices in the subgraph graph.
          self.program_s = gloo.Program(vert_s, frag_s)
          self.program_s.bind(self.vbo_s)
          self.program_s['u_model'] = self.model
          self.program_s['u_view'] = self.view
          self.program_s['u_projection'] = self.projection
          self.program_s['u_graph_size'] = [1.0, 1.0, 1.0]
          self.program_s['u_picking'] = False
  
          #init shaders used for the subgraph-edges
          self.program_e_s = gloo.Program(vs_s, fs_s)
          self.program_e_s['u_size'] = 1
          self.program_e_s['u_model'] = self.model
          self.program_e_s['u_view'] = self.view
          self.program_e_s['u_projection'] = self.projection
          #self.program_e['l_color'] = self.linecolor.astype(np.float32)
          self.program_e_s.bind(self.vbo_s)
  
  
          #set up the viewport and the gl state.
          set_viewport(0, 0, *self.physical_size)
  
          set_state(clear_color='white', depth_test=True, blend=True,
                    blend_func=('src_alpha', 'one_minus_src_alpha'), depth_func = ('lequal'))
  
      """
          Function that recolors vertices based on the selected statistic
          Maps the statisic stored in G to a colormap passed to the function
          Then updates the necessary color array.
      """    
      def color_vertices(self, G, vertex_property, dtype = False, cm = 'plasma'):
          #if we are visualing the clusters we should use a discrete colormap
          #otherwise use the passed colormap
          if dtype == True:
              G.vertex_properties["RGBA"] = nwt.Network.map_property_to_color(G, G.vertex_properties["clusters"])
          else:
              G.vertex_properties["RGBA"] = nwt.Network.map_property_to_color(G, G.vertex_properties[vertex_property], colormap=cm)
          #set the color and update the Vertices.
          self.current_color = vertex_property
          color = G.vertex_properties["RGBA"].get_2d_array(range(4)).T
          self.data['a_bg_color'] = color
          self.vbo = gloo.VertexBuffer(self.data)
          self.program.bind(self.vbo)
          #self.program_e.bind(self.vbo)
          self.update()
  
      """
          Maps a statistic of the vertices based on the size of the canvas to size of
          the drawn object.
      """
      def size_vertices(self, G, propertymap):
          size = nwt.Network.map_vertices_to_range(G, [30*self.pixel_scale, 8*self.pixel_scale], propertymap).get_array()
          self.data['a_size'] = size
          self.vbo = gloo.VertexBuffer(self.data)
          self.program.bind(self.vbo)
          #self.program_e.bind(self.vbo)
          self.update()
  
  
      """
          Function to dim all nodes and edges that do not belong to a cluster chosen 
          in the graph view. Returns a copy of the graph with the alpha channel saved.
          OPTMIZE HERE: could just return an alpha array to reduce memory usage.
      """
      def focus_on_cluster(self, G, c_id):
          G_copy = nwt.gt.Graph(G, directed=False)
          e_color = G_copy.edge_properties["RGBA"].get_2d_array(range(4)).T
          vertices = np.argwhere(self.labels != c_id)
          for v in range(vertices.shape[0]):
              idx = vertices[v][0]
              vtx = G_copy.vertex(idx)
              for e in vtx.all_edges():
                  if (int(e.source()), int(e.target())) in self.edge_dict.keys():
                      index = int(self.edge_dict[int(e.source()), int(e.target())])
                      if vtx == int(e.source()):
                          e_color[index][3] = 0.05
                      elif vtx == int(e.target()):
                          e_color[index][3] = 0.05
                  else:
                      index = int(self.edge_dict[int(e.target()), int(e.source())])
                      if vtx == int(e.target()):
                          e_color[index][3] = 0.05
                      elif vtx == int(e.source()):
                          e_color[index][3] = 0.05
  
          G_copy.edge_properties["RGBA"] = G_copy.new_edge_property("vector<double>", vals = e_color)
  
          return G_copy
  
      """
          Function that sets the size of the vertices based on the distance from the 
          camera.
      """
      def vertexSizeFromDistance(self, G, camera_pos):
          location = G.vertex_properties["p"].get_2d_array(range(3)).T
          cam_array = np.zeros(location.shape, dtype=np.float32)
          len_array = np.zeros(location.shape[0])
          offset_array = np.zeros(location.shape, dtype=np.float32)
          cam_array[:][0:3] = camera_pos

          offset = [(self.bbu[0]-self.bbl[0])/2, (self.bbu[1]-self.bbl[1])/2, (self.bbu[2]-self.bbl[2])/2]

          location = location - offset
          location = location - camera_pos
          for i in range(location.shape[0]):
              len_array[i] = np.sqrt(np.power(location[i][0],2) + np.power(location[i][1],2) + np.power(location[i][2],2))
  

          G.vertex_properties['dist_from_camera'] = G.new_vertex_property('float', vals=len_array)
          self.data['a_size'] = nwt.Network.map_vertices_to_range(G, [1*self.pixel_scale, 60*self.pixel_scale], 'dist_from_camera').get_array()
  
  
          size = nwt.Network.map_vertices_to_range(G, [1.0, 0.5], 'dist_from_camera').get_array()
          edges = G.get_edges()
          for e in range(edges.shape[0]):
              idx = int(4*edges[e][2])
              self.line_data['a_linewidth'][idx] = size[edges[e][0]]
              self.line_data['a_linewidth'][idx+1] = size[edges[e][1]]
              self.line_data['a_linewidth'][idx+2] = size[edges[e][0]]
              self.line_data['a_linewidth'][idx+3] = size[edges[e][1]]
  
  
          #self.vbo = gloo.VertexBuffer(self.data)
          #self.vbo_line = gloo.VertexBuffer(self.line_data)
          #self.program.bind(self.vbo)
          #self.program_e.bind(self.vbo_line)
          #self.update()
  
      """
          Function that scales the alpha channel of each vertex in the graph based on
          The distance from the camera.
          Sometimes needs to be done separetly.
      """
      def vertexAlphaFromDistance(self, G, camera_pos):
          location = G.vertex_properties["p"].get_2d_array(range(3)).T
          cam_array = np.zeros(location.shape, dtype=np.float32)
          len_array = np.zeros(location.shape[0])
          #offset_array = np.zeros(location.shape, dtype=np.float32)
          cam_array[:][0:3] = camera_pos

          offset = [(self.bbu[0]-self.bbl[0])/2, (self.bbu[1]-self.bbl[1])/2, (self.bbu[2]-self.bbl[2])/2]

          location = location - offset
          location = location - camera_pos
          for i in range(location.shape[0]):
              len_array[i] = np.sqrt(np.power(location[i][0],2) + np.power(location[i][1],2) + np.power(location[i][2],2))
  
  
          test = nwt.Network.map_vertices_to_range(G, [0.0, 1.0], 'dist_from_camera').get_array()
          color = G.vertex_properties["RGBA"].get_2d_array(range(4)).T
          for i in range(location.shape[0]):
              color[i][3] = test[i]
          G.vertex_properties["RGBA"] = G.new_vertex_property("vector<double>", vals = color)
          self.data['a_bg_color'] = color
  
          edges = G.get_edges()
          for e in range(edges.shape[0]):
              idx = int(4*edges[e][2])
              self.line_data['a_fg_color'][idx] = color[edges[e][0]]
              self.line_data['a_fg_color'][idx+1] = color[edges[e][1]]
              self.line_data['a_fg_color'][idx+2] = color[edges[e][0]]
              self.line_data['a_fg_color'][idx+3] = color[edges[e][1]]
  
  
  
          self.vbo = gloo.VertexBuffer(self.data)
          self.vbo_line = gloo.VertexBuffer(self.line_data)
          self.program.bind(self.vbo)
          self.program_e.bind(self.vbo_line)
          self.update()
  
      """
          Sets the edge color based on the the cluster the vertices belongs to
          Propertymap is a VERTEXPROPERTYMAP since the color of the edges is based
          on the clusters the edges belong to.
      """    
      def color_edges(self, G, propertymap="clusters"):
          if propertymap == "clusters":
              for e in G.edges():
                  if G.vertex_properties[propertymap][e.source()] == G.vertex_properties[propertymap][e.target()]:
                      G.edge_properties["RGBA"][e] = G.vertex_properties["RGBA"][e.source()]
                  else:
                      G.edge_properties["RGBA"][e] = [0.0, 0.0, 0.0, 0.8]
  
  
      """
          Helper function that generates the framebuffer object that stores the vertices
          Generates the vertex buffer based on the graph G that is passed to the function
          Sets the color, generates the graph and subgraph color if necessary.
      """
      def gen_vertex_vbo(self, G):
          color = G.vertex_properties["RGBA"].get_2d_array(range(4)).T
          size = nwt.Network.map_vertices_to_range(G, [30*self.pixel_scale, 8*self.pixel_scale], 'degree').get_array()
  
          position = G.vertex_properties["pos"].get_2d_array(range(3)).T
          #for p in range(position.shape[0]):
          #    position[p][0] = position[p][0] + self.clusters["a_position"][G.vertex_properties["clusters"][G.vertex(p)]][0]
          #    position[p][1] = position[p][1] + self.clusters["a_position"][G.vertex_properties["clusters"][G.vertex(p)]][1]
          #    position[p][2] = position[p][2] + self.clusters["a_position"][G.vertex_properties["clusters"][G.vertex(p)]][2]
          #G.vertex_properties["pos"] = G.new_vertex_property("vector<double>", vals = position)
          edges = G.get_edges();
          edges = edges[:, 0:2]
          #width = nwt.Network.map_edges_to_range(G, [1*self.pixel_scale, 5*self.pixel_scale], 'volume').get_array()
          #ecolor = G.edge_properties["RGBA"].get_2d_array(range(4)).T
  
          self.data = np.zeros(G.num_vertices(), dtype=[('a_position', np.float32, 3),
                    ('a_fg_color', np.float32, 4),
                    ('a_bg_color', np.float32, 4),
                    ('a_size', np.float32, 1),
                    ('a_linewidth', np.float32, 1),
                    ('a_unique_id', np.float32, 4),
                    ('a_selection', np.float32, 1),
                    ])
  
          #self.edges = edges.astype(np.uint32)
          self.data['a_position'] = position
          #fg color is the color of the ring
          self.data['a_fg_color'] = 0, 0, 0, 1
          self.data['a_bg_color'] = color
          self.data['a_size'] = size
          self.data['a_linewidth'] = 4.*self.pixel_scale
          self.data['a_unique_id'] = self.gen_vertex_id(G)
          self.data['a_selection'] = G.vertex_properties["selection"].get_array()
          #self.data['a_graph_size'] = [bbu-bbl]
  

          self.program['u_graph_size'] = [self.bbu-self.bbl]

  
          self.vbo = gloo.VertexBuffer(self.data)
          self.gen_line_vbo(G)
          if(self.subgraphs):
              self.vbo_s = gloo.VertexBuffer(self.clusters)
              self.index_s = gloo.IndexBuffer(self.edges_s)
          #self.index = gloo.IndexBuffer(self.edges)
          self.program_e.bind(self.vbo_line)
          self.program.bind(self.vbo)
          if(self.subgraphs):
              #self.program_e_s.bind(self.vbo_s)
              self.program_s.bind(self.vbo_s)

          if DEBUG:
              print(self.view)

          self.update()
  
      """
          Helper function that creates colored "block" lines based on the edges
          in the graph. Generates the framebuffer object and fills it with the relavant data.
          Note that each line segment is saved as a two triangles that share the same
          two points on the centerline, but are offset according to the normal of the
          line segmente to control thickness dynamically.
      """    
      def gen_line_vbo(self, G):
          #Set the data.
          self.line_data = np.zeros(G.num_edges()*4, dtype=[('a_position', np.float32, 3),
                                    ('a_normal', np.float32, 2),
                                    ('a_fg_color', np.float32, 4),
                                    ('a_linewidth', np.float32, 1),
                                    ])
          self.edges = np.random.randint(size=(G.num_edges()*2, 3), low=0,
                                    high=(G.num_edges()-1)).astype(np.uint32)
          color = G.edge_properties["RGBA"].get_2d_array(range(4)).T
          edges = G.get_edges()
          #size need to be changed to the size based on the current property map
          size = nwt.Network.map_vertices_to_range(G, [1.0, 0.5], 'degree').get_array()
          for e in range(edges.shape[0]):
              idx = int(4*edges[e][2])
              p0 = G.vertex_properties["pos"][G.vertex(edges[e][0])]
              p1 = G.vertex_properties["pos"][G.vertex(edges[e][1])]
              d = np.subtract(p1, p0)
              #d_norm = np.multiply(d, 1/np.sqrt(np.power(d[0],2) + np.power(d[1],2)))
              d_norm = d[0:2]
              d_norm = d_norm / np.sqrt(np.power(d_norm[0],2) + np.power(d_norm[1],2))
              norm = np.zeros((2,), dtype=np.float32)
              norm[0] = d_norm[1]
              norm[1] = d_norm[0]*-1
              #print(np.sqrt(norm[0]*norm[0] + norm[1]*norm[1]))
              #thickness = G.edge_properties["thickness"][e]
              thickness = 1.0
              self.edge_dict[int(edges[e][0]), int(edges[e][1])] = int(edges[e][2])
              self.line_data['a_position'][idx] = p0
              self.line_data['a_normal'][idx] = norm
              self.line_data['a_fg_color'][idx] = color[edges[e][2]]
              #a_linewidth is a vector.
              self.line_data['a_linewidth'][idx] = size[edges[e][0]]
  
              self.line_data['a_position'][idx+1] = p1
              self.line_data['a_normal'][idx+1] = norm
              self.line_data['a_fg_color'][idx+1] = color[edges[e][2]]
              self.line_data['a_linewidth'][idx+1] = size[edges[e][1]]
  
              self.line_data['a_position'][idx+2] = p0
              self.line_data['a_normal'][idx+2] = -norm
              self.line_data['a_fg_color'][idx+2] = color[edges[e][2]]
              self.line_data['a_linewidth'][idx+2] = size[edges[e][0]]
  
              self.line_data['a_position'][idx+3] = p1
              self.line_data['a_normal'][idx+3] = -norm
              self.line_data['a_fg_color'][idx+3] = color[edges[e][2]]
              self.line_data['a_linewidth'][idx+3] = size[edges[e][1]]
  
              self.edges[e*2] = [idx, idx+1, idx+3]
              self.edges[e*2+1] = [idx, idx+2, idx+3]
          
          #Set the buffer object and update the shader programs.
          self.program_e = gloo.Program(vs, fs)
          #self.program_e['l_color'] = self.linecolor.astype(np.float32)
          self.vbo_line = gloo.VertexBuffer(self.line_data)
          self.index = gloo.IndexBuffer(self.edges)
          self.program_e['u_size'] = 1
          self.program_e['u_model'] = self.model
          self.program_e['u_view'] = self.view
          self.program_e['u_projection'] = self.projection
          self.program_e.bind(self.vbo_line)
  
  
      """
          Helper function that generates the edges between the cluster in the layout.
          Color is based on the cluster source/target color and transitions between the
          two.
      """
      def gen_cluster_line_vbo(self, G):
          #create a graph that stores the edges of between the clusters
          self.G_cluster = nwt.gt.Graph(directed=False)
          self.G_cluster.vertex_properties["pos"] = self.G_cluster.new_vertex_property("vector<double>", val=np.zeros((3,1), dtype=np.float32))
          self.G_cluster.vertex_properties["RGBA"] = self.G_cluster.new_vertex_property("vector<double>", val=np.zeros((4,1), dtype=np.float32))
          for v in range(len(self.cluster_pos)):
              self.G_cluster.add_vertex()
              self.G_cluster.vertex_properties["pos"][self.G_cluster.vertex(v)] = np.asarray(self.cluster_pos[v], dtype=np.float32)
          self.G_cluster.edge_properties["weight"] = self.G_cluster.new_edge_property("int", val = 0)
          #for each edge in the original graph, generate appropriate subgraph edges without repretiions
          #i.e. controls the thichness of the edges in the subgraph view.
          for e in G.edges():
              #if the source and target cluster is not equal to each other
              #add an inter subgraph edge.
              if(G.vertex_properties["clusters"][e.source()] != G.vertex_properties["clusters"][e.target()]):
                  #temp_e.append([G.vertex_properties["clusters"][e.source()], G.vertex_properties["clusters"][e.target()]])
                  self.G_cluster.add_edge(self.G_cluster.vertex(G.vertex_properties["clusters"][e.source()]), \
                                           self.G_cluster.vertex(G.vertex_properties["clusters"][e.target()]))
                  self.G_cluster.edge_properties["weight"][self.G_cluster.edge(self.G_cluster.vertex(G.vertex_properties["clusters"][e.source()]), \
                                                 self.G_cluster.vertex(G.vertex_properties["clusters"][e.target()]))] += 1
                  self.G_cluster.vertex_properties["RGBA"][self.G_cluster.vertex(G.vertex_properties["clusters"][e.source()])]    \
                                          = G.vertex_properties["RGBA"][e.source()]
                  self.G_cluster.vertex_properties["RGBA"][self.G_cluster.vertex(G.vertex_properties["clusters"][e.target()])]    \
                                          = G.vertex_properties["RGBA"][e.target()]
  
          self.cluster_line_data = np.zeros(self.G_cluster.num_edges()*4, dtype=[('a_position', np.float32, 3),
                            ('a_normal', np.float32, 2),
                            ('a_fg_color', np.float32, 4),
                            ('a_linewidth', np.float32, 1),
                            ])
          self.cluster_edges = np.random.randint(size=(self.G_cluster.num_edges()*2, 3), low=0,
                                    high=(G.num_edges()-1)).astype(np.uint32)
  
          edges = self.G_cluster.get_edges()
          #size need to be changed to the size based on the current property map
          size = nwt.Network.map_edges_to_range(self.G_cluster, [1.0, 0.5], 'weight').get_array()
          color = self.G_cluster.vertex_properties["RGBA"].get_2d_array(range(4)).T
          #generate the vertex buffer and the connections buffer.
          for e in range(edges.shape[0]):
              idx = int(4*edges[e][2])
              p0 = self.G_cluster.vertex_properties["pos"][self.G_cluster.vertex(edges[e][0])]
              p1 = self.G_cluster.vertex_properties["pos"][self.G_cluster.vertex(edges[e][1])]
              d = np.subtract(p1, p0)
              #d_norm = np.multiply(d, 1/np.sqrt(np.power(d[0],2) + np.power(d[1],2)))
              d_norm = d[0:2]
              d_norm = d_norm / np.sqrt(np.power(d_norm[0],2) + np.power(d_norm[1],2))
              norm = np.zeros((2,), dtype=np.float32)
              norm[0] = d_norm[1]
              norm[1] = d_norm[0]*-1
              #print(np.sqrt(norm[0]*norm[0] + norm[1]*norm[1]))
              #thickness = G.edge_properties["thickness"][e]
              self.cluster_dict[int(edges[e][0]), int(edges[e][1])] = int(edges[e][2])
              self.cluster_line_data['a_position'][idx] = p0
              self.cluster_line_data['a_normal'][idx] = norm
              self.cluster_line_data['a_fg_color'][idx] = color[edges[e][0]]
              self.cluster_line_data['a_linewidth'][idx] = size[e]
  
              self.cluster_line_data['a_position'][idx+1] = p1
              self.cluster_line_data['a_normal'][idx+1] = norm
              self.cluster_line_data['a_fg_color'][idx+1] = color[edges[e][1]]
              self.cluster_line_data['a_linewidth'][idx+1] = size[e]
  
              self.cluster_line_data['a_position'][idx+2] = p0
              self.cluster_line_data['a_normal'][idx+2] = -norm
              self.cluster_line_data['a_fg_color'][idx+2] = color[edges[e][0]]
              self.cluster_line_data['a_linewidth'][idx+2] = size[e]
  
              self.cluster_line_data['a_position'][idx+3] = p1
              self.cluster_line_data['a_normal'][idx+3] = -norm
              self.cluster_line_data['a_fg_color'][idx+3] = color[edges[e][1]]
              self.cluster_line_data['a_linewidth'][idx+3] = size[e]
  
              self.cluster_edges[e*2] = [idx, idx+1, idx+3]
              self.cluster_edges[e*2+1] = [idx, idx+2, idx+3]
  
  
          self.program_e_s = gloo.Program(vs_s, fs_s)
          self.index_clusters_s = gloo.IndexBuffer(self.cluster_edges)
          self.vbo_cluster_lines = gloo.VertexBuffer(self.cluster_line_data)
  
          self.program_e_s['u_size'] = 1
          self.program_e_s['u_model'] = self.model
          self.program_e_s['u_view'] = self.view
          self.program_e_s['u_projection'] = self.projection
          self.program_e_s.bind(self.vbo_cluster_lines)
  
  
      """
          Updates the vertex buffers based on the current position of the cluster.
          Updates it's position.    
      """
      def update_cluster_line_vbo(self):
  
          for v in range(len(self.cluster_pos)):
              self.G_cluster.vertex_properties["pos"][self.G_cluster.vertex(v)] = np.asarray(self.cluster_pos[v], dtype=np.float32)
          #OPTIMIZE HERE to update only one cluster at a time.
          edges = self.G_cluster.get_edges()
          #size need to be changed to the size based on the current property map
          size = nwt.Network.map_edges_to_range(self.G_cluster, [1.0, 0.5], 'weight').get_array()
          color = self.G_cluster.vertex_properties["RGBA"].get_2d_array(range(4)).T
          for e in range(edges.shape[0]):
              idx = int(4*edges[e][2])
              p0 = self.G_cluster.vertex_properties["pos"][self.G_cluster.vertex(edges[e][0])]
              p1 = self.G_cluster.vertex_properties["pos"][self.G_cluster.vertex(edges[e][1])]
              d = np.subtract(p1, p0)
              #d_norm = np.multiply(d, 1/np.sqrt(np.power(d[0],2) + np.power(d[1],2)))
              d_norm = d[0:2]
              d_norm = d_norm / np.sqrt(np.power(d_norm[0],2) + np.power(d_norm[1],2))
              norm = np.zeros((2,), dtype=np.float32)
              norm[0] = d_norm[1]
              norm[1] = d_norm[0]*-1
              #print(np.sqrt(norm[0]*norm[0] + norm[1]*norm[1]))
              #thickness = G.edge_properties["thickness"][e]
              self.cluster_dict[int(edges[e][0]), int(edges[e][1])] = int(edges[e][2])
              self.cluster_line_data['a_position'][idx] = p0
              self.cluster_line_data['a_normal'][idx] = norm
              self.cluster_line_data['a_fg_color'][idx] = color[edges[e][0]]
              self.cluster_line_data['a_linewidth'][idx] = size[e]
  
              self.cluster_line_data['a_position'][idx+1] = p1
              self.cluster_line_data['a_normal'][idx+1] = norm
              self.cluster_line_data['a_fg_color'][idx+1] = color[edges[e][1]]
              self.cluster_line_data['a_linewidth'][idx+1] = size[e]
  
              self.cluster_line_data['a_position'][idx+2] = p0
              self.cluster_line_data['a_normal'][idx+2] = -norm
              self.cluster_line_data['a_fg_color'][idx+2] = color[edges[e][0]]
              self.cluster_line_data['a_linewidth'][idx+2] = size[e]
  
              self.cluster_line_data['a_position'][idx+3] = p1
              self.cluster_line_data['a_normal'][idx+3] = -norm
              self.cluster_line_data['a_fg_color'][idx+3] = color[edges[e][1]]
              self.cluster_line_data['a_linewidth'][idx+3] = size[e]
  
          self.program_e_s = gloo.Program(vs_s, fs_s)
          self.index_clusters_s = gloo.IndexBuffer(self.cluster_edges)
          self.vbo_cluster_lines = gloo.VertexBuffer(self.cluster_line_data)
  
          self.program_e_s['u_size'] = 1
          self.program_e_s['u_model'] = self.model
          self.program_e_s['u_view'] = self.view
          self.program_e_s['u_projection'] = self.projection
          self.program_e_s.bind(self.vbo_cluster_lines)
  
      """
          Genererates a unique index for every vertex.
      """    
      def gen_vertex_id(self, G):
          self.color_dict = {}
          base = [0, 0, 0, 255]
          idx = 0
          #colors = cm.get_cmap('Wistia', G.num_vertices()*2)
          v_id = np.zeros((G.num_vertices(), 4), dtype=np.float32)
          for v in G.vertices():
              color = np.multiply(base, 1/255.0)
              v_id[int(v)] = color
              self.color_dict[tuple(color)] = int(v)
              idx += 1
              base = [int(idx/(255*255)), int((idx/255)%255), int(idx%255), 255]
  
          return(v_id)
  
      """
          Generates a unique index for every cluster.
      """
      def gen_cluster_id(self, G):
          self.cluster_dict = {}
          base = [0, 0, 0, 255]
          idx = 0
          #colors = cm.get_cmap('Wistia', G.num_vertices()*2)
          v_id = np.zeros((self.n_c, 4), dtype=np.float32)
          for v in range(self.n_c):
              color = np.multiply(base, 1/255.0)
              v_id[int(v)] = color
              self.cluster_dict[tuple(color)] = int(v)
              idx += 1
              base = [int(idx/(255*255)), int((idx/255)%255), int(idx%255), 255]
  
          return(v_id)
  
  
      """
          Generates the bounding box of the radial glyph.
      """
      def gen_cluster_coords(self, center, diameter):
          radius = diameter/2.0
          top = center[1]+radius
          bottom = center[1]-radius
          left = center[0]-radius
          right = center[0]+radius
  
          positions = [[right, bottom, center[2]],
                      [right, top, center[2]],
                      [left, top, center[2]],
                      [left, bottom, center[2]]]
  
  
          values = [[1.0, -1.0],
                    [1.0, 1.0,],
                    [-1.0, 1.0],
                    [-1.0, -1.0]]
          return positions, values
  
  
      """
          Layout algorithm that expands the cluster based on the location of the of the clusters
      """
      def expand_based_on_clusters(self, G, n):
          pos = G.vertex_properties["pos"].get_2d_array(range(3)).T
          for p in range(pos.shape[0]):
              pos[p][0] = pos[p][0] + self.clusters["a_position"][G.vertex_properties["clusters"][G.vertex(p)]][0]
              pos[p][1] = pos[p][1] + self.clusters["a_position"][G.vertex_properties["clusters"][G.vertex(p)]][1]
              pos[p][2] = pos[p][2] + self.clusters["a_position"][G.vertex_properties["clusters"][G.vertex(p)]][2]
          G.vertex_properties["pos"] = G.new_vertex_property("vector<double>", vals = pos)
          for i in range(n):
              index = 4*i
              #generate the vertex filter for this cluster
              num_v_in_cluster = len(np.argwhere(self.labels == i))
              vfilt = np.zeros([G.num_vertices(), 1], dtype="bool")
              vfilt[np.argwhere(self.labels == i)] = 1
              vfilt_prop = G.new_vertex_property("bool", vals = vfilt)
              G.set_vertex_filter(vfilt_prop)
  
              #get the filtered properties
              g = nwt.gt.Graph(G, prune=True, directed=False)
              positions = g.vertex_properties["pos"].get_2d_array(range(3)).T
              position = np.sum(positions, 0)/num_v_in_cluster
              p, v = self.gen_cluster_coords(position, np.sum(g.vertex_properties['degree'].get_array()))
              self.clusters['a_position'][index:index+4] = np.asarray(p, dtype=np.float32)
              self.clusters['a_value'][index:index+4] = np.asarray(v, dtype=np.float32)
              G.clear_filters()
              self.cluster_pos[i] = position
          color = G.vertex_properties["RGBA"].get_2d_array(range(4)).T
          size = nwt.Network.map_vertices_to_range(G, [30*self.pixel_scale, 8*self.pixel_scale], 'degree').get_array()
  
          position = G.vertex_properties["pos"].get_2d_array(range(3)).T
          #for p in range(position.shape[0]):
          #    position[p][0] = position[p][0] + self.clusters["a_position"][G.vertex_properties["clusters"][G.vertex(p)]][0]
          #    position[p][1] = position[p][1] + self.clusters["a_position"][G.vertex_properties["clusters"][G.vertex(p)]][1]
          #    position[p][2] = position[p][2] + self.clusters["a_position"][G.vertex_properties["clusters"][G.vertex(p)]][2]
          #G.vertex_properties["pos"] = G.new_vertex_property("vector<double>", vals = position)
          edges = G.get_edges();
          edges = edges[:, 0:2]
          #width = nwt.Network.map_edges_to_range(G, [1*self.pixel_scale, 5*self.pixel_scale], 'volume').get_array()
          #ecolor = G.edge_properties["RGBA"].get_2d_array(range(4)).T
  
          self.data = np.zeros(G.num_vertices(), dtype=[('a_position', np.float32, 3),
                    ('a_fg_color', np.float32, 4),
                    ('a_bg_color', np.float32, 4),
                    ('a_size', np.float32, 1),
                    ('a_linewidth', np.float32, 1),
                    ('a_unique_id', np.float32, 4),
                    ('a_selection', np.float32, 1),
                    ])
  
          #self.edges = edges.astype(np.uint32)
          self.data['a_position'] = position
          #fg color is the color of the ring
          self.data['a_fg_color'] = 0, 0, 0, 1
          self.data['a_bg_color'] = color
          self.data['a_size'] = size
          self.data['a_linewidth'] = 4.*self.pixel_scale
          self.data['a_unique_id'] = self.gen_vertex_id(G)
          self.data['a_selection'] = G.vertex_properties["selection"].get_array()
          #self.data['a_graph_size'] = [bbu-bbl]
  
          self.program['u_graph_size'] = [bbu-bbl]
          self.vbo = gloo.VertexBuffer(self.data)
          self.gen_line_vbo(G)
          if(self.subgraphs):
              self.vbo_s = gloo.VertexBuffer(self.clusters)
              self.index_s = gloo.IndexBuffer(self.edges_s)
          #self.index = gloo.IndexBuffer(self.edges)
          self.program_e.bind(self.vbo_line)
          self.program.bind(self.vbo)
          if(self.subgraphs):
              #self.program_e_s.bind(self.vbo_s)
              self.program_s.bind(self.vbo_s)

          if DEBUG:
              print(self.view)

          self.update()
  
  
      """
          Function that generates the clusters for an unclustered graph
          These are to be represented by the arcs
      """    
      def gen_clusters(self, G, bbl, bbu, n_c = None, edge_metric = 'volume', vertex_metric = 'degree'):
  
          #Generate the clusters
          self.labels = nwt.Network.spectral_clustering(G,'length', n_clusters = n_c)
          #self.labels = nwt.Network.spectral_clustering(G,'length')
  
          #Add clusters as a vertex property
          G.vertex_properties["clusters"] = G.new_vertex_property("int", vals=self.labels)
          num_clusters = len(np.unique(self.labels))
          self.n_c = n_c
  
          #add colormap
          G.vertex_properties["RGBA"] = nwt.Network.map_property_to_color(G, G.vertex_properties["clusters"])
  
          #generate an empty property set for the clusters.
          self.clusters = np.zeros(num_clusters*4, dtype=[('a_position', np.float32, 3),
                        ('a_value', np.float32, 2),
                        ('a_bg_color', np.float32, 4),
                        ('a_cluster_color', np.float32, 4),
                        ('a_arc_length', np.float32, 1),
                        ('a_outer_arc_length', np.float32, 4),
                        ('a_unique_id', np.float32, 4),
                        ])
          self.edges_s = np.random.randint(size=(num_clusters*2, 3), low=0,
                                    high=4).astype(np.uint32)
          #fill the foreground color as halo
          #self.clusters['a_fg_color'] = 1., 1., 1., 0.0
          #self.clusters['a_linewidth'] = 4.*self.pixel_scale
  
          G.vertex_properties["pos"] = nwt.gt.sfdp_layout(G, groups = G.vertex_properties["clusters"], pos = G.vertex_properties["pos"])
          temp = [];
          temp_pos = [];
          #Find the global total of the metric.
          global_metric = np.sum(G.edge_properties[edge_metric].get_array(), 0)
          unique_color = self.gen_cluster_id(G)
  
          #generate the property values for every cluster
          for i in range(num_clusters):
              idx = 4*i
              #generate the vertex filter for this cluster
              num_v_in_cluster = len(np.argwhere(self.labels == i))
              vfilt = np.zeros([G.num_vertices(), 1], dtype="bool")
              vfilt[np.argwhere(self.labels == i)] = 1
              vfilt_prop = G.new_vertex_property("bool", vals = vfilt)
              G.set_vertex_filter(vfilt_prop)
  
              #get the filtered properties
              g = nwt.gt.Graph(G, prune=True, directed=False)
              positions = g.vertex_properties["pos"].get_2d_array(range(3)).T
              position = np.sum(positions, 0)/num_v_in_cluster
  
              #calculate the arclength for the global statistic
              arc_length = np.sum(g.edge_properties[edge_metric].get_array(), 0)/global_metric*np.pi*2
              arc_length_vertex = np.ones((4,1), dtype = np.float32)
              array = g.vertex_properties[vertex_metric].get_array()
  
              #calculate metric distribution and turn it into arc_lengths
              t_vertex_metric = np.sum(array)
              arc_length_vertex[0] = np.sum(array < 2)/t_vertex_metric
              arc_length_vertex[1] = np.sum(array == 2)/t_vertex_metric
              arc_length_vertex[2] = np.sum(array == 3)/t_vertex_metric
              arc_length_vertex[3] = np.sum(array > 3)/t_vertex_metric
  
              #arc_length_vertex = np.asarray(arc_length_vertex, dtype = np.float32)
              #arc_length_vertex = (max(arc_length_vertex) - min(arc_length_vertex)) \
              #* (arc_length_vertex- min(arc_length_vertex))
              for j in range(len(arc_length_vertex)):
                  if j != 0:
                      arc_length_vertex[j] += arc_length_vertex[j-1]