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

  from vispy.util.transforms import perspective, translate, rotate, scale
  import vispy.gloo.gl as glcore

  from vispy import app

  import copy

  
  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
  

  #class storing the path. a vertex in the path is defined as a vertex idx
  #and a list of all vertices required to reach the next point in the path
  class path_point:
      #Init an empty vertex with no path
      def __init__(self, idx):
          self.idx = idx
          self.v_path = []
          self.e_path = []
      
      #Remove all future path vertices attached to this vertex
      def clear_path(self):
          self.v_path = []
          self.e_path = []
          
      # == comparison operator    
      def __eq__(self, other):
          if self.idx == other.idx:
              return True
          else:
              return False
      # != comparison operator
      def __ne__(self, other):
          if self.idx != other.idx:
              return True
          else:
              return False
          
      def __str__(self):
          print("PathPoint[", self.idx, "], Chain = [", self.v_path, "]")
          
  

  #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.line_data = np.zeros(ne, dtype=[('a_position', np.float32, 3),
                                    ('a_normal', np.float32, 2),
                                    ('a_fg_color', np.float32, 4),
                                    ('a_linewidth', np.float32, 1),
                                    ])
      
              
          self.clusters = np.zeros(n*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.cluster_line_data = np.zeros(ne, 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=(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 thic/k 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
  

          self.vbo_line = gloo.VertexBuffer(self.line_data)

          #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_line)
      

          #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_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.vbo_cluster_lines = gloo.VertexBuffer(self.cluster_line_data)
          self.program_e_s.bind(self.vbo_cluster_lines)

  
  
          #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'))

          
          
          self.timer = app.Timer('auto', connect=self.on_timer, start=False)

          #self.constant = app.Timer('auto', connect=self.update, start=True)
          self.num=0
          print(self.context.config)

          
      def on_timer(self, event):
          #get the temporary positions of the vertices (and edges)
          self.old_pos = np.add(self.old_pos, self.slopes)
          #during each iteration set the new positions in the GPU 
          self.data['a_position'] = self.old_pos
          #Adjust the edges
          edges = self.G.get_edges()
          for e in range(edges.shape[0]):
              idx = int(4*edges[e][2])
              p0 = self.old_pos[edges[e][0], :]
              p1 = self.old_pos[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
  
              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_position'][idx+1] = p1
              self.line_data['a_normal'][idx+1] = norm
  
              self.line_data['a_position'][idx+2] = p0
              self.line_data['a_normal'][idx+2] = -norm
  
              self.line_data['a_position'][idx+3] = p1
              self.line_data['a_normal'][idx+3] = -norm
          
          #send data to GPU renderer
          self.vbo.set_data(self.data)
          self.program.bind(self.vbo)
          self.vbo_line = gloo.VertexBuffer(self.line_data)
          self.program_e.bind(self.vbo_line)
  
  
          self.update_clusters(self.old_pos)
          edges = self.G_cluster.get_edges()
  #        #generate the vertex buffer and the connections buffer.
          for e in range(edges.shape[0]):
              idx = int(4*edges[e][2])
              p0 = self.cluster_pos[int(edges[e][0])]
              p1 = self.cluster_pos[int(edges[e][1])]
              #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_position'][idx+1] = p1
              self.cluster_line_data['a_normal'][idx+1] = norm
  
              self.cluster_line_data['a_position'][idx+2] = p0
              self.cluster_line_data['a_normal'][idx+2] = -norm
  
              self.cluster_line_data['a_position'][idx+3] = p1
              self.cluster_line_data['a_normal'][idx+3] = -norm
  
          self.vbo_cluster_lines.set_data(self.cluster_line_data)
          self.vbo_s.set_data(self.clusters)
          self.program_s.bind(self.vbo_s)
          self.program_e_s.bind(self.vbo_cluster_lines)
  

          self.refresh()

  
      """
          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.refresh()

          
      def update_color_buffers(self):
          color = self.G.vertex_properties["RGBA"].get_2d_array(range(4)).T
          self.data['a_bg_color'] = color
          edges = self.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)
          
          
      """
          Function takes a graph and a state and sets all vertices and edges to 
          the transparency defined by state
      """
      def make_all_transparent(self, state):
          for v in self.G.vertices():
              temp = self.G.vertex_properties["RGBA"][v]
              temp[3] = state
              self.G.vertex_properties["RGBA"][v] = temp
          for e in self.G.edges():
              temp = self.G.edge_properties["RGBA"][e]
              temp[3] = state
              self.G.edge_properties["RGBA"][e] = temp
          self.update_color_buffers()

  
      """
          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.refresh()

  
  
      """
          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.refresh()

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

      """
          Test function that only binds the buffer
      """
      def gen_vertex_vbo_minimalist(self):

          self.refresh()

          self.vbo.set_data(self.data)
          self.program.bind(self.vbo)

          self.refresh()

  
      """
          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.refresh()

  
      """
          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_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)