def on_draw(self, event):
blending_mode = blending_modes[self.blending_mode_index]
render.set_blending(blending_mode)
gloo.set_clear_color((0.30, 0.30, 0.35, 1.00))
gloo.clear(color=True, depth=True)
w, h = self.physical_size
if self.model is None:
aspect = w / h
v = views[self.view_index]
if v == "perspective":
self.model, self.view, self.projection = render.create_transform_perspective(aspect=aspect)
else:
self.model, self.view, self.projection = render.create_transform_ortho(aspect=aspect, view=v, fake_ortho=True)
rotation = self.rotation_index
if self.run_phi:
self.phi += 0.2
actual_model = render.apply_model_rotation(self.model, rotation=0, phi=self.phi)
current_variant = self.variants[self.variant_index]
current_mode = modes[self.mode_index]
self.glblock.render(current_variant, actual_model, self.view, self.projection, rotation=rotation, mode=current_mode)
v = lambda *a: np.array(a, dtype=np.float32)
render.draw_line(v(0, 0, 0), v(10, 0, 0), actual_model, self.view, self.projection, color=(1, 0, 0, 1))
render.draw_line(v(0, 0, 0), v(0, 10, 0), actual_model, self.view, self.projection, color=(0, 1, 0, 1))
render.draw_line(v(0, 0, 0), v(0, 0, 10), actual_model, self.view, self.projection, color=(0, 0, 1, 1))
def __init__(self, parent=None):
scene.SceneCanvas.__init__(self, parent=parent)
self.parent = parent
self.has_redrawn = True
self.data = None
self.data_changed = False
self.data_program = gloo.Program(data_vert, data_frag)
path = os.path.dirname(os.path.realpath(__file__))
path = os.path.join(path, 'colormaps/transform/Seismic.npy')
self.colormap = Colormap(path)
self.colormap_program = gloo.Program(colormap_vert, colormap_frag)
# horizontal / vertical / diagonal
self.line_type = None
# x for a vertical line, y for a horizontal line
self.line_coord = None
# start and end points
self.line_positions = [(0, 0), (0, 0)]
self.linecut_program = gloo.Program(linecut_vert, linecut_frag)
self.linecut_program['a_position'] = self.line_positions
gloo.set_clear_color((1, 1, 1, 1))
def draw_depth(self):
program = gloo.Program(_depth_vertex_code, _depth_fragment_code)
program.bind(self.vertex_buffer)
program['u_mv'] = _compute_model_view(self.mat_model, self.mat_view)
program['u_mvp'] = _compute_model_view_proj(self.mat_model,
self.mat_view,
self.mat_proj)
# Texture where we render the scene
render_tex = gloo.Texture2D(shape=self.shape + (4, ),
format=gl.GL_RGBA,
internalformat=gl.GL_RGBA32F)
# Frame buffer object
fbo = gloo.FrameBuffer(render_tex,
gloo.RenderBuffer(self.shape, format='depth'))
with fbo:
gloo.set_state(depth_test=True)
gloo.set_state(cull_face=True)
gloo.set_cull_face('back') # Back-facing polygons will be culled
gloo.set_clear_color((0.0, 0.0, 0.0, 0.0))
gloo.clear(color=True, depth=True)
gloo.set_viewport(0, 0, *self.size)
program.draw('triangles', self.index_buffer)
# Retrieve the contents of the FBO texture
self.depth = self.read_fbo_color_rgba32f(fbo)
self.depth = self.depth[:, :,
0] # Depth is saved in the first channel
def __init__(self):
app.Canvas.__init__(self, keys='interactive', size=((W * 5), (H * 5)))
self.program = gloo.Program(VERT_SHADER, FRAG_SHADER)
self.texture = gloo.Texture2D(I, interpolation='linear')
self.program['u_texture'] = self.texture
self.program.bind(gloo.VertexBuffer(data))
self.view = np.eye(4, dtype=np.float32)
self.model = np.eye(4, dtype=np.float32)
self.projection = np.eye(4, dtype=np.float32)
self.program['u_model'] = self.model
self.program['u_view'] = self.view
self.projection = ortho(0, W, 0, H, -1, 1)
self.program['u_projection'] = self.projection
gloo.set_clear_color('white')
self._timer = app.Timer('auto', connect=self.update, start=True)
self.sim_is_initialized = False
self.sim = None
self.show()
def __init__(self, **kwargs):
app.Canvas.__init__(self, **kwargs)
self.geometry = 0, 0, 400, 400
mesh = create_sphere(10, 10, radius=2.)
vertices = mesh.get_vertices()
tris = mesh.get_faces()
data=vertices[:, 2]
self.filled_buf = gloo.IndexBuffer(tris)
self.program = ModularProgram(VERT_CODE, FRAG_CODE)
colormap = get_colormap('autumn')
self.color = Function(colormap.glsl_map)
self.program.frag['color'] = self.color('floor(v_value*10.+0.5)/10.')
# Set attributes
self.program['a_position'] = gloo.VertexBuffer(vertices)
self.program['a_value'] = gloo.VertexBuffer(normalize(data, data.min(), data.max()))
# Handle transformations
self.init_transforms()
gloo.set_clear_color((1, 1, 1, 1))
gloo.set_state(depth_test=True)
self._timer = app.Timer('auto', connect=self.update_transforms)
self._timer.start()
def __init__(self, size, cam):
app.Canvas.__init__(self, show=False, size=size)
self.shape = (size[1], size[0])
self.yz_flip = np.eye(4, dtype=np.float32)
self.yz_flip[1, 1], self.yz_flip[2, 2] = -1, -1
self.set_cam(cam)
# Set up shader programs
self.program_col = gloo.Program(_vertex_code_colored, _fragment_code_colored)
self.program_bbox = gloo.Program(_vertex_code_colored, _fragment_code_bbox)
self.program_tex = gloo.Program(_vertex_code_textured, _fragment_code_textured)
self.program_bg = gloo.Program(_vertex_code_background, _fragment_code_background)
# Texture where we render the color/depth and its FBO
self.col_tex = gloo.Texture2D(shape=self.shape + (3,))
self.fbo = gloo.FrameBuffer(self.col_tex, gloo.RenderBuffer(self.shape))
self.fbo.activate()
gloo.set_state(depth_test=True, blend=False, cull_face=True)
gl.glEnable(gl.GL_LINE_SMOOTH)
gloo.set_clear_color((0.0, 0.0, 0.0))
gloo.set_viewport(0, 0, *self.size)
# Set up background render quad in NDC
quad = [[-1, -1], [1, -1], [1, 1], [-1, 1]]
tex = [[0, 1], [1, 1], [1, 0], [0, 0]]
vertices_type = [('a_position', np.float32, 2), ('a_texcoord', np.float32, 2)]
collated = np.asarray(list(zip(quad, tex)), vertices_type)
self.bg_vbuffer = gloo.VertexBuffer(collated)
self.bg_ibuffer = gloo.IndexBuffer([0, 1, 2, 0, 2, 3])
def __init__(self, size, cam):
config = dict(red_size=8,
green_size=8,
blue_size=8,
alpha_size=8,
depth_size=24,
stencil_size=0,
double_buffer=True,
stereo=False,
samples=0)
app.Canvas.__init__(self, show=False, size=size, config=config)
self.shape = (size[1], size[0])
self.yz_flip = np.eye(4, dtype=np.float32)
self.yz_flip[1, 1], self.yz_flip[2, 2] = -1, -1
self.set_cam(cam)
# Set up shader programs
self.program_col = gloo.Program(_vertex_code_colored,
_fragment_code_colored)
self.program_tex = gloo.Program(_vertex_code_textured,
_fragment_code_textured)
# Texture where we render the color/depth and its FBO
self.col_tex = gloo.Texture2D(shape=self.shape + (3, ))
self.fbo = gloo.FrameBuffer(self.col_tex,
gloo.RenderBuffer(self.shape))
self.fbo.activate()
gloo.set_state(depth_test=True, blend=False, cull_face=True)
gl.glEnable(gl.GL_LINE_SMOOTH)
gloo.set_clear_color((0.0, 0.0, 0.0))
gloo.set_viewport(0, 0, *self.size)
def __init__(self):
app.Canvas.__init__(self,
title='Rain [Move mouse]',
size=(512, 512),
keys='interactive')
# Build data
# --------------------------------------
n = 500
self.data = np.zeros(n, [('a_position', np.float32, 2),
('a_fg_color', np.float32, 4),
('a_size', np.float32, 1)])
self.index = 0
self.program = Program(vertex, fragment)
self.vdata = VertexBuffer(self.data)
self.program.bind(self.vdata)
self.program['u_antialias'] = 1.00
self.program['u_linewidth'] = 1.00
self.program['u_model'] = np.eye(4, dtype=np.float32)
self.program['u_view'] = np.eye(4, dtype=np.float32)
self.activate_zoom()
gloo.set_clear_color('white')
gloo.set_state(blend=True,
blend_func=('src_alpha', 'one_minus_src_alpha'))
self.timer = app.Timer('auto', self.on_timer, start=True)
self.show()
def __init__(self):
app.Canvas.__init__(self, keys='interactive')
self.size = W * 5, H * 5
self.program = gloo.Program(VERT_SHADER, FRAG_SHADER)
self.texture = gloo.Texture3D(I, interpolation='nearest',
wrapping='clamp_to_edge')
self.program['u_texture'] = self.texture
self.program['i'] = 0.0
self.program.bind(gloo.VertexBuffer(data))
self.view = np.eye(4, dtype=np.float32)
self.model = np.eye(4, dtype=np.float32)
self.projection = np.eye(4, dtype=np.float32)
self.program['u_model'] = self.model
self.program['u_view'] = self.view
self.projection = ortho(0, W, 0, H, -1, 1)
self.program['u_projection'] = self.projection
self.i = 0
gloo.set_clear_color('white')
self._timer = app.Timer('auto', connect=self.on_timer, start=True)
def __init__(self):
app.Canvas.__init__(self, size=(1024, 1024), title='Skybox example',
keys='interactive')
self.cubeSize = 10
self.pressed = False
self.azimuth = pi / 2.0
self.elevation = pi / 2.0
self.distanceMin = 1
self.distanceMax = 50
self.distance = 30
self.sensitivity = 5.0
self.view = getView(self.azimuth, self.elevation, self.distance)
self.model = np.eye(4, dtype=np.float32)
self.projection = np.eye(4, dtype=np.float32)
self.program = gloo.Program(vertex_shader, fragment_shader, count=24)
self.program['a_position'] = faces*self.cubeSize
self.program['a_texcoord'] = faces
self.program['a_texture'] = gloo.TextureCube(texture, interpolation='linear')
self.program['u_model'] = self.model
self.program['u_view'] = self.view
gloo.set_viewport(0, 0, *self.physical_size)
self.projection = perspective(60.0, self.size[0] /
float(self.size[1]), 1.0, 100.0)
self.program['u_projection'] = self.projection
gl.glEnable(gl.GL_DEPTH_TEST)
gloo.set_clear_color('black')
self.show()
def __init__(self):
app.Canvas.__init__(self, keys='interactive')
self.size = 800, 600
self.vertices, self.filled, self.outline = cube()
self.filled_buf = gloo.IndexBuffer(self.filled)
self.outline_buf = gloo.IndexBuffer(self.outline)
self.program = gloo.Program(vert, frag)
self.program.bind(gloo.VertexBuffer(self.vertices))
self.view = np.eye(4, dtype=np.float32)
self.model = np.eye(4, dtype=np.float32)
self.projection = np.eye(4, dtype=np.float32)
translate(self.view, 0, 0, -5)
self.program['u_model'] = self.model
self.program['u_view'] = self.view
self.theta = 0
self.phi = 0
gloo.set_clear_color('white')
gloo.set_state('opaque')
gloo.set_polygon_offset(1, 1)
self._timer = app.Timer('auto', connect=self.on_timer, start=True)
def __init__(self, *args, **kwargs):
app.Canvas.__init__(self, *args, **kwargs)
self.program = gloo.Program(self.read_shader('1.vert'), self.read_shader('3.frag'))
# Fill screen with single quad, fragment shader does all the real work
self.program["position"] = [(-1, -1), (-1, 1), (1, 1),
(-1, -1), (1, 1), (1, -1)]
self._starttime = time.time()
self.program['time'] = 0
self.program['cameraPos'] = (0.0, 3.0, -6.0)
self.program['cameraLookat'] = (0.0, -0.85, 0.5)
self.program['lightDir'] = normalize(np.array((-1, -1, -1))) # needs to be normalized
self.program['lightColour'] = (1.4, 3.0, 0.3)
self.program['diffuse'] = (0.27, 0.27, 0.27)
self.program['ambientFactor'] = 0.45
self.program['rotateWorld'] = True
self.program['scale'] = 1.5
self.program['offset'] = 1.8
self.program['cubeWidth'] = 1
self.program['angleA'] = 1
self.program['angleB'] = 1
self.apply_zoom()
gloo.set_clear_color(color='black')
self._timer = app.Timer('auto', connect=self.update, start=True)
self.show()
def __init__(self, emulate3d=True):
app.Canvas.__init__(self, keys='interactive', size=((W*5), (H*5)))
if emulate3d:
tex_cls = gloo.TextureEmulated3D
else:
tex_cls = gloo.Texture3D
self.texture = tex_cls(img_array, interpolation='nearest',
wrapping='clamp_to_edge')
self.program = ModularProgram(VERT_SHADER, FRAG_SHADER)
self.program.frag['sampler_type'] = self.texture.glsl_sampler_type
self.program.frag['sample'] = self.texture.glsl_sample
self.program['u_texture'] = self.texture
self.program['i'] = 0.0
self.program.bind(gloo.VertexBuffer(data))
self.view = np.eye(4, dtype=np.float32)
self.model = np.eye(4, dtype=np.float32)
self.projection = np.eye(4, dtype=np.float32)
self.program['u_model'] = self.model
self.program['u_view'] = self.view
self.projection = ortho(0, W, 0, H, -1, 1)
self.program['u_projection'] = self.projection
self.i = 0
gloo.set_clear_color('white')
self._timer = app.Timer('auto', connect=self.on_timer, start=True)
self.show()
def __init__(self):
app.Canvas.__init__(self, keys='interactive', size=(800, 600))
self.vertices, self.filled, self.outline = cube()
self.filled_buf = gloo.IndexBuffer(self.filled)
self.outline_buf = gloo.IndexBuffer(self.outline)
self.program = gloo.Program(vert, frag)
self.program.bind(gloo.VertexBuffer(self.vertices))
self.view = translate((0, 0, -5))
self.model = np.eye(4, dtype=np.float32)
gloo.set_viewport(0, 0, self.physical_size[0], self.physical_size[1])
self.projection = perspective(45.0, self.size[0] /
float(self.size[1]), 2.0, 10.0)
self.program['u_projection'] = self.projection
self.program['u_model'] = self.model
self.program['u_view'] = self.view
self.theta = 0
self.phi = 0
gloo.set_clear_color('white')
gloo.set_state('opaque')
gloo.set_polygon_offset(1, 1)
self._timer = app.Timer('auto', connect=self.on_timer, start=True)
self.show()
def draw_color(self):
program = gloo.Program(_color_vertex_code, _color_fragment_code)
program.bind(self.vertex_buffer)
program['u_light_eye_pos'] = [0, 0, 0]
program['u_light_ambient_w'] = self.ambient_weight
program['u_mv'] = _compute_model_view(self.mat_model, self.mat_view)
# program['u_nm'] = compute_normal_matrix(self.model, self.view)
program['u_mvp'] = _compute_model_view_proj(self.mat_model,
self.mat_view,
self.mat_proj)
# Texture where we render the scene
render_tex = gloo.Texture2D(shape=self.shape + (4, ))
# Frame buffer object
fbo = gloo.FrameBuffer(render_tex, gloo.RenderBuffer(self.shape))
with fbo:
gloo.set_state(depth_test=True)
gloo.set_state(cull_face=True)
gloo.set_cull_face('back') # Back-facing polygons will be culled
gloo.set_clear_color(self.bg_color)
gloo.clear(color=True, depth=True)
gloo.set_viewport(0, 0, *self.size)
program.draw('triangles', self.index_buffer)
# Retrieve the contents of the FBO texture
self.rgb = gloo.read_pixels(
(0, 0, self.size[0], self.size[1]))[:, :, :3]
self.rgb = np.copy(self.rgb)
def __init__(self):
app.Canvas.__init__(self, size=(512, 512),
keys='interactive')
self.image = Program(img_vertex, img_fragment, 4)
self.image['position'] = (-1, -1), (-1, +1), (+1, -1), (+1, +1)
self.image['texcoord'] = (0, 0), (0, +1), (+1, 0), (+1, +1)
#self.image['vmin'] = +0.1
#self.image['vmax'] = +0.9
self.image['vmin'] = 0.1
self.image['vmax'] = 1.0
self.image['cmap'] = 1 # Colormap index to use
self.image['colormaps'] = colormaps
self.image['colormaps'].interpolation = 'linear'
self.image['colormaps_shape'] = colormaps.shape[1], colormaps.shape[0]
self.image['image'] = I.astype('float32')
self.image['image'].interpolation = 'linear'
set_clear_color('black')
self.timer = app.Timer(0.25, self.on_timer)
self.timer.start()
self.show()
def draw_distortion(self, *Contexts):
'''Distorter.draw(list_of_drawables)
Draw the drawables to the right and left-eye render buffers,
then apply the distortion and display these buffers to the screen
TODO:
How can we globally handle view?
Should we even bother trying to find the 'right' way to do this?
'''
gloo.set_clear_color('black')
gloo.set_state(depth_test=True)
with self.left_eye:
gloo.clear(color=True, depth=True)
for context in Contexts:
context.translate(0, self.IPD / 2, 0)
context.set_projection(self.L_projection)
context.draw()
with self.right_eye:
gloo.clear(color=True, depth=True)
for context in Contexts:
context.translate(0, -self.IPD / 2, 0)
context.set_projection(self.R_projection)
context.draw()
gloo.clear(color=True, depth=True)
self.left_eye_program.draw('triangles', self.left_eye_indices)
self.right_eye_program.draw('triangles', self.right_eye_indices)
def __init__(self):
app.Canvas.__init__(self, keys='interactive')
self.size = W * 5, H * 5
self.program = gloo.Program(VERT_SHADER, FRAG_SHADER)
self.texture = gloo.Texture3D(I,
interpolation='nearest',
wrapping='clamp_to_edge')
self.program['u_texture'] = self.texture
self.program['i'] = 0.0
self.program.bind(gloo.VertexBuffer(data))
self.view = np.eye(4, dtype=np.float32)
self.model = np.eye(4, dtype=np.float32)
self.projection = np.eye(4, dtype=np.float32)
self.program['u_model'] = self.model
self.program['u_view'] = self.view
self.projection = ortho(0, W, 0, H, -1, 1)
self.program['u_projection'] = self.projection
self.i = 0
gloo.set_clear_color('white')
self._timer = app.Timer('auto', connect=self.on_timer, start=True)
def __init__(self, parent=None):
scene.SceneCanvas.__init__(self, parent=parent)
self.parent = parent
self.has_redrawn = True
self.data = None
self.program = gloo.Program(vert, frag)
self.colormap = ColorMap('colormaps/transform/Seismic.ppm')
self.program_cm = gloo.Program(cm_vert, cm_frag)
#self.
self.line_type = None
self.line_coord = 0
self.line_positions = [(0, 0), (0, 0)]
self.program_line = gloo.Program(basic_vert, basic_frag)
self.program_line['a_position'] = self.line_positions
gloo.set_clear_color((1, 1, 1, 1))
canvas_size = (1000, 800)
graph_size = (900, 700)
margin_x = (canvas_size[0]-graph_size[0]) / 2.
margin_y = (canvas_size[1]-graph_size[1]) / 2.
pos_xax = np.array([[margin_x, canvas_size[1]-margin_y],
[canvas_size[0]-margin_x, canvas_size[1]-margin_y]])
self.axis_x = AxisVisual(pos_xax, (0, 100), (0., 1.))
self.tr_sys = visuals.transforms.TransformSystem(self)
def __init__(self):
app.Canvas.__init__(self,
size=(1024, 1024),
title='Skybox example',
keys='interactive')
self.cubeSize = 10
self.pressed = False
self.azimuth = pi / 2.0
self.elevation = pi / 2.0
self.distanceMin = 1
self.distanceMax = 50
self.distance = 30
self.sensitivity = 5.0
self.view = getView(self.azimuth, self.elevation, self.distance)
self.model = np.eye(4, dtype=np.float32)
self.projection = np.eye(4, dtype=np.float32)
self.program = gloo.Program(vertex_shader, fragment_shader, count=24)
self.program['a_position'] = faces * self.cubeSize
self.program['a_texcoord'] = faces
self.program['a_texture'] = gloo.TextureCube(texture,
interpolation='linear')
self.program['u_model'] = self.model
self.program['u_view'] = self.view
gloo.set_viewport(0, 0, *self.physical_size)
self.projection = perspective(60.0, self.size[0] / float(self.size[1]),
1.0, 100.0)
self.program['u_projection'] = self.projection
gl.glEnable(gl.GL_DEPTH_TEST)
gloo.set_clear_color('black')
self.show()
def __init__(self,):
app.Canvas.__init__(self)
self.size = 800, 600
# fovy, zfar params
self.fovy = 45.0
self.zfar = 10.0
width, height = self.size
self.aspect = width / float(height)
self.program = gloo.Program(vert, frag)
self.view = np.eye(4, dtype=np.float32)
self.model = np.eye(4, dtype=np.float32)
self.projection = np.eye(4, dtype=np.float32)
translate(self.view, 0, 0, -5.0)
self.program['u_model'] = self.model
self.program['u_view'] = self.view
self.theta = 0
self.phi = 0
self.visible = True
self._timer = app.Timer(1.0 / 60)
self._timer.connect(self.on_timer)
self._timer.start()
# ---------------------------------
gloo.set_clear_color((1, 1, 1, 1))
gloo.set_state('opaque')
gloo.set_polygon_offset(1, 1)
def __init__(self):
app.Canvas.__init__(self, keys='interactive', size=((W * 5), (H * 5)))
self.program = gloo.Program(VERT_SHADER, FRAG_SHADER)
self.texture = gloo.Texture2D(I,
interpolation='linear',
internalformat='r32f')
self.program['u_texture'] = self.texture
self.program.bind(gloo.VertexBuffer(data))
self.view = np.eye(4, dtype=np.float32)
self.model = np.eye(4, dtype=np.float32)
self.projection = np.eye(4, dtype=np.float32)
self.program['u_model'] = self.model
self.program['u_view'] = self.view
self.projection = ortho(0, W, 0, H, -1, 1)
self.program['u_projection'] = self.projection
gloo.set_clear_color('white')
self._timer = app.Timer('auto', connect=self.update, start=True)
self.show()
def draw_distortion(self, *Contexts):
'''Distorter.draw(list_of_drawables)
Draw the drawables to the right and left-eye render buffers,
then apply the distortion and display these buffers to the screen
TODO:
How can we globally handle view?
Should we even bother trying to find the 'right' way to do this?
'''
gloo.set_clear_color('black')
gloo.set_state(depth_test=True)
with self.left_eye:
gloo.clear(color=True, depth=True)
for context in Contexts:
context.translate(0, self.IPD / 2, 0)
context.set_projection(self.L_projection)
context.draw()
with self.right_eye:
gloo.clear(color=True, depth=True)
for context in Contexts:
context.translate(0, -self.IPD / 2, 0)
context.set_projection(self.R_projection)
context.draw()
gloo.clear(color=True, depth=True)
self.left_eye_program.draw('triangles', self.left_eye_indices)
self.right_eye_program.draw('triangles', self.right_eye_indices)
def __init__(self,controller, **kwargs):
app.Canvas.__init__(self, **kwargs)
self._controller = controller
self.geometry = 0, 0, 400, 400
self.program = gloo.Program("shaders/raytracingalgo.vertexshader", "shaders/raytracingalgo.fragmentshader")
self.program['a_position'] = [(-1., -1.), (-1., +1.),(+1., -1.), (+1., +1.)]
self.program['sphere_position_0'] = (.75, .1, 1.)
self.program['sphere_radius_0'] = .6
self.program['sphere_color_0'] = (1., 1., 1.)
self.program['sphere_position_1'] = (-.75, .1, 2.25)
self.program['sphere_radius_1'] = .6
self.program['sphere_color_1'] = (1., 1., 1.)
self.program['plane_position'] = (0., -.5, 0.)
self.program['plane_normal'] = (0., 1., 0.)
self.program['light_intensity'] = 1.
self.program['light_specular'] = (1., 50.)
self.program['light_position'] = (5., 5., -10.)
self.program['light_color'] = (1., 1., 1.)
self.program['ambient'] = .05
self.program['O'] = (0., 0., -1.)
gloo.set_clear_color((1, 1, 1, 1))
gloo.set_state(depth_test=True)
#self.program.draw('triangle_strip')
#self.active = True
self._timer = app.Timer('auto', connect=self.timedUpdate, start=True)
self._fps = 1
self._timerfps = 24
self._softFPS = []
def __init__(self, *args, **kwargs):
app.Canvas.__init__(self, *args, **kwargs)
self.program = gloo.Program(self.read_shader('1.vert'), self.read_shader('1.frag'))
# Fill screen with single quad, fragment shader does all the real work
self.program["position"] = [(-1, -1), (-1, 1), (1, 1),
(-1, -1), (1, 1), (1, -1)]
self._starttime = time.time()
self.program['time'] = 0
self.program['cameraPos'] = (0.0, 3.0, -6.0)
self.program['cameraLookat'] = (0.0, -0.85, 0.5)
self.program['lightDir'] = (-1.4, 0.8, -1.0) # needs to be normalized
self.program['lightColour'] = (3.0, 1.4, 0.3)
self.program['diffuse'] = (0.3, 0.3, 0.3)
self.program['ambientFactor'] = 0.35
self.program['rotateWorld'] = 1
# self.program['ao'] = True
# self.program['shadows'] = True
# self.program['antialias'] = False # mutually exclusive with dof
self.apply_zoom()
gloo.set_clear_color(color='black')
self._timer = app.Timer('auto', connect=self.update, start=True)
self.show()
def __init__(self):
app.Canvas.__init__(self, title='Rain [Move mouse]',
size=(512, 512), keys='interactive')
# Build data
# --------------------------------------
n = 500
self.data = np.zeros(n, [('a_position', np.float32, 2),
('a_fg_color', np.float32, 4),
('a_size', np.float32, 1)])
self.index = 0
self.program = Program(vertex, fragment)
self.vdata = VertexBuffer(self.data)
self.program.bind(self.vdata)
self.program['u_antialias'] = 1.00
self.program['u_linewidth'] = 1.00
self.program['u_model'] = np.eye(4, dtype=np.float32)
self.program['u_view'] = np.eye(4, dtype=np.float32)
self.activate_zoom()
gloo.set_clear_color('white')
gloo.set_state(blend=True,
blend_func=('src_alpha', 'one_minus_src_alpha'))
self.timer = app.Timer('auto', self.on_timer, start=True)
self.show()
def __init__(self,):
app.Canvas.__init__(self)
self.size = 800, 600
# fovy, zfar params
self.fovy = 45.0
self.zfar = 10.0
width, height = self.size
self.aspect = width / float(height)
self.program = gloo.Program(vert, frag)
self.model = np.eye(4, dtype=np.float32)
self.projection = np.eye(4, dtype=np.float32)
self.view = translate((0, 0, -5.0))
self.program['u_model'] = self.model
self.program['u_view'] = self.view
self.theta = 0
self.phi = 0
self.visible = True
self._timer = app.Timer(1.0 / 60)
self._timer.connect(self.on_timer)
self._timer.start()
# ---------------------------------
gloo.set_clear_color((1, 1, 1, 1))
gloo.set_state('opaque')
gloo.set_polygon_offset(1, 1)
def __init__(self):
app.Canvas.__init__(self, keys='interactive', size=(800, 600))
self.vertices, self.filled, self.outline = cube()
self.filled_buf = gloo.IndexBuffer(self.filled)
self.outline_buf = gloo.IndexBuffer(self.outline)
self.program = gloo.Program(vert, frag)
self.program.bind(gloo.VertexBuffer(self.vertices))
self.view = translate((0, 0, -5))
self.model = np.eye(4, dtype=np.float32)
gloo.set_viewport(0, 0, self.physical_size[0], self.physical_size[1])
self.projection = perspective(45.0, self.size[0] / float(self.size[1]),
2.0, 10.0)
self.program['u_projection'] = self.projection
self.program['u_model'] = self.model
self.program['u_view'] = self.view
self.theta = 0
self.phi = 0
self.transparency = 1
gloo.set_clear_color((0, 0, 0), 0.1)
gloo.set_state('opaque')
gloo.set_polygon_offset(1, 1)
#self._timer = app.Timer('auto', connect=self.on_timer, start=True) #Siempre poner un timer asi se pone bien la funcion update!! solo en pyglet, en pyqt5 funciona joya!!!
self._monitor = MidiMonitor(connect=self.on_midi)
self.show()
def __init__(self, parent=None):
scene.SceneCanvas.__init__(self, parent=parent)
self.parent = parent
self.has_redrawn = True
self.data = None
self.data_changed = False
self.data_program = gloo.Program(data_vert, data_frag)
path = os.path.dirname(os.path.realpath(__file__))
path = os.path.join(path, 'colormaps/transform/Seismic.npy')
self.colormap = Colormap(path)
self.colorbar_program = gloo.Program(colormap_vert, colormap_frag)
# horizontal / vertical / diagonal
self.line_type = None
# x for a vertical line, y for a horizontal line
self.line_coord = None
# Start and end points for a linecut
self.mouse_start = (0, 0)
self.mouse_end = (0, 0)
self.linecut_program = gloo.Program(linecut_vert, linecut_frag)
self.linecut_program['a_position'] = [self.mouse_start, self.mouse_end]
gloo.set_clear_color((1, 1, 1, 1))
def on_timer(self, event):
# Animation speed based on global time.
t = event.elapsed
c = Color(self.color).rgb
# Simple sinusoid wave animation.
s = abs(0.5 + 0.5 * math.sin(t))
gloo.set_clear_color((c[0] * s, c[1] * s, c[2] * s, 1))
self.update()
def on_timer(self, event):
# Animation speed based on global time.
t = event.elapsed
c = Color(self.color).rgb
# Simple sinusoid wave animation.
s = abs(0.5 + 0.5 * math.sin(t))
gloo.set_clear_color((c[0] * s, c[1] * s, c[2] * s, 1))
self.update()
def __init__(self):
app.Canvas.__init__(self, size=(500, 500), keys='interactive')
self.program = gloo.Program(VERT_SHADER, FRAG_SHADER)
self.program['u_tex1'] = gloo.Texture2D(im1, interpolation='linear')
self.program['u_tex2'] = gloo.Texture2D(im2, interpolation='linear')
self.program.bind(gloo.VertexBuffer(data))
gloo.set_clear_color('white')
def __init__(self,
rows: int = 1,
cols: int = cn.SENSOR_COUNT,
length: int = 100,
program: gloo.Program = None,
show_grid=True,
*args,
**kwargs):
"""
Creates a canvas that displays multiple signals in a grid.
:param rows: Row count in the grid.
:param cols: Column count in the grid.
:param length: Length of a single sequence.
:param program: The gloo program being used.
"""
super().__init__(*args, size=cn.DEFAULT_WINDOW_SIZE, **kwargs)
gloo.set_clear_color((1, 1, 1, 1))
gloo.set_viewport(0, 0, *self.physical_size)
self.native.setMinimumSize(300, 150)
self.rows: int = rows
self.cols: int = cols
self.length: int = length
self.program: gloo.Program = program if program else gloo.Program(
VERTEX_SHADER, FRAGMENT_SHADER)
self.signal_values: np.ndarray = np.empty(0, dtype=np.float32)
self.signal_colors: np.ndarray = np.empty((0, 3), dtype=np.float32)
self.row_col_time_indices: np.ndarray = np.empty((0, 3),
dtype=np.float32)
self._update_program()
self.program['u_scale'] = (1., 1.)
self.program['u_size'] = (rows, cols)
self.program['u_n'] = length
self._timer: app.Timer = app.Timer(connect=self.update, start=True)
self.connect(self.on_close)
self.visuals = []
if show_grid:
for i in range(cols - 1):
self.visuals.append(
InfiniteLineVisual((i + 1) / cols, color=(0, 0, 0, 1)))
for i in range(rows - 1):
self.visuals.append(
InfiniteLineVisual((i + 1) / rows,
vertical=False,
color=(0, 0, 0, 1)))
self.visuals.append(
InfiniteLineVisual(cn.SENSOR_DRAW_COEFFICIENT[0],
vertical=False,
color=(0, 0, 0, 1)))
def on_draw(event):
"""
We create a callback function called when the canvas needs to be refreshed
This on_draw function renders the entire scene.
"""
# First, we clear the window in white
# (it is necessary to do that at every frame)
gloo.set_clear_color((1.0, 1.0, 1.0, 1.0))
gloo.clear()
program.draw('line_strip')
def draw_no_distortion(self, *Contexts):
'''Distorter WITHOUT applying distortion or chromatic aberration corrections
FOR DEBUG
'''
gloo.set_clear_color('black')
gloo.set_state(depth_test=True)
gloo.clear(color=True, depth=True)
for context in Contexts:
context.set_projection(self.L_projection)
context.draw()
def draw_no_distortion(self, *Contexts):
'''Distorter WITHOUT applying distortion or chromatic aberration corrections
FOR DEBUG
'''
gloo.set_clear_color('black')
gloo.set_state(depth_test=True)
gloo.clear(color=True, depth=True)
for context in Contexts:
context.set_projection(self.L_projection)
context.draw()
def __init__(self):
app.Canvas.__init__(self, keys='interactive')
# Create program
self._program = gloo.Program(VERT_SHADER, FRAG_SHADER)
# Set uniform and attribute
self._program['u_color'] = 0.2, 1.0, 0.4, 1
self._program['a_position'] = gloo.VertexBuffer(vPosition)
gloo.set_clear_color('white')
def __init__(self, camera, mesh,
vertex_shader=VERTEX_SHADER_BASIC, fragment_shader=FRAGMENT_SHADER_COLOR,
clip_near=0.001, clip_far=100.0,
background_color=(.0, .0, .0),
ambient_light=0.15, directional_light_vector=[0., 0., 0.]):
"""
Initialize the mesh renderer
:param camera: Camera instance
:param mesh: Mesh containing vertices and faces (e.g. fom PyMesh)
:param vertex_shader: Vertex shader code
:param fragment_shader: Fragment shader code
:param clip_near: Clip-near value (elements closer than this won't be rendered)
:param clip_far: Clip-far value (elements farther than this won't be rendered)
:param background_color: Background color
:param ambient_light: Ambient light factor
:param directional_light_vector: Vector of directional light
"""
# Initialize Vispy canvas:
app.Canvas.__init__(self, show=False, size=camera.image_size)
self.shape = (camera.image_size[1], camera.image_size[0])
self.camera = camera
self.mesh = mesh
self.background_color = background_color
self.ambient_light = ambient_light
self.directional_light_vector = np.asarray(directional_light_vector)
self.clip_near = clip_near
self.clip_far = clip_far
# OpenGL shader program:
self.gl_program = gloo.Program(vertex_shader, fragment_shader)
# Matrix to convert to OpenGL camera system (flipping Y-Z axes):
self.yz_flip = np.eye(4, dtype=np.float32)
self.yz_flip[1, 1], self.yz_flip[2, 2] = -1, -1
# Model matrix (defining the mesh/model pose):
self.model_matrix = np.eye(4, dtype=np.float32)
# Projection matrix:
self.projection_matrix = convert_hz_intrinsic_to_opengl_projection(
camera.K, 0, 0, camera.image_size[0], camera.image_size[1], clip_near, clip_far, True)
# Texture to render the image into:FBO
self.image_texture = gloo.Texture2D(shape=self.shape + (3,))
# Corresponding FBO (frame buffer):
self.fbo = gloo.FrameBuffer(self.image_texture, gloo.RenderBuffer(self.shape))
self.fbo.activate()
# Drawing parameters (face culling, background color, viewport size, etc.):
gloo.set_state(depth_test=True, blend=False, cull_face=False)
gloo.set_clear_color(background_color)
gloo.set_viewport(0, 0, *self.size)
def __init__(self):
""" initialize the canvas """
app.Canvas.__init__(self,
size=(512, 512),
title='SR Voronoi Visualizer',
keys='interactive')
self.tri = 16 # 16 edges for each point
self.shrinkage = width / 2
# define vertices, indices, color
V, I, C = genVIC(pointz, self.tri, color)
self.BarStart = V.shape[0]
# set initial scale and center point
self.centerpos = [0, 0]
self.scale = 1
# hard-coded bar coordinates in the mean time
self.BarCenter = [0.9, -0.9]
self.BarDim = [
barWidth / pix2nm / self.shrinkage, 0.05 / np.sqrt(self.scale)
]
bV, bI, bC = genScaleBar(self.BarDim, self.BarCenter)
bI = bI + self.BarStart
# bind to data
V = np.vstack((V, bV))
I = np.vstack((I, bI))
C = np.vstack((C, bC))
# shader program
tet = gloo.Program(vert=vertex, frag=fragment) #, count=V.shape[0])
self.I = gloo.IndexBuffer(I)
self.V = gloo.VertexBuffer(V)
self.C = gloo.VertexBuffer(C)
tet['a_position'] = self.V
tet['a_color'] = self.C
# intialize transformation matrix
self.view = np.eye(4, dtype=np.float32)
self.model = np.eye(4, dtype=np.float32)
self.projection = np.eye(4, dtype=np.float32)
# set view
self.view = translate((0, 0, -3))
tet['u_model'] = self.model
tet['u_view'] = self.view
tet['u_projection'] = self.projection
# bind program
self.program = tet
# config and set viewport
gloo.set_viewport(0, 0, *self.physical_size)
gloo.set_clear_color('black')
gloo.set_state('opaque')
gloo.set_polygon_offset(1.0, 1.0)
# bind a timer
self.timer = app.Timer('auto', self.on_timer)
self.timer.start()
# show the canvas
self.show()
def on_draw(self, event):
# Image rect
with self.framebuffer:
set_clear_color('gray')
clear(color=True, depth=True)
set_state(depth_test=True)
self.cube.draw('triangle_strip')
set_clear_color('pink')
clear(color=True)
set_state(depth_test=True)
self.quad.draw('triangle_strip')
def __init__(self):
app.Canvas.__init__(self, keys='interactive', title = 'Hydra tracker')
self._program = gloo.Program(VERT_SHADER, FRAG_SHADER)
self._vbo = gloo.VertexBuffer(vertex_data)
self._program['texture1'] = gloo.Texture2D(im1)
self._program.bind(self._vbo)
self._program_lines = gloo.Program(VERT_SHADER, FRAG_SHADER_LINES)
self._program_lines.bind(self._vbo)
gloo.set_clear_color('black')
self._timer = app.Timer('auto', connect=self.update, start=True)
self.show()
def __init__(self):
app.Canvas.__init__(self, keys='interactive')
# Create program
self._program = gloo.Program(VERT_SHADER, FRAG_SHADER)
# Set uniform and attribute
self._program['u_color'] = 0.2, 1.0, 0.4, 1
self._program['a_position'] = gloo.VertexBuffer(vPosition)
gloo.set_clear_color('white')
self.show()
def on_draw(self, event):
# Draw the same scene as as in hello_quad.py, but draw it to the FBO
with self._fbo:
gloo.set_clear_color((0.0, 0.0, 0.5, 1))
gloo.clear(color=True, depth=True)
gloo.set_viewport(0, 0, *self.size)
self._program1.draw('triangle_strip')
# Now draw result to a full-screen quad
# Init
gloo.set_clear_color('white')
gloo.clear(color=True, depth=True)
self._program2.draw('triangle_strip')
def on_draw(self, event):
""" canvas update callback """
gloo.set_clear_color((0.0, 0.0, 0.0, 1.0))
gloo.clear()
# Filled cube
gloo.set_state(blend=True, depth_test=True, polygon_offset_fill=True)
self.program['u_color'] = [1.0, 1.0, 1.0, 0.8]
self.program.draw('triangles', self.F)
# draw outline
gloo.set_state(blend=True, depth_test=True, polygon_offset_fill=True)
self.program['u_color'] = [1.0, 1.0, 1.0, 1.0]
self.program.draw('lines', self.E)
def on_draw(self, event):
# Draw the same scene as as in hello_quad.py, but draw it to the FBO
with self._fbo:
gloo.set_clear_color((0.0, 0.0, 0.5, 1))
gloo.clear(color=True, depth=True)
gloo.set_viewport(0, 0, *self.size)
self._program1.draw('triangle_strip')
# Now draw result to a full-screen quad
# Init
gloo.set_clear_color('white')
gloo.clear(color=True, depth=True)
self._program2.draw('triangle_strip')
def __init__(self, data, theta=30.0, phi=90.0, z=6.0):
""" initialize data for plotting
Parameters
----------
data : array_like
3D data, Nx3
theta : float
rotation around y axis
phi : float
rotation around z axis
z : float
view depth
"""
app.Canvas.__init__(self,
size=(800, 400),
title='plot3d',
keys='interactive')
# build shader program
program = gloo.Program(vert=vertex, frag=fragment)
# initialize 3D view
view = np.eye(4, dtype=np.float32)
model = np.eye(4, dtype=np.float32)
projection = np.eye(4, dtype=np.float32)
# update program
program['u_model'] = model
program['u_view'] = view
program['u_projection'] = projection
program['a_position'] = data
# bind
self.program = program
self.theta = theta
self.phi = phi
self.z = z
# config
gloo.set_viewport(0, 0, *self.physical_size)
gloo.set_clear_color('white')
gloo.set_state('translucent')
# config your lines
gloo.set_line_width(2.0)
# show the canvas
self.show()
def __init__(self):
app.Canvas.__init__(self, keys='interactive', size=(800, 600))
rospy.init_node('imu_visualizer')
# assert_node_alive('torso_arduino')
rospy.Subscriber('imu/data_raw', Imu, self.on_imu)
# Cleanup when termniating the node
rospy.on_shutdown(self.shutdown)
self.vertices, self.filled, self.outline = cube()
self.filled_buf = gloo.IndexBuffer(self.filled)
self.outline_buf = gloo.IndexBuffer(self.outline)
self.program = gloo.Program(vert, frag)
self.program.bind(gloo.VertexBuffer(self.vertices))
self.view = translate((0, 0, -5))
self.model = np.eye(4, dtype=np.float32)
gloo.set_viewport(0, 0, self.physical_size[0], self.physical_size[1])
self.projection = perspective(45.0, self.size[0] / float(self.size[1]),
2.0, 10.0)
self.program['u_projection'] = self.projection
self.program['u_model'] = self.model
self.program['u_view'] = self.view
self.yaw = 0 # yaw
self.roll = 0 # roll
self.pitch = 0 # pitch
gloo.set_clear_color('white')
# gloo.set_clear_color('black')
gloo.set_state('opaque')
gloo.set_polygon_offset(1, 1)
self.first = True
self.yaw0 = None
self._timer = app.Timer('auto', connect=self.on_timer, start=True)
self.show()
app.run()
rospy.signal_shutdown("Shutting done.")
self.shutdown()
print('Node shutdown.')
def __init__(self, data, theta=30.0, phi=90.0, z=6.0):
""" initialize data for plotting
Parameters
----------
data : array_like
3D data, Nx3
theta : float
rotation around y axis
phi : float
rotation around z axis
z : float
view depth
"""
app.Canvas.__init__(self,
size=(800, 400),
title='plot3d',
keys='interactive')
# build shader program
program = gloo.Program(vert=vertex, frag=fragment)
# initialize 3D view
view = np.eye(4, dtype=np.float32)
model = np.eye(4, dtype=np.float32)
projection = np.eye(4, dtype=np.float32)
# update program
program['u_model'] = model
program['u_view'] = view
program['u_projection'] = projection
program['a_position'] = data
# bind
self.program = program
self.theta = theta
self.phi = phi
self.z = z
# config
gloo.set_viewport(0, 0, *self.physical_size)
gloo.set_clear_color('white')
gloo.set_state('translucent')
# config your lines
gloo.set_line_width(2.0)
# show the canvas
self.show()
def on_draw(self, event):
# draw scene to FBO instead of output buffer
with self._fbo:
gloo.set_clear_color('black')
gloo.clear(color=True, depth=True)
gloo.set_viewport(0,0, *self.size)
# render each of the modules
for module in self.renderList:
if(module.rendering): # make sure it's ready
module.program.draw('triangle_strip') # draw the module
# draw to full screen
# gloo.set_clear_color('black')
gloo.clear(color=True,depth=True)
#self.left_eye_program_draw('triangles', self.left_eye_indices)
self._program2.draw('triangle_strip')
def __init__(self, V, C, I, E,
figsize=(512, 512), title='tetplot'):
""" initialize the canvas """
app.Canvas.__init__(self, size=figsize, title=title,
keys='interactive')
# shader program
tet = gloo.Program(vert=vertex, frag=fragment)
# bind to data
tet['a_position'] = V
tet['a_color'] = C
self.I = gloo.IndexBuffer(I)
self.E = gloo.IndexBuffer(E)
# intialize transformation matrix
view = np.eye(4, dtype=np.float32)
model = np.eye(4, dtype=np.float32)
projection = np.eye(4, dtype=np.float32)
tet['u_model'] = model
tet['u_view'] = view
tet['u_projection'] = projection
# bind your program
self.program = tet
# config and set viewport
gloo.set_viewport(0, 0, *self.physical_size)
gloo.set_clear_color('white')
gloo.set_state('translucent')
gloo.set_polygon_offset(0.0, 0.0)
# update parameters
self.theta = 0.0
self.phi = 0.0
self.z = 5.0
# bind a timer
self.timer = app.Timer('auto', self.on_timer)
self.timer.start()
# control plots
gloo.set_line_width(1.0)
# show the canvas
self.show()
def __init__(self):
app.Canvas.__init__(self, show=True, size=(512, 512),
keys='interactive')
self.image = Program(img_vertex, img_fragment, 4)
self.image['position'] = (-1, -1), (-1, +1), (+1, -1), (+1, +1)
self.image['texcoord'] = (0, 0), (0, +1), (+1, 0), (+1, +1)
self.image['vmin'] = +0.1
self.image['vmax'] = +0.9
self.image['cmap'] = 0 # Colormap index to use
self.image['colormaps'] = colormaps
self.image['colormaps'].interpolation = 'linear'
self.image['colormaps_shape'] = colormaps.shape[1], colormaps.shape[0]
self.image['image'] = I.astype('float32')
self.image['image'].interpolation = 'linear'
set_clear_color('black')
def on_initialize(self, event):
# Build data
# --------------------------------------
n = 500
self.data = np.zeros(n, [('a_position', np.float32, 2),
('a_fg_color', np.float32, 4),
('a_size', np.float32, 1)])
self.index = 0
self.program = Program(vertex, fragment)
self.vdata = VertexBuffer(self.data)
self.program.bind(self.vdata)
self.program['u_antialias'] = 1.00
self.program['u_linewidth'] = 1.00
self.program['u_model'] = np.eye(4, dtype=np.float32)
self.program['u_view'] = np.eye(4, dtype=np.float32)
gloo.set_clear_color('white')
gloo.set_state(blend=True,
blend_func=('src_alpha', 'one_minus_src_alpha'))
self.timer = app.Timer('auto', self.on_timer, start=True)
def __init__(self, *args, **kwargs):
app.Canvas.__init__(self, *args, **kwargs)
self.program = gloo.Program(self.read_shader('1.vert'), self.read_shader('skeleton_video.frag'))
# Fill screen with single quad, fragment shader does all the real work
self.program["position"] = [(-1, -1), (-1, 1), (1, 1),
(-1, -1), (1, 1), (1, -1)]
self.program["frame"] = gloo.Texture2D(shape=(480, 640, 2), format='luminance_alpha')
width, height = self.physical_size
gloo.set_viewport(0, 0, width, height)
self.program['resolution'] = [width, height]
openni2.initialize()
nite2.initialize()
self.user_tracker = nite2.UserTracker(False)
gloo.set_clear_color(color='black')
self._timer = app.Timer('auto', connect=self.update, start=True)
self.show()
def __init__(self, **kwargs):
app.Canvas.__init__(self, **kwargs)
self.geometry = 0, 0, 400, 400
self.program = gloo.Program(VERT_CODE, FRAG_CODE)
# Set attributes
self.program['a_position'] = gloo.VertexBuffer(positions)
self.program['a_texcoord'] = gloo.VertexBuffer(texcoords)
self.program['u_texture'] = gloo.Texture2D(load_crate())
# Handle transformations
self.init_transforms()
gloo.set_clear_color((1, 1, 1, 1))
gloo.set_state(depth_test=True)
self._timer = app.Timer('auto', connect=self.update_transforms)
self._timer.start()
def __init__(self):
app.Canvas.__init__(self, keys='interactive')
# Create program
self._program = gloo.Program(VERT_SHADER, FRAG_SHADER)
# Create vertex buffer
self._vbo = gloo.VertexBuffer(vertex_data)
# Set uniforms, samplers, attributes
# We create one VBO with all vertex data (array of structures)
# and create two views from it for the attributes.
self._program['texture1'] = gloo.Texture2D(im1)
self._program.bind(self._vbo) # This does:
#self._program['a_position'] = self._vbo['a_position']
#self._program['a_texcoords'] = self._vbo['a_texcoords']
gloo.set_clear_color('white')
self._timer = app.Timer('auto', connect=self.update, start=True)
