def _update_mapper(self):
"""
Map vtkPolyData to the actor.
"""
polydata = vtk.vtkPolyData()
offsets = self._get_odf_offsets(self.mask)
if len(offsets) == 0:
self.mapper.SetInputData(polydata)
return None
sph_dirs = self._get_sphere_directions()
sf = self._get_sf(self.mask)
all_vertices = self._get_all_vertices(offsets, sph_dirs, sf)
all_faces = self._get_all_faces(len(offsets), len(sph_dirs))
all_colors = self._generate_color_for_vertices(sf)
# TODO: There is a lot of deep copy here.
# Optimize (see viz_network.py example).
set_polydata_triangles(polydata, all_faces)
set_polydata_vertices(polydata, all_vertices)
set_polydata_colors(polydata, all_colors)
self.mapper.SetInputData(polydata)
def generate_points():
centers = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
colors = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]]) * 255
vtk_vertices = Points()
# Create the topology of the point (a vertex)
vtk_faces = CellArray()
# Add points
for i in range(len(centers)):
p = centers[i]
id = vtk_vertices.InsertNextPoint(p)
vtk_faces.InsertNextCell(1)
vtk_faces.InsertCellPoint(id)
# Create a polydata object
polydata = PolyData()
# Set the vertices and faces we created as the geometry and topology of the
# polydata
polydata.SetPoints(vtk_vertices)
polydata.SetVerts(vtk_faces)
set_polydata_colors(polydata, colors)
mapper = PolyDataMapper()
mapper.SetInputData(polydata)
mapper.SetVBOShiftScaleMethod(False)
point_actor = Actor()
point_actor.SetMapper(mapper)
return point_actor
def test_polydata_polygon(interactive=False):
# Create a cube
my_triangles = np.array([[0, 6, 4],
[0, 2, 6],
[0, 3, 2],
[0, 1, 3],
[2, 7, 6],
[2, 3, 7],
[4, 6, 7],
[4, 7, 5],
[0, 4, 5],
[0, 5, 1],
[1, 5, 7],
[1, 7, 3]], dtype='i8')
my_vertices = np.array([[0.0, 0.0, 0.0],
[0.0, 0.0, 1.0],
[0.0, 1.0, 0.0],
[0.0, 1.0, 1.0],
[1.0, 0.0, 0.0],
[1.0, 0.0, 1.0],
[1.0, 1.0, 0.0],
[1.0, 1.0, 1.0]])
colors = my_vertices * 255
my_polydata = vtk.vtkPolyData()
utils.set_polydata_vertices(my_polydata, my_vertices)
utils.set_polydata_triangles(my_polydata, my_triangles)
npt.assert_equal(len(my_vertices), my_polydata.GetNumberOfPoints())
npt.assert_equal(len(my_triangles), my_polydata.GetNumberOfCells())
npt.assert_equal(utils.get_polydata_normals(my_polydata), None)
res_triangles = utils.get_polydata_triangles(my_polydata)
res_vertices = utils.get_polydata_vertices(my_polydata)
npt.assert_array_equal(my_vertices, res_vertices)
npt.assert_array_equal(my_triangles, res_triangles)
utils.set_polydata_colors(my_polydata, colors)
npt.assert_equal(utils.get_polydata_colors(my_polydata), colors)
utils.update_polydata_normals(my_polydata)
normals = utils.get_polydata_normals(my_polydata)
npt.assert_equal(len(normals), len(my_vertices))
mapper = utils.get_polymapper_from_polydata(my_polydata)
actor1 = utils.get_actor_from_polymapper(mapper)
actor2 = utils.get_actor_from_polydata(my_polydata)
scene = window.Scene()
for actor in [actor1, actor2]:
scene.add(actor)
if interactive:
window.show(scene)
arr = window.snapshot(scene)
report = window.analyze_snapshot(arr)
npt.assert_equal(report.objects, 1)
[1, 9, 3], #good
[3, 7, 9], #good
[3, 5, 7]], dtype='i8') #good
utils.set_polydata_vertices(my_polydata, my_vertices)
utils.set_polydata_triangles(my_polydata, my_triangles)
file_name = "my_star2D.vtk"
save_polydata(my_polydata, file_name)
print("Surface saved in " + file_name)
star_polydata = load_polydata(file_name)
star_vertices = utils.get_polydata_vertices(star_polydata)
colors = star_vertices * 255
utils.set_polydata_colors(star_polydata, colors)
print("new surface colors")
print(utils.get_polydata_colors(star_polydata))
# get vtkActor
star_actor = utils.get_actor_from_polydata(star_polydata)
star_actor.GetProperty().BackfaceCullingOff()
# Create a scene
scene = window.Scene()
scene.add(star_actor)
scene.set_camera(position=(0, 0, 7), focal_point=(0, 0, 0))
scene.zoom(3)
# display
# window.show(scene, size=(1000, 1000), reset_camera=False) this allows the picture to be moved around
[0, 1, 3],
[2, 7, 6],
[2, 3, 7],
[4, 6, 7],
[4, 7, 5],
[0, 4, 5],
[0, 5, 1],
[1, 5, 7],
[1, 7, 3]], dtype='i8')
my_colors = my_vertices * 255 # transform from [0, 1] to [0, 255]
# use a FURY util to apply the above values to the polydata
utils.set_polydata_vertices(my_polydata, my_vertices)
utils.set_polydata_triangles(my_polydata, my_triangles)
utils.set_polydata_colors(my_polydata, my_colors)
# in VTK, shaders are applied at the mapper level
# get mapper from polydata
cube_actor = utils.get_actor_from_polydata(my_polydata)
mapper = cube_actor.GetMapper()
# add the cube to a scene and show it
scene = window.Scene()
scene.add(cube_actor)
scene.background((1, 1, 1))
window.show(scene, size=(500, 500))
# let's use a frag shader to change how the cube is rendered
def custom_glyph(centers, directions=None, colors=(1, 0, 0),
normals=(1, 0, 0), sq_params=None,
geom='square', scale=1, **kwargs):
"""Return a custom glyph actor
"""
if geom.lower() == 'square':
unit_verts, unit_triangles = square()
origin_z = 0
elif geom.lower() == 'box':
unit_verts, unit_triangles = box()
origin_z = 0.5
elif geom.lower() == 'octahedron':
unit_verts, unit_triangles = octahedron()
origin_z = 0.5
elif geom.lower() == 'icosahedron':
unit_verts, unit_triangles = icosahedron()
origin_z = 0.5
elif geom.lower() == 'superquadric':
unit_verts, unit_triangles = superquadric(sq_params)
origin_z = 0.5
else:
unit_verts, unit_triangles = None
origin_z = 0
# update vertices
big_vertices = np.tile(unit_verts, (centers.shape[0], 1))
big_centers = np.repeat(centers, unit_verts.shape[0], axis=0)
# center it
big_vertices -= np.array([0.5, 0.5, origin_z])
# apply centers position
big_vertices += big_centers
# scale them
if isinstance(scale, (list, tuple, np.ndarray)):
scale = np.repeat(scale, unit_verts.shape[0], axis=0)
scale = scale.reshape((big_vertices.shape[0], 1))
big_vertices *= scale
# update triangles
big_triangles = np.tile(unit_triangles, (centers.shape[0], 1))
z = np.repeat(np.arange(0, centers.shape[0] *
unit_verts.shape[0], step=unit_verts.shape[0]),
unit_triangles.shape[0],
axis=0).reshape((big_triangles.shape[0], 1))
big_triangles = np.add(z, big_triangles, casting="unsafe")
# update colors
if isinstance(colors, (tuple, list)):
colors = np.array([colors] * centers.shape[0])
big_colors = np.repeat(colors*255, unit_verts.shape[0], axis=0)
# update normals
if isinstance(normals, (tuple, list)):
normals = np.array([normals] * centers.shape[0])
big_normals = np.repeat(normals, unit_verts.shape[0], axis=0)
# if isinstance(normals, (tuple, list)):
# directions = np.array([directions] * centers.shape[0])
# big_dirs = np.repeat(normals, unit_verts.shape[0], axis=0)
r, p, t = cart2sphere(0, 0, 1)
m = euler_matrix(r, p, t, 'rxzy')
print(big_vertices)
big_vertices -= big_centers
big_vertices = np.dot(m[:3, :3], big_vertices.T).T + big_centers
# Create a Polydata
pd = vtk.vtkPolyData()
set_polydata_vertices(pd, big_vertices)
set_polydata_triangles(pd, big_triangles)
set_polydata_colors(pd, big_colors)
set_polydata_normals(pd, big_normals)
update_polydata_normals(pd)
current_actor = get_actor_from_polydata(pd)
if geom.lower() == 'square':
current_actor.GetProperty().BackfaceCullingOff()
return current_actor
file_name = "my_cube.vtk"
io_vtk.save_polydata(my_polydata, file_name)
print("Surface saved in " + file_name)
###############################################################################
# Load the ``vtkPolyData``
cube_polydata = io_vtk.load_polydata(file_name)
###############################################################################
# add color based on vertices position
cube_vertices = ut_vtk.get_polydata_vertices(cube_polydata)
colors = cube_vertices * 255
ut_vtk.set_polydata_colors(cube_polydata, colors)
print("new surface colors")
print(ut_vtk.get_polydata_colors(cube_polydata))
###############################################################################
# Visualize surfaces
# get vtkActor
cube_actor = ut_vtk.get_actor_from_polydata(cube_polydata)
# renderer and scene
renderer = window.Renderer()
renderer.add(cube_actor)
renderer.set_camera(position=(10, 5, 7), focal_point=(0.5, 0.5, 0.5))
renderer.zoom(3)
[3, 15, 16],
[3, 4, 16], #end of shape
], dtype='i8')
utils.set_polydata_vertices(my_polydata, my_vertices)
utils.set_polydata_triangles(my_polydata, my_triangles)
file_name = "my_rhombicube.vtk"
save_polydata(my_polydata, file_name)
print("Surface saved in " + file_name)
rhombicube_polydata = load_polydata(file_name)
rhombicube_vertices = utils.get_polydata_vertices(rhombicube_polydata)
colors = rhombicube_vertices * 255
utils.set_polydata_colors(rhombicube_polydata, colors)
print("new surface colors")
print(utils.get_polydata_colors(rhombicube_polydata))
# get vtkActor
rhombicube_actor = utils.get_actor_from_polydata(rhombicube_polydata)
rhombicube_actor.GetProperty().BackfaceCullingOff() #gets rid of the winding order issue (look at later and other algorithms that get rid of winding order)
# Create a scene
scene = window.Scene()
scene.add(rhombicube_actor)
scene.set_camera(position=(0, 0, 7), focal_point=(0, 0, 0))
scene.zoom(0)
# display
file_name = "my_cube.vtk"
save_polydata(my_polydata, file_name)
print("Surface saved in " + file_name)
###############################################################################
# Load the ``vtkPolyData``
cube_polydata = load_polydata(file_name)
###############################################################################
# add color based on vertices position
cube_vertices = utils.get_polydata_vertices(cube_polydata)
colors = cube_vertices * 255
utils.set_polydata_colors(cube_polydata, colors)
print("new surface colors")
print(utils.get_polydata_colors(cube_polydata))
###############################################################################
# Visualize surfaces
# get vtkActor
cube_actor = utils.get_actor_from_polydata(cube_polydata)
# Create a scene
scene = window.Scene()
scene.add(cube_actor)
scene.set_camera(position=(10, 5, 7), focal_point=(0.5, 0.5, 0.5))
scene.zoom(3)
def test_fireballs_on_canvas():
scene = window.Scene()
showm = window.ShowManager(scene)
# colors = 255 * np.array([
# [.85, .07, .21], [.56, .14, .85], [.16, .65, .20], [.95, .73, .06],
# [.95, .55, .05], [.62, .42, .75], [.26, .58, .85], [.24, .82, .95],
# [.95, .78, .25], [.85, .58, .35], [1., 1., 1.]
# ])
colors = np.random.rand(1000000, 3) * 255
n_points = colors.shape[0]
np.random.seed(42)
centers = 500 * np.random.rand(n_points, 3) - 250
radius = .5 * np.ones(n_points)
polydata = vtk.vtkPolyData()
verts = np.array([[0.0, 0.0, 0.0], [0.0, 1.0, 0.0], [1.0, 1.0, 0.0],
[1.0, 0.0, 0.0]])
verts -= np.array([0.5, 0.5, 0])
big_verts = np.tile(verts, (centers.shape[0], 1))
big_cents = np.repeat(centers, verts.shape[0], axis=0)
big_verts += big_cents
big_scales = np.repeat(radius, verts.shape[0], axis=0)
big_verts *= big_scales[:, np.newaxis]
tris = np.array([[0, 1, 2], [2, 3, 0]], dtype='i8')
big_tris = np.tile(tris, (centers.shape[0], 1))
shifts = np.repeat(
np.arange(0, centers.shape[0] * verts.shape[0], verts.shape[0]),
tris.shape[0])
big_tris += shifts[:, np.newaxis]
big_cols = np.repeat(colors, verts.shape[0], axis=0)
big_centers = np.repeat(centers, verts.shape[0], axis=0)
big_centers *= big_scales[:, np.newaxis]
set_polydata_vertices(polydata, big_verts)
set_polydata_triangles(polydata, big_tris)
set_polydata_colors(polydata, big_cols)
vtk_centers = numpy_support.numpy_to_vtk(big_centers, deep=True)
vtk_centers.SetNumberOfComponents(3)
vtk_centers.SetName("center")
polydata.GetPointData().AddArray(vtk_centers)
canvas_actor = get_actor_from_polydata(polydata)
canvas_actor.GetProperty().BackfaceCullingOff()
scene.add(canvas_actor)
mapper = canvas_actor.GetMapper()
mapper.MapDataArrayToVertexAttribute(
"center", "center", vtk.vtkDataObject.FIELD_ASSOCIATION_POINTS, -1)
mapper.AddShaderReplacement(
vtk.vtkShader.Vertex, "//VTK::ValuePass::Dec", True, """
//VTK::ValuePass::Dec
in vec3 center;
out vec3 centeredVertexMC;
""", False)
mapper.AddShaderReplacement(
vtk.vtkShader.Vertex, "//VTK::ValuePass::Impl", True, """
//VTK::ValuePass::Impl
centeredVertexMC = vertexMC.xyz - center;
float scalingFactor = 1. / abs(centeredVertexMC.x);
centeredVertexMC *= scalingFactor;
vec3 CameraRight_worldspace = vec3(MCVCMatrix[0][0], MCVCMatrix[1][0], MCVCMatrix[2][0]);
vec3 CameraUp_worldspace = vec3(MCVCMatrix[0][1], MCVCMatrix[1][1], MCVCMatrix[2][1]);
vec3 vertexPosition_worldspace = center + CameraRight_worldspace * .5 * centeredVertexMC.x + CameraUp_worldspace * .5 * centeredVertexMC.y;
gl_Position = MCDCMatrix * vec4(vertexPosition_worldspace, 1.);
""", False)
mapper.AddShaderReplacement(
vtk.vtkShader.Fragment, "//VTK::ValuePass::Dec", True, """
//VTK::ValuePass::Dec
in vec3 centeredVertexMC;
uniform float time;
float snoise(vec3 uv, float res) {
const vec3 s = vec3(1e0, 1e2, 1e3);
uv *= res;
vec3 uv0 = floor(mod(uv, res)) * s;
vec3 uv1 = floor(mod(uv + vec3(1.), res)) * s;
vec3 f = fract(uv);
f = f * f * (3. - 2. * f);
vec4 v = vec4(uv0.x + uv0.y + uv0.z, uv1.x + uv0.y + uv0.z,
uv0.x + uv1.y + uv0.z, uv1.x + uv1.y + uv0.z);
vec4 r = fract(sin(v * 1e-1) * 1e3);
float r0 = mix(mix(r.x, r.y, f.x), mix(r.z, r.w, f.x), f.y);
r = fract(sin((v + uv1.z - uv0.z) * 1e-1) * 1e3);
float r1 = mix(mix(r.x, r.y, f.x), mix(r.z, r.w, f.x), f.y);
return mix(r0, r1, f.z) * 2. - 1.;
}
""", False)
mapper.AddShaderReplacement(
vtk.vtkShader.Fragment, "//VTK::Light::Impl", True, """
// Renaming variables passed from the Vertex Shader
vec3 color = vertexColorVSOutput.rgb;
vec3 point = centeredVertexMC;
float len = length(point);
float fColor = 2. - 2. * len;
vec3 coord = vec3(atan(point.x, point.y) / 6.2832 + .5, len * .4, .5);
for(int i = 1; i <= 7; i++) {
float power = pow(2., float(i));
fColor += (1.5 / power) * snoise(coord +
vec3(0., -time * .005, time * .001), power * 16.);
}
if(fColor < 0) discard;
//color = vec3(fColor);
color *= fColor;
fragOutput0 = vec4(color, 1.);
""", False)
global timer
timer = 0
def timer_callback(obj, event):
global timer
timer += 1.
showm.render()
@window.vtk.calldata_type(window.vtk.VTK_OBJECT)
def vtk_shader_callback(caller, event, calldata=None):
program = calldata
global timer
if program is not None:
try:
program.SetUniformf("time", timer)
except ValueError:
pass
mapper.AddObserver(window.vtk.vtkCommand.UpdateShaderEvent,
vtk_shader_callback)
showm.initialize()
showm.add_timer_callback(True, 100, timer_callback)
showm.start()
def test_spheres_on_canvas():
scene = window.Scene()
showm = window.ShowManager(scene, reset_camera=False)
# colors = 255 * np.array([
# [.85, .07, .21], [.56, .14, .85], [.16, .65, .20], [.95, .73, .06],
# [.95, .55, .05], [.62, .42, .75], [.26, .58, .85], [.24, .82, .95],
# [.95, .78, .25], [.85, .58, .35], [1., 1., 1.]
# ])
n_points = 2000000
colors = np.array([[255, 0, 0], [0, 255, 0],
[0, 0, 255]]) #255 * np.random.rand(n_points, 3)
# n_points = colors.shape[0]
np.random.seed(42)
centers = np.array(
[[2, 0, 0], [0, 2, 0], [0, 0, 0]]
) # 500 * np.random.rand(n_points, 3) - 250 # np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
radius = [2, 2, 2] # np.random.rand(n_points) # [1, 1, 2]
polydata = vtk.vtkPolyData()
verts, faces = fp.prim_square()
big_verts = np.tile(verts, (centers.shape[0], 1))
big_cents = np.repeat(centers, verts.shape[0], axis=0)
big_verts += big_cents
# print(big_verts)
big_scales = np.repeat(radius, verts.shape[0], axis=0)
# print(big_scales)
big_verts *= big_scales[:, np.newaxis]
# print(big_verts)
tris = np.array([[0, 1, 2], [2, 3, 0]], dtype='i8')
big_tris = np.tile(tris, (centers.shape[0], 1))
shifts = np.repeat(
np.arange(0, centers.shape[0] * verts.shape[0], verts.shape[0]),
tris.shape[0])
big_tris += shifts[:, np.newaxis]
# print(big_tris)
big_cols = np.repeat(colors, verts.shape[0], axis=0)
# print(big_cols)
big_centers = np.repeat(centers, verts.shape[0], axis=0)
# print(big_centers)
big_centers *= big_scales[:, np.newaxis]
# print(big_centers)
set_polydata_vertices(polydata, big_verts)
set_polydata_triangles(polydata, big_tris)
set_polydata_colors(polydata, big_cols)
vtk_centers = numpy_support.numpy_to_vtk(big_centers, deep=True)
vtk_centers.SetNumberOfComponents(3)
vtk_centers.SetName("center")
polydata.GetPointData().AddArray(vtk_centers)
canvas_actor = get_actor_from_polydata(polydata)
canvas_actor.GetProperty().BackfaceCullingOff()
scene.add(canvas_actor)
mapper = canvas_actor.GetMapper()
mapper.MapDataArrayToVertexAttribute(
"center", "center", vtk.vtkDataObject.FIELD_ASSOCIATION_POINTS, -1)
mapper.AddShaderReplacement(
vtk.vtkShader.Vertex, "//VTK::ValuePass::Dec", True, """
//VTK::ValuePass::Dec
in vec3 center;
uniform mat4 Ext_mat;
out vec3 centeredVertexMC;
out vec3 cameraPosition;
out vec3 viewUp;
""", False)
mapper.AddShaderReplacement(
vtk.vtkShader.Vertex, "//VTK::ValuePass::Impl", True, """
//VTK::ValuePass::Impl
centeredVertexMC = vertexMC.xyz - center;
float scalingFactor = 1. / abs(centeredVertexMC.x);
centeredVertexMC *= scalingFactor;
vec3 CameraRight_worldspace = vec3(MCVCMatrix[0][0], MCVCMatrix[1][0], MCVCMatrix[2][0]);
vec3 CameraUp_worldspace = vec3(MCVCMatrix[0][1], MCVCMatrix[1][1], MCVCMatrix[2][1]);
vec3 vertexPosition_worldspace = center + CameraRight_worldspace * 1 * centeredVertexMC.x + CameraUp_worldspace * 1 * centeredVertexMC.y;
gl_Position = MCDCMatrix * vec4(vertexPosition_worldspace, 1.);
""", False)
mapper.AddShaderReplacement(
vtk.vtkShader.Fragment, "//VTK::ValuePass::Dec", True, """
//VTK::ValuePass::Dec
in vec3 centeredVertexMC;
in vec3 cameraPosition;
in vec3 viewUp;
uniform vec3 Ext_camPos;
uniform vec3 Ext_viewUp;
""", False)
mapper.AddShaderReplacement(
vtk.vtkShader.Fragment, "//VTK::Light::Impl", True, """
// Renaming variables passed from the Vertex Shader
vec3 color = vertexColorVSOutput.rgb;
vec3 point = centeredVertexMC;
fragOutput0 = vec4(color, 0.7);
/*
// Comparing camera position from vertex shader and python
float dist = distance(cameraPosition, Ext_camPos);
if(dist < .0001)
fragOutput0 = vec4(1, 0, 0, 1);
else
fragOutput0 = vec4(0, 1, 0, 1);
// Comparing view up from vertex shader and python
float dist = distance(viewUp, Ext_viewUp);
if(dist < .0001)
fragOutput0 = vec4(1, 0, 0, 1);
else
fragOutput0 = vec4(0, 1, 0, 1);
*/
float len = length(point);
// VTK Fake Spheres
float radius = 1.;
if(len > radius)
discard;
vec3 normalizedPoint = normalize(vec3(point.xy, sqrt(1. - len)));
vec3 direction = normalize(vec3(1., 1., 1.));
float df = max(0, dot(direction, normalizedPoint));
float sf = pow(df, 24);
fragOutput0 = vec4(max(df * color, sf * vec3(1)), 1);
""", False)
@vtk.calldata_type(vtk.VTK_OBJECT)
def vtk_shader_callback(caller, event, calldata=None):
res = scene.size()
camera = scene.GetActiveCamera()
cam_pos = camera.GetPosition()
foc_pnt = camera.GetFocalPoint()
view_up = camera.GetViewUp()
# cam_light_mat = camera.GetCameraLightTransformMatrix()
# comp_proj_mat = camera.GetCompositeProjectionTransformMatrix()
# exp_proj_mat = camera.GetExplicitProjectionTransformMatrix()
# eye_mat = camera.GetEyeTransformMatrix()
# model_mat = camera.GetModelTransformMatrix()
# model_view_mat = camera.GetModelViewTransformMatrix()
# proj_mat = camera.GetProjectionTransformMatrix(scene)
view_mat = camera.GetViewTransformMatrix()
mat = view_mat
np.set_printoptions(precision=3, suppress=True)
np_mat = np.zeros((4, 4))
for i in range(4):
for j in range(4):
np_mat[i, j] = mat.GetElement(i, j)
program = calldata
if program is not None:
# print("\nCamera position: {}".format(cam_pos))
# print("Focal point: {}".format(foc_pnt))
# print("View up: {}".format(view_up))
# print(mat)
# print(np_mat)
# print(np.dot(-np_mat[:3, 3], np_mat[:3, :3]))
# a = np.array(cam_pos) - np.array(foc_pnt)
# print(a / np.linalg.norm(a))
# print(cam_light_mat)
# #print(comp_proj_mat)
# print(exp_proj_mat)
# print(eye_mat)
# print(model_mat)
# print(model_view_mat)
# print(proj_mat)
# print(view_mat)
program.SetUniform2f("Ext_res", res)
program.SetUniform3f("Ext_camPos", cam_pos)
program.SetUniform3f("Ext_focPnt", foc_pnt)
program.SetUniform3f("Ext_viewUp", view_up)
program.SetUniformMatrix("Ext_mat", mat)
mapper.AddObserver(vtk.vtkCommand.UpdateShaderEvent, vtk_shader_callback)
global timer
timer = 0
def timer_callback(obj, event):
global timer
timer += 1.
showm.render()
scene.azimuth(2)
# scene.elevation(5)
# scene.roll(5)
label = vtk.vtkOpenGLBillboardTextActor3D()
label.SetInput("FURY Rocks!!!")
label.SetPosition(1., 1., 1)
label.GetTextProperty().SetFontSize(40)
label.GetTextProperty().SetColor(.5, .5, .5)
# TODO: Get Billboard's mapper
# l_mapper = label.GetActors()
# scene.add(label)
scene.add(actor.axes())
scene.background((1, 1, 1))
# scene.set_camera(position=(1.5, 2.5, 15), focal_point=(1.5, 2.5, 1.5),
# view_up=(0, 1, 0))
scene.set_camera(position=(1.5, 2.5, 25),
focal_point=(0, 0, 0),
view_up=(0, 1, 0))
showm.initialize()
showm.add_timer_callback(True, 100, timer_callback)
showm.start()
def initialize(self):
# Bring used components
self.registerVtkWebProtocol(protocols.vtkWebMouseHandler())
self.registerVtkWebProtocol(protocols.vtkWebViewPort())
self.registerVtkWebProtocol(protocols.vtkWebViewPortImageDelivery())
self.registerVtkWebProtocol(protocols.vtkWebViewPortGeometryDelivery())
# Update authentication key to use
self.updateSecret(_WebSpheres.authKey)
# Create default pipeline (Only once for all the session)
if not _WebSpheres.view:
# FURY specific code
scene = window.Scene()
scene.background((1, 1, 1))
n_points = 1000000
translate = 100
colors = 255 * np.random.rand(n_points, 3)
centers = translate * np.random.rand(n_points, 3) - translate / 2
radius = np.random.rand(n_points) / 10
polydata = vtk.vtkPolyData()
verts = np.array([[0.0, 0.0, 0.0], [0.0, 1.0, 0.0],
[1.0, 1.0, 0.0], [1.0, 0.0, 0.0]])
verts -= np.array([0.5, 0.5, 0])
big_verts = np.tile(verts, (centers.shape[0], 1))
big_cents = np.repeat(centers, verts.shape[0], axis=0)
big_verts += big_cents
# print(big_verts)
big_scales = np.repeat(radius, verts.shape[0], axis=0)
# print(big_scales)
big_verts *= big_scales[:, np.newaxis]
# print(big_verts)
tris = np.array([[0, 1, 2], [2, 3, 0]], dtype='i8')
big_tris = np.tile(tris, (centers.shape[0], 1))
shifts = np.repeat(
np.arange(0, centers.shape[0] * verts.shape[0],
verts.shape[0]), tris.shape[0])
big_tris += shifts[:, np.newaxis]
# print(big_tris)
big_cols = np.repeat(colors, verts.shape[0], axis=0)
# print(big_cols)
big_centers = np.repeat(centers, verts.shape[0], axis=0)
# print(big_centers)
big_centers *= big_scales[:, np.newaxis]
# print(big_centers)
set_polydata_vertices(polydata, big_verts)
set_polydata_triangles(polydata, big_tris)
set_polydata_colors(polydata, big_cols)
vtk_centers = numpy_to_vtk(big_centers, deep=True)
vtk_centers.SetNumberOfComponents(3)
vtk_centers.SetName("center")
polydata.GetPointData().AddArray(vtk_centers)
canvas_actor = get_actor_from_polydata(polydata)
canvas_actor.GetProperty().BackfaceCullingOff()
mapper = canvas_actor.GetMapper()
mapper.MapDataArrayToVertexAttribute(
"center", "center", vtk.vtkDataObject.FIELD_ASSOCIATION_POINTS,
-1)
vtk_major_version = vtk.vtkVersion.GetVTKMajorVersion()
vtk_minor_version = vtk.vtkVersion.GetVTKMinorVersion()
if vtk_major_version > 8 or (vtk_major_version == 8
and vtk_minor_version >= 90):
mapper = canvas_actor.GetShaderProperty()
mapper.AddShaderReplacement(
vtk.vtkShader.Vertex, "//VTK::ValuePass::Dec", True, """
//VTK::ValuePass::Dec
in vec3 center;
out vec3 centeredVertexMC;
""", False)
mapper.AddShaderReplacement(
vtk.vtkShader.Vertex, "//VTK::ValuePass::Impl", True, """
//VTK::ValuePass::Impl
centeredVertexMC = vertexMC.xyz - center;
float scalingFactor = 1. / abs(centeredVertexMC.x);
centeredVertexMC *= scalingFactor;
vec3 cameraRight = vec3(MCVCMatrix[0][0], MCVCMatrix[1][0],
MCVCMatrix[2][0]);
vec3 cameraUp = vec3(MCVCMatrix[0][1], MCVCMatrix[1][1],
MCVCMatrix[2][1]);
vec2 squareVertices = vec2(.5, -.5);
vec3 vertexPosition = center + cameraRight * squareVertices.x *
vertexMC.x + cameraUp * squareVertices.y *
vertexMC.y;
gl_Position = MCDCMatrix * vec4(vertexPosition, 1.);
gl_Position /= gl_Position.w;
""", False)
mapper.AddShaderReplacement(
vtk.vtkShader.Fragment, "//VTK::ValuePass::Dec", True, """
//VTK::ValuePass::Dec
in vec3 centeredVertexMC;
""", False)
mapper.AddShaderReplacement(
vtk.vtkShader.Fragment, "//VTK::Light::Impl", True, """
// Renaming variables passed from the Vertex Shader
vec3 color = vertexColorVSOutput.rgb;
vec3 point = centeredVertexMC;
float len = length(point);
// VTK Fake Spheres
float radius = 1.;
if(len > radius)
discard;
vec3 normalizedPoint = normalize(vec3(point.xy, sqrt(1. - len)));
vec3 direction = normalize(vec3(1., -1., 1.));
float df = max(0, dot(direction, normalizedPoint));
float sf = pow(df, 24);
fragOutput0 = vec4(max(df * color, sf * vec3(1)), 1);
""", False)
scene.add(canvas_actor)
#scene.add(actor.axes())
showm = window.ShowManager(scene)
renderWindow = showm.window
# VTK Web application specific
_WebSpheres.view = renderWindow
self.getApplication().GetObjectIdMap().\
SetActiveObject('VIEW', renderWindow)
