def convert_renderer(pv_renderer):
"""Convert a pyvista renderer to a pythreejs renderer."""
# verify plotter hasn't been closed
width, height = pv_renderer.width, pv_renderer.height
pv_camera = pv_renderer.camera
children = meshes_from_actors(pv_renderer.actors.values(),
pv_camera.focal_point)
lights = extract_lights_from_renderer(pv_renderer)
aspect = width / height
camera = pvcamera_to_threejs_camera(pv_camera, lights, aspect)
children.append(camera)
if pv_renderer.axes_enabled:
children.append(tjs.AxesHelper(0.1))
scene = tjs.Scene(children=children,
background=color_to_hex(pv_renderer.background_color))
# replace inf with a real value here due to changes in
# ipywidges==6.4.0 see
# https://github.com/ipython/ipykernel/issues/771
inf = 1E20
orbit_controls = tjs.OrbitControls(
controlling=camera,
maxAzimuthAngle=inf,
maxDistance=inf,
maxZoom=inf,
minAzimuthAngle=-inf,
)
renderer = tjs.Renderer(
camera=camera,
scene=scene,
alpha=True,
clearOpacity=0,
controls=[orbit_controls],
width=width,
height=height,
antialias=pv_renderer.GetUseFXAA(),
)
if pv_renderer.has_border:
bdr_color = color_to_hex(pv_renderer.border_color)
renderer.layout.border = f'solid {pv_renderer.border_width}px {bdr_color}'
# for now, we can't dynamically size the render windows. If
# unset, the renderer widget will attempt to resize and the
# threejs renderer will not resize.
# renderer.layout.width = f'{width}px'
# renderer.layout.height = f'{height}px'
return renderer
def _domain_axes_default(self):
offset_vector = (self.ds.domain_left_edge -
self.ds.domain_center) * 0.1
position = tuple((self.ds.domain_left_edge +
offset_vector).in_units("code_length").d)
# We probably don't want to use the AxesHelper as it doesn't expose the
# material, which can result in it not being easy to see. But for now...
ah = pythreejs.AxesHelper(
position=position,
scale=tuple(self.ds.domain_width.in_units("code_length").d),
)
return ah
def display_jupyter(self, window_size=(800, 600), axes_arrow_length=None):
"""Returns a PyThreeJS Renderer and AnimationAction for displaying and
animating the scene inside a Jupyter notebook.
Parameters
==========
window_size : 2-tuple of integers
2-tuple containing the width and height of the renderer window in
pixels.
axes_arrow_length : float
If a positive value is supplied a red (x), green (y), and blue (z)
arrows of the supplied length will be displayed as arrows for the
global axes.
Returns
=======
vbox : widgets.VBox
A vertical box containing the action (pythreejs.AnimationAction)
and renderer (pythreejs.Renderer).
"""
if p3js is None:
raise ImportError('pythreejs needs to be installed.')
self._generate_meshes_tracks()
view_width = window_size[0]
view_height = window_size[1]
camera = p3js.PerspectiveCamera(position=[1, 1, 1],
aspect=view_width / view_height)
key_light = p3js.DirectionalLight()
ambient_light = p3js.AmbientLight()
children = self._meshes + [camera, key_light, ambient_light]
if axes_arrow_length is not None:
children += [p3js.AxesHelper(size=abs(axes_arrow_length))]
scene = p3js.Scene(children=children)
controller = p3js.OrbitControls(controlling=camera)
renderer = p3js.Renderer(camera=camera,
scene=scene,
controls=[controller],
width=view_width,
height=view_height)
clip = p3js.AnimationClip(tracks=self._tracks, duration=self.times[-1])
action = p3js.AnimationAction(p3js.AnimationMixer(scene), clip, scene)
return widgets.VBox([action, renderer])
def __init__(self):
# TODO: arguments for width/height
self._width = 600
self._height = 400
self._ball = _three.Mesh(
geometry=_three.SphereGeometry(
radius=1,
widthSegments=30,
heightSegments=20,
),
material=_three.MeshLambertMaterial(color='lightgray'),
)
self._axes = _three.AxesHelper(size=1.2)
self._ambient_light = _three.AmbientLight(
intensity=0.5,
)
self._directional_light1 = _three.DirectionalLight(
position=[0, 0, 1],
intensity=0.6,
)
self._directional_light2 = _three.DirectionalLight(
position=[0, 0, -1],
intensity=0.6,
)
self._scene = _three.Scene(
children=[
self._ball,
self._axes,
self._ambient_light,
self._directional_light1,
self._directional_light2,
],
)
self._camera = _three.PerspectiveCamera(
position=[0, 0, 2.4],
up=[0, 0, 1],
aspect=self._width/self._height,
)
self._controls = _three.OrbitControls(controlling=self._camera)
self._renderer = _three.Renderer(
camera=self._camera,
scene=self._scene,
controls=[self._controls],
width=self._width,
height=self._height,
#alpha=True,
#clearOpacity=0.5,
)
def viewer_cloth(cloth):
view_width = 800
view_height = 600
camera = THREE.PerspectiveCamera(position=[20, 5, 30],
aspect=view_width / view_height)
key_light = THREE.DirectionalLight(position=[10, 10, 10])
ambient_light = THREE.AmbientLight()
axes_helper = THREE.AxesHelper(0.5)
scene = THREE.Scene()
controller = THREE.OrbitControls(controlling=camera)
renderer = THREE.Renderer(camera=camera,
scene=scene,
controls=[controller],
width=view_width,
height=view_height)
scene.children = [cloth, axes_helper, camera, key_light, ambient_light]
return renderer
def mesh_animation(times, xt, faces):
""" Animate a mesh from a sequence of mesh vertex positions
Args:
times - a list of time values t_i at which the configuration x is specified
xt - i.e., x(t). A list of arrays representing mesh vertex positions at times t_i.
Dimensions of each array should be the same as that of mesh.geometry.array
TODO nt - n(t) vertex normals
faces - array of faces, with vertex loop for each face
Side effects:
displays rendering of mesh, with animation action
Returns: None
TODO renderer - THREE.Render to show the default scene
TODO position_action - THREE.AnimationAction IPython widget
"""
position_morph_attrs = []
for pos in xt[
1:]: # xt[0] uses as the Mesh's default/initial vertex position
position_morph_attrs.append(
THREE.BufferAttribute(pos, normalized=False))
# Testing mesh.geometry.morphAttributes = {'position': position_morph_attrs}
geom = THREE.BufferGeometry(
attributes={
'position': THREE.BufferAttribute(xt[0], normalized=False),
'index': THREE.BufferAttribute(faces.ravel())
},
morphAttributes={'position': position_morph_attrs})
matl = THREE.MeshStandardMaterial(side='DoubleSide',
color='red',
wireframe=True,
morphTargets=True)
mesh = THREE.Mesh(geom, matl)
# create key frames
position_track = THREE.NumberKeyframeTrack(
name='.morphTargetInfluences[0]',
times=times,
values=list(range(0, len(times))))
# create animation clip from the morph targets
position_clip = THREE.AnimationClip(tracks=[position_track])
# create animation action
position_action = THREE.AnimationAction(THREE.AnimationMixer(mesh),
position_clip, mesh)
# TESTING
camera = THREE.PerspectiveCamera(position=[2, 1, 2], aspect=600 / 400)
scene = THREE.Scene(children=[
mesh, camera,
THREE.AxesHelper(0.2),
THREE.DirectionalLight(position=[3, 5, 1], intensity=0.6),
THREE.AmbientLight(intensity=0.5)
])
renderer = THREE.Renderer(
camera=camera,
scene=scene,
controls=[THREE.OrbitControls(controlling=camera)],
width=600,
height=400)
display(renderer, position_action)
def __init__(self,
cmap=None,
norm=None,
figsize=None,
unit=None,
log=None,
nan_color=None,
masks=None,
pixel_size=None,
tick_size=None,
background=None,
show_outline=True,
extend=None,
xlabel=None,
ylabel=None,
zlabel=None):
if figsize is None:
figsize = (config.plot.width, config.plot.height)
# Figure toolbar
self.toolbar = PlotToolbar(ndim=3)
# Prepare colormaps
self.cmap = cmap
self.cmap.set_bad(color=nan_color)
self.scalar_map = cm.ScalarMappable(norm=norm, cmap=self.cmap)
self.masks_scalar_map = None
if len(masks) > 0:
self.masks_cmap = masks["cmap"]
self.masks_cmap.set_bad(color=nan_color)
self.masks_scalar_map = cm.ScalarMappable(norm=norm,
cmap=self.masks_cmap)
self.axlabels = {"x": xlabel, "y": ylabel, "z": zlabel}
self.positions = None
self.pixel_size = pixel_size
self.tick_size = tick_size
self.show_outline = show_outline
self.unit = unit
# Create the colorbar image
self.cbar_image = ipw.Image()
self.cbar_fig, self.cbar = self._create_colorbar(figsize, extend)
# Create the point cloud material with pythreejs
self.points_material = self._create_points_material()
self.points_geometry = None
self.point_cloud = None
self.outline = None
self.axticks = None
self.camera_reset = {}
# Define camera
self.camera = p3.PerspectiveCamera(position=[0, 0, 0],
aspect=config.plot.width /
config.plot.height)
# Add red/green/blue axes helper
self.axes_3d = p3.AxesHelper()
# Create the pythreejs scene
self.scene = p3.Scene(children=[self.camera, self.axes_3d],
background=background)
# Add camera controller
self.controls = p3.OrbitControls(controlling=self.camera)
# Render the scene into a widget
self.renderer = p3.Renderer(camera=self.camera,
scene=self.scene,
controls=[self.controls],
width=figsize[0],
height=figsize[1])
def visualise(mesh,
geometric_field,
number_of_dimensions,
xi_interpolation,
dependent_field=None,
variable=None,
mechanics_animation=False,
colour_map_dependent_component_number=None,
cmap='gist_rainbow',
resolution=1,
node_labels=False):
if number_of_dimensions != 3:
print(
'Warning: Only visualisation of 3D meshes is currently supported.')
return
if xi_interpolation != [1, 1, 1]:
print(
'Warning: Only visualisation of 3D elements with linear Lagrange \
interpolation along all coordinate directions is currently \
supported.')
return
view_width = 600
view_height = 600
debug = False
if debug:
vertices = [[0, 0, 0], [0, 0, 1], [0, 1, 0], [0, 1, 1], [1, 0, 0],
[1, 0, 1], [1, 1, 0], [1, 1, 1]]
faces = [[0, 1, 3], [0, 3, 2], [0, 2, 4], [2, 6, 4], [0, 4, 1],
[1, 4, 5], [2, 3, 6], [3, 7, 6], [1, 5, 3], [3, 5, 7],
[4, 6, 5], [5, 6, 7]]
vertexcolors = [
'#000000', '#0000ff', '#00ff00', '#ff0000', '#00ffff', '#ff00ff',
'#ffff00', '#ffffff'
]
else:
# Get mesh topology information.
num_nodes = mesh_tools.num_nodes_get(mesh, mesh_component=1)
node_nums = list(range(1, num_nodes + 1))
num_elements, element_nums = mesh_tools.num_element_get(
mesh, mesh_component=1)
# Convert geometric field to a morphic mesh and export to json
mesh = mesh_tools.OpenCMISS_to_morphic(mesh,
geometric_field,
element_nums,
node_nums,
dimension=3,
interpolation='linear')
vertices, faces, _, xi_element_nums, xis = get_faces(
mesh, res=resolution, exterior_only=True, include_xi=True)
vertices = vertices.tolist()
faces = faces.tolist()
centroid = np.mean(vertices, axis=0)
max_positions = np.max(vertices, axis=0)
min_positions = np.min(vertices, axis=0)
range_positions = max_positions - min_positions
if (dependent_field is not None) and (colour_map_dependent_component_number
is not None):
solution = np.zeros(xis.shape[0])
for idx, (xi, xi_element_num) in enumerate(zip(xis, xi_element_nums)):
solution[idx] = mesh_tools.interpolate_opencmiss_field_xi(
dependent_field,
xi,
element_ids=[xi_element_num],
dimension=3,
deriv=1)[colour_map_dependent_component_number - 1]
minima = min(solution)
maxima = max(solution)
import matplotlib
norm = matplotlib.colors.Normalize(vmin=minima, vmax=maxima, clip=True)
mapper = cm.ScalarMappable(norm=norm, cmap=cm.get_cmap(name=cmap))
vertex_colors = np.zeros((len(vertices), 3), dtype='float32')
for idx, v in enumerate(solution):
vertex_colors[idx, :] = mapper.to_rgba(v, alpha=None)[:3]
# else:
# raise ValueError('Visualisation not supported.')
else:
vertex_colors = np.tile(np.array([0.5, 0.5, 0.5], dtype='float32'),
(len(vertices), 1))
geometry = pjs.BufferGeometry(attributes=dict(
position=pjs.BufferAttribute(vertices, normalized=False),
index=pjs.BufferAttribute(
np.array(faces).astype(dtype='uint16').ravel(), normalized=False),
color=pjs.BufferAttribute(vertex_colors),
))
if mechanics_animation:
deformed_vertices = np.zeros((xis.shape[0], 3), dtype='float32')
for idx, (xi, xi_element_num) in enumerate(zip(xis, xi_element_nums)):
deformed_vertices[idx, :] = \
mesh_tools.interpolate_opencmiss_field_xi(
dependent_field, xi, element_ids=[xi_element_num],
dimension=3,
deriv=1)[0][:3]
geometry.morphAttributes = {
'position': [
pjs.BufferAttribute(deformed_vertices),
]
}
geometry.exec_three_obj_method('computeFaceNormals')
geometry.exec_three_obj_method('computeVertexNormals')
surf1 = pjs.Mesh(geometry,
pjs.MeshPhongMaterial(color='#ff3333',
shininess=150,
morphTargets=True,
side='FrontSide'),
name='A')
surf2 = pjs.Mesh(geometry,
pjs.MeshPhongMaterial(color='#ff3333',
shininess=150,
morphTargets=True,
side='BackSide'),
name='B')
surf = pjs.Group(children=[surf1, surf2])
# camera = pjs.PerspectiveCamera(
# fov=20, position=[range_positions[0] * 10,
# range_positions[1] * 10,
# range_positions[2] * 10],
# width=view_width,
# height=view_height, near=1,
# far=max(range_positions) * 10)
camera = pjs.PerspectiveCamera(position=[
range_positions[0] * 3, range_positions[1] * 3,
range_positions[2] * 3
],
aspect=view_width / view_height)
camera.up = [0, 0, 1]
camera.lookAt(centroid.tolist())
scene3 = pjs.Scene(children=[
surf1, surf2, camera,
pjs.DirectionalLight(position=[3, 5, 1], intensity=0.6),
pjs.AmbientLight(intensity=0.5)
])
axes = pjs.AxesHelper(size=range_positions[0] * 2)
scene3.add(axes)
A_track = pjs.NumberKeyframeTrack(
name='scene/A.morphTargetInfluences[0]',
times=[0, 3],
values=[0, 1])
B_track = pjs.NumberKeyframeTrack(
name='scene/B.morphTargetInfluences[0]',
times=[0, 3],
values=[0, 1])
pill_clip = pjs.AnimationClip(tracks=[A_track, B_track])
pill_action = pjs.AnimationAction(pjs.AnimationMixer(scene3),
pill_clip, scene3)
renderer3 = pjs.Renderer(
camera=camera,
scene=scene3,
controls=[pjs.OrbitControls(controlling=camera)],
width=view_width,
height=view_height)
display(renderer3, pill_action)
else:
geometry.exec_three_obj_method('computeFaceNormals')
geometry.exec_three_obj_method('computeVertexNormals')
surf1 = pjs.Mesh(geometry=geometry,
material=pjs.MeshLambertMaterial(
vertexColors='VertexColors',
side='FrontSide')) # Center the cube.
surf2 = pjs.Mesh(geometry=geometry,
material=pjs.MeshLambertMaterial(
vertexColors='VertexColors',
side='BackSide')) # Center the cube.
surf = pjs.Group(children=[surf1, surf2])
camera = pjs.PerspectiveCamera(position=[
range_positions[0] * 3, range_positions[1] * 3,
range_positions[2] * 3
],
aspect=view_width / view_height)
camera.up = [0, 0, 1]
camera.lookAt(centroid.tolist())
# if perspective:
# camera.mode = 'perspective'
# else:
# camera.mode = 'orthographic'
lights = [
pjs.DirectionalLight(position=[
range_positions[0] * 16, range_positions[1] * 12,
range_positions[2] * 17
],
intensity=0.5),
pjs.AmbientLight(intensity=0.8),
]
orbit = pjs.OrbitControls(controlling=camera,
screenSpacePanning=True,
target=centroid.tolist())
scene = pjs.Scene()
axes = pjs.AxesHelper(size=max(range_positions) * 2)
scene.add(axes)
scene.add(surf1)
scene.add(surf2)
scene.add(lights)
if node_labels:
# Add text labels for each mesh node.
v, ids = mesh.get_node_ids(group='_default')
for idx, v in enumerate(v):
text = make_text(str(ids[idx]), position=(v[0], v[1], v[2]))
scene.add(text)
# Add text for axes labels.
x_axis_label = make_text('x',
position=(max(range_positions) * 2, 0, 0))
y_axis_label = make_text('y',
position=(0, max(range_positions) * 2, 0))
z_axis_label = make_text('z',
position=(0, 0, max(range_positions) * 2))
scene.add(x_axis_label)
scene.add(y_axis_label)
scene.add(z_axis_label)
renderer = pjs.Renderer(scene=scene,
camera=camera,
controls=[orbit],
width=view_width,
height=view_height)
camera.zoom = 1
display(renderer)
return vertices, faces
def __init__(self,
scipp_obj_dict=None,
positions=None,
axes=None,
masks=None,
cmap=None,
log=None,
vmin=None,
vmax=None,
color=None,
aspect=None,
background=None,
nan_color=None,
pixel_size=None,
tick_size=None,
show_outline=True):
super().__init__(scipp_obj_dict=scipp_obj_dict,
positions=positions,
axes=axes,
masks=masks,
cmap=cmap,
log=log,
vmin=vmin,
vmax=vmax,
color=color,
aspect=aspect,
button_options=['X', 'Y', 'Z'])
self.vslice = None
self.current_cut_surface_value = None
self.cut_slider_steps = 10.
self.cbar_image = widgets.Image()
self.cut_options = {
"Xplane": 0,
"Yplane": 1,
"Zplane": 2,
"Xcylinder": 3,
"Ycylinder": 4,
"Zcylinder": 5,
"Sphere": 6,
"Value": 7
}
# Prepare colormaps
self.cmap = copy(cm.get_cmap(self.params["values"][self.name]["cmap"]))
self.cmap.set_bad(color=nan_color)
self.scalar_map = cm.ScalarMappable(
norm=self.params["values"][self.name]["norm"], cmap=self.cmap)
self.masks_scalar_map = None
if self.params["masks"][self.name]["show"]:
self.masks_cmap = copy(
cm.get_cmap(self.params["masks"][self.name]["cmap"]))
self.masks_cmap.set_bad(color=nan_color)
self.masks_scalar_map = cm.ScalarMappable(
norm=self.params["values"][self.name]["norm"],
cmap=self.masks_cmap)
# Generate the colorbar image
self.create_colorbar()
# Useful variables
self.permutations = {"x": ["y", "z"], "y": ["x", "z"], "z": ["x", "y"]}
self.remaining_inds = [0, 1]
# Search the coordinates to see if one contains vectors. If so, it will
# be used as position vectors.
self.axlabels = {"x": "", "y": "", "z": ""}
self.positions = None
self.pixel_size = pixel_size
self.tick_size = tick_size
if positions is not None:
coord = self.data_array.coords[positions]
self.positions = np.array(coord.values, dtype=np.float32)
self.axlabels.update({
"x": name_with_unit(coord, name="X"),
"y": name_with_unit(coord, name="Y"),
"z": name_with_unit(coord, name="Z")
})
else:
# If no positions are supplied, create a meshgrid from coordinate
# axes.
coords = []
labels = []
for dim, val in self.slider.items():
if val.disabled:
arr = self.slider_coord[self.name][dim]
if self.histograms[self.name][dim][dim]:
arr = to_bin_centers(arr, dim)
coords.append(arr.values)
labels.append(
name_with_unit(self.slider_coord[self.name][dim]))
z, y, x = np.meshgrid(*coords, indexing='ij')
self.positions = np.array(
[x.ravel(), y.ravel(), z.ravel()], dtype=np.float32).T
if self.pixel_size is None:
self.pixel_size = coords[0][1] - coords[0][0]
self.axlabels.update({
"z": labels[0],
"y": labels[1],
"x": labels[2]
})
# Find spatial and value limits
self.xminmax, self.center_of_mass = self.get_spatial_extents()
self.vminmax = [
sc.min(self.data_array.data).value,
sc.max(self.data_array.data).value
]
# Create the point cloud with pythreejs
self.points_geometry, self.points_material, self.points = \
self.create_points_geometry()
# Create outline around point positions
self.outline, self.axticks = self.create_outline()
# Save the size of the outline box for later
self.box_size = np.diff(list(self.xminmax.values()), axis=1).ravel()
# Define camera: look at the centre of mass of the points
camera_lookat = self.center_of_mass
camera_pos = np.array(self.center_of_mass) + 1.2 * self.box_size
self.camera = p3.PerspectiveCamera(position=list(camera_pos),
aspect=config.plot.width /
config.plot.height)
# Add red/green/blue axes helper
self.axes_3d = p3.AxesHelper(10.0 * np.linalg.norm(camera_pos))
# Create the pythreejs scene
self.scene = p3.Scene(children=[
self.camera, self.axes_3d, self.points, self.outline, self.axticks
],
background=background)
# Add camera controller
self.controller = p3.OrbitControls(controlling=self.camera,
target=camera_lookat)
self.camera.lookAt(camera_lookat)
# Render the scene into a widget
self.renderer = p3.Renderer(camera=self.camera,
scene=self.scene,
controls=[self.controller],
width=config.plot.width,
height=config.plot.height)
# Update visibility of outline according to keyword arg
self.outline.visible = show_outline
self.axticks.visible = show_outline
# Opacity slider: top value controls opacity if no cut surface is
# active. If a cut curface is present, the upper slider is the opacity
# of the slice, while the lower slider value is the opacity of the
# data not in the cut surface.
self.opacity_slider = widgets.FloatRangeSlider(
min=0.0,
max=1.0,
value=[0.1, 1],
step=0.01,
description="Opacity slider: When no cut surface is active, the "
"max value of the range slider controls the overall opacity, "
"and the lower value has no effect. When a cut surface is "
"present, the max value is the opacity of the slice, while the "
"min value is the opacity of the background.",
continuous_update=True,
style={'description_width': '60px'})
self.opacity_slider.observe(self.update_opacity, names="value")
self.opacity_checkbox = widgets.Checkbox(
value=self.opacity_slider.continuous_update,
description="Continuous update",
indent=False,
layout={"width": "20px"})
self.opacity_checkbox_link = widgets.jslink(
(self.opacity_checkbox, 'value'),
(self.opacity_slider, 'continuous_update'))
self.toggle_outline_button = widgets.ToggleButton(value=show_outline,
description='',
button_style='')
self.toggle_outline_button.observe(self.toggle_outline, names="value")
# Run a trigger to update button text
self.toggle_outline({"new": show_outline})
# Add buttons to provide a choice of different cut surfaces:
# - Cartesian X, Y, Z
# - Cylindrical X, Y, Z (cylinder major axis)
# - Sperical R
# - Value-based iso-surface
# Note additional spaces required in cylindrical names because
# options must be unique.
self.cut_surface_buttons = widgets.ToggleButtons(
options=[('X ', self.cut_options["Xplane"]),
('Y ', self.cut_options["Yplane"]),
('Z ', self.cut_options["Zplane"]),
('R ', self.cut_options["Sphere"]),
(' X ', self.cut_options["Xcylinder"]),
(' Y ', self.cut_options["Ycylinder"]),
(' Z ', self.cut_options["Zcylinder"]),
('', self.cut_options["Value"])],
value=None,
description='Cut surface:',
button_style='',
tooltips=[
'X-plane', 'Y-plane', 'Z-plane', 'Sphere', 'Cylinder-X',
'Cylinder-Y', 'Cylinder-Z', 'Value'
],
icons=(['cube'] * 3) + ['circle-o'] + (['toggle-on'] * 3) +
['magic'],
style={"button_width": "55px"},
layout={'width': '350px'})
self.cut_surface_buttons.observe(self.update_cut_surface_buttons,
names="value")
# Add a capture for a click event: if the active button is clicked,
# this resets the togglebuttons value to None and deletes the cut
# surface.
self.cut_surface_buttons.on_msg(self.check_if_reset_needed)
# Add slider to control position of cut surface
self.cut_slider = widgets.FloatSlider(min=0,
max=1,
description="Position:",
disabled=True,
value=0.5,
layout={"width": "350px"})
self.cut_checkbox = widgets.Checkbox(value=True,
description="Continuous update",
indent=False,
layout={"width": "20px"},
disabled=True)
self.cut_checkbox_link = widgets.jslink(
(self.cut_checkbox, 'value'),
(self.cut_slider, 'continuous_update'))
self.cut_slider.observe(self.update_cut_surface, names="value")
# Allow to change the thickness of the cut surface
self.cut_surface_thickness = widgets.BoundedFloatText(
value=0.05 * self.box_size.max(),
min=0,
layout={"width": "150px"},
disabled=True,
description="Thickness:",
style={'description_width': 'initial'})
self.cut_surface_thickness.observe(self.update_cut_surface,
names="value")
self.cut_thickness_link = widgets.jslink(
(self.cut_slider, 'step'), (self.cut_surface_thickness, 'value'))
self.cut_slider.observe(self.update_cut_surface, names="value")
# Put widgets into boxes
self.cut_surface_controls = widgets.HBox([
self.cut_surface_buttons,
widgets.VBox([
widgets.HBox([self.cut_slider, self.cut_checkbox]),
self.cut_surface_thickness
])
])
self.box = widgets.VBox([
widgets.HBox([self.renderer, self.cbar_image]),
widgets.VBox(self.vbox),
widgets.HBox([
self.opacity_slider, self.opacity_checkbox,
self.toggle_outline_button
]), self.cut_surface_controls
])
# Update list of members to be returned in the SciPlot object
self.members.update({
"camera": self.camera,
"scene": self.scene,
"renderer": self.renderer
})
return
def display_scene(lm_scene):
"""Display Lightmetrica scene."""
# Scene
scene = three.Scene()
# Camera
# Get lm camera information
lm_main_camera = lm_scene.camera()
lm_camera_params = lm_main_camera.underlying_value()
camera = three.PerspectiveCamera(fov=lm_camera_params['vfov'],
aspect=lm_camera_params['aspect'],
near=0.1,
far=10000)
camera.position = lm_camera_params['eye']
camera.up = lm_camera_params['up']
scene.add(camera)
# Mesh
def add_lm_scene_mesh():
# Default material
mat_default = three.MeshBasicMaterial(color='#000000',
wireframe=True,
transparent=True,
opacity=0.2,
depthTest=False)
# Convert lm mesh
def traverse_func(node, trans):
# Underlying mesh
mesh = node.primitive.mesh
if mesh is None:
return
# Iterate through all triangles
vs = []
def process_triangle(face_index, tri):
vs.append(list(tri.p1.p))
vs.append(list(tri.p2.p))
vs.append(list(tri.p3.p))
mesh.foreach_triangle(process_triangle)
# Create geometry
ps_attr = three.BufferAttribute(array=vs, normalized=False)
geom = three.BufferGeometry(attributes={'position': ps_attr})
# Create mesh
mesh = three.Mesh(geometry=geom, material=mat_default)
mesh.matrixAutoUpdate = False
mesh.matrix = trans.T.flatten().tolist()
scene.add(mesh)
lm_scene.traverse_primitive_nodes(traverse_func)
add_lm_scene_mesh()
# View frustum
def add_view_frustum():
position = np.array(lm_camera_params['eye'])
center = np.array(lm_camera_params['center'])
up = np.array(lm_camera_params['up'])
aspect = lm_camera_params['aspect']
fov = math.radians(lm_camera_params['vfov'])
M = lookat_matrix(position, center, up)
z = 5
half_fov = fov * .5
y = math.tan(half_fov) * z
x = aspect * y
p = list(position)
p1 = list(position + np.dot(M, [-x, -y, -z]))
p2 = list(position + np.dot(M, [x, -y, -z]))
p3 = list(position + np.dot(M, [x, y, -z]))
p4 = list(position + np.dot(M, [-x, y, -z]))
# Add mesh
geom = three.Geometry(
vertices=[p, p1, p2, p, p2, p3, p, p3, p4, p, p4, p1])
mat = three.MeshBasicMaterial(color='#00ff00',
wireframe=True,
side='DoubleSide')
mesh = three.Line(geometry=geom, material=mat)
scene.add(mesh)
add_view_frustum()
# Axis
axes = three.AxesHelper(size=1)
scene.add(axes)
# Renderer
controls = three.OrbitControls(controlling=camera)
# Rendered image size
w = 1000
h = w / lm_camera_params['aspect']
# We need to set both target and lookAt in this order.
# Otherwise the initial target position becomes wrong.
# cf. https://github.com/jupyter-widgets/pythreejs/issues/200
controls.target = lm_camera_params['center']
camera.lookAt(lm_camera_params['center'])
renderer = three.Renderer(camera=camera,
scene=scene,
width=w,
height=h,
controls=[controls])
# Button to reset camera configuration
# Note that we need to press the button twice to reset the control
# to the correct target possibly due to the bug of pythreejs.
reset_camera_button = widgets.Button(description="Reset Camera")
@reset_camera_button.on_click
def reset_camera_button_on_click(b):
controls.reset()
controls.target = lm_camera_params['center']
camera.lookAt(lm_camera_params['center'])
# Display all
display(reset_camera_button)
display(renderer)
return scene, camera, renderer