def display_scene(scene):
"""
:param smc: input structure structure molecule component
"""
obs = traverse_scene_object(scene)
scene = Scene(children=list(obs.children))
box = Box3.exec_three_obj_method("setFromObject", scene)
extent = (max(box.max.z - box.min.z, box.max.y - box.min.y,
box.max.x - box.min.x) * 1.2)
camera = OrthographicCamera(-extent,
extent,
extent,
-extent,
-2000,
2000,
position=(0, 0, 2))
camera.children.extend([
AmbientLight(color="#cccccc", intensity=0.75),
DirectionalLight(color="#ccaabb", position=[0, 20, 10], intensity=0.5),
])
renderer = Renderer(
camera=camera,
background="white",
background_opacity=1,
scene=scene,
controls=[OrbitControls(controlling=camera)],
width=500,
height=500,
antialias=True,
)
display(renderer)
def __init__(
self,
width=768,
height=512,
near=0.01,
far=1000,
background="#111111",
antialias=True,
):
key_light = DirectionalLight(color="white", position=[3, 3, 3], intensity=0.66)
c = PerspectiveCamera(40, width / height, near, far)
c.position = [3, 3, 3]
c.up = [0, 0, 1]
c.add(key_light)
pl = PointLight(color="white", intensity=0.1, position=[3, 3, 3])
self._scene = Scene()
self._scene.background = background
self._scene.add(AmbientLight())
self._scene.add(pl)
renderer = Renderer(
camera=c,
scene=self._scene,
antialias=antialias,
controls=[OrbitControls(controlling=c)],
height=height,
width=width,
)
display(renderer)
def display_StructureMoleculeComponent(smc):
"""
:param smc: input structure structure molecule component
"""
obs = traverse_scene_object(smc.initial_scene_data)
obs_children = list(obs.children)
obs_children.extend([
AmbientLight(color='#cccccc', intensity=0.75),
DirectionalLight(color='#ccaabb', position=[0, 20, 10], intensity=0.5)
])
diag = np.linalg.norm(np.sum(smc._lattice.matrix, axis=0))
scene = Scene(children=obs_children)
c = OrthographicCamera(-diag,
diag,
diag,
-diag,
-4000,
4000,
position=(0, 0, 0.001))
renderer = Renderer(camera=c,
background='black',
background_opacity=1,
scene=scene,
controls=[OrbitControls(controlling=c)],
width=500,
height=500)
display(renderer)
def pseudomaterial_render(atoms):
c = cm.get_cmap("plasma")
scale_axis_vertices = [[-1, -1, -1], [9, -1, -1]]
scale_line_geom = Geometry(vertices=scale_axis_vertices,
colors=['black'] * len(scale_axis_vertices))
scale_lines = Line(
geometry=scale_line_geom,
material=LineBasicMaterial(linewidth=50, vertexColors='VertexColors'),
type='LinePieces',
)
a = atoms.a[1]
cube_vertices = [[0, 0, 0], [a, 0, 0], [a, 0, a], [a, 0, 0], [a, a, 0],
[a, a, a], [a, a, 0], [0, a, 0], [0, a, a], [0, a, 0],
[0, 0, 0], [0, 0, a], [a, 0, a], [a, a, a], [0, a, a],
[0, 0, a]]
linesgeom = Geometry(vertices=cube_vertices,
colors=['black'] * len(cube_vertices))
lines = Line(
geometry=linesgeom,
material=LineBasicMaterial(linewidth=5, vertexColors='VertexColors'),
type='LinePieces',
)
balls = []
for p in atoms.itertuples():
positions = (p.x * p.a, p.y * p.a, p.z * p.a)
new_ball = Mesh(
geometry=SphereGeometry(radius=p.sigma,
widthSegments=32,
heightSegments=24),
material=MeshLambertMaterial(color=rgb2hex(c(p.epsilon_norm))),
position=positions)
balls.append(new_ball)
# [scale*2*a,scale*2*a,scale*2*a]
camera = PerspectiveCamera(position=[25, a, a],
up=[0, 1, 0],
children=[
DirectionalLight(color='white',
position=[3, 5, 1],
intensity=0.5)
])
scene = Scene(children=[
scale_lines, lines, *balls, camera,
AmbientLight(color='#777')
])
renderer = Renderer(
camera=camera,
scene=scene,
controls=[OrbitControls(controlling=camera, target=[a, a, a])])
return renderer
def __init__(
self,
figsize: Tuple[int, int] = None,
background: Union[str, Tuple[float, float, float]] = None,
register_default: bool = True,
):
"""
Create a new figure.
All arguments are optional.
Arguments:
figsize: The size to make the visualization
background: color to make background
register_default: register the default layers
"""
if figsize is None:
figsize = (_DEFAULT_FIGURE_WIDTH, _DEFAULT_FIGURE_HEIGHT)
self._figsize = figsize
self._layer_lookup = dict()
self._camera = PerspectiveCamera(
position=tuple(np.array([0, 0, 5])),
up=(0, 1, 0),
far=1e6,
aspect=self._figsize[0] / self._figsize[1],
children=[
DirectionalLight(
color="#ffffff",
position=tuple(np.array([3, 5, 1])),
intensity=0.6,
),
],
)
self._click_callbacks = dict()
self.controls = [OrbitControls(controlling=self._camera)]
self._controllable_layers = []
self.background = background
if register_default:
for layer in [
MeshLayer,
ScatterLayer,
LinesLayer,
AxesLayer,
GraphLayer,
ImshowLayer,
GridLayer,
]:
self.register_layer(layer)
def display_scene(scene, size=500):
"""
Render a Scene object with pythreejs.
:param scene: Scene object
:param size: Display size
:return:
"""
obs = _traverse_scene_object(scene)
logger.debug(type(obs))
scene2render = Scene(children=list(obs.children))
logger.debug(len(scene2render.children))
# cannot use the setFromObject function because the function call is asyncronous
# https://github.com/jupyter-widgets/pythreejs/issues/282
bounding_box = scene.bounding_box
extent = max([p[1] - p[0] for p in zip(*bounding_box)]) * 1.2
logger.debug(f"extent : {extent}")
camera = OrthographicCamera(-extent,
+extent,
extent,
-extent,
-2000,
2000,
position=[0, 0, 10])
origin = scene.origin or (0, 0, 0)
cam_target = tuple(-i for i in origin)
controls = OrbitControls(target=cam_target, controlling=camera)
camera.lookAt(cam_target)
scene2render.children = scene2render.children + (
AmbientLight(color="#cccccc", intensity=0.75),
DirectionalLight(color="#ccaabb", position=[0, 20, 10], intensity=0.5),
camera,
)
renderer = Renderer(
camera=camera,
background="white",
background_opacity=1,
scene=scene2render,
controls=[controls],
width=size,
height=size,
antialias=True,
)
logger.debug("Start drawing to the notebook")
display(renderer)
def renderScene(items: List[Mesh],
width: int = WIDTH,
height: int = HEIGHT,
camera_z: float = CAM_Z,
mid_point: List[float] = [0, 0, 0]) -> Renderer:
c = PerspectiveCamera(fov=90,
aspect=width / height,
near=1,
far=1000,
position=[0, 0, camera_z],
up=[0, 1, 0],
children=[
DirectionalLight(color='white',
position=[3, 5, 1],
intensity=0.5)
])
for x in items:
x.position = [x.position[i] - mid_point[i] for i in range(3)]
scene = Scene(children=items + [c, AmbientLight(color='#777777')],
background='#000000')
renderer = Renderer(camera=c,
scene=scene,
width=width,
height=height,
controls=[OrbitControls(controlling=c)])
# scene = Scene(children=items+[c, AmbientLight(color='#777777')])
# renderer = WebGLRenderer(camera=c,
# scene=scene,
# width=width, height=height,
# controls=[OrbitControls(controlling=c)],
# alpha=True)
# renderer.setClearColor('#000000', 0.5)
renderer.render(scene, c)
return renderer, scene, c
def display_scene(scene):
"""
:param smc: input structure structure molecule component
"""
obs = traverse_scene_object(scene)
logger.debug(type(obs))
scene2render = Scene(children=list(obs.children))
logger.debug(len(scene2render.children))
# cannot use the setFromObject function because the function call is asyncronous
# https://github.com/jupyter-widgets/pythreejs/issues/282
bounding_box = scene.bounding_box
extent = max([p[1] - p[0] for p in zip(*bounding_box)]) * 1.2
logger.debug(f"extent : {extent}")
camera = OrthographicCamera(-extent,
extent,
extent,
-extent,
-2000,
2000,
position=(0, 0, 2))
scene2render.children = scene2render.children + (
AmbientLight(color="#cccccc", intensity=0.75),
DirectionalLight(color="#ccaabb", position=[0, 20, 10], intensity=0.5),
)
renderer = Renderer(
camera=camera,
background="white",
background_opacity=1,
scene=scene2render,
controls=[OrbitControls(controlling=camera)],
width=500,
height=500,
antialias=True,
)
logger.debug("Start drawing to the notebook")
display(renderer)
def build_display(self,
position=None,
rotation=None,
camera_type="orthographic"):
"""
:param position: Camera Position
:param rotation: Camera Rotation
:param camera_type: Camera Type "orthographic" or "perspective"
"""
import itertools
import math
from OCC.Core.BRepPrimAPI import BRepPrimAPI_MakeSphere
from OCC.Display.WebGl.jupyter_renderer import Axes, Grid, _add
from pythreejs import (
AmbientLight,
CombinedCamera,
DirectionalLight,
OrbitControls,
Picker,
Renderer,
Scene,
)
# Get the overall bounding box
if self._shapes:
self._bb = BoundingBox([self._shapes.values()])
else: # if nothing registered yet, create a fake bb
self._bb = BoundingBox([[BRepPrimAPI_MakeSphere(5.0).Shape()]])
bb_max = self._bb.max
orbit_radius = 1.5 * self._bb._max_dist_from_center()
# Set up camera
camera_target = self._bb.center
camera_position = _add(
self._bb.center,
self._scale(
[1, 1, 1] if position is None else self._scale(position)))
camera_zoom = self._camera_initial_zoom
self._camera = CombinedCamera(position=camera_position,
width=self._size[0],
height=self._size[1])
self._camera.up = (0.0, 0.0, 1.0)
self._camera.mode = camera_type
self._camera_target = camera_target
self._camera.position = camera_position
if rotation is not None:
self._camera.rotation = rotation
# Set up lights in every of the 8 corners of the global bounding box
positions = list(
itertools.product(*[(-orbit_radius, orbit_radius)] * 3))
key_lights = [
DirectionalLight(color="white", position=pos, intensity=0.5)
for pos in positions
]
ambient_light = AmbientLight(intensity=0.1)
# Set up Helpers
self.axes = Axes(bb_center=self._bb.center, length=bb_max * 1.1)
self.horizontal_grid = Grid(bb_center=self._bb.center,
maximum=bb_max,
colorCenterLine="#aaa",
colorGrid="#ddd")
self.vertical_grid = Grid(bb_center=self._bb.center,
maximum=bb_max,
colorCenterLine="#aaa",
colorGrid="#ddd")
# Set up scene
temp_elems = [
ambient_light, self.horizontal_grid.grid, self.vertical_grid.grid,
self._camera
]
environment = self.axes.axes + key_lights + temp_elems
scene_shp = Scene(children=[
self._displayed_pickable_objects,
self._displayed_non_pickable_objects
] + environment)
# Set up Controllers
inf = 1e20
orbit_controls = OrbitControls(
controlling=self._camera,
target=camera_target,
target0=camera_target,
maxAzimuthAngle=inf,
maxDistance=inf,
maxZoom=inf,
minAzimuthAngle=-inf,
)
self._controller = orbit_controls
# Update controller to instantiate camera position
self._camera.zoom = camera_zoom
self._update()
# setup Picker
self._picker = Picker(controlling=self._displayed_pickable_objects,
event="dblclick")
self._picker.observe(self.click)
self._renderer = Renderer(
camera=self._camera,
background=self._background,
background_opacity=self._background_opacity,
scene=scene_shp,
controls=[self._controller, self._picker],
width=self._size[0],
height=self._size[1],
antialias=True,
)
# set rotation and position for each grid
self.horizontal_grid.set_position((0, 0, 0))
self.horizontal_grid.set_rotation((math.pi / 2.0, 0, 0, "XYZ"))
self.vertical_grid.set_position((0, -bb_max, 0))
self._savestate = (self._camera.rotation, self._controller.target)
def Display(self):
# Get the overall bounding box
if self._shapes:
self._bb = BoundingBox([self._shapes.values()])
else: # if nothing registered yet, create a fake bb
self._bb = BoundingBox([[BRepPrimAPI_MakeSphere(5.).Shape()]])
bb_max = self._bb.max
bb_diag = 2 * self._bb.diagonal
# Set up camera
camera_target = self._bb.center
camera_position = self._scale([1, 1, 1])
self._camera = CombinedCamera(position=camera_position,
width=self._size[0], height=self._size[1],
far=10 * bb_diag, orthoFar=10 * bb_diag)
self._camera.up = (0.0, 0.0, 1.0)
self._camera.lookAt(camera_target)
self._camera.mode = 'orthographic'
self._camera_target = camera_target
self._camera.position = camera_position
# Set up lights in every of the 8 corners of the global bounding box
key_lights = [
DirectionalLight(color='white', position=position, intensity=0.12)
for position in list(itertools.product((-bb_diag, bb_diag), (-bb_diag, bb_diag), (-bb_diag, bb_diag)))
]
ambient_light = AmbientLight(intensity=1.0)
# Set up Helpers
self.axes = Axes(bb_center=self._bb.center, length=bb_max * 1.1)
self.grid = Grid(bb_center=self._bb.center, maximum=bb_max, colorCenterLine='#aaa', colorGrid='#ddd')
# Set up scene
environment = self.axes.axes + key_lights + [ambient_light, self.grid.grid, self._camera]
scene_shp = Scene(children=[self._displayed_pickable_objects,
self._displayed_non_pickable_objects] + environment)
# Set up Controllers
self._controller = OrbitControls(controlling=self._camera, target=camera_target)
self._renderer = Renderer(camera=self._camera,
background=self._background,
background_opacity=self._background_opacity,
scene=scene_shp,
controls=[self._controller, self._picker],
width=self._size[0],
height=self._size[1],
antialias=True)
# needs to be done after setup of camera
self.grid.set_rotation((math.pi / 2.0, 0, 0, "XYZ"))
self.grid.set_position((0, 0, 0))
# Workaround: Zoom forth and back to update frame. Sometimes necessary :(
self._camera.zoom = 1.01
self._update()
self._camera.zoom = 1.0
self._update()
# then display both 3d widgets and webui
display(HBox([self._renderer, self.html]))
def DisplayMesh(self,
mesh,
color=default_mesh_color):
""" Display a MEFISTO2 triangle mesh
"""
if not HAVE_SMESH:
print("SMESH not installed, DisplayMesh method unavailable.")
return
if not isinstance(mesh, SMESH_Mesh):
raise AssertionError("You mush provide an SMESH_Mesh instance")
mesh_ds = mesh.GetMeshDS() # the mesh data source
face_iter = mesh_ds.facesIterator()
# vertices positions are stored to a liste
vertices_position = []
for _ in range(mesh_ds.NbFaces()-1):
face = face_iter.next()
#print('Face %i, type %i' % (i, face.GetType()))
#print(dir(face))
# if face.GetType == 3 : triangle mesh, then 3 nodes
for j in range(3):
node = face.GetNode(j)
#print('Coordinates of node %i:(%f,%f,%f)'%(i, node.X(), node.Y(), node.Z()))
vertices_position.append(node.X())
vertices_position.append(node.Y())
vertices_position.append(node.Z())
number_of_vertices = len(vertices_position)
# then we build the vertex and faces collections as numpy ndarrays
np_vertices = np.array(vertices_position, dtype='float32').reshape(int(number_of_vertices / 3), 3)
# Note: np_faces is just [0, 1, 2, 3, 4, 5, ...], thus arange is used
np_faces = np.arange(np_vertices.shape[0], dtype='uint32')
# set geometry properties
buffer_geometry_properties = {'position': BufferAttribute(np_vertices),
'index' : BufferAttribute(np_faces)}
# build a BufferGeometry instance
mesh_geometry = BufferGeometry(attributes=buffer_geometry_properties)
mesh_geometry.exec_three_obj_method('computeVertexNormals')
# then a default material
mesh_material = MeshPhongMaterial(color=color,
polygonOffset=True,
polygonOffsetFactor=1,
polygonOffsetUnits=1,
shininess=0.5,
wireframe=False,
side='DoubleSide')
edges_material = MeshPhongMaterial(color='black',
polygonOffset=True,
polygonOffsetFactor=1,
polygonOffsetUnits=1,
shininess=0.5,
wireframe=True)
# create a mesh unique id
mesh_id = uuid.uuid4().hex
# finally create the mash
shape_mesh = Mesh(geometry=mesh_geometry,
material=mesh_material,
name=mesh_id)
edges_mesh = Mesh(geometry=mesh_geometry,
material=edges_material,
name=mesh_id)
# a special display for the mesh
camera_target = [0., 0., 0.] # the point to look at
camera_position = [0, 0., 100.] # the camera initial position
camera = PerspectiveCamera(position=camera_position,
lookAt=camera_target,
up=[0, 0, 1],
fov=50,
children=[DirectionalLight(color='#ffffff',
position=[50, 50, 50],
intensity=0.9)])
scene_shp = Scene(children=[shape_mesh, edges_mesh, camera, AmbientLight(color='#101010')])
renderer = Renderer(camera=camera,
background=self._background,
background_opacity=self._background_opacity,
scene=scene_shp,
controls=[OrbitControls(controlling=camera, target=camera_target)],
width=self._size[0],
height=self._size[1],
antialias=True)
display(renderer)
def Display(self, position=None, rotation=None):
# Get the overall bounding box
if self._shapes:
self._bb = BoundingBox([self._shapes.values()])
else: # if nothing registered yet, create a fake bb
self._bb = BoundingBox([[BRepPrimAPI_MakeSphere(5.).Shape()]])
bb_max = self._bb.max
orbit_radius = 1.5 * self._bb._max_dist_from_center()
# Set up camera
camera_target = self._bb.center
camera_position = _add(
self._bb.center,
self._scale(
[1, 1, 1] if position is None else self._scale(position)))
camera_zoom = self._camera_initial_zoom
self._camera = CombinedCamera(position=camera_position,
width=self._size[0],
height=self._size[1])
self._camera.up = (0.0, 0.0, 1.0)
self._camera.mode = 'orthographic'
self._camera_target = camera_target
self._camera.position = camera_position
if rotation is not None:
self._camera.rotation = rotation
# Set up lights in every of the 8 corners of the global bounding box
positions = list(
itertools.product(*[(-orbit_radius, orbit_radius)] * 3))
key_lights = [
DirectionalLight(color='white', position=pos, intensity=0.5)
for pos in positions
]
ambient_light = AmbientLight(intensity=0.1)
# Set up Helpers
self.axes = Axes(bb_center=self._bb.center, length=bb_max * 1.1)
self.horizontal_grid = Grid(bb_center=self._bb.center,
maximum=bb_max,
colorCenterLine='#aaa',
colorGrid='#ddd')
self.vertical_grid = Grid(bb_center=self._bb.center,
maximum=bb_max,
colorCenterLine='#aaa',
colorGrid='#ddd')
# Set up scene
environment = self.axes.axes + key_lights + [
ambient_light, self.horizontal_grid.grid, self.vertical_grid.grid,
self._camera
]
scene_shp = Scene(children=[
self._displayed_pickable_objects,
self._displayed_non_pickable_objects
] + environment)
# Set up Controllers
self._controller = OrbitControls(controlling=self._camera,
target=camera_target,
target0=camera_target)
# Update controller to instantiate camera position
self._camera.zoom = camera_zoom
self._update()
# setup Picker
self._picker = Picker(controlling=self._displayed_pickable_objects,
event='dblclick')
self._picker.observe(self.click)
self._renderer = Renderer(camera=self._camera,
background=self._background,
background_opacity=self._background_opacity,
scene=scene_shp,
controls=[self._controller, self._picker],
width=self._size[0],
height=self._size[1],
antialias=True)
# set rotation and position for each grid
self.horizontal_grid.set_position((0, 0, 0))
self.horizontal_grid.set_rotation((math.pi / 2.0, 0, 0, "XYZ"))
self.vertical_grid.set_position((0, -bb_max, 0))
self._savestate = (self._camera.rotation, self._controller.target)
# then display both 3d widgets and webui
display(HBox([VBox([HBox(self._controls), self._renderer]),
self.html]))
def render(self, position=None, rotation=None, zoom=None):
# Render all shapes
for i, shape in enumerate(self.shapes):
s = shape["shape"]
# Assume that all are edges when first element is an edge
if is_edge(s[0]):
self._render_shape(i,
edges=s,
render_edges=True,
edge_color=shape["color"],
edge_width=3)
elif is_vertex(s[0]):
self._render_shape(i,
vertices=s,
render_edges=False,
vertex_color=shape["color"],
vertex_width=6)
else:
# shape has only 1 object, hence first=True
self._render_shape(i,
shape=s[0],
render_edges=True,
mesh_color=shape["color"])
# Get the overall bounding box
self.bb = BoundingBox([shape["shape"] for shape in self.shapes])
bb_max = self.bb.max
bb_diag = 2 * self.bb.diagonal
# Set up camera
camera_target = self.bb.center
camera_position = self._scale(
[1, 1, 1] if position is None else position)
camera_zoom = 1.0 if zoom is None else zoom
self.camera = CombinedCamera(position=camera_position,
width=self.width,
height=self.height,
far=10 * bb_diag,
orthoFar=10 * bb_diag)
self.camera.up = (0.0, 0.0, 1.0)
self.camera.lookAt(camera_target)
self.camera.mode = 'orthographic'
self.camera.position = camera_position
if rotation is not None:
self.camera.rotation = rotation
# Set up lights in every of the 8 corners of the global bounding box
key_lights = [
DirectionalLight(color='white', position=position, intensity=0.12)
for position in list(
itertools.product((-bb_diag, bb_diag), (-bb_diag,
bb_diag), (-bb_diag,
bb_diag)))
]
ambient_light = AmbientLight(intensity=1.0)
# Set up Helpers
self.axes = Axes(bb_center=self.bb.center, length=bb_max * 1.1)
self.grid = Grid(bb_center=self.bb.center,
maximum=bb_max,
colorCenterLine='#aaa',
colorGrid='#ddd')
# Set up scene
environment = self.axes.axes + key_lights + [
ambient_light, self.grid.grid, self.camera
]
self.scene = Scene(children=environment + [self.pickable_objects])
# Set up Controllers
self.controller = OrbitControls(controlling=self.camera,
target=camera_target)
self.picker = Picker(controlling=self.pickable_objects,
event='dblclick')
self.picker.observe(self.pick)
# Create Renderer instance
self.renderer = Renderer(scene=self.scene,
camera=self.camera,
controls=[self.controller, self.picker],
antialias=True,
width=self.width,
height=self.height)
self.renderer.localClippingEnabled = True
self.renderer.clippingPlanes = [
Plane((1, 0, 0), self.grid.size / 2),
Plane((0, 1, 0), self.grid.size / 2),
Plane((0, 0, 1), self.grid.size / 2)
]
# needs to be done after setup of camera
self.grid.set_rotation((math.pi / 2.0, 0, 0, "XYZ"))
self.grid.set_position((0, 0, 0))
self.savestate = (self.camera.rotation, self.controller.target)
# Workaround: Zoom forth and back to update frame. Sometimes necessary :(
self.camera.zoom = camera_zoom + 0.01
self._update()
self.camera.zoom = camera_zoom
self._update()
return self.renderer
def render(self, position=None, rotation=None, zoom=2.5):
self.camera_initial_zoom = zoom
start_render_time = self._start_timer()
# Render all shapes
for i, shape in enumerate(self.shapes):
s = shape["shape"]
# Assume that all are edges when first element is an edge
if is_edge(s[0]):
self._render_shape(i,
edges=s,
render_edges=True,
edge_color=shape["color"],
edge_width=3)
elif is_vertex(s[0]):
self._render_shape(i,
vertices=s,
render_edges=False,
vertex_color=shape["color"],
vertex_width=6)
else:
# shape has only 1 object, hence first=True
self._render_shape(i,
shape=s[0],
render_edges=True,
mesh_color=shape["color"])
# Get the overall bounding box
self.bb = BoundingBox([shape["shape"] for shape in self.shapes])
bb_max = self.bb.max
orbit_radius = 2 * self.bb.max_dist_from_center()
# Set up camera
camera_target = self.bb.center
camera_up = (0.0, 0.0, 1.0)
if rotation != (0, 0, 0):
position = rotate(position, *rotation)
camera_position = self._add(
self.bb.center,
self._scale(
[1, 1, 1] if position is None else self._scale(position)))
self.camera = CombinedCamera(
position=camera_position,
width=self.width,
height=self.height
# far=10 * orbit_radius,
# orthoFar=10 * orbit_radius
)
self.camera.up = camera_up
self.camera.mode = 'orthographic'
self.camera.position = camera_position
# Set up lights in every of the 8 corners of the global bounding box
positions = list(
itertools.product(*[(-orbit_radius, orbit_radius)] * 3))
key_lights = [
DirectionalLight(color='white', position=position, intensity=0.12)
for position in positions
]
ambient_light = AmbientLight(intensity=1.0)
# Set up Helpers
self.axes = Axes(bb_center=self.bb.center, length=bb_max * 1.1)
self.grid = Grid(bb_center=self.bb.center,
maximum=bb_max,
colorCenterLine='#aaa',
colorGrid='#ddd')
# Set up scene
environment = self.axes.axes + key_lights + [
ambient_light, self.grid.grid, self.camera
]
self.scene = Scene(children=environment + [self.pickable_objects])
# Set up Controllers
self.controller = OrbitControls(controlling=self.camera,
target=camera_target,
target0=camera_target)
# Update controller to instantiate camera position
self.camera.zoom = zoom
self._update()
self.picker = Picker(controlling=self.pickable_objects,
event='dblclick')
self.picker.observe(self.pick)
# Create Renderer instance
self.renderer = Renderer(scene=self.scene,
camera=self.camera,
controls=[self.controller, self.picker],
antialias=True,
width=self.width,
height=self.height)
self.renderer.localClippingEnabled = True
self.renderer.clippingPlanes = [
Plane((1, 0, 0), self.grid.size / 2),
Plane((0, 1, 0), self.grid.size / 2),
Plane((0, 0, 1), self.grid.size / 2)
]
# needs to be done after setup of camera
self.grid.set_rotation((math.pi / 2.0, 0, 0, "XYZ"))
self.grid.set_position((0, 0, 0))
self.savestate = (self.camera.rotation, self.controller.target)
self._stop_timer("overall render time", start_render_time)
return self.renderer
def add_shapes(self,
shapes,
progress,
position=None,
rotation=None,
zoom=2.5,
reset=True):
def all_shapes(shapes, loc=None):
loc = shapes["loc"] if loc is None else loc * shapes["loc"]
result = []
for shape in shapes["parts"]:
if shape.get("parts") is None:
compounds = [
c for c in shape["shape"]
if is_compound(c) or is_solid(c) or is_shape(c)
]
if compounds:
if loc is None:
result.append(shape["shape"])
else:
reloc_shape = [
Shape(s).moved(loc).wrapped for s in compounds
]
result.append(reloc_shape)
else:
result += all_shapes(shape, loc)
return result
self.shapes = shapes
self.all_shapes = all_shapes(shapes)
# Render Shapes
render_timer = Timer(self.timeit, "| overall render time")
self.pickable_objects, self.pick_mapping = self.cq_renderer.render(
self.shapes, progress)
render_timer.stop()
progress.update()
bb_timer = Timer(self.timeit, "| create bounding box")
# Get bounding box
self.bb = self.get_bounding_box(self.all_shapes)
bb_timer.stop()
progress.update()
configure_timer = Timer(self.timeit, "| configure view")
bb_max = self.bb.max_dist_from_center()
orbit_radius = 4 * self.bb_factor * bb_max
# Calculate camera postion
if position is None and rotation is None: # no new defaults
if reset or self.camera_position is None: # no existing position
self.camera_position = self._add(self.bb.center,
self._scale((1, 1, 1)))
else:
position = rotate(position or (1, 1, 1), *(rotation or (0, 0, 0)))
self.camera_position = self._add(self.bb.center,
self._scale(position))
if reset or self.zoom is None:
self.zoom = zoom
# Set up Helpers relative to bounding box
xy_max = max(abs(self.bb.xmin), abs(self.bb.xmax), abs(self.bb.ymin),
abs(self.bb.ymax)) * 1.2
self.grid = Grid(
bb_center=self.bb.center,
maximum=xy_max,
colorCenterLine="#aaa",
colorGrid="#ddd",
)
self.grid.set_visibility(False)
self.axes = Axes(bb_center=self.bb.center,
length=self.grid.grid.size / 2)
self.axes.set_visibility(False)
# Set up the controller relative to bounding box
self.controller.target = self.bb.center
self.controller.target0 = self.bb.center
# Set up lights in every of the 8 corners of the global bounding box
positions = list(
itertools.product(*[(-orbit_radius, orbit_radius)] * 3))
self.key_lights = [
DirectionalLight(color="white", position=position, intensity=0.12)
for position in positions
]
# Set up Picker
self.picker = Picker(controlling=self.pickable_objects,
event="dblclick")
self.picker.observe(self.pick)
self.renderer.controls = self.renderer.controls + [self.picker]
# Set up camera
self.update_camera(self.camera_position, self.zoom, orbit_radius)
# Add objects to scene
self._fix_camera()
self.add_to_scene()
# needs to be done after setup of camera
self.grid.set_rotation((math.pi / 2.0, 0, 0, "XYZ"))
self.grid.set_position((0, 0, 0))
self.renderer.localClippingEnabled = True
self.renderer.clippingPlanes = [] # turn off when not in clipping view
self.clippingPlanes = [
Plane((-1, 0, 0),
0.02 if abs(self.bb.xmax) < 1e-4 else self.bb.xmax *
self.bb_factor),
Plane((0, -1, 0),
0.02 if abs(self.bb.ymax) < 1e-4 else self.bb.ymax *
self.bb_factor),
Plane((0, 0, -1),
0.02 if abs(self.bb.zmax) < 1e-4 else self.bb.zmax *
self.bb_factor),
]
self.savestate = (self.camera.rotation, self.controller.target)
configure_timer.stop()
progress.update()
return self.renderer
def visualize(self):
"""Start the visualization and initialize widgets"""
from pythreejs import PlainGeometry, Mesh, LambertMaterial, \
PhongMaterial, DirectionalLight, \
PerspectiveCamera, Scene, AmbientLight, \
Renderer, OrbitControls, Line, \
LineBasicMaterial, BoxGeometry, make_text
from matplotlib import colors
from matplotlib import cm
from IPython.display import display
import numpy as np
import ipywidgets as widgets
bbox = self._compute_bounding_box()
diam = bbox[1, :] - bbox[0, :]
center = .5 * _np.sum(bbox, axis=0)
xmin, ymin, zmin = bbox[0, :]
xmax, ymax, zmax = bbox[1, :]
position = (center + 2.5 * diam).tolist()
# Generate coordinate system base
box = PlainGeometry(
vertices=_np.array([[xmin, ymin, zmin], [xmax, ymin, zmin],
[xmin, ymin, zmin], [xmin, ymax, zmin],
[xmin, ymin, zmin], [xmin, ymin, zmax]]),
colors=['red', 'red', 'green', 'green', 'blue', 'blue'])
self._coord_box = Line(geometry=box,
material=LineBasicMaterial(
linewidth=10, vertexColors='VertexColors'),
type='LinePieces')
if self.data is not None:
vis_data = self.data
if not self.is_real:
vis_data = _np.real(self.data)
if not self.is_scalar:
vis_data = _np.sum(_np.abs(self.data)**2, axis=2)
self._vis_data = vis_data
self._cmap = cm.jet
self._vmin = vis_data.min()
self._vmax = vis_data.max()
cnorm = colors.Normalize(vmin=self._vmin, vmax=self._vmax)
facecolors = self._convert_data_to_colors(self._cmap, cnorm,
vis_data)
else:
facecolors = self.elements.shape[0] * [
3 * [_np.array([1., 1., 1.])]
]
self._geom = PlainGeometry(vertices=self.vertices,
faces=self.elements,
faceColors=facecolors)
self._mesh = Mesh(
geometry=self._geom,
material=LambertMaterial(vertexColors='VertexColors'))
self._wireframe = Mesh(geometry=self._geom,
material=PhongMaterial(wireframe=True,
color='black'))
light = DirectionalLight(color='white',
position=position,
intensity=0.5)
camera = PerspectiveCamera(position=position, fov=20)
self._scene = Scene(children=[
self._coord_box, self._mesh, self._wireframe,
AmbientLight(color='white')
])
self._renderer = Renderer(camera=camera,
background='white',
background_opacity=1,
scene=self._scene,
controls=[OrbitControls(controlling=camera)])
self._axes_info = widgets.Label(value="x: red; y: green; z: blue")
coord_system_toggle = widgets.Checkbox(
value=self._coord_box.visible,
description='Show coordinate axes',
disabled=False)
coord_system_toggle.observe(self.on_toggle_coord_system, names='value')
if self.data is not None:
# Enable/Disable wireframe
wireframe_toggle = widgets.Checkbox(value=self._wireframe.visible,
description='Enable wireframe',
disabled=False)
wireframe_toggle.observe(self.on_toggle_wireframe, names='value')
# Change vmin/vmax
vmin_box = widgets.FloatText(value=self._vmin,
description='vmin:',
disabled=False)
vmin_box.observe(self.on_change_vmin, names='value')
vmax_box = widgets.FloatText(value=self._vmax,
description='vmax:',
disabled=False)
vmax_box.observe(self.on_change_vmax, names='value')
vmin_info = widgets.Label(
value='Lower bound: {0}'.format(self._vmin))
vmax_info = widgets.Label(
value='Upper bound: {0}'.format(self._vmax))
range_info_box = widgets.VBox([vmin_info, vmax_info])
range_change = widgets.HBox([vmin_box, vmax_box])
toggles = widgets.HBox([wireframe_toggle, coord_system_toggle])
vbox = widgets.VBox(
[self._axes_info, range_info_box, range_change, toggles])
display(self._renderer, vbox)
else:
display(self._renderer, self._axes_info, coord_system_toggle)