def __init__(self,
n_volume_max=10,
threshold=None,
relative_step_size=0.8,
emulate_texture=False):
Visual.__init__(self)
self._n_volume_max = n_volume_max
# Only show back faces of cuboid. This is required because if we are
# inside the volume, then the front faces are outside of the clipping
# box and will not be drawn.
self.set_gl_state('translucent', cull_face=False)
tex_cls = TextureEmulated3D if emulate_texture else Texture3D
# Storage of information of volume
self._initial_shape = True
self._vol_shape = ()
self._vertex_cache_id = ()
self._clim = None
# Create gloo objects
self._vbo = None
self._tex = tex_cls((10, 10, 10),
interpolation='linear',
wrapping='clamp_to_edge')
# Set custom vertex shader
vert_shader, frag_shader = get_shaders(n_volume_max)
frag_dict['additive_multi_volume'] = frag_shader
# Create program
self._program = ModularProgram(vert_shader)
self.textures = []
for i in range(n_volume_max):
self.textures.append(
tex_cls((10, 10, 10),
interpolation='linear',
wrapping='clamp_to_edge'))
self._program['u_volumetex_{0}'.format(i)] = self.textures[i]
self._index_buffer = None
# Set params
self.method = 'additive_multi_volume'
self.relative_step_size = relative_step_size
for i in range(n_volume_max):
self._program.frag['cmap{0:d}'.format(i)] = Function(
get_colormap('grays').glsl_map)
self._program['u_enabled_{0}'.format(i)] = 0
self._program['u_weight_{0}'.format(i)] = 1
self.xd = None
self._block_size = None
self.volumes = {}
self._create_vertex_data()
def __init__(self, pos=None, color=None, size=None):
Visual.__init__(self, self.VERTEX_SHADER, self.FRAGMENT_SHADER)
self._pos = pos
self._color = color
self._size = size
self.set_gl_state(blend=True,
blend_func=('src_alpha', 'one_minus_src_alpha'))
self._draw_mode = 'points'
def __init__(self,
points,
simplices,
vertex_color=None,
mask_color=None,
alpha=1.0,
mode='triangles'):
""" initialize tetrahedra face plot
Parameters
----------
points : NDArray of float32
N x 3 points coordinates
simplices : NDArray of uint32
N x 4 connectivity matrix
Note
----
initialize triangles structure
"""
Visual.__init__(self, vcode=vert, fcode=frag)
# set data
self.shared_program.vert['position'] = gloo.VertexBuffer(points)
if vertex_color is None:
vertex_color = np.ones((points.shape[0], 4), dtype=np.float32)
else:
assert vertex_color.shape[0] == points.shape[0]
# vertex color may be grayscale
if np.ndim(vertex_color) == 1:
f = vertex_color[:, np.newaxis]
v = np.repeat(f, 4, axis=1)
v[:, -1] = 1.0
vertex_color = v.astype(np.float32)
self.shared_program['a_color'] = vertex_color
# mask colors, alpha channel is not used when mask_color is given.
if mask_color is None:
mask_color = [1.0, 1.0, 1.0, alpha]
self.shared_program['u_color'] = mask_color
# build buffer
if mode is 'triangles':
vbo = sim2tri(simplices)
elif mode is 'lines':
vbo = sim2edge(simplices)
else:
raise ValueError('Drawing mode = ' + mode + ' not supported')
self._index_buffer = gloo.IndexBuffer(vbo)
# config OpenGL, 'translucent' or 'additive'
self.set_gl_state('additive',
blend=True,
depth_test=False,
cull_face=False,
polygon_offset_fill=False,
polygon_offset=(1, 1))
self._draw_mode = mode
def __init__(self,
vol,
clim=None,
method='mip',
threshold=None,
relative_step_size=0.8,
cmap='grays',
emulate_texture=False):
tex_cls = TextureEmulated3D if emulate_texture else Texture3D
# Storage of information of volume
self._vol_shape = ()
self._clim = None
self._need_vertex_update = True
# Set the colormap
self._cmap = get_colormap(cmap)
# Create gloo objects
self._vertices = VertexBuffer()
self._texcoord = VertexBuffer(
np.array([
[0, 0, 0],
[1, 0, 0],
[0, 1, 0],
[1, 1, 0],
[0, 0, 1],
[1, 0, 1],
[0, 1, 1],
[1, 1, 1],
],
dtype=np.float32))
self._tex = tex_cls((10, 10, 10),
interpolation='linear',
wrapping='clamp_to_edge')
# Create program
Visual.__init__(self, vcode=VERT_SHADER, fcode="")
self.shared_program['u_volumetex'] = self._tex
self.shared_program['a_position'] = self._vertices
self.shared_program['a_texcoord'] = self._texcoord
self._draw_mode = 'triangle_strip'
self._index_buffer = IndexBuffer()
# Only show back faces of cuboid. This is required because if we are
# inside the volume, then the front faces are outside of the clipping
# box and will not be drawn.
self.set_gl_state('translucent', cull_face=False)
# Set data
self.set_data(vol, clim)
# Set params
self.method = method
self.relative_step_size = relative_step_size
self.threshold = threshold if (threshold is not None) else vol.mean()
self.freeze()
def __init__(self, vertices=None, faces=None, normals=None, lr_index=None,
hemisphere='both', sulcus=None, alpha=1., mask_color='orange',
camera=None, meshdata=None, invert_normals=False):
"""Init."""
self._camera = None
self._translucent = True
self._alpha = alpha
self._hemisphere = hemisphere
self._n_overlay = 0
self._data_lim = []
# Initialize the vispy.Visual class with the vertex / fragment buffer :
Visual.__init__(self, vcode=VERT_SHADER, fcode=FRAG_SHADER)
# _________________ BUFFERS _________________
# Vertices / faces / normals / color :
def_3 = np.zeros((0, 3), dtype=np.float32)
self._vert_buffer = gloo.VertexBuffer(def_3)
self._normals_buffer = gloo.VertexBuffer(def_3)
self._bgd_buffer = gloo.VertexBuffer()
self._xrange_buffer = gloo.VertexBuffer()
self._alphas_buffer = gloo.VertexBuffer()
self._index_buffer = gloo.IndexBuffer()
# _________________ PROGRAMS _________________
self.shared_program.vert['a_position'] = self._vert_buffer
self.shared_program.vert['a_normal'] = self._normals_buffer
self.shared_program.vert['u_n_overlays'] = self._n_overlay
self.shared_program.frag['u_alpha'] = alpha
# _________________ LIGHTS _________________
self.shared_program.frag['u_light_intensity'] = LIGHT_INTENSITY
self.shared_program.frag['u_coef_ambient'] = COEF_AMBIENT
self.shared_program.frag['u_coef_specular'] = COEF_SPECULAR
self.shared_program.frag['u_light_position'] = LIGHT_POSITION
self.shared_program.frag['camtf'] = vist.NullTransform()
# _________________ DATA / CAMERA / LIGHT _________________
# Data :
self.set_data(vertices, faces, normals, hemisphere, lr_index,
invert_normals, sulcus, meshdata)
# Camera :
self.set_camera(camera)
self.mask_color = mask_color
# Slices :
self.xmin, self.xmax = None, None
self.ymin, self.ymax = None, None
self.zmin, self.zmax = None, None
self.inv_light = False
# _________________ GL STATE _________________
self.set_gl_state('translucent', depth_test=True, cull_face=False,
blend=True, blend_func=('src_alpha',
'one_minus_src_alpha'))
self._draw_mode = 'triangles'
self.freeze()
def __init__(self, data, color, symbol="disc", size=3):
Visual.__init__(self, vert, frag)
self.size = size
self.symbol = symbol
self.shared_program["a_position"] = np.float32(data)
self.shared_program["a_size"] = np.repeat(
self.size, data.shape[0]).astype(np.float32)
self.shared_program["a_color"] = VertexBuffer(color.rgba)
self._draw_mode = "points"
def __init__(self, points, simplices, vertex_color=None,
mask_color=None, alpha=1.0,
mode='triangles'):
""" initialize tetrahedra face plot
Parameters
----------
points : NDArray of float32
N x 3 points coordinates
simplices : NDArray of uint32
N x 4 connectivity matrix
Note
----
initialize triangles structure
"""
Visual.__init__(self, vcode=vert, fcode=frag)
# set data
self.shared_program.vert['position'] = gloo.VertexBuffer(points)
if vertex_color is None:
vertex_color = np.ones((points.shape[0], 4), dtype=np.float32)
else:
assert vertex_color.shape[0] == points.shape[0]
# vertex color may be grayscale
if np.ndim(vertex_color) == 1:
f = vertex_color[:, np.newaxis]
v = np.repeat(f, 4, axis=1)
v[:, -1] = 1.0
vertex_color = v.astype(np.float32)
self.shared_program['a_color'] = vertex_color
# mask colors, alpha channel is not used when mask_color is given.
if mask_color is None:
mask_color = [1.0, 1.0, 1.0, alpha]
self.shared_program['u_color'] = mask_color
# build buffer
if mode is 'triangles':
vbo = sim2tri(simplices)
elif mode is 'lines':
vbo = sim2edge(simplices)
else:
raise ValueError('Drawing mode = ' + mode + ' not supported')
self._index_buffer = gloo.IndexBuffer(vbo)
# config OpenGL, 'translucent' or 'additive'
self.set_gl_state('additive',
blend=True,
depth_test=False,
cull_face=False,
polygon_offset_fill=False,
polygon_offset=(1, 1))
self._draw_mode = mode
def __init__(self, vertices=None, faces=None, normals=None, lr_index=None,
hemisphere='both', sulcus=None, alpha=1., mask_color='orange',
camera=None, meshdata=None, invert_normals=False):
"""Init."""
self._camera = None
self._translucent = True
self._alpha = alpha
self._hemisphere = hemisphere
self._n_overlay = 0
self._data_lim = []
# Initialize the vispy.Visual class with the vertex / fragment buffer :
Visual.__init__(self, vcode=VERT_SHADER, fcode=FRAG_SHADER)
# _________________ BUFFERS _________________
# Vertices / faces / normals / color :
def_3 = np.zeros((0, 3), dtype=np.float32)
self._vert_buffer = gloo.VertexBuffer(def_3)
self._normals_buffer = gloo.VertexBuffer(def_3)
self._bgd_buffer = gloo.VertexBuffer()
self._xrange_buffer = gloo.VertexBuffer()
self._alphas_buffer = gloo.VertexBuffer()
self._index_buffer = gloo.IndexBuffer()
# _________________ PROGRAMS _________________
self.shared_program.vert['a_position'] = self._vert_buffer
self.shared_program.vert['a_normal'] = self._normals_buffer
self.shared_program.vert['u_n_overlays'] = self._n_overlay
self.shared_program.frag['u_alpha'] = alpha
# _________________ LIGHTS _________________
self.shared_program.frag['u_light_intensity'] = LIGHT_INTENSITY
self.shared_program.frag['u_coef_ambient'] = COEF_AMBIENT
self.shared_program.frag['u_coef_specular'] = COEF_SPECULAR
self.shared_program.frag['u_light_position'] = LIGHT_POSITION
self.shared_program.frag['camtf'] = vist.NullTransform()
# _________________ DATA / CAMERA / LIGHT _________________
# Data :
self.set_data(vertices, faces, normals, hemisphere, lr_index,
invert_normals, sulcus, meshdata)
# Camera :
self.set_camera(camera)
self.mask_color = mask_color
# _________________ GL STATE _________________
self.set_gl_state('translucent', depth_test=True, cull_face=False,
blend=True, blend_func=('src_alpha',
'one_minus_src_alpha'))
self._draw_mode = 'triangles'
self.freeze()
def __init__(self, parent):
self._parent = parent
self._pos_vbo = gloo.VertexBuffer()
self._color_vbo = gloo.VertexBuffer()
Visual.__init__(self,
vcode=self.VERTEX_SHADER,
fcode=self.FRAGMENT_SHADER,
gcode=None)
self._draw_mode = 'lines'
self._connect = 'segments'
self.set_gl_state('translucent', depth_test=False)
self.freeze()
def __init__(self, vertices=None, faces=None, normals=None, sulcus=None,
alpha=1., camera=None):
"""Init."""
self._camera = None
self._camera_transform = vist.NullTransform()
self._translucent = True
self._alpha = alpha
self._n_overlay = 0
self._data_lim = []
self._colormaps = []
# Initialize the vispy.Visual class with the vertex / fragment buffer :
Visual.__init__(self, vcode=VERT_SHADER, fcode=FRAG_SHADER)
# _________________ BUFFERS _________________
# Vertices / faces / normals / color :
def_3 = np.zeros((0, 3), dtype=np.float32)
self._vert_buffer = gloo.VertexBuffer(def_3)
self._normals_buffer = gloo.VertexBuffer(def_3)
self._bgd_buffer = gloo.VertexBuffer()
self._xrange_buffer = gloo.VertexBuffer()
self._alphas_buffer = gloo.VertexBuffer()
self._index_buffer = gloo.IndexBuffer()
# _________________ PROGRAMS _________________
self.shared_program.vert['a_position'] = self._vert_buffer
self.shared_program.vert['a_normal'] = self._normals_buffer
self.shared_program.vert['u_n_overlays'] = self._n_overlay
self.shared_program.frag['u_alpha'] = alpha
# _________________ TEXTURE _________________
color_1d = np.c_[np.array([1.] * 4), np.array(SULCUS_COLOR)].T
text_1d = gloo.Texture1D(color_1d.astype(np.float32))
self.shared_program.vert['u_bgd_text'] = text_1d
# _________________ LIGHTS _________________
self.shared_program.frag['u_light_intensity'] = LIGHT_INTENSITY
self.shared_program.frag['u_coef_ambient'] = COEF_AMBIENT
# _________________ DATA / CAMERA / LIGHT _________________
self.set_data(vertices, faces, normals, sulcus)
self.set_camera(camera)
# _________________ GL STATE _________________
self.set_gl_state('translucent', depth_test=True, cull_face=False,
blend=True, blend_func=('src_alpha',
'one_minus_src_alpha'))
self._draw_mode = 'triangles'
self.freeze()
def __init__(self, positions, colors):
Visual.__init__(self, vertex_shader, fragment_shader)
self.positions = positions
self.colors = colors
self.frames = self.positions.shape[0]
self._vertices = gloo.VertexBuffer()
self.set_vertex_data(0)
self._draw_mode = 'points'
self.texture = gloo.Texture2D(load_star_image(),
interpolation='linear')
self.shared_program['u_texture'] = self.texture
self.shared_program.vert['color'] = self.colors
self.pointsize = 5
self.set_gl_state(clear_color=(0.0, 0.0, 0.03, 1.0),
depth_test=False,
blend=True,
blend_func=('src_alpha', 'one'))
def __init__(self, data):
Visual.__init__(self, self.VERTEX_SHADER, self.FRAGMENT_SHADER)
nsignals, nsamples = data.shape
# nsamples, nsignals = data.shape
self._data = data
a_index = np.c_[np.repeat(np.arange(nsignals), nsamples),
np.tile(np.arange(nsamples), nsignals)
].astype(np.float32)
# Doesn't seem to work nor to be very efficient.
# indices = nsignals * np.arange(nsamples)
# indices = indices[None, :] + np.arange(nsignals)[:, None]
# indices = indices.flatten().astype(np.uint32)
# self._ibuffer = gloo.IndexBuffer(indices)
self._buffer = gloo.VertexBuffer(data.reshape(-1, 1))
self.shared_program['a_position'] = self._buffer
self.shared_program['a_index'] = a_index
x_transform = Function(X_TRANSFORM)
x_transform['nsamples'] = nsamples
self.shared_program.vert['get_x'] = x_transform
y_transform = Function(Y_TRANSFORM)
y_transform['scale'] = Variable('uniform float u_signal_scale', 1.)
y_transform['nsignals'] = nsignals
self.shared_program.vert['get_y'] = y_transform
self._y_transform = y_transform
colormap = Function(DISCRETE_CMAP)
rng = np.random.RandomState(0)
cmap = rng.uniform(size=(1, nsignals, 3),
low=.5, high=.9).astype(np.float32)
tex = gloo.Texture2D((cmap * 255).astype(np.uint8))
colormap['colormap'] = Variable('uniform sampler2D u_colormap', tex)
colormap['ncolors'] = nsignals
self.shared_program.frag['get_color'] = colormap
self._draw_mode = 'line_strip'
self.set_gl_state('translucent', depth_test=False)
def __init__(self, pos, domain=(0., 1.), tick_direction=(-1., 0.),
scale_type="linear", axis_color=(1, 1, 1),
tick_color=(0.7, 0.7, 0.7), **kwargs):
Visual.__init__(self, **kwargs)
if scale_type != 'linear':
raise NotImplementedError('only linear scaling is currently '
'supported')
self.pos = np.array(pos, float)
self.domain = domain
self.tick_direction = np.array(tick_direction, float)
self.tick_direction = self.tick_direction
self.scale_type = scale_type
self.axis_color = axis_color
self.tick_color = tick_color
self.minor_tick_length = 5 # px
self.major_tick_length = 10 # px
self.label_margin = 5 # px
self._text = None
self._line = None
self._ticks = None
def __init__(self, data, rect=(0, 0, 1, 1), depth=0.0, **kwargs):
self._data = data
self._depth = depth
vertices = np.array([(-1, -1), (-1, +1), (+1, -1), (+1, +1)],
dtype=np.float32)
r = self._rect = rect
texCoord = np.array([(r[0], r[1]), (r[0], r[1] + r[3]),
(r[0] + r[2], r[1]), (r[0] + r[2], r[1] + r[3])],
dtype=np.float32)
self._texNeedUpdate = False
self._texCoordNeedUpdate = False
self._depthNeedUpdate = False
Visual.__init__(self, VERTEX_SHADER, FRAGMENT_SHADER)
self.shared_program["position"] = VertexBuffer(vertices)
self.shared_program["texCoord"] = VertexBuffer(texCoord)
self.shared_program['depth'] = self._depth
self.shared_program['texture'] = self._data
self.set_gl_state(blend=True,
blend_func=('src_alpha', 'one_minus_src_alpha'))
self._draw_mode = 'triangle_strip'
def __init__(self, meshdata, color=None, light_vec=(1, 0, 0)):
Visual.__init__(self, vertex_shader, fragment_shader)
v = meshdata.get_vertices(indexed='faces').astype(float32)
self._vertices = VertexBuffer(v)
v_norm = meshdata.get_vertex_normals(indexed='faces').astype(float32)
self._normals = VertexBuffer(v_norm)
if color is not None:
if len(color) == 3:
color = r_[array(color), 1.]
self._colors = color
else:
v_col = meshdata.get_vertex_colors(indexed='faces').astype(float32)
self._colors = VertexBuffer(v_col)
self._light_vec = light_vec
self._draw_mode = 'triangles'
self.set_gl_state('opaque', depth_test=True, cull_face=True)
def __init__(self, root, aggregatedTexture, light=None, camera=None):
Visual.__init__(self, *aggregatedTexture.generateShaderCode())
# GL init and settings
self._draw_mode = 'triangles'
wrappers.set_cull_face(mode='back')
self.set_gl_state('opaque', depth_test=True, cull_face=True)
# Default arguments
if light is None:
light = SimpleLight
self.light = light(parent=self)
if camera is None:
raise RuntimeError('Default camera is not yet supported')
self.camera = camera
# Set mesh root node
self.root = root
# Initialize buffers
self._vertexBuffer = None
self._normalBuffer = None
self._materialIDBuffer = None
self._textureCoordinateBuffer = None
self._textureBuffer = aggregatedTexture
# Bind the texture buffer
self.shared_program['aggregatedTexture'] = self._textureBuffer.build()
self.shared_program.vert[
'aggregatedTextureWidth'] = aggregatedTexture.shape[0]
self.shared_program.vert[
'aggregatedTextureHeight'] = aggregatedTexture.shape[1]
self.updateLight()
self.updateMesh()
def __init__(self, meshdata):
Visual.__init__(self, VERT_SHADER, FRAG_SHADER)
v = meshdata.get_vertices(indexed='faces').astype(float32)
self._vertices = VertexBuffer(v)
v_norm = meshdata.get_vertex_normals(indexed='faces').astype(float32)
self._normals = VertexBuffer(v_norm)
v_col = meshdata.get_vertex_colors(indexed='faces').astype(float32)
self._colors = VertexBuffer(v_col)
self.set_light(
position=(1., 0., 0.),
ambient=.2,
diffuse=.8,
)
self._draw_mode = 'triangles'
# self.set_gl_state('opaque', depth_test=True, cull_face=True)
self.set_gl_state('translucent',
depth_test=True,
cull_face=False,
blend=True,
blend_func=('src_alpha', 'one_minus_src_alpha'))
def __init__(self,
n_volume_max=10,
threshold=None,
relative_step_size=0.8,
emulate_texture=False):
# Choose texture class
tex_cls = TextureEmulated3D if emulate_texture else Texture3D
self._n_volume_max = n_volume_max
self._initial_shape = True
self._vol_shape = (10, 10, 10)
self._need_vertex_update = True
# Create OpenGL program
vert_shader, frag_shader = get_shaders(n_volume_max)
# We deliberately don't use super here because we don't want to call
# VolumeVisual.__init__
Visual.__init__(self, vcode=vert_shader, fcode=frag_shader)
# Create gloo objects
self._vertices = VertexBuffer()
self._texcoord = VertexBuffer(
np.array([
[0, 0, 0],
[1, 0, 0],
[0, 1, 0],
[1, 1, 0],
[0, 0, 1],
[1, 0, 1],
[0, 1, 1],
[1, 1, 1],
],
dtype=np.float32))
self.textures = []
for i in range(n_volume_max):
# Set up texture object
self.textures.append(
tex_cls(self._vol_shape,
interpolation='linear',
wrapping='clamp_to_edge'))
# Pass texture object and default colormap to shader program
self.shared_program['u_volumetex_{0}'.format(i)] = self.textures[i]
self.shared_program.frag['cmap{0:d}'.format(i)] = Function(
get_colormap('grays').glsl_map)
# Make sure all textures are disbaled
self.shared_program['u_enabled_{0}'.format(i)] = 0
self.shared_program['u_weight_{0}'.format(i)] = 1
self.shared_program['a_position'] = self._vertices
self.shared_program['a_texcoord'] = self._texcoord
self.shared_program['u_shape'] = self._vol_shape[::-1]
self._draw_mode = 'triangle_strip'
self._index_buffer = IndexBuffer()
self.shared_program.frag['sampler_type'] = self.textures[
0].glsl_sampler_type
self.shared_program.frag['sample'] = self.textures[0].glsl_sample
# Only show back faces of cuboid. This is required because if we are
# inside the volume, then the front faces are outside of the clipping
# box and will not be drawn.
self.set_gl_state('translucent', cull_face=False)
self.relative_step_size = relative_step_size
self.volumes = defaultdict(dict)
self._data_shape = None
self._block_size = np.array([1, 1, 1])
try:
self.freeze()
except AttributeError: # Older versions of VisPy
pass
def __init__(self):
Visual.__init__(self, vcode=vert, fcode=frag)
def __init__(self):
Visual.__init__(self, self.VERTEX_SHADER, self.FRAGMENT_SHADER)
self._vert = []
self._color = []
self._draw_mode = 'lines'
def __init__(self,
vertices=None,
faces=None,
normals=None,
lr_index=None,
hemisphere='both',
sulcus=None,
alpha=1.,
mask_color='orange',
light_position=[100.] * 3,
light_color=[1.] * 4,
light_intensity=[1.] * 3,
coef_ambient=.05,
coef_specular=.5,
vertfcn=None,
camera=None,
meshdata=None,
invert_normals=False):
"""Init."""
self._camera = None
self._camera_transform = vist.NullTransform()
self._translucent = True
self._alpha = alpha
self._hemisphere = hemisphere
# Initialize the vispy.Visual class with the vertex / fragment buffer :
Visual.__init__(self, vcode=VERT_SHADER, fcode=FRAG_SHADER)
# _________________ TRANSFORMATIONS _________________
self._vertfcn = vist.NullTransform() if vertfcn is None else vertfcn
# _________________ BUFFERS _________________
# Vertices / faces / normals / color :
def_3 = np.zeros((0, 3), dtype=np.float32)
def_4 = np.zeros((0, 4), dtype=np.float32)
self._vert_buffer = gloo.VertexBuffer(def_3)
self._color_buffer = gloo.VertexBuffer(def_4)
self._normals_buffer = gloo.VertexBuffer(def_3)
self._mask_buffer = gloo.VertexBuffer()
self._sulcus_buffer = gloo.VertexBuffer()
self._index_buffer = gloo.IndexBuffer()
# _________________ PROGRAMS _________________
self.shared_program.vert['a_position'] = self._vert_buffer
self.shared_program.vert['a_color'] = self._color_buffer
self.shared_program.vert['a_normal'] = self._normals_buffer
self.shared_program.frag['u_alpha'] = alpha
# _________________ DATA / CAMERA / LIGHT _________________
self.set_data(vertices, faces, normals, hemisphere, lr_index,
invert_normals, sulcus, meshdata)
self.set_camera(camera)
self.mask_color = mask_color
self.light_color = light_color
self.light_position = light_position
self.light_intensity = light_intensity
self.coef_ambient = coef_ambient
self.coef_specular = coef_specular
# _________________ GL STATE _________________
self.set_gl_state('translucent',
depth_test=True,
cull_face=False,
blend=True,
blend_func=('src_alpha', 'one_minus_src_alpha'))
self._draw_mode = 'triangles'
self.freeze()
def __init__(self, n_volume_max=16, emulate_texture=False, bgcolor='white', resolution=256):
# Choose texture class
tex_cls = TextureEmulated3D if emulate_texture else Texture3D
self._n_volume_max = n_volume_max
self._vol_shape = (resolution, resolution, resolution)
self._need_vertex_update = True
self._data_bounds = None
self.resolution = resolution
# We deliberately don't use super here because we don't want to call
# VolumeVisual.__init__
Visual.__init__(self, vcode=VERT_SHADER, fcode="")
self.volumes = defaultdict(dict)
# We turn on clipping straight away - the following variable is needed
# by _update_shader
self._clip_data = True
# Set up initial shader so that we can start setting shader variables
# that don't depend on what volumes are actually active.
self._update_shader()
# Set initial clipping parameters
self.shared_program['u_clip_min'] = [0, 0, 0]
self.shared_program['u_clip_max'] = [1, 1, 1]
# Set up texture vertices - note that these variables are required by
# the parent VolumeVisual class.
self._vertices = VertexBuffer()
self._texcoord = VertexBuffer(
np.array([[0, 0, 0],
[1, 0, 0],
[0, 1, 0],
[1, 1, 0],
[0, 0, 1],
[1, 0, 1],
[0, 1, 1],
[1, 1, 1]], dtype=np.float32))
self._draw_mode = 'triangle_strip'
self._index_buffer = IndexBuffer()
self.shared_program['a_position'] = self._vertices
self.shared_program['a_texcoord'] = self._texcoord
# Only show back faces of cuboid. This is required because if we are
# inside the volume, then the front faces are outside of the clipping
# box and will not be drawn.
self.set_gl_state('translucent', cull_face=False)
# Set up the underlying volume shape and define textures
self._vol_shape = (resolution, resolution, resolution)
self.shared_program['u_shape'] = self._vol_shape
self.textures = []
for i in range(n_volume_max):
# Set up texture object
self.textures.append(tex_cls(self._vol_shape, interpolation='linear',
wrapping='clamp_to_edge'))
# Pass texture object to shader program
self.shared_program['u_volumetex_{0}'.format(i)] = self.textures[i]
# Make sure all textures are disabled
self.shared_program['u_enabled_{0}'.format(i)] = 0
self.shared_program['u_weight_{0}'.format(i)] = 1
# Don't use downsampling initially (1 means show 1:1 resolution)
self.shared_program['u_downsample'] = 1.
# Set up texture sampler
self.shared_program.frag['sampler_type'] = self.textures[0].glsl_sampler_type
self.shared_program.frag['sample'] = self.textures[0].glsl_sample
# Set initial background color
self.shared_program['u_bgcolor'] = Color(bgcolor).rgba
# Prevent additional attributes from being added
try:
self.freeze()
except AttributeError: # Older versions of VisPy
pass
def __init__(self):
Visual.__init__(self, self.VERTEX_SHADER, self.FRAGMENT_SHADER)
self._vert = []
self._color = []
self._draw_mode = 'lines'
def __init__(self, n_volume_max=10, threshold=None, relative_step_size=0.8,
emulate_texture=False):
# Choose texture class
tex_cls = TextureEmulated3D if emulate_texture else Texture3D
self._n_volume_max = n_volume_max
self._initial_shape = True
self._vol_shape = (10, 10, 10)
self._need_vertex_update = True
# Create OpenGL program
vert_shader, frag_shader = get_shaders(n_volume_max)
# We deliberately don't use super here because we don't want to call
# VolumeVisual.__init__
Visual.__init__(self, vcode=vert_shader, fcode=frag_shader)
# Create gloo objects
self._vertices = VertexBuffer()
self._texcoord = VertexBuffer(
np.array([
[0, 0, 0],
[1, 0, 0],
[0, 1, 0],
[1, 1, 0],
[0, 0, 1],
[1, 0, 1],
[0, 1, 1],
[1, 1, 1],
], dtype=np.float32))
self.textures = []
for i in range(n_volume_max):
# Set up texture object
self.textures.append(tex_cls(self._vol_shape, interpolation='linear',
wrapping='clamp_to_edge'))
# Pass texture object and default colormap to shader program
self.shared_program['u_volumetex_{0}'.format(i)] = self.textures[i]
self.shared_program.frag['cmap{0:d}'.format(i)] = Function(get_colormap('grays').glsl_map)
# Make sure all textures are disbaled
self.shared_program['u_enabled_{0}'.format(i)] = 0
self.shared_program['u_weight_{0}'.format(i)] = 1
self.shared_program['a_position'] = self._vertices
self.shared_program['a_texcoord'] = self._texcoord
self.shared_program['u_shape'] = self._vol_shape[::-1]
self._draw_mode = 'triangle_strip'
self._index_buffer = IndexBuffer()
self.shared_program.frag['sampler_type'] = self.textures[0].glsl_sampler_type
self.shared_program.frag['sample'] = self.textures[0].glsl_sample
# Only show back faces of cuboid. This is required because if we are
# inside the volume, then the front faces are outside of the clipping
# box and will not be drawn.
self.set_gl_state('translucent', cull_face=False)
self.relative_step_size = relative_step_size
self.volumes = defaultdict(dict)
self._data_shape = None
self._block_size = np.array([1,1,1])
try:
self.freeze()
except AttributeError: # Older versions of VisPy
pass
def __init__(self,
vertices,
faces,
colors=None,
texture=None,
textureCoordinates=None,
light=None,
ambientMaterialConstant=0.5,
diffuseMaterialConstant=0.4,
specularMaterialConstant=0.3,
vertexShader=defaultVertexShader,
fragmentShader=defaultFragmentShader,
camera=None):
Visual.__init__(self, vertexShader, fragmentShader)
# Culling mode (for debugging)
#wrappers.set_cull_face(mode='back')
# Default arguments
if colors is None and texture is None:
colors = np.array([(0.5, 0.5, 0.5)
for index in range(vertices.shape[0])],
dtype=np.float32)
elif colors is not None and len(colors) is 3 and (isinstance(
colors[0], float) or isinstance(colors[0], int)):
colors = np.array([colors for index in range(len(vertices))],
dtype=np.float32)
if light is None:
light = SimpleLight(self, color=(1.0, 1.0, 1.0))
else:
light = light(self)
# Geometry setup
self._meshData = MeshData(vertices=vertices,
faces=faces,
vertex_colors=colors)
self._vertices = None
self._colors = None
self._texture = None
self._textureCoordinates = None
self._normals = None
self._draw_mode = 'triangles'
self.set_gl_state('opaque', depth_test=True, cull_face=True)
# Light setup
self._light = light
self._camera = camera
self._ambientMaterialConstant = ambientMaterialConstant
self._diffuseMaterialConstant = diffuseMaterialConstant
self._specularMaterialConstant = specularMaterialConstant
# Initial updates
self.updateMesh(vertices=vertices,
faces=faces,
colors=colors,
texture=texture,
textureCoordinates=textureCoordinates)
self.updateLight()