def on_draw(self, event):
with self._fbo:
gloo.clear('black')
gloo.set_viewport(0, 0, *self.size)
self.program.draw()
self.im = self._fbo.read()
app.quit()
def key_event(event):
if event.key.name == 'Escape':
app.quit()
if event.key.name == 'P':
print("Added point")
tr = view.node_transform(image)
x, y = tr.map(app.current_pos)[:2]
c, r = int(x), int(y)
points.append(np.array((r, c)))
update_drawing()
if event.key.name == 'D':
tr = view.node_transform(image)
x, y = tr.map(app.current_pos)[:2]
c, r = int(x), int(y)
deltas = np.array(points) - np.array((r, c))
sq_dists = np.sum(deltas * deltas, axis=1)
del points[np.argmin(sq_dists)]
update_drawing()
if event.key.name == 'S':
df = pd.DataFrame(points, columns=['X', 'Y'])
df.to_csv(output_fpath, index=False)
def update_vertices(ev, *args):
global vis, timescale, canvas, frames, lag, paused, record, start_shot, started_shot, finished_shot
if not paused:
index = int((ev.count - lag) / timescale) % vis.frames
vis.set_vertex_data(index)
if start_shot and index == 0:
if started_shot:
finished_shot = True
print("Start round")
record = True
started_shot = True
else:
lag += 1
if record:
im = canvas.render()
frames.append(im)
if finished_shot:
print("Start saving")
record = False
can_record = False
app.quit()
canvas.close()
print("Saving...")
write_recording()
def on_draw(self, event):
self.program['iGlobalTime'] += 1.0 / self._rate
self.program.draw()
if self._duration is not None and self.program[
'iGlobalTime'] >= self._duration:
app.quit()
def on_timer(self,event):
if self.animation is not None:
self.t = 2.0 - (default_timer() - self.t0) / 10.0
if self.t < 2.0 and self.t > 0.0:
self.animation(self)
else:
app.quit()
def on_draw(self, event):
if self.render_rgb:
self.draw_color() # Render color image
if self.render_depth:
self.draw_depth() # Render depth image
if self.render_normal:
self.draw_normal() # Render normal image
app.quit() # Immediately exit the application after the first drawing
def draw(self):
if self._glsl:
fragment = fragment_template % self._glsl
self._glsl = None
# Check to see if the shader will compile successfully before we
# set it. We do this here because the ShaderWatcher runs in a
# different thread and so can't access the GL context.
frag_handle = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(frag_handle, fragment)
gl.glCompileShader(frag_handle)
status = gl.glGetShaderParameter(frag_handle, gl.GL_COMPILE_STATUS)
if not status:
errors = gl.glGetShaderInfoLog(frag_handle)
errors = self.process_errors(errors)
print("Shader failed to compile:", file=sys.stderr)
print(errors, file=sys.stderr)
# Switch to error shader
self._glsl = error_shader
self.update()
else:
self.program.set_shaders(vertex, fragment)
gl.glDeleteShader(frag_handle)
if self._interactive:
self.program.draw()
if self._ffmpeg_pipe is not None:
img = _screenshot()
self.write_video_frame(img)
self._render_frame_index += 1
if self._render_frame_count is not None and self._render_frame_index >= self._render_frame_count:
app.quit()
return
self.advance_time()
else:
with self._fbo:
rs = list(self._render_size)
if self._tile_coord[0] + rs[0] > self._output_size[0]:
rs[0] = self._output_size[0] - self._tile_coord[0]
if self._tile_coord[1] + rs[1] > self._output_size[1]:
rs[1] = self._output_size[1] - self._tile_coord[1]
gloo.set_viewport(0, 0, *rs)
self.program['iOffset'] = self._tile_coord
self.program.draw()
img = _screenshot()
row = self._output_size[1] - self._tile_coord[1] - rs[1]
col = self._tile_coord[0]
self._img[row:row + rs[1], col:col + rs[0], :] = img
def draw(self):
if self._glsl:
fragment = fragment_template % self._glsl
self._glsl = None
# Check to see if the shader will compile successfully before we
# set it. We do this here because the ShaderWatcher runs in a
# different thread and so can't access the GL context.
frag_handle = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(frag_handle, fragment)
gl.glCompileShader(frag_handle)
status = gl.glGetShaderParameter(frag_handle, gl.GL_COMPILE_STATUS)
if not status:
errors = gl.glGetShaderInfoLog(frag_handle)
errors = self.process_errors(errors)
print("Shader failed to compile:", file=sys.stderr)
print(errors, file=sys.stderr)
# Switch to error shader
self._glsl = error_shader
self.update()
else:
self.program.set_shaders(vertex, fragment)
gl.glDeleteShader(frag_handle)
if self._interactive:
self.program.draw()
if self._ffmpeg_pipe is not None:
img = _screenshot()
self.write_video_frame(img)
self._render_frame_index += 1
if self._render_frame_count is not None and self._render_frame_index >= self._render_frame_count:
app.quit()
return
self.advance_time()
else:
with self._fbo:
rs = list(self._render_size)
if self._tile_coord[0] + rs[0] > self._output_size[0]:
rs[0] = self._output_size[0] - self._tile_coord[0]
if self._tile_coord[1] + rs[1] > self._output_size[1]:
rs[1] = self._output_size[1] - self._tile_coord[1]
gloo.set_viewport(0, 0, *rs)
self.program['iOffset'] = self._tile_coord
self.program.draw()
img = _screenshot()
row = self._output_size[1] - self._tile_coord[1] - rs[1]
col = self._tile_coord[0]
self._img[row:row + rs[1], col:col + rs[0], :] = img
def on_draw(self, event):
self.program['iGlobalTime'] += 1.0 / self._rate
self.program.draw()
if self._stdout is not None:
framebuffer = vispy.gloo.util._screenshot((0, 0, self.physical_size[0], self.physical_size[1]))
self._stdout.write(framebuffer.tobytes())
if self._duration is not None and self.program['iGlobalTime'] >= self._duration:
app.quit()
def on_draw(self, event):
# Render in the FBO.
with self._fbo:
gloo.clear((1,1,1,1))
gloo.set_viewport(0, 0, *self.true_size)
self.program.draw(gl.GL_TRIANGLE_STRIP)
# Retrieve the contents of the FBO texture.
self.shadowsArray = _screenshot((0, 0, self.true_size[0], self.true_size[1]))
# Immediately exit the application.
app.quit()
def on_timer(self, event):
if self._interactive:
self.update()
else:
# update() doesn't call on_draw() if window is hidden under some toolkits,
# so call draw() directly
self.draw()
# update tiles
self._tile_index += 1
clock_time_elapsed = time.clock() - self._clock_time_start
rendered_tile_count = self._tile_index + self._render_frame_index * self._tile_count
total_tile_count = self._tile_count * self._render_frame_count
clock_time_per_tile = clock_time_elapsed / float(
rendered_tile_count)
clock_time_total = clock_time_per_tile * total_tile_count
clock_time_remain = clock_time_total - clock_time_elapsed
print("Tile %d / %d (%.2f%%); %s elapsed; %s remaining; %s total" % \
(rendered_tile_count,
total_tile_count,
rendered_tile_count * 100.0 / total_tile_count,
str(datetime.timedelta(seconds=round(clock_time_elapsed))),
str(datetime.timedelta(seconds=round(clock_time_remain))),
str(datetime.timedelta(seconds=round(clock_time_total)))))
if self._tile_index == self._tile_count:
if self._ffmpeg_pipe:
self.write_video_frame(self._img)
self._render_frame_index += 1
if self._render_frame_count is not None and self._render_frame_index >= self._render_frame_count:
app.quit()
return
# Reset tile indices
self._tile_index = 0
self._tile_coord = [0, 0]
self.advance_time()
else:
self.write_img(self._img, self._output)
app.quit()
return
else:
self._tile_coord[0] += self._render_size[0]
if self._tile_coord[0] >= self._output_size[0]:
self._tile_coord[0] = 0
self._tile_coord[1] += self._render_size[1]
if self._progress_file:
self.write_img(self._img, self._progress_file)
def on_timer(self, event):
if self._interactive:
self.update()
else:
# update() doesn't call on_draw() if window is hidden under some toolkits,
# so call draw() directly
self.draw()
# update tiles
self._tile_index += 1
clock_time_elapsed = time.clock() - self._clock_time_start
rendered_tile_count = self._tile_index + self._render_frame_index * self._tile_count
total_tile_count = self._tile_count * self._render_frame_count
clock_time_per_tile = clock_time_elapsed / float(rendered_tile_count)
clock_time_total = clock_time_per_tile * total_tile_count
clock_time_remain = clock_time_total - clock_time_elapsed
print("Tile %d / %d (%.2f%%); %s elapsed; %s remaining; %s total" % \
(rendered_tile_count,
total_tile_count,
rendered_tile_count * 100.0 / total_tile_count,
str(datetime.timedelta(seconds=round(clock_time_elapsed))),
str(datetime.timedelta(seconds=round(clock_time_remain))),
str(datetime.timedelta(seconds=round(clock_time_total)))))
if self._tile_index == self._tile_count:
if self._ffmpeg_pipe:
self.write_video_frame(self._img)
self._render_frame_index += 1
if self._render_frame_count is not None and self._render_frame_index >= self._render_frame_count:
app.quit()
return
# Reset tile indices
self._tile_index = 0
self._tile_coord = [0, 0]
self.advance_time()
else:
self.write_img(self._img, self._output)
app.quit()
return
else:
self._tile_coord[0] += self._render_size[0]
if self._tile_coord[0] >= self._output_size[0]:
self._tile_coord[0] = 0
self._tile_coord[1] += self._render_size[1]
if self._progress_file:
self.write_img(self._img, self._progress_file)
def on_draw(self, event):
# Render in the FBO.
with self._fbo:
gloo.clear('black')
gloo.set_viewport(0, 0, *self.size)
self.program.draw()
# Retrieve the contents of the FBO texture.
self.im = _screenshot((0, 0, self.size[0], self.size[1]))
self._time = time() - self._t0
# Immediately exit the application.
app.quit()
def on_draw(self, event):
if self.render_rgb:
self.draw_color() # Render color image
if self.render_depth:
self.draw_depth() # Render depth image
if self.render_obj_coords:
self.draw_obj_coords()
if self.render_segmentation:
self.draw_segmentation()
if self.render_bounding_boxes:
self.draw_bounding_boxes()
app.quit() # Immediately exit the application after the first drawing
def on_draw(self, event):
with self._fbo:
gloo.clear('black')
self.program.bind(self.verts_buf)
self.program.draw('triangles', self.tris_buf)
# Retrieve depth
# For some reason, vispy flipuds images in read_pixels, so we
# unflip here. This is inefficient but vispy-compatible
self.depth = read_fbo_color_rgba32f(self._fbo)
self.depth = np.flipud(self.depth)
self._time = time() - self._t0
app.quit()
def on_draw(self, event):
# Render in the FBO.
with self._fbo:
gloo.clear('black')
gloo.set_viewport(0, 0, *self.size)
self.program.draw()
# Retrieve the contents of the FBO texture.
self.im = read_pixels((0, 0, self.size[0], self.size[1]),
True,
out_type='float')
self._time = time() - self._t0
# Immediately exit the application.
app.quit()
def handle_key(ev):
global timescale, record, can_record, frames, filename, canvas, paused, start_shot, view
if ev.text == ']':
# Increase speed
timescale /= 2
print("Timescale is now", timescale)
elif ev.text == '[':
# Decrease speed
timescale *= 2
print("Timescale is now", timescale)
elif ev.text == 'r':
# Start record
if record:
print("Already recording")
elif can_record:
record = True
print("Started recording")
# Measure fps
canvas.measure_fps(callback=set_fps)
else:
print("Record is disabled")
elif ev.text == 's':
if can_record and record:
record = False
can_record = False
app.quit()
canvas.close()
print("Saving...")
write_recording()
elif ev.text == 'f':
canvas.size = (1920, 1080)
elif ev.text == 'h':
canvas.size = (1280, 720)
elif ev.text == '=':
vis.pointsize += 1
print(f"Pointsize is {vis.pointsize}")
elif ev.text == '-':
vis.pointsize -= 1
print(f"Pointsize is {vis.pointsize}")
elif ev.text == ' ':
if paused:
print("Unpaused")
else:
print("Paused")
paused = not paused
elif ev.text == 'm':
start_shot = True
elif ev.text == 'z':
view.camera.distance *= 0.9
elif ev.text == 'x':
view.camera.distance *= 1.1
def vispar():
def _exeval(f, *x, **y):
nonlocal _error
assert _done == _todo == []
# _todo.insert(0,fog(print,'Hello wurlzy'))
_todo.insert(0, fog(f, *x, **y))
while not _done and not _error:
pass
assert _todo == []
if _error:
assert not _done
temp = _error
_error = None
raise temp
out = _done.pop()
assert not _done
return out
def _exec(*x, **y):
return _exeval(exec, *x, **y)
def _eval(*x, **y):
return _exeval(eval, *x, **y)
_error = None
_todo = []
_done = [] # Results of _todo
import rp.r_iterm_comm as ric
_level = ric.pseudo_terminal_level
run_as_new_thread(pseudo_terminal, globals(), exec=_exec, eval=_eval)
while ric.pseudo_terminal_level == _level:
pass
while 1:
if ric.pseudo_terminal_level == _level:
break
try:
from vispy import app
app.process_events()
except:
print("harry potwar strikes again! keep chuggin...")
pass
if _todo:
try:
_done.append(_todo.pop()())
except BaseException as e:
_error = e
assert not _todo
print('...aaaannndddd were DONE chuggin.')
app.quit(
) # NOT nessecary but PERHAPS its nicer than having a crashy window...make this optional though!!!
def key_event(event):
app.tags[app.current_id] = key_to_tag[event.key.name]
try:
im, app.current_id = next(app.image_generator)
app.image.set_data(im)
app.counter += 1
textstr = "Image {}".format(app.counter)
app.t1.text = textstr
canvas.update()
except StopIteration:
app.dataset.put_overlay("classes", app.tags)
app.quit()
def on_draw(self, event):
if args.outputfile:
faces = [[0, 0], [90, 0], [180, 0], [270, 0], [0, 90], [0, 270]]
self.model = numpy.dot(rotate(faces[args.faces - 1][0], (0, 0, 1)),
rotate(faces[args.faces - 1][0], (0, 1, 0)))
self.shader_nodes['u_model'] = self.model
self.shader_traces['u_model'] = self.model
gloo.clear()
self.program = self.shader_nodes
self.program.draw('points')
self.program = self.shader_traces
self.program.draw('lines')
if args.outputfile:
self.im = _screenshot((0, 0, self.size[0], self.size[1]))
app.quit()
def exit(*args, **kwargs):
"""Exit the sketch.
`exit()` overrides Python's builtin exit() function and makes sure
that necessary cleanup steps are performed before exiting the
sketch.
:param args: positional argumets to pass to Python's builtin
`exit()` function.
:param kwargs: keyword-arguments to pass to Python's builtin
`exit()` function.
"""
default_sketch.show(visible=False)
app.quit()
builtins.exit(*args, **kwargs)
def exit(*args, **kwargs):
"""Exit the sketch.
`exit()` overrides Python's builtin exit() function and makes sure
that necessary cleanup steps are performed before exiting the
sketch.
:param args: positional argumets to pass to Python's builtin
`exit()` function.
:param kwargs: keyword-arguments to pass to Python's builtin
`exit()` function.
"""
if not (p5.sketch is None):
if builtins.current_renderer == "vispy":
from vispy import app
p5.sketch.show(visible=False)
app.quit()
p5.exit(*args, **kwargs)
def on_draw(self, event):
max_quality = max(float(q.text) for q in self.quality)
logger.debug("Signal quality is %.2f" % max_quality)
if max_quality > SIGNAL_QUALITY_THRESHOLD:
logger.debug("Signal quality poor, counter reset")
self.quality_count = 0
else:
self.quality_count += 1
logger.debug(f"Signal quality counter at {self.quality_count}")
if self.quality_count >= SIGNAL_STABILITY_COUNT:
logger.info("Signal stabilized!")
return app.quit()
super().on_draw(event)
def on_draw(self, event):
main()
app.quit()
def cube(im_in, azimuth=30., elevation=45., name=None,
ext=ext, do_axis=True, show_label=True,
cube_label = {'x':'x', 'y':'y', 't':'t'},
colormap='gray', roll=-180., vmin=0., vmax=1.,
figsize=figsize, figpath=figpath, **kwargs):
"""
Visualization of the stimulus as a cube
"""
im = im_in.copy()
N_X, N_Y, N_frame = im.shape
fx, fy, ft = get_grids(N_X, N_Y, N_frame)
import numpy as np
from vispy import app, scene
try:
AffineTransform = scene.transforms.AffineTransform
except:
AffineTransform = scene.transforms.MatrixTransform
app.use_app('pyglet')
from vispy.util.transforms import perspective, translate, rotate
canvas = scene.SceneCanvas(size=figsize, bgcolor='white', dpi=450)
view = canvas.central_widget.add_view()
# frame = scene.visuals.Cube(size = (N_X/2, N_frame/2, N_Y/2), color=(0., 0., 0., 0.),
# edge_color='k',
# parent=view.scene)
for p in ([1, 1, 1, -1, 1, 1], [1, 1, -1, -1, 1, -1], [1, -1, 1, -1, -1, 1],[1, -1, -1, -1, -1, -1],
[1, 1, 1, 1, -1, 1], [-1, 1, 1, -1, -1, 1], [1, 1, -1, 1, -1, -1], [-1, 1, -1, -1, -1, -1],
[1, 1, 1, 1, 1, -1], [-1, 1, 1, -1, 1, -1], [1, -1, 1, 1, -1, -1], [-1, -1, 1, -1, -1, -1]):
# line = scene.visuals.Line(pos=np.array([[p[0]*N_Y/2, p[1]*N_X/2, p[2]*N_frame/2], [p[3]*N_Y/2, p[4]*N_X/2, p[5]*N_frame/2]]), color='black', parent=view.scene)
line = scene.visuals.Line(pos=np.array([[p[0]*N_X/2, p[1]*N_frame/2, p[2]*N_Y/2],
[p[3]*N_X/2, p[4]*N_frame/2, p[5]*N_Y/2]]), color='black', parent=view.scene)
opts = {'parent':view.scene, 'cmap':'grays', 'clim':(0., 1.)}
image_xy = scene.visuals.Image(np.rot90(im[:, :, 0], 3), **opts)
tr_xy = AffineTransform()
tr_xy.rotate(90, (1, 0, 0))
tr_xy.translate((-N_X/2, -N_frame/2, -N_Y/2))
image_xy.transform = tr_xy
image_xt = scene.visuals.Image(np.fliplr(im[:, -1, :]), **opts)
tr_xt = AffineTransform()
tr_xt.rotate(90, (0, 0, 1))
tr_xt.translate((N_X/2, -N_frame/2, N_Y/2))
image_xt.transform = tr_xt
image_yt = scene.visuals.Image(np.rot90(im[-1, :, :], 1), **opts)
tr_yt = AffineTransform()
tr_yt.rotate(90, (0, 1, 0))
tr_yt.translate((+N_X/2, -N_frame/2, N_Y/2))
image_yt.transform = tr_yt
if do_axis:
t = {}
for text in ['x', 'y', 't']:
t[text] = scene.visuals.Text(cube_label[text], parent=canvas.scene, face='Helvetica', color='black')
t[text].font_size = 8
t['x'].pos = canvas.size[0] // 3, canvas.size[1] - canvas.size[1] // 8
t['t'].pos = canvas.size[0] - canvas.size[0] // 5, canvas.size[1] - canvas.size[1] // 6
t['y'].pos = canvas.size[0] // 12, canvas.size[1] // 2
cam = scene.TurntableCamera(elevation=35, azimuth=30)
cam.fov = 45
cam.scale_factor = N_X * 1.7
if do_axis: margin = 1.3
else: margin = 1
cam.set_range((-N_X/2, N_X/2), (-N_Y/2*margin, N_Y/2/margin), (-N_frame/2, N_frame/2))
view.camera = cam
if not(name is None):
im = canvas.render(size=figsize)
app.quit()
import vispy.io as io
io.write_png(name + ext, im)
else:
app.quit()
return im
def visualize(z_in, azimuth=25., elevation=30.,
thresholds=[0.94, .89, .75, .5, .25, .1], opacities=[.9, .8, .7, .5, .2, .1],
# thresholds=[0.94, .89, .75], opacities=[.99, .7, .2],
# thresholds=[0.7, .5, .2], opacities=[.95, .5, .2],
fourier_label = {'f_x':'f_x', 'f_y':'f_y', 'f_t':'f_t'},
name=None, ext=ext, do_axis=True, do_grids=False, draw_projections=True,
colorbar=False, f_N=2., f_tN=2., figsize=figsize, figpath=figpath, **kwargs):
"""
Visualization of the Fourier spectrum by showing 3D contour plots at different thresholds
parameters
----------
z : envelope of the cloud
"""
z = z_in.copy()
N_X, N_Y, N_frame = z.shape
fx, fy, ft = get_grids(N_X, N_Y, N_frame)
# Normalize the amplitude.
z /= z.max()
from vispy import app, scene
try:
AffineTransform = scene.transforms.AffineTransform
except:
AffineTransform = scene.transforms.MatrixTransform
app.use_app('pyglet')
#from vispy.util.transforms import perspective, translate, rotate
from vispy.color import Color
transparent = Color(color='black', alpha=0.)
import colorsys
canvas = scene.SceneCanvas(size=figsize, bgcolor='white', dpi=450)
view = canvas.central_widget.add_view()
vol_data = np.rollaxis(np.rollaxis(z, 1), 2)
# volume = scene.visuals.Volume(vol_data, parent=view.scene)#frame)
center = scene.transforms.STTransform(translate=( -N_X/2, -N_Y/2, -N_frame/2))
# volume.transform = center
# volume.cmap = 'blues'
if draw_projections:
from vispy.color import Colormap
cm = Colormap([(1.0, 1.0, 1.0, 1.0), 'k'])
opts = {'parent':view.scene, 'cmap':cm, 'clim':(0., 1.)}
energy_xy = np.rot90(np.max(z, axis=2)[:, ::-1], 3)[:, ::-1]
fourier_xy = scene.visuals.Image(np.rot90(energy_xy), **opts)
tr_xy = AffineTransform()
tr_xy.rotate(90, (0, 0, 1))
tr_xy.translate((N_X/2, -N_Y/2, -N_frame/2))
fourier_xy.transform = tr_xy
energy_xt = np.rot90(np.max(z, axis=1)[:, ::-1], 3)[::-1, ::-1]
fourier_xt = scene.visuals.Image(energy_xt, **opts)
tr_xt = AffineTransform()
tr_xt.rotate(90, (1, 0, 0))
tr_xt.translate((-N_X/2, N_Y/2, -N_frame/2))
fourier_xt.transform = tr_xt
energy_yt = np.max(z, axis=0)#[:, ::-1]
fourier_yt = scene.visuals.Image(energy_yt, **opts)
tr_yt = AffineTransform()
tr_yt.rotate(90, (0, 1, 0))
tr_yt.translate((-N_X/2, -N_Y/2, N_frame/2))
fourier_yt.transform = tr_yt
# Generate iso-surfaces at different energy levels
surfaces = []
for i_, (threshold, opacity) in enumerate(list(zip(thresholds, opacities))):
surfaces.append(scene.visuals.Isosurface(z, level=threshold,
# color=Color(np.array(colorsys.hsv_to_rgb(1.*i_/len(thresholds), 1., 1.)), alpha=opacity),
color=Color(np.array(colorsys.hsv_to_rgb(.66, 1., 1.)), alpha=opacity),
shading='smooth', parent=view.scene)
)
surfaces[-1].transform = center
# Draw a sphere at the origin
axis = scene.visuals.XYZAxis(parent=view.scene)
for p in ([1, 1, 1, -1, 1, 1], [1, 1, -1, -1, 1, -1], [1, -1, 1, -1, -1, 1],[1, -1, -1, -1, -1, -1],
[1, 1, 1, 1, -1, 1], [-1, 1, 1, -1, -1, 1], [1, 1, -1, 1, -1, -1], [-1, 1, -1, -1, -1, -1],
[1, 1, 1, 1, 1, -1], [-1, 1, 1, -1, 1, -1], [1, -1, 1, 1, -1, -1], [-1, -1, 1, -1, -1, -1]):
line = scene.visuals.Line(pos=np.array([[p[0]*N_X/2, p[1]*N_Y/2, p[2]*N_frame/2], [p[3]*N_X/2, p[4]*N_Y/2, p[5]*N_frame/2]]), color='black', parent=view.scene)
axisX = scene.visuals.Line(pos=np.array([[0, -N_Y/2, 0], [0, N_Y/2, 0]]), color='red', parent=view.scene)
axisY = scene.visuals.Line(pos=np.array([[-N_X/2, 0, 0], [N_X/2, 0, 0]]), color='green', parent=view.scene)
axisZ = scene.visuals.Line(pos=np.array([[0, 0, -N_frame/2], [0, 0, N_frame/2]]), color='blue', parent=view.scene)
if do_axis:
t = {}
for text in ['f_x', 'f_y', 'f_t']:
t[text] = scene.visuals.Text(fourier_label[text], parent=canvas.scene, face='Helvetica', color='black')
t[text].font_size = 8
t['f_x'].pos = canvas.size[0] // 3, canvas.size[1] - canvas.size[1] // 8
t['f_y'].pos = canvas.size[0] - canvas.size[0] // 8, canvas.size[1] - canvas.size[1] // 6
t['f_t'].pos = canvas.size[0] // 8, canvas.size[1] // 2
cam = scene.TurntableCamera(elevation=elevation, azimuth=azimuth, up='z')
cam.fov = 48
cam.scale_factor = N_X * 1.8
if do_axis: margin = 1.35
else: margin = 1
cam.set_range((-N_X/2*margin, N_X/2/margin), (-N_Y/2*margin, N_Y/2/margin), (-N_frame/2*margin, N_frame/2/margin))
view.camera = cam
im = canvas.render(size=figsize)
app.quit()
if not(name is None):
import vispy.io as io
io.write_png(name + ext, im)
else:
return im
def draw(self):
for i in range(4):
if self._bufXglsl[i]:
fragment = fragment_template % self._bufXglsl[i]
self._bufXglsl[i] = None
frag_handle = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(frag_handle, fragment)
gl.glCompileShader(frag_handle)
status = gl.glGetShaderParameter(frag_handle,
gl.GL_COMPILE_STATUS)
if not status:
errors = gl.glGetShaderInfoLog(frag_handle)
errors = self.process_errors(errors)
print('Shader failed to compile:', file=sys.stderr)
print(errors, file=sys.stderr)
exit(1)
else:
self._BufX[i].set_shaders(vertex, fragment)
gl.glDeleteShader(frag_handle)
if self._glsl:
fragment = fragment_template % self._glsl
self._glsl = None
# Check to see if the shader will compile successfully before we
# set it. We do this here because the ShaderWatcher runs in a
# different thread and so can't access the GL context.
frag_handle = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(frag_handle, fragment)
gl.glCompileShader(frag_handle)
status = gl.glGetShaderParameter(frag_handle,
gl.GL_COMPILE_STATUS)
if not status:
errors = gl.glGetShaderInfoLog(frag_handle)
errors = self.process_errors(errors)
print('Shader failed to compile:', file=sys.stderr)
print(errors, file=sys.stderr)
exit(1)
# Switch to error shader
self._glsl = error_shader
self.update()
else:
self.program.set_shaders(vertex, fragment)
gl.glDeleteShader(frag_handle)
if self._interactive:
for i in range(4):
with self._fboX[self._doubleFboid][i]:
gloo.set_clear_color((0.0, 0.0, 0.0, 0.0))
gloo.clear(color=True, depth=True)
gloo.set_viewport(0, 0, *self.physical_size)
self._BufX[i].draw()
self.program.draw()
if self._ffmpeg_pipe is not None:
img = _screenshot()
self.write_video_frame(img)
self._render_frame_index += 1
if self._render_frame_count is not None \
and self._render_frame_index \
>= self._render_frame_count:
app.quit()
return
self._doubleFbo = not self._doubleFbo
self._doubleFboid=(0 if self._doubleFbo else 1)
self.advance_time()
self.program['iFrame'] = self._render_frame_index
self.set_Buf_uniform('iFrame' , self._render_frame_index)
self.set_channel_input()
self.set_Buf_channel_input()
else:
for i in range(4):
with self._fboX[self._doubleFboid][i]:
gloo.set_clear_color((0.0, 0.0, 0.0, 0.0))
gloo.clear(color=True, depth=True)
gloo.set_viewport(0, 0, *self.physical_size)
self._BufX[i].draw()
with self._fbo:
rs = list(self._render_size)
if self._tile_coord[0] + rs[0] > self._output_size[0]:
rs[0] = self._output_size[0] - self._tile_coord[0]
if self._tile_coord[1] + rs[1] > self._output_size[1]:
rs[1] = self._output_size[1] - self._tile_coord[1]
gloo.set_viewport(0, 0, *rs)
self.program['iOffset'] = self._tile_coord
self.program.draw()
self._doubleFbo = not self._doubleFbo
self._doubleFboid=(0 if self._doubleFbo else 1)
self.program['iFrame'] = self._render_frame_index
self.set_Buf_uniform('iFrame' , self._render_frame_index)
self.set_channel_input()
self.set_Buf_channel_input()
img = _screenshot()
row = self._output_size[1] - self._tile_coord[1] - rs[1]
col = self._tile_coord[0]
self._img[row:row + rs[1], col:col + rs[0], :] = img
def on_close(self, event):
app.quit()
super().on_close(event)
def cube(im_in, azimuth=30., elevation=45., name=None,
ext=ext, do_axis=True, show_label=True,
cube_label = {'x':'x', 'y':'y', 't':'t'},
colormap='gray', roll=-180., vmin=0., vmax=1.,
figsize=figsize, **kwargs):
"""
Visualization of the stimulus as a cube
"""
if not(os.path.isdir(figpath)): os.mkdir(figpath)
im = im_in.copy()
N_X, N_Y, N_frame = im.shape
fx, fy, ft = get_grids(N_X, N_Y, N_frame)
import numpy as np
from vispy import app, scene
app.use_app('pyglet')
from vispy.util.transforms import perspective, translate, rotate
canvas = scene.SceneCanvas(size=figsize, bgcolor='white', dpi=450)
view = canvas.central_widget.add_view()
# frame = scene.visuals.Cube(size = (N_X/2, N_frame/2, N_Y/2), color=(0., 0., 0., 0.),
# edge_color='k',
# parent=view.scene)
for p in ([1, 1, 1, -1, 1, 1], [1, 1, -1, -1, 1, -1], [1, -1, 1, -1, -1, 1],[1, -1, -1, -1, -1, -1],
[1, 1, 1, 1, -1, 1], [-1, 1, 1, -1, -1, 1], [1, 1, -1, 1, -1, -1], [-1, 1, -1, -1, -1, -1],
[1, 1, 1, 1, 1, -1], [-1, 1, 1, -1, 1, -1], [1, -1, 1, 1, -1, -1], [-1, -1, 1, -1, -1, -1]):
# line = scene.visuals.Line(pos=np.array([[p[0]*N_Y/2, p[1]*N_X/2, p[2]*N_frame/2], [p[3]*N_Y/2, p[4]*N_X/2, p[5]*N_frame/2]]), color='black', parent=view.scene)
line = scene.visuals.Line(pos=np.array([[p[0]*N_X/2, p[1]*N_frame/2, p[2]*N_Y/2],
[p[3]*N_X/2, p[4]*N_frame/2, p[5]*N_Y/2]]), color='black', parent=view.scene)
opts = {'parent':view.scene, 'cmap':'grays', 'clim':(0., 1.)}
image_xy = scene.visuals.Image(np.rot90(im[:, :, 0], 3), **opts)
tr_xy = scene.transforms.MatrixTransform()
tr_xy.rotate(90, (1, 0, 0))
tr_xy.translate((-N_X/2, -N_frame/2, -N_Y/2))
image_xy.transform = tr_xy
image_xt = scene.visuals.Image(np.fliplr(im[:, -1, :]), **opts)
tr_xt = scene.transforms.MatrixTransform()
tr_xt.rotate(90, (0, 0, 1))
tr_xt.translate((N_X/2, -N_frame/2, N_Y/2))
image_xt.transform = tr_xt
image_yt = scene.visuals.Image(np.rot90(im[-1, :, :], 1), **opts)
tr_yt = scene.transforms.MatrixTransform()
tr_yt.rotate(90, (0, 1, 0))
tr_yt.translate((+N_X/2, -N_frame/2, N_Y/2))
image_yt.transform = tr_yt
if do_axis:
t = {}
for text in ['x', 'y', 't']:
t[text] = scene.visuals.Text(cube_label[text], parent=canvas.scene, face='Helvetica', color='black')
t[text].font_size = 8
t['x'].pos = canvas.size[0] // 3, canvas.size[1] - canvas.size[1] // 8
t['t'].pos = canvas.size[0] - canvas.size[0] // 5, canvas.size[1] - canvas.size[1] // 6
t['y'].pos = canvas.size[0] // 12, canvas.size[1] // 2
cam = scene.TurntableCamera(elevation=35, azimuth=30)
cam.fov = 45
cam.scale_factor = N_X * 1.7
if do_axis: margin = 1.3
else: margin = 1
cam.set_range((-N_X/2, N_X/2), (-N_Y/2*margin, N_Y/2/margin), (-N_frame/2, N_frame/2))
view.camera = cam
if not(name is None):
im = canvas.render(size=figsize)
app.quit()
import vispy.io as io
io.write_png(name + ext, im)
else:
app.quit()
return im
def on_close(self, event):
app.quit()
def quit(self):
app.quit()
def on_draw(self, event):
self.program['iGlobalTime'] += 1.0 / self._rate
self.program.draw()
if self._duration is not None and self.program['iGlobalTime'] >= self._duration:
app.quit()
return _screenshot((0,0,canvas.size[0],canvas.size[1]))[:,:,:3]
#animation = VideoClip(make_frame, duration=5).resize(width=350)
#animation = VideoClip(make_frame, duration=5).resize(width=800,height=600)
animation = VideoClip(make_frame, duration=10)
#animation.write_gif('otto.gif', fps=2, opt='OptimizePlus')
animation.write_videofile("surfVideo.webm",preset="medium",fps=20,audio=False)
######### close canvas only here ...
app.process_events()
canvas.close()
app.process_events()
app.quit()
#try to create sound version ...
audioclip = AudioFileClip("../data/zkmaudio.wav")
videoclip = VideoFileClip("surfVideo.webm")
l = videoclip.duration
print("video length:",l)
audio = audioclip.set_duration(l) # same length as video
videoclip.set_audio(audio)
#textclip = TextClip("ZKM Open Codes", fontsize=20, color='white').set_pos("center","center")
# get font list with:
#TextClip.list("font")
# we could also add the text directly, see above
textclip = TextClip("ZKM Open Codes", font="FreeSans",fontsize=40, color='white',method='label')
t = textclip.set_duration(l)
# compose everything. make sure to set audio here!
def on_close(self, event):
app.quit()
super().on_close(event)
def visualize(z_in, azimuth=25., elevation=30.,
thresholds=[0.94, .89, .75, .5, .25, .1], opacities=[.9, .8, .7, .5, .2, .1],
# thresholds=[0.94, .89, .75], opacities=[.99, .7, .2],
# thresholds=[0.7, .5, .2], opacities=[.95, .5, .2],
fourier_label = {'f_x':'f_x', 'f_y':'f_y', 'f_t':'f_t'},
name=None, ext=ext, do_axis=True, do_grids=False, draw_projections=True,
colorbar=False, f_N=2., f_tN=2., figsize=figsize, **kwargs):
"""
Visualization of the Fourier spectrum by showing 3D contour plots at different thresholds
parameters
----------
z : envelope of the cloud
"""
if not(os.path.isdir(figpath)): os.mkdir(figpath)
z = z_in.copy()
N_X, N_Y, N_frame = z.shape
fx, fy, ft = get_grids(N_X, N_Y, N_frame)
# Normalize the amplitude.
z /= z.max()
from vispy import app, scene
app.use_app('pyglet')
#from vispy.util.transforms import perspective, translate, rotate
from vispy.color import Color
transparent = Color(color='black', alpha=0.)
import colorsys
canvas = scene.SceneCanvas(size=figsize, bgcolor='white', dpi=450)
view = canvas.central_widget.add_view()
vol_data = np.rollaxis(np.rollaxis(z, 1), 2)
# volume = scene.visuals.Volume(vol_data, parent=view.scene)#frame)
center = scene.transforms.STTransform(translate=( -N_X/2, -N_Y/2, -N_frame/2))
# volume.transform = center
# volume.cmap = 'blues'
if draw_projections:
from vispy.color import Colormap
cm = Colormap([(1.0, 1.0, 1.0, 1.0), 'k'])
opts = {'parent':view.scene, 'cmap':cm, 'clim':(0., 1.)}
energy_xy = np.rot90(np.max(z, axis=2)[:, ::-1], 3)
fourier_xy = scene.visuals.Image(np.rot90(energy_xy), **opts)
tr_xy = scene.transforms.MatrixTransform()
tr_xy.rotate(90, (0, 0, 1))
tr_xy.translate((N_X/2, -N_Y/2, -N_frame/2))
fourier_xy.transform = tr_xy
energy_xt = np.rot90(np.max(z, axis=1)[:, ::-1], 3)
fourier_xt = scene.visuals.Image(energy_xt, **opts)
tr_xt = scene.transforms.MatrixTransform()
tr_xt.rotate(90, (1, 0, 0))
tr_xt.translate((-N_X/2, N_Y/2, -N_frame/2))
fourier_xt.transform = tr_xt
energy_yt = np.max(z, axis=0)[:, ::-1]
fourier_yt = scene.visuals.Image(energy_yt, **opts)
tr_yt = scene.transforms.MatrixTransform()
tr_yt.rotate(90, (0, 1, 0))
tr_yt.translate((-N_X/2, -N_Y/2, N_frame/2))
fourier_yt.transform = tr_yt
# Generate iso-surfaces at different energy levels
surfaces = []
for i_, (threshold, opacity) in enumerate(zip(thresholds, opacities)):
surfaces.append(scene.visuals.Isosurface(z, level=threshold,
# color=Color(np.array(colorsys.hsv_to_rgb(1.*i_/len(thresholds), 1., 1.)), alpha=opacity),
color=Color(np.array(colorsys.hsv_to_rgb(.66, 1., 1.)), alpha=opacity),
shading='smooth', parent=view.scene)
)
surfaces[-1].transform = center
# Draw a sphere at the origin
axis = scene.visuals.XYZAxis(parent=view.scene)
for p in ([1, 1, 1, -1, 1, 1], [1, 1, -1, -1, 1, -1], [1, -1, 1, -1, -1, 1],[1, -1, -1, -1, -1, -1],
[1, 1, 1, 1, -1, 1], [-1, 1, 1, -1, -1, 1], [1, 1, -1, 1, -1, -1], [-1, 1, -1, -1, -1, -1],
[1, 1, 1, 1, 1, -1], [-1, 1, 1, -1, 1, -1], [1, -1, 1, 1, -1, -1], [-1, -1, 1, -1, -1, -1]):
line = scene.visuals.Line(pos=np.array([[p[0]*N_X/2, p[1]*N_Y/2, p[2]*N_frame/2], [p[3]*N_X/2, p[4]*N_Y/2, p[5]*N_frame/2]]), color='black', parent=view.scene)
axisX = scene.visuals.Line(pos=np.array([[0, -N_Y/2, 0], [0, N_Y/2, 0]]), color='red', parent=view.scene)
axisY = scene.visuals.Line(pos=np.array([[-N_X/2, 0, 0], [N_X/2, 0, 0]]), color='green', parent=view.scene)
axisZ = scene.visuals.Line(pos=np.array([[0, 0, -N_frame/2], [0, 0, N_frame/2]]), color='blue', parent=view.scene)
if do_axis:
t = {}
for text in ['f_x', 'f_y', 'f_t']:
t[text] = scene.visuals.Text(fourier_label[text], parent=canvas.scene, face='Helvetica', color='black')
t[text].font_size = 8
t['f_x'].pos = canvas.size[0] // 3, canvas.size[1] - canvas.size[1] // 8
t['f_y'].pos = canvas.size[0] - canvas.size[0] // 8, canvas.size[1] - canvas.size[1] // 6
t['f_t'].pos = canvas.size[0] // 8, canvas.size[1] // 2
cam = scene.TurntableCamera(elevation=elevation, azimuth=azimuth, up='z')
cam.fov = 48
cam.scale_factor = N_X * 1.8
if do_axis: margin = 1.35
else: margin = 1
cam.set_range((-N_X/2*margin, N_X/2/margin), (-N_Y/2*margin, N_Y/2/margin), (-N_frame/2*margin, N_frame/2/margin))
view.camera = cam
im = canvas.render(size=figsize)
app.quit()
if not(name is None):
import vispy.io as io
io.write_png(name + ext, im)
else:
return im
def receive_data(sock, canvas): global joints_coordinates global points global trajectory global env_number global point global joint global traject global view global stop stop = False obj_number = 0 while not stop: msg_byte, user = udp.recvfrom(1024) msg_list = json.loads(msg_byte) msg = np.array(msg_list) if msg[2] == 2: stop = True app.quit() sock.close() elif msg[2] == 3: env_number = int(msg[0]) if env_number == 1: env_shape = (1, 1) else: env_shape = msg[3] obj_number = int(msg[1]) joints_coordinates = np.empty((env_number, 4, 3)) points = np.empty((env_number, msg[1], 3)) trajectory = [np.empty((1, 3)) for _ in range(env_number)] view = canvas.central_widget.add_view() camera = scene.cameras.TurntableCamera(fov=100) camera.set_range((90, -90, -90), (-90, 90, -90), (90, -90, -90)) view.camera = camera threads = [] line, column = 0, 0 for i in range(env_number): point.append(visuals.Markers()) joint.append(visuals.LinePlot()) traject.append(visuals.Markers()) x = column*105 y = line*105 threads.append(threading.Thread(target=update, args=(i, x, y, obj_number))) if column < (env_shape[1]-1): column += 1 else: line += 1 column = 0 view.add(point[i]) view.add(joint[i]) view.add(traject[i]) threads[i].setDaemon(True) threads[i].start() elif msg[2] == 4: trajectory = [np.empty((1, 3)) for _ in range(env_number)] else: ide = int(msg[0]) msg = msg.reshape(-1, 3) index = msg[0, :] joints_coordinates[ide] = msg[1:5, :] points[ide] = msg[5:5+obj_number, :] if index[2] == 1: trajectory[ide] = np.array([0.0, 0.0, 51.3]) trajectory[ide] = np.vstack((trajectory[ide], msg[-1, :])) time.sleep(0.005)
def run_simulation(self):
global_step = 0
level_step_counter = 1e10
current_net = self.net
current_net.to(self.device)
last_positions = self.net.positions
pos_max = self.pos_max
pos_min = self.pos_min
centering = self.centering
while True:
position_change = torch.mean(
torch.norm(current_net.positions - last_positions, 2, dim=1))
last_positions = current_net.positions.clone()
if position_change < 0.001 and level_step_counter > self.min_num_steps:
print("move to new level")
level_step_counter = 0
if global_step > 0:
current_net = current_net.give_positions_to_parent(
perturbation=0.1)
if current_net is None:
break
last_positions = current_net.positions.clone()
current_net.to(self.device)
centering = min(
self.max_centering,
centering + self.additional_centering_per_level)
print("positions:", last_positions.shape, "centering:",
centering)
layout = NetworkForceLayout(
current_net,
spring_optimal_distance=1.,
attraction_normalization=0.,
repulsion=1.,
step_size=self.step_size,
step_discount_factor=self.step_discount_factor,
centering=centering,
drag=0.2,
noise=0.,
mac=0.5,
num_dim=2,
force_limit=1.,
distance_exponent=self.distance_exponent,
device=self.device)
for i in range(self.steps_per_frame):
layout.simulation_step()
level_step_counter += 1
global_step += 1
positions = layout.x.cpu().numpy()[np.newaxis, :].copy()
n_pos_max = np.max(positions)
n_pos_min = np.min(positions)
pos_max = self.range_gamma * n_pos_max + (
1 - self.range_gamma) * pos_max
pos_min = self.range_gamma * n_pos_min + (
1 - self.range_gamma) * pos_min
positions -= pos_min
positions /= (pos_max - pos_min)
positions = positions * 0.8 + 0.1
if self.plot_connections:
edges = np.zeros((current_net.num_connections * 3, 3),
dtype=np.float32)
edges[0::3, :2] = positions[
0, current_net.connections[:, 0].cpu(), :]
edges[1::3, :2] = positions[
0, current_net.connections[:, 1].cpu(), :]
edges[2::3, :] = float('nan')
edges[0::3, 2] = 1.
edges[1::3, 2] = 1.
edges = pd.DataFrame(data=edges)
edges.columns = ['x', 'y', 'val']
edges_lines = self.ds_canvas.line(
edges, 'x', 'y',
agg=ds.sum('val')).values.astype(np.float32)
edges_lines[edges_lines != edges_lines] = 0.
edges_lines = pow(edges_lines / edges_lines.max(), 0.25)
# edges_lines = gaussian_filter(edges_lines, sigma=0.8)
self.viz.edge_textures = edges_lines[np.newaxis, :, :]
self.viz.set_new_node_positions(
positions,
new_weights=current_net.weights[None, :].cpu().numpy())
self.viz.update()
# time.sleep(0.1)
self.layout = layout.x.cpu().numpy()
app.quit()
def quit(self):
app.quit()
