def __init__(self, size=(1600, 900), no_distort=False):
'''Distorter object: Applies distortion to Contexts and drawables
- size (X, Y): Size of monitor
- distortion (Bool): Apply distortion or not?
'''
self.size = size
self.left_eye_tex = gloo.Texture2D(shape=(4096, 4096) + (3, ))
self.right_eye_tex = gloo.Texture2D(shape=(4096, 4096) + (3, ))
self.left_eye = gloo.FrameBuffer(self.left_eye_tex,
gloo.RenderBuffer(self.size))
self.right_eye = gloo.FrameBuffer(self.right_eye_tex,
gloo.RenderBuffer(self.size))
self.left_eye_program, self.left_eye_indices = Mesh.make_eye(
self.left_eye_tex, 'left')
self.right_eye_program, self.right_eye_indices = Mesh.make_eye(
self.right_eye_tex, 'right')
self.IPD = 0.0647 # Interpupilary distance in m
# Male: 64.7 mm
# Female: 62.3 mm
self.L_projection = parameters.projection_left.T
self.R_projection = parameters.projection_right.T
self.no_distort = no_distort
if self.no_distort:
self.projection = perspective(30.0, 1920 / float(1080), 2.0, 10.0)
self.draw = self.draw_no_distortion
else:
self.draw = self.draw_distortion
def init_BufX(self):
# Create texture to render to
# Create FBO, attach the color buffer and depth buffer
self._texX = []
self._fboX = []
self._BufX = []
self._texX.append([])
self._fboX.append([])
self._texX.append([])
self._fboX.append([])
for i in range(4):
self._texX[0].append(
gloo.Texture2D(shape=self._render_size[::-1] + (4, ),
format='rgba',
interpolation='linear',
wrapping='repeat',
internalformat='rgba32f'))
self._fboX[0].append(
gloo.FrameBuffer(
self._texX[0][i],
gloo.RenderBuffer(shape=self._render_size[::-1])))
self._texX[1].append(
gloo.Texture2D(shape=self._render_size[::-1] + (4, ),
format='rgba',
interpolation='linear',
wrapping='repeat',
internalformat='rgba32f'))
self._fboX[1].append(
gloo.FrameBuffer(
self._texX[1][i],
gloo.RenderBuffer(shape=self._render_size[::-1])))
self._BufX.append(
gloo.Program(vertex, fragment_template % error_shader))
def test_buffer(self):
# Some data that we need
data = np.zeros(100, np.uint16)
im2 = np.zeros((50, 50), np.uint16)
im3 = np.zeros((20, 20, 20), np.uint16)
shaders = gloo.VertexShader("x"), gloo.FragmentShader("x")
items = [
# Buffers
(gloo.buffer.Buffer(target=gl.GL_ARRAY_BUFFER), 'set_data', data),
(gloo.buffer.VertexBuffer(np.uint16), 'set_data', data),
(gloo.buffer.ElementBuffer(np.uint16), 'set_data', data),
# Textures
(gloo.Texture2D(), 'set_data', im2),
(gloo.Texture3D(), 'set_data', im3),
# FBO stuff
(gloo.RenderBuffer(), 'set_shape', (1, 1)),
(gloo.FrameBuffer(), 'attach_color', gloo.RenderBuffer((1, 1))),
# Shader stuff
(gloo.VertexShader(), 'set_code', "x"),
(gloo.FragmentShader(), 'set_code', "x"),
(gloo.Program(), 'attach', shaders),
]
for ob, funcname, value in items:
self._fix_ob(ob)
#print('Testing GLObject compliance for %s' % ob.__class__.__name__)
# Initially a clear state
self.assertEqual(ob._need_update, False)
# Set value, now we should have a "dirty" state
x = ob
for part in funcname.split('.'):
x = getattr(x, part)
x(value)
self.assertEqual(ob._need_update, True)
# Activate the object
ob.activate()
# Now we should be activated
self.assertEqual(len(ob._actions), 3)
self.assertEqual(ob._actions[0], 'create')
self.assertEqual(ob._actions.count('update'), 1)
self.assertEqual(ob._actions.count('activate'), 1)
# Deactivate
ob.deactivate()
# Now we should be deactivated
self.assertEqual(len(ob._actions), 4)
self.assertEqual(ob._actions[-1], 'deactivate')
# Activate some more
for i in range(10):
ob.activate()
# Create and update should not have been called
self.assertEqual(ob._actions.count('create'), 1)
self.assertEqual(ob._actions.count('update'), 1)
def __init__(self, canvas=None, _protocol=None):
if canvas is None:
canvas = gloo.context.FakeCanvas()
self.canvas: app.Canvas = canvas
self.parameters: Dict[str, Any] = dict()
self.custom_programs: Dict[str, gloo.Program] = dict()
self.data_appendix: Dict[str, Any] = dict()
self.transform_uniforms = dict()
self.protocol: protocol.AbstractProtocol = _protocol
self._buffer_shape = (calib.CALIB_DISP_WIN_SIZE_HEIGHT,
calib.CALIB_DISP_WIN_SIZE_WIDTH)
self._out_texture = gloo.Texture2D(self._buffer_shape + (3, ),
format='rgb')
self._out_fb = gloo.FrameBuffer(self._out_texture)
self.frame = self._out_fb
# Create display program: renders the out texture from FB to screen
self.square = [[-1, -1], [-1, 1], [1, -1], [1, 1]]
self._display_prog = gloo.Program(self._vertex_display,
self._frag_display,
count=4)
self._display_prog['a_position'] = self.square
self._display_prog['u_texture'] = self._out_texture
# Get all visual parameters
self.static_parameters: List[Parameter] = []
self.variable_parameters: List[Parameter] = []
self.trigger_functions: List[Callable] = []
self._collect_parameters()
self.is_active = True
gloo.set_state(depth_test=True)
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 cubemap_to_dual_paraboloid(cube_faces):
_, height, width, n_channels = cube_faces.shape
height, width = height * 2, width * 2
internal_format = 'rgba32f' if n_channels == 4 else 'rgb32f'
with ContextProvider((height, width)):
rendtex = gloo.Texture2D((height, width, n_channels),
interpolation='linear',
wrapping='repeat',
internalformat=internal_format)
framebuffer = gloo.FrameBuffer(
rendtex, gloo.RenderBuffer((width, height, n_channels)))
program = CubemapToDualParaboloidProgram().compile()
program['u_cubemap'] = gloo.TextureCubeMap(
cube_faces, internalformat=internal_format, mipmap_levels=8)
results = []
for i in [0, 1]:
with framebuffer:
gloo.set_viewport(0, 0, width, height)
program['u_hemisphere'] = i
program.draw(gl.GL_TRIANGLE_STRIP)
results.append(
np.flipud(
gloo.read_pixels(out_type=np.float32, format='rgb')))
return results[0], results[1]
def __init__(self, size, num_points: int, center, color, radius):
'''[summary]
Arguments:
size {[type]} -- size of the rendered image
num_points {int} -- number of valid depth values
center {[type]} -- the (x, y) coordinate of each valid depth value
color {[type]} -- encode the 16bit depth value to (R, G) channels, corresponding to 'center'
'''
# We hide the canvas upon creation.
app.Canvas.__init__(self, show=False, size=size)
self._t0 = time()
# Texture where we render the scene.
self._rendertex = gloo.Texture2D(shape=size[::-1] + (4, ))
# FBO.
self._fbo = gloo.FrameBuffer(self._rendertex,
gloo.RenderBuffer(size[::-1]))
# Regular program that will be rendered to the FBO.
V = np.zeros(num_points, [("center", np.float32, 2),
("color", np.float32, 3),
("radius", np.float32, 1)])
V["center"] = center
V["color"] = color
V["radius"] = radius
self.program = gloo.Program(vertex, fragment)
self.program.bind(gloo.VertexBuffer(V))
self.program['resolution'] = self.size
# We manually draw the hidden canvas.
self.update()
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,
program,
rview=1,
zview=None,
zoom_speed=0.1,
move_speed=0.01,
*args,
**kwargs):
""" Constructor
"""
InteractiveViewportMixin.__init__(self, rview, zview, zoom_speed,
move_speed)
Canvas.__init__(self, *args, **kwargs)
#
self._program = program
self._program.set_projection_matrix(self.get_projection_matrix())
self._program.set_view_matrix(self.get_view_matrix())
# Set up framebuffer
width, height = self.physical_size
shape = (height, width, 3)
rendertex = gloo.Texture2D(shape)
self._fbo = gloo.FrameBuffer(rendertex, gloo.RenderBuffer(shape))
self._display_program = TextureDisplayShader(rendertex)
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 render(self, region=None, size=None, bgcolor=None, crop=None):
self.set_current()
# Set up a framebuffer to render to
offset = (0, 0) if region is None else region[:2]
csize = self.size if region is None else region[2:]
s = self.pixel_scale
size = tuple([x * s for x in csize]) if size is None else size
fbo = gloo.FrameBuffer(color=gloo.RenderBuffer(size[::-1]),
depth=gloo.RenderBuffer(size[::-1]))
self.push_fbo(fbo, offset, csize)
try:
if crop is None:
h, w = fbo.color_buffer.shape[:2]
crop = (0, 0, w, h)
self._draw_scene(bgcolor=bgcolor)
color = read_pixels(crop, mode='color', out_type='unsigned_byte')
depth = read_pixels(crop, mode='depth', out_type='float')
return color, depth
finally:
self.pop_fbo()
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 draw_segmentation(self):
program = gloo.Program(_segmentation_vertex_code,
_segmentation_fragment_code)
# 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))
self.do_render(program, fbo, self.retrieve_segmentation)
def __init__(self, size=(960, 540)):
app.Canvas.__init__(self, show=False, size=size)
self._t0 = time()
self._rendertex = gloo.Texture2D(shape=self.size[::-1] + (4, ))
self._fbo = gloo.FrameBuffer(self._rendertex,
gloo.RenderBuffer(self.size[::-1]))
self.program = gloo.Program(vertex, fragment)
def draw_color(self):
program = gloo.Program(_color_vertex_code, _color_fragment_code)
program['u_light_eye_pos'] = [0, 0, 0]
program['u_light_ambient_w'] = self.ambient_weight
# 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))
self.do_render(program, fbo, self.retrieve_color)
def __init__(self, *args, **kwargs):
AbstractVisual.__init__(self, *args, **kwargs)
# Create mask model
self._mask_model = sphere.UVSphere(azim_lvls=50,
elev_lvls=50,
azimuth_range=np.pi / 2,
upper_elev=np.pi / 4,
radius=1.0)
self._mask_position_buffer = gloo.VertexBuffer(
self._mask_model.a_position)
self._mask_index_buffer = gloo.IndexBuffer(self._mask_model.indices)
# Set textures and FBs
self._mask_texture = gloo.Texture2D(self._buffer_shape + (3, ),
format='rgb')
self._mask_depth_buffer = gloo.RenderBuffer(self._buffer_shape)
self._mask_fb = gloo.FrameBuffer(self._mask_texture,
self._mask_depth_buffer)
self._raw_texture = gloo.Texture2D(self._buffer_shape + (3, ),
format='rgb')
self._raw_depth_buffer = gloo.RenderBuffer(self._buffer_shape)
self._raw_fb = gloo.FrameBuffer(self._raw_texture,
self._raw_depth_buffer)
self._display_texture = gloo.Texture2D(self._buffer_shape + (3, ),
format='rgb')
self._display_fb = gloo.FrameBuffer(self._display_texture)
# Create mask program: renders binary mask of quarter-sphere to FB
sphere_vert = self.parse_vertex_shader(self._sphere_vert)
self._mask_program = gloo.Program(sphere_vert, self._mask_frag)
self._mask_program['a_position'] = self._mask_position_buffer
# Create out program: renders the output texture to FB
# by combining raw and mask textures
# (to be saved and re-rendered in display program)
# square = [[-1, -1], [-1, 1], [1, -1], [1, 1]]
self._out_prog = gloo.Program(self._out_vert, self._out_frag, count=4)
self._out_prog['a_position'] = self.square
self._out_prog['u_raw_texture'] = self._raw_texture
self._out_prog['u_mask_texture'] = self._mask_texture
self._out_prog['u_out_texture'] = self._out_texture
def create_rend_target(size):
shape = (size[1], size[0])
rendtex = gloo.Texture2D((*shape, 4),
interpolation='linear',
internalformat='rgba32f')
depthtex = gloo.Texture2D((*shape, 1),
format='depth_component',
internalformat='depth_component32_oes')
framebuffer = gloo.FrameBuffer(rendtex, depthtex)
return framebuffer, rendtex, depthtex
def draw_obj_coords(self):
program = gloo.Program(_obj_coords_vertex_code,
_obj_coords_fragment_code)
# 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))
self.do_render(program, fbo, self.retrieve_obj_coords)
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 generate_image(img_def):
c = context.FakeCanvas()
img = _load_img(img_def['background']['path'])
h, w, _ = img.shape
render_fbo = gloo.FrameBuffer(gloo.Texture2D(img), gloo.RenderBuffer(
(h, w)))
program = gloo.Program(_vert_std, _frag_tex)
program['a_pos'] = _unit_square()
program['a_tex_coord'] = _unit_square()
gloo.set_state(blend=True,
blend_func=('one', 'one_minus_src_alpha'),
depth_test=True,
depth_func='always')
with render_fbo:
gloo.set_viewport(0, 0, w, h)
gloo.set_clear_depth(0)
gloo.clear(depth=True, color=False)
instances = img_def['instances']
# The unsigned byte depth buffer extraction sets a limit of 255 instances.
# Can be extracted as short if necessary.
assert (len(instances) <= 255)
for i, inst in enumerate(instances):
img = _load_img(inst['path'])
ih, iw, _ = img.shape
x, y, s, r = (inst[k] for k in ['x', 'y', 's', 'r'])
program['u_tex'] = gloo.Texture2D(img, interpolation='linear')
program['u_mvp'] = \
transforms.translate((-0.5, -0.5, 0)) @ \
transforms.scale((s * iw, s * ih, 1)) @ \
transforms.rotate(r, (0, 0, 1)) @ \
transforms.translate((x, y, -i-1)) @ \
transforms.ortho(0, w, 0, h, 0, 255)
program.draw()
rgb = render_fbo.read(alpha=False)
depth = gl.glReadPixels(0, 0, w, h, gl.GL_DEPTH_COMPONENT,
gl.GL_UNSIGNED_BYTE)
if not isinstance(depth, np.ndarray):
depth = np.frombuffer(depth, np.uint8)
depth = np.flip(depth.reshape(h, w), axis=0)
masks = np.empty((h, w, len(instances)), np.bool)
for i in range(len(instances)):
masks[:, :, i] = depth == i + 1
return rgb, depth, masks
def render(self, size=(400, 400)):
self.set_current()
fbo = gloo.FrameBuffer(color=gloo.RenderBuffer(size[::-1]),
depth=gloo.RenderBuffer(size[::-1]))
try:
self.update_resolution(size)
fbo.activate()
self.program.draw()
return fbo.read()
finally:
fbo.deactivate()
self.update_resolution()
def __init__(self, im, conf, roi, logger):
vispy.set_log_level('DEBUG')
try:
vispy.use(app='glfw', gl='gl+')
except RuntimeError as e:
pass
app.Canvas.__init__(self,
keys = 'interactive',
size = (conf['ipmWidth'], conf['ipmHeight']),
position = (0,0),
title = 'IPM',
show = False,
resizable = False)
self._rendertex = gloo.Texture2D(shape=(self.size[1], self.size[0], 4))
self._fbo = gloo.FrameBuffer(self._rendertex,
gloo.RenderBuffer((self.size[1], self.size[0])))
try:
fragmentShaderSourceString = open(FRAGMENT_SHADER_FILENAME).read()
except:
logger.fatal("%s does not exist !", FRAGMENT_SHADER_FILENAME)
sys.exit()
try:
vertexShaderSourceString = open(VERTEX_SHADER_FILENAME).read()
except:
logger.fatal("%s does not exist !", VERTEX_SHADER_FILENAME)
sys.exit()
self.program = gloo.Program(vertexShaderSourceString, fragmentShaderSourceString)
self.program["position"] = [(-1, -1), (-1, 1), (1, 1), (-1, -1), (1, 1), (1, -1)]
gloo.set_viewport(0, 0, *self.size)
tex = gloo.Texture2D(im)
tex.interpolation = 'linear'
tex.wrapping = 'repeat'
self.program['iChannel'] = tex
if len(im.shape) == 3:
self.program['iChannelResolution'] = (im.shape[1], im.shape[0], im.shape[2])
else:
self.program['iChannelResolution'] = (im.shape[1], im.shape[0], 1)
self.program['iResolution'] = (self.size[0], self.size[1], 0.)
self.getUniforms(conf, roi)
self.update()
app.run()
return self
def __init__(self,
size=(512, 512),
save_png=False,
compression=0,
layer_cls=VispyLayer,
**kwargs):
app.Canvas.__init__(self, size=size, **kwargs)
Renderer.__init__(self,
size=size,
save_png=save_png,
compression=compression,
layer_cls=layer_cls)
self._rendertex = gloo.Texture2D(shape=self._size + (4, ))
self._fbo = gloo.FrameBuffer(self._rendertex,
gloo.RenderBuffer(self._size))
def __init__(self, mesh, color, size):
# We hide the canvas upon creation.
app.Canvas.__init__(self, show=False, size=size)
self._t0 = time()
# Texture where we render the scene.
self._rendertex = gloo.Texture2D(shape=self.size[::-1] + (4, ),
internalformat='rgba32f')
# FBO.
self._fbo = gloo.FrameBuffer(self._rendertex,
gloo.RenderBuffer(self.size[::-1]))
# Regular program that will be rendered to the FBO.
self.program = gloo.Program(vertex_shader, fragment_shader)
self.program["position"] = mesh
self.program['color'] = color
# We manually draw the hidden canvas.
self.update()
def __init__(self, size, near, far, camera, *args, **kwargs):
super().__init__(size=size, *args, **kwargs)
gloo.set_state(depth_test=True)
gloo.set_viewport(0, 0, *self.size)
self.program = None
self.size = size
self.far = far
self.near = near
# Buffer shapes are HxW, not WxH...
self._rendertex = gloo.Texture2D(shape=(size[1], size[0]) + (4, ))
self._fbo = gloo.FrameBuffer(
self._rendertex, gloo.RenderBuffer(shape=(size[1], size[0])))
self.camera = camera
self.model_mat = np.eye(4)
self.mesh = None
def __init__(self, size=(600, 600)):
# We hide the canvas upon creation.
app.Canvas.__init__(self, show=False, size=size)
self._t0 = time()
# Texture where we render the scene.
self._rendertex = gloo.Texture2D(shape=self.size + (4,))
# FBO.
self._fbo = gloo.FrameBuffer(self._rendertex,
gloo.RenderBuffer(self.size))
# Regular program that will be rendered to the FBO.
self.program = gloo.Program(vertex, fragment)
self.program["position"] = [(-1, -1), (-1, 1), (1, 1),
(-1, -1), (1, 1), (1, -1)]
self.program["scale"] = 3
self.program["center"] = [-0.5, 0]
self.program["iter"] = 300
self.program['resolution'] = self.size
# We manually draw the hidden canvas.
self.update()
def __init__(self, title, width=800, height=600, wireframe=False, pixel_scale=1.0 ):
app.Canvas.__init__(self, resizable=False, size=(width, height), show=False, px_scale=pixel_scale )
self.width = width
self.height = height
self.wireframe = wireframe
self._rendertex = gloo.Texture2D(shape=(height,width,4), internalformat="rgba32f")
#self._rendertex = gloo.Texture2D(shape=(height,width,4), internalformat="rgba8")
self._fbo = gloo.FrameBuffer(self._rendertex,
gloo.RenderBuffer((height,width,4) ))
self.quad_bg = gloo.Program(vertex_bg, fragment_bg, count=4)
self.quad_bg['position'] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.quad_bg['texcoord'] = [(0, 1), (0, 0), (1, 1), (1, 0)]
gloo.set_clear_color('white')
self.update()
def __init__(self):
app.Canvas.__init__(self, keys='interactive')
self.size = 560, 420
# Create texture to render to
shape = self.size[1], self.size[0]
self._rendertex = gloo.Texture2D((shape + (3, )))
# Create FBO, attach the color buffer and depth buffer
self._fbo = gloo.FrameBuffer(self._rendertex, gloo.RenderBuffer(shape))
# Create program to render a shape
self._program1 = gloo.Program(VERT_SHADER1, FRAG_SHADER1)
self._program1['u_color'] = 0.9, 1.0, 0.4, 1
self._program1['a_position'] = gloo.VertexBuffer(vPosition)
# Create program to render FBO result
self._program2 = gloo.Program(VERT_SHADER2, FRAG_SHADER2)
self._program2['a_position'] = gloo.VertexBuffer(vPosition)
self._program2['a_texcoord'] = gloo.VertexBuffer(vTexcoord)
self._program2['u_texture1'] = self._rendertex
def __init__(self):
app.Canvas.__init__(self)
self.size = 560, 420
# Create texture to render to
self._rendertex = gloo.Texture2D()
# Create FBO, attach the color buffer and depth buffer
self._fbo = gloo.FrameBuffer(self._rendertex, gloo.RenderBuffer())
# Create program to render a shape
self._program1 = gloo.Program( gloo.VertexShader(VERT_SHADER1),
gloo.FragmentShader(FRAG_SHADER1) )
self._program1['u_color'] = 0.9, 1.0, 0.4, 1
self._program1['a_position'] = gloo.VertexBuffer(vPosition)
# Create program to render FBO result
self._program2 = gloo.Program( gloo.VertexShader(VERT_SHADER2),
gloo.FragmentShader(FRAG_SHADER2) )
self._program2['a_position'] = gloo.VertexBuffer(vPosition)
self._program2['a_texcoord'] = gloo.VertexBuffer(vTexcoord)
self._program2['u_texture1'] = self._rendertex
def __init__(self):
app.Canvas.__init__(self)
# Create program
self._program = gloo.Program(VERT_SHADER, FRAG_SHADER)
# Creat FBO
self._fbo = gloo.FrameBuffer()
self._fbo.attach_depth(gloo.RenderBuffer(im1.shape))
# Create vbo
self._vbo = gloo.VertexBuffer(vertex_data)
# Create textures
self._tex1 = gloo.Texture2D(im1)
self._tex2 = gloo.Texture2D(im1.shape)
for tex in (self._tex1, self._tex2):
tex.set_filter('NEAREST', 'NEAREST')
# Set uniforms and attributes
self._program.set_vars(self._vbo)
self._program['u_texsize'] = im1.shape[1], im1.shape[0]
