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()