def setupDataDisplay(self, indices=range(1, 15)): """requires that you have already set a number of things on self""" self.indices = indices self.displayData = DataProcessing.getDisplayData( self.rawData, self.startTime, self.endTime, self.storedAmplitude, self.lowPass, self.highPass, self.indices) self.setupZoom(self.displayData) self.channels = self.rawData.ch_names self.samplingRate = self.rawData.info['sfreq'] displayChannels = [self.channels[i] for i in indices] displayPositions = np.linspace(0.9, -0.9, len(displayChannels)) self.annotationTimes = [] self.positionsToTextMap = {} for i in range(0, len(displayPositions)): self.positionsToTextMap[(-0.97, displayPositions[i])] = str( displayChannels[i]) self.program = gloo.Program(SERIES_VERT_SHADER, SERIES_FRAG_SHADER) self.vertices = gloo.VertexBuffer(V) self.zoomBoxBuffer = gloo.VertexBuffer(V3) self.progAnnotations = gloo.Program(progAnnotations_vertex_shader, progAnnotations_fragment_shader) self.progAnnotations.bind(self.vertices) self.progZoom = gloo.Program(zoombox_vertex_shader, zoombox_fragment_shader) self.progZoom.bind(self.zoomBoxBuffer) self.setupZoomStep2() self.myTextDrawer = TextDrawer(self.physical_size[1], self.physical_size[0]) self.myLineDrawer = LineDrawer() print "height " + str(self.physical_size[1]) self.progText = gloo.Program(text_vertex_shader, text_fragment_shader) self.fontBMP = vispy.io.imread("FixedSys.bmp") tvar = np.array(self.fontBMP[:, :, 0]) self.fontBMP = np.dstack((self.fontBMP, tvar)) self.fontTexture = gloo.Texture2D(self.fontBMP, format="rgba") self.textVerticesArr = self.myTextDrawer.computeTextsData( self.positionsToTextMap) self.updateLines() self.textVertices = gloo.VertexBuffer(self.textVerticesArr) self.progText.bind(self.textVertices) self.progText["myTextureSampler"] = self.fontTexture gloo.set_viewport(0, 0, *self.physical_size) self.updateTextBoxes() self.dragZoom = False self.oldPos = None self.newPos = None self.orig = None self.new = None self.posDiff = None self.events.mouse_press.connect((self, 'mouse_press')) self.events.mouse_release.connect((self, 'mouse_release')) self.events.mouse_move.connect((self, 'on_mouse_move')) # self._timer = app.Timer('auto', connect=self.on_timer, start=True) gloo.set_state(clear_color='black', blend=True, blend_func=('src_alpha', 'one_minus_src_alpha')) self.update()
def add_overlay(self, data, vertices=None, to_overlay=None, mask_data=None, **kwargs): """Add an overlay to the mesh. Note that the current implementation limit to a number of of four overlays. Parameters ---------- data : array_like Array of data of shape (n_data,). vertices : array_like | None The vertices to color with the data of shape (n_data,). to_overlay : int | None Add data to a specific overlay. This parameter must be a integer. mask_data : array_like | None Array to specify if some vertices have to be considered as masked (and use the `mask_color` color) kwargs : dict | {} Additional color color properties (cmap, clim, vmin, vmax, under, over, translucent) """ # Check input variables : if vertices is None: vertices = np.ones((len(self), ), dtype=bool) # Send data to the mask : if isinstance(mask_data, np.ndarray) and len(mask_data) == len(self): self._bgd_data[mask_data] = .5 self._bgd_buffer.set_data(self._bgd_data) if not len(vertices): logger.warning('Vertices array is empty. Abandoning.') return data = np.asarray(data) to_overlay = self._n_overlay if to_overlay is None else to_overlay data_lim = (data.min(), data.max()) if len(self._data_lim) < to_overlay + 1: self._data_lim.append(data_lim) else: self._data_lim[to_overlay] = data_lim # ------------------------------------------------------------- # TEXTURE COORDINATES # ------------------------------------------------------------- need_reshape = to_overlay >= self._xrange.shape[1] if need_reshape: # Add column of zeros : z_ = np.zeros((len(self), ), dtype=np.float32) z_text = np.zeros((1, LUT_LEN, 4), dtype=np.float32) self._xrange = np.c_[self._xrange, z_] self._alphas = np.c_[self._alphas, z_] self._text2d_data = np.concatenate((self._text2d_data, z_text)) # (x, y) coordinates of the overlay for the texture : self._xrange[vertices, to_overlay] = normalize(data) # Transparency : self._alphas[vertices, to_overlay] = 1. # transparency level # ------------------------------------------------------------- # TEXTURE COLOR # ------------------------------------------------------------- # Colormap interpolation (if needed): colormap = Colormap(**kwargs) vec = np.linspace(data_lim[0], data_lim[1], LUT_LEN) self._text2d_data[to_overlay, ...] = colormap.to_rgba(vec) # ------------------------------------------------------------- # BUFFERS # ------------------------------------------------------------- if need_reshape: # Re-define buffers : self._xrange_buffer = gloo.VertexBuffer(self._xrange) self._text2d = gloo.Texture2D(self._text2d_data) self._alphas_buffer = gloo.VertexBuffer(self._alphas) # Send buffers to vertex shader : self.shared_program.vert['u_range'] = self._xrange_buffer self.shared_program.vert['u_alphas'] = self._alphas_buffer self.shared_program.vert['u_over_text'] = self._text2d else: self._xrange_buffer.set_data(self._xrange) self._text2d.set_data(self._text2d_data) self._alphas_buffer.set_data(self._alphas) # Update the number of overlays : self._n_overlay = to_overlay + 1 self.shared_program.vert['u_n_overlays'] = self._n_overlay
def set_data(self, vertices, filled, outline): self.filled_buf = gloo.IndexBuffer(filled) self.outline_buf = gloo.IndexBuffer(outline) self.vertices_buff = gloo.VertexBuffer(vertices) self.program.bind(self.vertices_buff) self.update()
def on_key_press(self, event): if event.text == 'q': img = self.render() io.write_png("../../render/render{:02d}.png".format(self.frame), img) if event.text == ' ': self.translate_X = self.center[0] self.translate_Y = self.center[1] self.translate_Z = self.center[2] self.rot_X = 0 self.rot_Y = 0 self.rot_Z = 0 # self.quaternion = Quaternion() # self.model = np.eye(4, dtype=np.float32) self.model = self.substract_center self.program['u_model'] = self.model self.update_camera() if event.text == 'f': if(self.has_faces and self.draw_points): self.draw_points = 0 self.update() if event.text == 'p': self.draw_points = 1 self.update() if event.text == 'b': self.program['u_point_size'] *= 1.2 self.update() if event.text == 's': self.program['u_point_size'] *= 1/1.2 self.update() if event.key == 'Right': if(self.frame < self.nframes - 1): self.frame += 1 print "frame{:d}".format(self.frame) self.data['a_position'] = self.vertices[self.frame * self.npoints:(self.frame+1) * self.npoints,:] # self.program['a_position'].set_data( self.data['a_position'] ) if(self.update_color): self.data['a_color'] = self.colors[self.frame * self.npoints:(self.frame+1) * self.npoints,:] if(self.has_labels): self.data['a_seg_color'] = self.seg_colors[self.frame * self.npoints:(self.frame+1) * self.npoints,:] else: self.data['a_seg_color'] = self.data['a_color'] # self.program['a_color'].set_data( self.data['a_color'] ) self.program.bind(gloo.VertexBuffer(self.data)) self.update() if event.key == 'Left': if(self.frame > 0): self.frame -= 1 print "frame{:d}".format(self.frame) self.data['a_position'] = self.vertices[self.frame * self.npoints:(self.frame+1) * self.npoints,:] # self.program['a_position'].set_data( self.data['a_position'] ) if(self.update_color): self.data['a_color'] = self.colors[self.frame * self.npoints:(self.frame+1) * self.npoints,:] if(self.has_labels): self.data['a_seg_color'] = self.seg_colors[self.frame * self.npoints:(self.frame+1) * self.npoints,:] else: self.data['a_seg_color'] = self.data['a_color'] # self.program['a_color'].set_data( self.data['a_color'] ) self.program.bind(gloo.VertexBuffer(self.data)) self.update() if event.text == 'c': if(self.has_labels and self.program['u_plot_seg'] == 0): self.program['u_plot_seg'] = 1 self.update() else: self.program['u_plot_seg'] = 0 self.update()
def __init__(self, vertices=None, faces=None, normals=None, lr_index=None, hemisphere='both', sulcus=None, alpha=1., mask_color='orange', camera=None, meshdata=None, invert_normals=False): """Init.""" self._camera = None self._translucent = True self._alpha = alpha self._hemisphere = hemisphere self._n_overlay = 0 self._data_lim = [] # Initialize the vispy.Visual class with the vertex / fragment buffer : Visual.__init__(self, vcode=VERT_SHADER, fcode=FRAG_SHADER) # _________________ BUFFERS _________________ # Vertices / faces / normals / color : def_3 = np.zeros((0, 3), dtype=np.float32) self._vert_buffer = gloo.VertexBuffer(def_3) self._normals_buffer = gloo.VertexBuffer(def_3) self._bgd_buffer = gloo.VertexBuffer() self._xrange_buffer = gloo.VertexBuffer() self._alphas_buffer = gloo.VertexBuffer() self._index_buffer = gloo.IndexBuffer() # _________________ PROGRAMS _________________ self.shared_program.vert['a_position'] = self._vert_buffer self.shared_program.vert['a_normal'] = self._normals_buffer self.shared_program.vert['u_n_overlays'] = self._n_overlay self.shared_program.frag['u_alpha'] = alpha # _________________ LIGHTS _________________ self.shared_program.frag['u_light_intensity'] = LIGHT_INTENSITY self.shared_program.frag['u_coef_ambient'] = COEF_AMBIENT self.shared_program.frag['u_coef_specular'] = COEF_SPECULAR self.shared_program.frag['u_light_position'] = LIGHT_POSITION self.shared_program.frag['camtf'] = vist.NullTransform() # _________________ DATA / CAMERA / LIGHT _________________ # Data : self.set_data(vertices, faces, normals, hemisphere, lr_index, invert_normals, sulcus, meshdata) # Camera : self.set_camera(camera) self.mask_color = mask_color # Slices : self.xmin, self.xmax = None, None self.ymin, self.ymax = None, None self.zmin, self.zmax = None, None self.inv_light = False # _________________ GL STATE _________________ self.set_gl_state('translucent', depth_test=True, cull_face=False, blend=True, blend_func=('src_alpha', 'one_minus_src_alpha')) self._draw_mode = 'triangles' self.freeze()
def update_position(self): """Update node positions.""" self.shared_program.vert['a_position'] = gloo.VertexBuffer( self.a_position.astype(np.float32))
def load(self, path, demean=False, scale=1.0): data = PlyData.read(path) self.vertices = np.zeros((data['vertex'].count, 3)) self.vertices[:, 0] = np.array(data['vertex']['x']) self.vertices[:, 1] = np.array(data['vertex']['y']) self.vertices[:, 2] = np.array(data['vertex']['z']) self.vertices *= scale self.centroid = np.mean(self.vertices, 0) if demean: self.centroid = np.zeros((1, 3), np.float32) self.vertices -= self.centroid self._compute_bbox() self.indices = np.asarray(list(data['face']['vertex_indices']), np.uint32) # Look for texture map as jpg or png filename = path.split('/')[-1] abs_path = path[:path.find(filename)] tex_to_load = None if os.path.exists(abs_path + filename[:-4] + '.jpg'): tex_to_load = abs_path + filename[:-4] + '.jpg' elif os.path.exists(abs_path + filename[:-4] + '.png'): tex_to_load = abs_path + filename[:-4] + '.png' # Try to read out texture coordinates if tex_to_load is not None: print('Loading {} with texture {}'.format(filename, tex_to_load)) image = cv2.flip(cv2.imread(tex_to_load, cv2.IMREAD_UNCHANGED), 0) # Must be flipped because of OpenGL self.texture = gloo.Texture2D(image) # If texcoords are face-wise if 'texcoord' in str(data): self.texcoord = np.asarray(list(data['face']['texcoord'])) assert self.indices.shape[0] == self.texcoord.shape[ 0] # Check same face count temp = np.zeros((data['vertex'].count, 2)) temp[self.indices.flatten()] = self.texcoord.reshape((-1, 2)) self.texcoord = temp # If texcoords are vertex-wise elif 'texture_u' in str(data): self.texcoord = np.zeros((data['vertex'].count, 2)) self.texcoord[:, 0] = np.array(data['vertex']['texture_u']) self.texcoord[:, 1] = np.array(data['vertex']['texture_v']) # If texture coords loaded succesfully if self.texcoord is not None: vertices_type = [('a_position', np.float32, 3), ('a_texcoord', np.float32, 2)] self.collated = np.asarray(list(zip(self.vertices, self.texcoord)), vertices_type) # Otherwise fall back to vertex colors else: self.colors = 0.5 * np.ones((data['vertex'].count, 3)) if 'blue' in str(data): print('Loading {} with vertex colors'.format(filename)) self.colors[:, 0] = np.array(data['vertex']['blue']) self.colors[:, 1] = np.array(data['vertex']['green']) self.colors[:, 2] = np.array(data['vertex']['red']) self.colors /= 255.0 else: print('Loading {} without any coloring!!'.format(filename)) vertices_type = [('a_position', np.float32, 3), ('a_color', np.float32, 3)] self.collated = np.asarray(list(zip(self.vertices, self.colors)), vertices_type) self.vertex_buffer = gloo.VertexBuffer(self.collated) self.index_buffer = gloo.IndexBuffer(self.indices.flatten())
def update_data(self, vertices): self.shared_program['a_position'] = gloo.VertexBuffer(vertices)
def render_line(self, queue): ''' This rendering algorithm works by tesselating the line into multiple triangles. Reference: https://blog.mapbox.com/drawing-antialiased-lines-with-opengl-8766f34192dc ''' if len(queue) == 0: return pos = [] posPrev = [] posCurr = [] posNext = [] markers = [] side = [] linewidth = [] join_type = [] cap_type = [] color = [] stroke_cap_codes = {'PROJECT': 0, 'SQUARE': 1, 'ROUND': 2} stroke_join_codes = {'MITER': 0, 'BEVEL': 1, 'ROUND': 2} for line in queue: if len(line[1]) == 0: continue for segment in line[1]: for i in range( len(segment) - 1): # the data is sent to renderer in line segments for j in [0, 0, 1, 0, 1, 1]: # all the vertices of triangles if i + j - 1 >= 0: posPrev.append(line[0][segment[i + j - 1]]) else: posPrev.append(line[0][segment[i + j]]) if i + j + 1 < len(segment): posNext.append(line[0][segment[i + j + 1]]) else: posNext.append(line[0][segment[i + j]]) posCurr.append(line[0][segment[i + j]]) # Is the vertex up/below the line segment markers.extend([1.0, -1.0, -1.0, -1.0, 1.0, -1.0]) # Left or right side of the segment side.extend([1.0, 1.0, -1.0, 1.0, -1.0, -1.0]) # Left vertex of each segment pos.extend([line[0][segment[i]]] * 6) linewidth.extend([line[3]] * 6) join_type.extend([stroke_join_codes[line[5]]] * 6) cap_type.extend([stroke_cap_codes[line[4]]] * 6) color.extend([line[2]] * 6) if len(pos) == 0: return posPrev = np.array(posPrev, np.float32) posCurr = np.array(posCurr, np.float32) posNext = np.array(posNext, np.float32) markers = np.array(markers, np.float32) side = np.array(side, np.float32) pos = np.array(pos, np.float32) linewidth = np.array(linewidth, np.float32) join_type = np.array(join_type, np.float32) cap_type = np.array(cap_type, np.float32) color = np.array(color, np.float32) self.line_prog['pos'] = gloo.VertexBuffer(pos) self.line_prog['posPrev'] = gloo.VertexBuffer(posPrev) self.line_prog['posCurr'] = gloo.VertexBuffer(posCurr) self.line_prog['posNext'] = gloo.VertexBuffer(posNext) self.line_prog['marker'] = gloo.VertexBuffer(markers) self.line_prog['side'] = gloo.VertexBuffer(side) self.line_prog['linewidth'] = gloo.VertexBuffer(linewidth) self.line_prog['join_type'] = gloo.VertexBuffer(join_type) self.line_prog['cap_type'] = gloo.VertexBuffer(cap_type) self.line_prog["color"] = gloo.VertexBuffer(color) self.line_prog.draw('triangles')
def _prepare_fbo(self, event): """ Draw the viewbox via an FBO. This method can be applied in any situation, regardless of the transformations to this viewbox. TODO: Right now, this implementation create a program, texture and FBO on *each* draw, because it does not work otherwise. This is probably a bug in gloo that prevents using two FBO's / programs at the same time. Also, we use plain gloo and calculate the transformation ourselves, assuming 2D only. Eventually we should just use the transform of self. I could not get that to work, probably because I do not understand the component system yet. """ from vispy import gloo render_vertex = """ attribute vec3 a_position; attribute vec2 a_texcoord; varying vec2 v_texcoord; void main() { gl_Position = vec4(a_position, 1.0); v_texcoord = a_texcoord; } """ render_fragment = """ uniform sampler2D u_texture; varying vec2 v_texcoord; void main() { vec4 v = texture2D(u_texture, v_texcoord); gl_FragColor = vec4(v.rgb, 1.0); } """ # todo: don't do this on every draw if True: # Create program self._myprogram = gloo.Program(render_vertex, render_fragment) # Create texture self._tex = gloo.Texture2D((10, 10, 4), interpolation='linear') self._myprogram['u_texture'] = self._tex # Create texcoords and vertices # Note y-axis is inverted here because the viewbox coordinate # system has origin in the upper-left, but the image is rendered # to the framebuffer with origin in the lower-left. texcoord = np.array([[0, 1], [1, 1], [0, 0], [1, 0]], dtype=np.float32) position = np.zeros((4, 3), np.float32) self._myprogram['a_texcoord'] = gloo.VertexBuffer(texcoord) self._myprogram['a_position'] = self._vert = \ gloo.VertexBuffer(position) # Get fbo, ensure it exists fbo = getattr(self, '_fbo', None) if True: # fbo is None: self._fbo = 4 self._fbo = fbo = gloo.FrameBuffer(self._tex, gloo.RenderBuffer((10, 10))) # Set texture coords to make the texture be drawn in the right place # Note that we would just use -1..1 if we would use a Visual. coords = [[0, 0], [self.size[0], self.size[1]]] transform = event.get_full_transform() coords = transform.map(coords) x1, y1, z = coords[0][:3] x2, y2, z = coords[1][:3] vertices = np.array( [[x1, y1, z], [x2, y1, z], [x1, y2, z], [x2, y2, z]], np.float32) self._vert.set_data(vertices) # Set fbo size (mind that this is set using shape!) resolution = [int(i + 0.5) for i in self._resolution] # set in draw() shape = resolution[1], resolution[0] # todo: use fbo.resize(shape) fbo.color_buffer.resize(shape + (4, )) fbo.depth_buffer.resize(shape) return fbo
def __init__(self, data, offset, scale): self.data = gloo.VertexBuffer(data) self.program = gloo.Program(vert, frag) self.program['pos'] = self.data self.set_transform(offset, scale)
def set_frame_data(self, data): self.program.set_vars(gloo.VertexBuffer(data))
def setup_regions(self): self.setup_points_selected = self.setup_regions all_points = np.array(self.__points) all_points = copy.copy(all_points) self.selected_regions = self.slice_regions if self.render_params['top_dogs_only']: self.selected_regions = self.top_dogs_regions if self.selected_regions == None: self.__parent__.pipelineWidget.cluster_layout.setRegions() self.selected_regions = self.slice_regions n_regions = len(self.selected_regions) #PREPARE DATA ARRAY total_n = 0 current_regions = 0 for i in range(len(all_points)): points = all_points[i] if self.render_params['top_dogs_only']: if self.__bfps[i].id in self.__top_dogs: n_in_region = sum([ len(region) for region in self.selected_regions[current_regions] ]) total_n += len(points) current_regions += 1 else: total_n += len(points) data = np.zeros(total_n, [('a_position', np.float32, 3), ('a_bg_color', np.float32, 4), ('a_fg_color', np.float32, 4), ('a_size', np.float32, 1)]) #POPULATE DATA ARRAY start = 0 current_regions = 0 for i in range(len(all_points)): points = all_points[i] if self.render_params['top_dogs_only']: if self.__bfps[i].id in self.__top_dogs: regions = self.selected_regions[current_regions] m = sum([len(region) for region in regions]) n = len(points) #assert(m == n) m innehåller inte alla points då de kan ha försvunnit i små regions datapoints = data[start:start + n] self.setupRegionData(datapoints, regions, points) current_regions += 1 start += n else: regions = self.selected_regions[current_regions] m = sum([len(region) for region in regions]) n = len(points) #assert(m == n) m innehåller inte alla points då de kan ha försvunnit i små regions datapoints = data[start:start + n] self.setupRegionData(datapoints, regions, points) current_regions += 1 start += n #else: # n = len(points) # data[start:start+n]['a_bg_color'] = np.array([0.7,0.7,0.9,0.5], dtype=np.float32) # data[start:start+n]['a_position'] = points # start += n data[0:total_n]['a_fg_color'] = 0, 0, 0, 1 data[0:total_n]['a_size'] = 10 #BIND DATA TO GL PROGRAM self.program_points.bind(gloo.VertexBuffer(data)) self.update()
def setup_planes(self): self.setup_points_selected = self.setup_regions all_points = np.array(self.__points) self.selected_planes = self.all_planes if self.render_params['top_dogs_only']: self.selected_planes = self.top_dog_planes #all_points = copy.copy(all_points) all_plane_points = copy.deepcopy(all_points) print("running setup planes with {} points".format( len(all_plane_points))) n_regions = len(self.selected_regions) #PREPARE DATA ARRAY total_n = 0 current_regions = 0 for i in range(len(all_plane_points)): points = all_plane_points[i] if self.render_params['top_dogs_only']: if self.__bfps[i].id in self.__top_dogs: n_in_region = sum([ len(region) for region in self.selected_regions[current_regions] ]) total_n += len(points) current_regions += 1 else: total_n += len(points) ##PREPARE DATA ARRAY #total_n = 0 #current_regions = 0 #for i in range(len(all_plane_points)): # points = all_plane_points[i] # if self.__bfps[i].id in self.__top_dogs : # n_in_region = sum([len(region) for region in self.selected_regions[current_regions]]) # total_n += len(points) # current_regions += 1 # elif self.render_params['top_dogs_only'] == False: # total_n += len(points) data = np.zeros(total_n, [('a_position', np.float32, 3), ('a_bg_color', np.float32, 4), ('a_fg_color', np.float32, 4), ('a_size', np.float32, 1)]) #POPULATE DATA ARRAY start = 0 current_regions = 0 for i in range(len(all_plane_points)): points = all_plane_points[i] if self.render_params['top_dogs_only']: if self.__bfps[i].id in self.__top_dogs: regions = self.selected_regions[current_regions] m = sum([len(region) for region in regions]) n = len(points) #assert(m == n) m innehåller inte alla points då de kan ha försvunnit i små regions for j in range(len(regions)): #plane = pf.fitPlane(points[regions[j]]) plane = self.selected_planes[current_regions][j] points[regions[j]] = elevatePointsToPlane( points[regions[j]], plane) datapoints = data[start:start + n] self.setupRegionData(datapoints, regions, points) current_regions += 1 start += n else: regions = self.selected_regions[current_regions] m = sum([len(region) for region in regions]) n = len(points) #assert(m == n) m innehåller inte alla points då de kan ha försvunnit i små regions for j in range(len(regions)): #plane = pf.fitPlane(points[regions[j]]) plane = self.selected_planes[current_regions][j] points[regions[j]] = elevatePointsToPlane( points[regions[j]], plane) datapoints = data[start:start + n] self.setupRegionData(datapoints, regions, points) current_regions += 1 start += n ##POPULATE DATA ARRAY #start = 0 #current_regions = 0 #for i in range(len(all_plane_points)): # points = all_plane_points[i] # n = len(points) # if self.__bfps[i].id in self.__top_dogs : # regions = self.selected_regions[current_regions] # datapoints = data[start:start+n] # for j in range(len(regions)): # plane = pf.fitPlane(points[regions[j]]) # points[regions[j]] = elevatePointsToPlane(points[regions[j]], plane) # #region_points = elevatePointsToPlane(points[:,0:2], self.all_planes[current_regions]) # self.setupRegionData(datapoints, regions, points) # current_regions += 1 # start += n # elif self.render_params['top_dogs_only'] == False: # n = len(points) # data[start:start+n]['a_bg_color'] = np.array([0.7,0.7,0.9,0.5], dtype=np.float32) # data[start:start+n]['a_position'] = points # start += n data[0:total_n]['a_fg_color'] = 0, 0, 0, 1 data[0:total_n]['a_size'] = 10 #BIND DATA TO GL PROGRAM self.program_points.bind(gloo.VertexBuffer(data)) self.update()
def updateLines(self): self.lineVerticesArr = self.myLineDrawer.computeLinesData( self.annotationTimes, self.startTime, self.endTime) self.lineVertices = gloo.VertexBuffer(self.lineVerticesArr) self.progAnnotations.bind(self.lineVertices)
def __init__(self, filename): self.basename = os.path.basename(filename) assert self.basename.endswith('.npz') self.accession_id = self.basename[0:-4] self.dump_prefix = './%s.' % self.accession_id self.dump_prefix = os.getenv('DUMP_PREFIX', self.dump_prefix) self.vol_slicer = SynspyImageManager(filename) self.vol_slicer.set_view() D, H, W, Nc = self.vol_slicer.data.shape app.Canvas.__init__(self, size=(min(800, W), min(800, H)), keys='interactive') self._hud_timer = None self.hud_items = [] self.program = gloo.Program() self.program.bind(gloo.VertexBuffer(quad)) self.textures, self.segment_map, self.segment_status = self.vol_slicer.get_textures( 0) self.program['u_image_texture'] = self.textures[0] self.program['u_map_texture'] = self.textures[1] self.program['u_measures_cube'] = self.textures[2] self.program['u_status_cube'] = self.textures[3] self.mouse_button_offset = 0 self.key_press_handlers = { 'B': self.toggle_blend, #'D': self.dump_or_report, 'D': self.report, 'E': self.toggle_erase, 'F': self.adjust_feature_level, 'G': self.adjust_gain, 'H': self.help, #'L': self.load_csv, 'N': self.adjust_neighbor_level, 'P': self.toggle_paint, 'R': self.reset, 'T': self.adjust_black_level, 'Up': self.adjust_depth, 'Down': self.adjust_depth, 'Left': self.adjust_paint_zoom, 'Right': self.adjust_paint_zoom, } self.frag_shaders = [ # green linear with binary segments (picked is brighter) ('green linear with binary segments', frag_shader( colorxfer='vec4(0.0, pixel.r * u_gain, 0.0, 1.0)', pick_off='vec3(0.2, 1, 1)', pick_on='vec3(1, 0.2, 1)', pick_def='vec3(1, 1, 0.2)', off='vec3(0.2, 0.6, 0.6)', on='vec3(0.6, 0.2, 0.6)', inrange='vec3(0.6, 0.6, 0.2)', )), ('gray intensity only', frag_shader( colorxfer= 'vec4(pixel.r, pixel.r, pixel.r, 1.0/u_gain) * u_gain', pick_off='vec3(0.2, 1, 1)', pick_on='vec3(1, 0.2, 1)', pick_def='vec3(1, 1, 1)', off='result.rgb', on='result.rgb', inrange='result.rgb', )), ('gray intensity with magenta=ON synapses', frag_shader( colorxfer= 'vec4(pixel.r, pixel.r, pixel.r, 1.0/u_gain) * u_gain', pick_off='vec3(0.2, 1, 1)', pick_on='vec3(1, 0.2, 1)', pick_def='vec3(1, 1, 1)', off='result.rgb', on='vec3(result.g, 0.2 * result.g, result.g) * 1.2', inrange='result.rgb', )), ('gray intensity with magenta=ON cyan=OFF yellow=neither synapses', frag_shader( colorxfer= 'vec4(pixel.r, pixel.r, pixel.r, 1.0/u_gain) * u_gain', pick_off='vec3(0.2, 1, 1)', pick_on='vec3(1, 0.2, 1)', pick_def='vec3(1, 1, 1)', off='vec3(0.2 * result.g, result.g, result.g) * 1.2', on='vec3(result.g, 0.2 * result.g, result.g) * 1.2', inrange='vec3(result.g, result.g, 0.2 * result.g) * 1.2', )) ] self.reset() self.text_hud = visuals.TextVisual('', color="white", font_size=12 * self.font_scale, anchor_x="left", bold=True) if not hasattr(self.text_hud, 'transforms'): # temporary backwards compatibility self.text_hud_transform = visuals.transforms.TransformSystem(self) self.prev_size = None self.set_viewport1((min(800, W), min(800, H))) self.show() # auto-load try: self.load_csv() except: pass # auto-dump self.auto_dumped = False @atexit.register def shutdown(): if not self.auto_dumped: sys.stderr.write('caught exit... dumping CSV...') self.dump_csv() sys.stderr.write('done.\n')
def quickTextDraw(self, text, x, y): self.positionsToTextMap[(x, y)] = text self.textVerticesArr = self.myTextDrawer.computeTextsData( self.positionsToTextMap) self.textVertices = gloo.VertexBuffer(self.textVerticesArr) self.progText.bind(self.textVertices)
def __init__(self, data, axis=-1, sf=1., color='random', title=None, space=2., scale=(.98, .9), font_size=10., width=1., method='gl', force_shape=None): """Init.""" # =========================== CHECKING =========================== assert isinstance(data, np.ndarray) and (data.ndim <= 3) assert isinstance(axis, int) assert isinstance(sf, (int, float)) assert isinstance(space, (int, float)) assert isinstance(scale, (tuple, list)) and len(scale) == 2 # =========================== VISUALS =========================== visuals.Visual.__init__(self, vertex_shader, fragment_shader) self.set_gl_state('translucent', depth_test=True, cull_face=False, blend=True, blend_func=('src_alpha', 'one_minus_src_alpha')) self._draw_mode = 'line_strip' self._txt = Text(bold=False, font_size=font_size) # =========================== DATA =========================== # Keep some inputs : self._sh = data.shape self._n = self._sh[axis] self._axis = axis self._sf = sf self._color = color self.scale = scale self.space = space self._prep = PrepareData(axis=-1) self.width = width self.method = method # =========================== BUFFERS =========================== # Create buffers (for data, index and color) rnd_1 = np.zeros((3, ), dtype=np.float32) rnd_3 = np.zeros((1, 3), dtype=np.float32) self._dbuffer = gloo.VertexBuffer(rnd_1) self._ibuffer = gloo.VertexBuffer(rnd_3) self._cbuffer = gloo.VertexBuffer(rnd_3) # Send to the program : self.shared_program.vert['a_position'] = self._dbuffer self.shared_program.vert['a_index'] = self._ibuffer self.shared_program.vert['a_color'] = self._cbuffer self.shared_program.vert['u_size'] = (1, 1) self.shared_program.vert['u_n'] = len(self) # Set data : self.set_data(data, axis, color, title, force_shape) self.freeze()
def update_color(self): """Update connexions colors.""" self.shared_program.vert['a_color'] = gloo.VertexBuffer( self.a_color.astype(np.float32))
def __init__(self, data, time=None, art=-1, wake=0, n1=1, n2=2, n3=3, rem=4, art_visual=1, wake_visual=0, rem_visual=-1, n1_visual=-2, n2_visual=-3, n3_visual=-4, art_color='#8bbf56', wake_color='#56bf8b', rem_color='#bf5656', n1_color='#aabcce', n2_color='#405c79', n3_color='#0b1c2c', line_width=2., antialias=False, unicolor=False): """Init.""" # =========================== VISUALS =========================== visuals.Visual.__init__(self, vertex_shader, fragment_shader) self._draw_mode = 'line_strip' # =========================== BUFFERS =========================== pos_2 = np.random.rand(1, 2).astype(np.float32) pos_1 = np.random.rand(1).astype(np.float32) self._position_vbo = gloo.VertexBuffer(pos_2) self._transient_vbo = gloo.VertexBuffer(pos_1) self.shared_program.vert['position'] = self._position_vbo self.shared_program.vert['transient'] = self._transient_vbo self._program.vert['to_vec4'] = vec2to4 self.line_width = line_width self.antialias = antialias self.unicolor = unicolor # Stage : self.art = art self.wake = wake self.rem = rem self.n1 = n1 self.n2 = n2 self.n3 = n3 # Stage visual : self.art_visual = art_visual self.wake_visual = wake_visual self.rem_visual = rem_visual self.n1_visual = n1_visual self.n2_visual = n2_visual self.n3_visual = n3_visual # Stage color : self.art_color = art_color self.wake_color = wake_color self.rem_color = rem_color self.n1_color = n1_color self.n2_color = n2_color self.n3_color = n3_color # Set data : self.set_data(data, time) self.freeze()
def add_point(self, point): self.positions.append(point) self.positions = self.positions[-self.length:] p = np.array(self.positions, dtype=np.float32) self.pos_vbo = gloo.VertexBuffer(p.copy())
def __init__(self, vertices, colors, K, nH, nW, faces = 0, image_grid = 0, labels = 0, nframes = 1, edge_thresh = 1000): app.Canvas.__init__(self, keys='interactive', size=(nW, nH)) numPnts = vertices.shape[0] / nframes self.frame = 0 self.nframes = nframes self.npoints = numPnts self.has_labels = 0 self.per_frame_label = 0 self.faces_buf = {} if( isinstance(labels, np.ndarray) ): self.per_frame_label = 1 self.has_labels = 1 seg_colors = np.zeros([np.prod(labels.shape), 4]).astype(np.float32) cmap = cmx.rainbow(np.linspace(0, 1, np.maximum( np.max(labels) + 1, len(np.unique(labels) ) ) ) ) # cmap = np.array([[1.0000, 0.2857, 0, 1.0], # [1.0000, 0.5714, 0, 1.0], # [1.0000, 0.8571, 0, 1.0], # [0.8571, 1.0000, 0, 1.0], # [0.5714, 1.0000, 0, 1.0], # [ 0, 1.0000, 0.8571, 1.0], # [ 0, 0.8571, 1.0000, 1.0], # [ 0, 0.5714, 1.0000, 1.0], # [ 0, 0.2857, 1.0000, 1.0], # [ 0, 0, 1.0000, 1.0], # [0.2857, 0, 1.0000, 1.0], # [0.8571, 0, 1.0000, 1.0]]) for i in np.unique(labels): seg_colors[:,3] = 1.0 if(i != -1): mask = labels == i seg_colors[mask.reshape(-1),:] = cmap[i,:] self.seg_colors = seg_colors self.has_faces = 0 self.draw_points = 1 if( isinstance(faces, dict) ): self.has_faces = 1 for f in range(nframes): self.faces = faces[f] vertices_f = vertices[f*numPnts:(f+1)*numPnts,:] mask = self.remove_long_edges(self.faces, vertices_f, edge_thresh) faces_temp = self.faces[mask, :] self.faces_buf[f] = gloo.IndexBuffer(faces_temp) elif(image_grid): self.has_faces = 1 ### we have two types of edges indices = np.array(range(nH*nW)).astype(np.uint32).reshape((-1,1)) triangles_type1 = np.hstack((indices, indices+1, indices + nW)) triangles_type2 = np.hstack((indices, indices+nW-1, indices + nW)) mask1 = np.ones((nH,nW),dtype=bool) mask2 = np.ones((nH,nW),dtype=bool) mask1[:,-1] = False mask1[-1,:] = False mask2[:, 0] = False mask2[-1,:] = False self.faces = np.vstack(( triangles_type1[mask1.reshape(-1), :], triangles_type2[mask2.reshape(-1), :])) ## all the frames use the same faces if(self.has_labels): if(not self.per_frame_label): # remove connections between different labels labels_temp = labels.reshape(-1) mask01 = labels_temp[self.faces[:,0]] == labels_temp[self.faces[:,1]] mask02 = labels_temp[self.faces[:,0]] == labels_temp[self.faces[:,2]] mask12 = labels_temp[self.faces[:,1]] == labels_temp[self.faces[:,2]] mask = np.logical_and(mask01, mask02) mask = np.logical_and(mask, mask12) self.faces = self.faces[mask,:] for f in range(nframes): vertices_f = vertices[f*numPnts:(f+1)*numPnts,:] mask = self.remove_long_edges(self.faces, vertices_f, edge_thresh) faces_temp = self.faces[mask, :] self.faces_buf[f] = gloo.IndexBuffer(faces_temp) # different frames have different faces if(self.has_labels): if(self.per_frame_label): for f in range(nframes): labels_temp = labels[f*numPnts:(f+1)*numPnts].reshape(-1) mask01 = labels_temp[self.faces[:,0]] == labels_temp[self.faces[:,1]] mask02 = labels_temp[self.faces[:,0]] == labels_temp[self.faces[:,2]] mask12 = labels_temp[self.faces[:,1]] == labels_temp[self.faces[:,2]] mask = np.logical_and(mask01, mask02) mask = np.logical_and(mask, mask12) faces_temp = self.faces[mask,:] vertices_f = vertices[f*numPnts:(f+1)*numPnts,:] mask = self.remove_long_edges(faces_temp, vertices_f, edge_thresh) faces_temp = faces_temp[mask,:] self.faces_buf[f] = gloo.IndexBuffer(faces_temp) self.vertices = vertices self.colors = np.hstack((colors, np.ones((colors.shape[0], 1)).astype(np.float32))) self.update_color = 0 if(colors.shape[0] == numPnts * nframes): self.update_color = 1 # data contains the data to render self.data = np.zeros(numPnts, [('a_position', np.float32, 3), ('a_color', np.float32, 4), ('a_seg_color', np.float32, 4)]) self.data['a_position'] = self.vertices[0:numPnts,:] self.data['a_color'] = self.colors[0:numPnts,:] if(self.has_labels): self.data['a_seg_color'] = self.seg_colors[0:numPnts,:] else: self.data['a_seg_color'] = self.colors[0:numPnts,:] self.center = np.mean(vertices, axis=0) self.program = gloo.Program(vert, frag) self.program.bind(gloo.VertexBuffer(self.data)) # self.program['a_color'] = self.data['a_color'] # self.program['a_position'] = self.data['a_position'] # self.program['a_seg_color'] = self.data['a_seg_color'] self.view = translate((0, 0, 0)) self.model = np.eye(4, dtype=np.float32) gloo.set_viewport(0, 0, self.physical_size[0], self.physical_size[1]) # gloo.set_viewport(0, 0, nW, nH) if(isinstance(K, np.ndarray)): projection = projection_from_intrinsics(K, nH, nW) else: projection = ortho_projection(nH, nW) #print projection self.projection = projection.T # self.projection = np.ascontiguousarray(projection) # self.projection = np.ascontiguousarray(projection.T) # self.projection = perspective(45.0, self.size[0] / # float(self.size[1]), 2.0, 1000.0) self.program['u_projection'] = self.projection self.program['u_model'] = self.model self.program['u_view'] = self.view self.program['u_color'] = 1, 1, 1, 1 self.program['u_plot_seg'] = 0 self.program['u_point_size'] = 5 self.nH = nH self.nW = nW self.last_x = 0 self.last_y = 0 self.substract_center = translate((-self.center[0], -self.center[1], -self.center[2])) self.add_center = translate((self.center[0], self.center[1], self.center[2])) self.translate_X = self.center[0] self.translate_Y = self.center[1] self.translate_Z = self.center[2] self.scale = - self.center[2] / 100 self.rot_X = 0 self.rot_Y = 0 self.rot_Z = 0 self.quaternion = Quaternion() self.theta = 0 self.phi = 0 #gloo.set_clear_color('black') gloo.set_clear_color('white') gloo.set_state('opaque') gloo.set_state(depth_test=True) # gloo.set_polygon_offset(1, 1) self.show()