def create(self):
self.cq_renderer = CadqueryRenderer(
quality=self.quality,
angular_tolerance=self.angular_tolerance,
edge_accuracy=self.edge_accuracy,
render_edges=self.render_edges,
render_shapes=self.render_shapes,
default_mesh_color=self.default_mesh_color,
default_edge_color=self.default_edge_color,
timeit=self.timeit,
)
# Set up camera
self.camera = CombinedCamera(
position=(1.0, 1.0, 1.0),
width=self.width,
height=self.height,
far=100,
orthoFar=100,
up=(0.0, 0.0, 1.0),
)
# needs to be an extra step to take effect
self.toggle_ortho(True)
# Set up scene
self.scene = Scene(children=[self.camera, AmbientLight(intensity=1.0)])
# Set up Controllers
camera_target = (0.0, 0.0, 0.0)
self.controller = OrbitControls(controlling=self.camera,
target=camera_target,
target0=camera_target)
# Create Renderer instance
self.renderer = Renderer(
scene=self.scene,
camera=self.camera,
controls=[self.controller],
antialias=True,
width=self.width,
height=self.height,
)
return self.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]))
class JupyterRenderer(object):
def __init__(self,
size=(640, 480),
compute_normals_mode=NORMAL.SERVER_SIDE,
parallel=False):
""" Creates a jupyter renderer.
size: a tuple (width, height). Must be a square, or shapes will look like deformed
compute_normals_mode: optional, set to SERVER_SIDE by default. This flag lets you choose the
way normals are computed. If SERVER_SIDE is selected (default value), then normals
will be computed by the Tesselator, packed as a python tuple, and send as a json structure
to the client. If, on the other hand, CLIENT_SIDE is chose, then the computer only compute vertex
indices, and let the normals be computed by the client (the web js machine embedded in the webrowser).
* SERVER_SIDE: higher server load, loading time increased, lower client load. Poor performance client will
choose this option (mobile terminals for instance)
* CLIENT_SIDE: lower server load, loading time decreased, higher client load. Higher performance clients will
choose this option (laptops, desktop machines).
* parallel: optional, False by default. If set to True, meshing runs in parallelized mode.
"""
self._background = 'white'
self._background_opacity = 1
self._size = size
self._compute_normals_mode = compute_normals_mode
self._parallel = parallel
self.html = HTML("Selected shape : None")
self._bb = None # the bounding box, necessary to compute camera position
# the default camera object
self._camera_target = [0., 0., 0.] # the point to look at
self._camera_position = [0, 0., 100.] # the camera initial position
self._camera = None
# a dictionnary of all the shapes belonging to the renderer
# each element is a key 'mesh_id:shape'
self._shapes = {}
# we save the renderer so that is can be accessed
self._renderer = None
# the group of 3d and 2d objects to render
self._displayed_pickable_objects = Group()
# the group of other objects (grid, trihedron etc.) that can't be selected
self._displayed_non_pickable_objects = Group()
# event manager/selection manager
self._picker = Picker(controlling=self._displayed_pickable_objects, event='mousedown')
self._current_shape_selection = None
self._current_mesh_selection = None
self._selection_color = format_color(232, 176, 36)
self._select_callbacks = [] # a list of all functions called after an object is selected
def click(value):
""" called whenever a shape or edge is clicked
"""
obj = value.owner.object
if self._current_mesh_selection is not None:
self._current_mesh_selection.material.color = self._current_selection_material_color
if obj is not None:
id_clicked = obj.name # the mesh id clicked
self._current_mesh_selection = obj
self._current_selection_material_color = obj.material.color
obj.material.color = self._selection_color
# get the shape from this mesh id
selected_shape = self._shapes[id_clicked]
html_value = "<b>Shape type:</b> %s<br>" % get_type_as_string(selected_shape)
html_value += "<b>Shape id:</b> %s<br>" % selected_shape
self.html.value = html_value
self._current_shape_selection = selected_shape
else:
self.html.value = "<b>Shape type:</b> None<br><b>Shape id:</b> None"
# then execute calbacks
for callback in self._select_callbacks:
callback(self._current_shape_selection)
self._picker.observe(click)
def register_select_callback(self, callback):
""" Adds a callback that will be called each time a shape is selected
"""
if not callable(callback):
raise AssertionError("You must provide a callable to register the callback")
else:
self._select_callbacks.append(callback)
def unregister_callback(self, callback):
""" Remove a callback from the callback list
"""
if not callback in self._select_callbacks:
raise AssertionError("This callback is not registered")
else:
self._select_callbacks.remove(callback)
def GetSelectedShape(self):
""" Returns the selected shape
"""
return self._current_shape_selection
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 DisplayShape(self,
shp, # the TopoDS_Shape to be displayed
shape_color=default_shape_color, # the default
render_edges=False,
edge_color=default_edge_color,
compute_uv_coords=False,
quality=1.0,
transparency=False,
opacity=1.,
topo_level='default',
update=False):
""" Displays a topods_shape in the renderer instance.
shp: the TopoDS_Shape to render
shape_color: the shape color, in html corm, eg '#abe000'
render_edges: optional, False by default. If True, compute and dislay all
edges as a linear interpolation of segments.
edge_color: optional, black by default. The color used for edge rendering,
in html form eg '#ff00ee'
compute_uv_coords: optional, false by default. If True, compute texture
coordinates (required if the shape has to be textured)
quality: optional, 1.0 by default. If set to something lower than 1.0,
mesh will be more precise. If set to something higher than 1.0,
mesh will be less precise, i.e. lower numer of triangles.
transparency: optional, False by default (opaque).
opacity: optional, float, by default to 1 (opaque). if transparency is set to True,
0. is fully opaque, 1. is fully transparent.
topo_level: "default" by default. The value should be either "compound", "shape", "vertex".
update: optional, False by default. If True, render all the shapes.
"""
if is_wire(shp) or is_edge(shp):
self.AddCurveToScene(shp, shape_color)
if topo_level != "default":
t = TopologyExplorer(shp)
map_type_and_methods = {"Solid": t.solids, "Face": t.faces, "Shell": t.shells,
"Compound": t.compounds, "Compsolid": t.comp_solids}
for subshape in map_type_and_methods[topo_level]():
self.AddShapeToScene(subshape, shape_color, render_edges, edge_color, compute_uv_coords, quality,
transparency, opacity)
else:
self.AddShapeToScene(shp, shape_color, render_edges, edge_color, compute_uv_coords, quality,
transparency, opacity)
if update:
self.Display()
def AddCurveToScene(self, shp, color):
""" shp is either a TopoDS_Wire or a TopodS_Edge.
"""
if is_edge(shp):
pnts = discretize_edge(shp)
elif is_wire(shp):
pnts = discretize_wire(shp)
np_edge_vertices = np.array(pnts, dtype=np.float32)
np_edge_indices = np.arange(np_edge_vertices.shape[0], dtype=np.uint32)
edge_geometry = BufferGeometry(attributes={
'position': BufferAttribute(np_edge_vertices),
'index' : BufferAttribute(np_edge_indices)
})
edge_material = LineBasicMaterial(color=color, linewidth=1)
edge_lines = Line(geometry=edge_geometry, material=edge_material)
# Add geometries to pickable or non pickable objects
self._displayed_pickable_objects.add(edge_lines)
def AddShapeToScene(self,
shp, # the TopoDS_Shape to be displayed
shape_color=default_shape_color, # the default
render_edges=False,
edge_color=default_edge_color,
compute_uv_coords=False,
quality=1.0,
transparency=False,
opacity=1.):
# first, compute the tesselation
tess = Tesselator(shp)
tess.Compute(uv_coords=compute_uv_coords,
compute_edges=render_edges,
mesh_quality=quality,
parallel=self._parallel)
# get vertices and normals
vertices_position = tess.GetVerticesPositionAsTuple()
number_of_triangles = tess.ObjGetTriangleCount()
number_of_vertices = len(vertices_position)
# number of vertices should be a multiple of 3
if number_of_vertices % 3 != 0:
raise AssertionError("Wrong number of vertices")
if number_of_triangles * 9 != number_of_vertices:
raise AssertionError("Wrong number of triangles")
# 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)}
if self._compute_normals_mode == NORMAL.SERVER_SIDE:
# get the normal list, converts to a numpy ndarray. This should not raise
# any issue, since normals have been computed by the server, and are available
# as a list of floats
np_normals = np.array(tess.GetNormalsAsTuple(), dtype='float32').reshape(-1, 3)
# quick check
if np_normals.shape != np_vertices.shape:
raise AssertionError("Wrong number of normals/shapes")
buffer_geometry_properties['normal'] = BufferAttribute(np_normals)
# build a BufferGeometry instance
shape_geometry = BufferGeometry(attributes=buffer_geometry_properties)
# if the client has to render normals, add the related js instructions
if self._compute_normals_mode == NORMAL.CLIENT_SIDE:
shape_geometry.exec_three_obj_method('computeVertexNormals')
# then a default material
shp_material = self._material(shape_color, transparent=transparency, opacity=opacity)
# create a mesh unique id
mesh_id = uuid.uuid4().hex
# finally create the mash
shape_mesh = Mesh(geometry=shape_geometry,
material=shp_material,
name=mesh_id)
# and to the dict of shapes, to have a mapping between meshes and shapes
self._shapes[mesh_id] = shp
# edge rendering, if set to True
edge_lines = None
if render_edges:
edges = list(map(lambda i_edge: [tess.GetEdgeVertex(i_edge, i_vert) for i_vert in range(tess.ObjEdgeGetVertexCount(i_edge))], range(tess.ObjGetEdgeCount())))
edges = list(filter(lambda edge: len(edge) == 2, edges))
np_edge_vertices = np.array(edges, dtype=np.float32).reshape(-1, 3)
np_edge_indices = np.arange(np_edge_vertices.shape[0], dtype=np.uint32)
edge_geometry = BufferGeometry(attributes={
'position': BufferAttribute(np_edge_vertices),
'index' : BufferAttribute(np_edge_indices)
})
edge_material = LineBasicMaterial(color=edge_color, linewidth=1)
edge_lines = LineSegments(geometry=edge_geometry, material=edge_material)
# Add geometries to pickable or non pickable objects
self._displayed_pickable_objects.add(shape_mesh)
if render_edges:
self._displayed_non_pickable_objects.add(edge_lines)
def _scale(self, vec):
r = self._bb.diagonal * 2.5
n = np.linalg.norm(vec)
new_vec = [v / n * r for v in vec]
return self._add(new_vec, self._bb.center)
def _add(self, vec1, vec2):
return list(v1 + v2 for v1, v2 in zip(vec1, vec2))
def _material(self, color, transparent=False, opacity=1.0):
material = CustomMaterial("standard")
material.color = color
material.clipping = True
material.side = "DoubleSide"
material.alpha = 0.7
material.polygonOffset = False
material.polygonOffsetFactor = 1
material.polygonOffsetUnits = 1
material.transparent = transparent
material.opacity = opacity
material.update("metalness", 0.3)
material.update("roughness", 0.8)
return material
def EraseAll(self):
self._shapes = {}
self._displayed_pickable_objects = Group()
self._current_shape_selection = None
self._current_mesh_selection = None
self._current_selection_material = None
self._renderer.scene = Scene(children=[])
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 _update(self):
self._controller.exec_three_obj_method('update')
def __repr__(self):
self.Display()
return ""
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
class CadqueryView(object):
def __init__(self,
width=600,
height=400,
quality=0.5,
render_edges=True,
default_mesh_color=None,
default_edge_color=None,
info=None):
self.width = width
self.height = height
self.quality = quality
self.render_edges = render_edges
self.info = info
self.features = ["mesh", "edges"]
self.bb = None
self.default_mesh_color = default_mesh_color or self._format_color(
166, 166, 166)
self.default_edge_color = default_edge_color or self._format_color(
128, 128, 128)
self.pick_color = self._format_color(232, 176, 36)
self.shapes = []
self.pickable_objects = Group()
self.pick_last_mesh = None
self.pick_last_mesh_color = None
self.pick_mapping = []
self.camera = None
self.axes = None
self.grid = None
self.scene = None
self.controller = None
self.renderer = None
self.savestate = None
def _format_color(self, r, g, b):
return '#%02x%02x%02x' % (r, g, b)
def _material(self, color, transparent=False, opacity=1.0):
material = CustomMaterial("standard")
material.color = color
material.clipping = True
material.side = "DoubleSide"
material.alpha = 0.7
material.polygonOffset = False
material.polygonOffsetFactor = 1
material.polygonOffsetUnits = 1
material.transparent = transparent
material.opacity = opacity
material.update("metalness", 0.3)
material.update("roughness", 0.8)
return material
def _render_shape(self,
shape_index,
shape=None,
edges=None,
vertices=None,
mesh_color=None,
edge_color=None,
vertex_color=None,
render_edges=False,
edge_width=1,
vertex_width=5,
deflection=0.05,
transparent=False,
opacity=1.0):
edge_list = None
edge_lines = None
points = None
shape_mesh = None
if shape is not None:
if mesh_color is None:
mesh_color = self.default_mesh_color
if edge_color is None:
edge_color = self.default_edge_color
if vertex_color is None:
vertex_color = self.default_edge_color # same as edge_color
# BEGIN copy
# The next lines are copied with light modifications from
# https://github.com/tpaviot/pythonocc-core/blob/master/src/Display/WebGl/jupyter_renderer.py
# first, compute the tesselation
tess = Tesselator(shape)
tess.Compute(uv_coords=False,
compute_edges=render_edges,
mesh_quality=self.quality,
parallel=True)
# get vertices and normals
vertices_position = tess.GetVerticesPositionAsTuple()
number_of_triangles = tess.ObjGetTriangleCount()
number_of_vertices = len(vertices_position)
# number of vertices should be a multiple of 3
if number_of_vertices % 3 != 0:
raise AssertionError("Wrong number of vertices")
if number_of_triangles * 9 != number_of_vertices:
raise AssertionError("Wrong number of triangles")
# 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')
# compute normals
np_normals = np.array(tess.GetNormalsAsTuple(),
dtype='float32').reshape(-1, 3)
if np_normals.shape != np_vertices.shape:
raise AssertionError("Wrong number of normals/shapes")
# build a BufferGeometry instance
shape_geometry = BufferGeometry(
attributes={
'position': BufferAttribute(np_vertices),
'index': BufferAttribute(np_faces),
'normal': BufferAttribute(np_normals)
})
shp_material = self._material(mesh_color,
transparent=True,
opacity=opacity)
shape_mesh = Mesh(geometry=shape_geometry,
material=shp_material,
name="mesh_%d" % shape_index)
if render_edges:
edge_list = list(
map(
lambda i_edge: [
tess.GetEdgeVertex(i_edge, i_vert)
for i_vert in range(
tess.ObjEdgeGetVertexCount(i_edge))
], range(tess.ObjGetEdgeCount())))
# END copy
if vertices is not None:
vertices_list = []
for vertex in vertices:
p = BRep_Tool.Pnt(vertex)
vertices_list.append((p.X(), p.Y(), p.Z()))
vertices_list = np.array(vertices_list, dtype=np.float32)
attributes = {
"position": BufferAttribute(vertices_list, normalized=False)
}
mat = PointsMaterial(color=vertex_color,
sizeAttenuation=False,
size=vertex_width)
geom = BufferGeometry(attributes=attributes)
points = Points(geometry=geom, material=mat)
if edges is not None:
edge_list = [discretize_edge(edge, deflection) for edge in edges]
if edge_list is not None:
edge_list = _flatten(list(map(_explode, edge_list)))
lines = LineSegmentsGeometry(positions=edge_list)
mat = LineMaterial(linewidth=edge_width, color=edge_color)
edge_lines = LineSegments2(lines,
mat,
name="edges_%d" % shape_index)
if shape_mesh is not None or edge_lines is not None or points is not None:
index_mapping = {"mesh": None, "edges": None, "shape": shape_index}
if shape_mesh is not None:
ind = len(self.pickable_objects.children)
self.pickable_objects.add(shape_mesh)
index_mapping["mesh"] = ind
if edge_lines is not None:
ind = len(self.pickable_objects.children)
self.pickable_objects.add(edge_lines)
index_mapping["edges"] = ind
if points is not None:
ind = len(self.pickable_objects.children)
self.pickable_objects.add(points)
index_mapping["mesh"] = ind
self.pick_mapping.append(index_mapping)
def get_transparent(self):
# if one object is transparent, all are
return self.pickable_objects.children[0].material.transparent
def _scale(self, vec):
r = self.bb.diagonal * 2.5
n = np.linalg.norm(vec)
new_vec = [v / n * r for v in vec]
return self._add(new_vec, self.bb.center)
def _add(self, vec1, vec2):
return list(v1 + v2 for v1, v2 in zip(vec1, vec2))
def _sub(self, vec1, vec2):
return list(v1 - v2 for v1, v2 in zip(vec1, vec2))
def _norm(self, vec):
n = np.linalg.norm(vec)
return [v / n for v in vec]
def _minus(self, vec):
return [-v for v in vec]
def direction(self):
return self._norm(self._sub(self.camera.position, self.bb.center))
def set_plane(self, i):
plane = self.renderer.clippingPlanes[i]
plane.normal = self._minus(self.direction())
def _update(self):
self.controller.exec_three_obj_method('update')
pass
def _reset(self):
self.camera.rotation, self.controller.target = self.savestate
self.camera.position = self._scale((1, 1, 1))
self.camera.zoom = 1.0
self._update()
# UI Handler
def change_view(self, typ, directions):
def reset(b):
self._reset()
def refit(b):
self.camera.zoom = 1.0
self._update()
def change(b):
self.camera.position = self._scale(directions[typ])
self._update()
if typ == "fit":
return refit
elif typ == "reset":
return reset
else:
return change
def bool_or_new(self, val):
return val if isinstance(val, bool) else val["new"]
def toggle_axes(self, change):
self.axes.set_visibility(self.bool_or_new(change))
def toggle_grid(self, change):
self.grid.set_visibility(self.bool_or_new(change))
def toggle_center(self, change):
self.grid.set_center(self.bool_or_new(change))
self.axes.set_center(self.bool_or_new(change))
def toggle_ortho(self, change):
self.camera.mode = 'orthographic' if self.bool_or_new(
change) else 'perspective'
def toggle_transparent(self, change):
value = self.bool_or_new(change)
for i in range(0, len(self.pickable_objects.children), 2):
self.pickable_objects.children[i].material.transparent = value
def toggle_black_edges(self, change):
value = self.bool_or_new(change)
for obj in self.pickable_objects.children:
if isinstance(obj, LineSegments2):
_, ind = obj.name.split("_")
ind = int(ind)
if isinstance(self.shapes[ind]["shape"][0], TopoDS_Compound):
obj.material.color = "#000" if value else self.default_edge_color
def set_visibility(self, ind, i, state):
feature = self.features[i]
group_index = self.pick_mapping[ind][feature]
if group_index is not None:
self.pickable_objects.children[group_index].visible = (state == 1)
def change_visibility(self, mapping):
def f(states):
diffs = state_diff(states.get("old"), states.get("new"))
for diff in diffs:
obj, val = _decomp(diff)
self.set_visibility(mapping[obj], val["icon"], val["new"])
return f
def pick(self, value):
if self.pick_last_mesh != value.owner.object:
# Reset
if value.owner.object is None or self.pick_last_mesh is not None:
self.pick_last_mesh.material.color = self.pick_last_mesh_color
self.pick_last_mesh = None
self.pick_last_mesh_color = None
# Change highlighted mesh
if isinstance(value.owner.object, Mesh):
_, ind = value.owner.object.name.split("_")
shape = self.shapes[int(ind)]
bbox = BoundingBox([shape["shape"]])
self.info.bb_info(shape["name"],
((bbox.xmin, bbox.xmax),
(bbox.ymin, bbox.ymax),
(bbox.zmin, bbox.zmax), bbox.center))
self.pick_last_mesh = value.owner.object
self.pick_last_mesh_color = self.pick_last_mesh.material.color
self.pick_last_mesh.material.color = self.pick_color
def clip(self, index):
def f(change):
self.renderer.clippingPlanes[index].constant = change["new"]
return f
# public methods to add shapes and render the view
def add_shape(self, name, shape, color="#ff0000"):
self.shapes.append({"name": name, "shape": shape, "color": color})
def is_ortho(self):
return (self.camera.mode == "orthographic")
def is_transparent(self):
return self.pickable_objects.children[0].material.transparent
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 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]))
class JupyterRenderer(object):
def __init__(self,
size=(640, 480),
compute_normals_mode=NORMAL.SERVER_SIDE,
parallel=False):
""" Creates a jupyter renderer.
size: a tuple (width, height). Must be a square, or shapes will look like deformed
compute_normals_mode: optional, set to SERVER_SIDE by default. This flag lets you choose the
way normals are computed. If SERVER_SIDE is selected (default value), then normals
will be computed by the Tesselator, packed as a python tuple, and send as a json structure
to the client. If, on the other hand, CLIENT_SIDE is chose, then the computer only compute vertex
indices, and let the normals be computed by the client (the web js machine embedded in the webrowser).
* SERVER_SIDE: higher server load, loading time increased, lower client load. Poor performance client will
choose this option (mobile terminals for instance)
* CLIENT_SIDE: lower server load, loading time decreased, higher client load. Higher performance clients will
choose this option (laptops, desktop machines).
* parallel: optional, False by default. If set to True, meshing runs in parallelized mode.
"""
self._background = 'white'
self._background_opacity = 1
self._size = size
self._compute_normals_mode = compute_normals_mode
self._parallel = parallel
self.html = HTML("Selected shape : None")
self._bb = None # the bounding box, necessary to compute camera position
# the default camera object
self._camera_target = [0., 0., 0.] # the point to look at
self._camera_position = [0, 0., 100.] # the camera initial position
self._camera = None
# a dictionnary of all the shapes belonging to the renderer
# each element is a key 'mesh_id:shape'
self._shapes = {}
# we save the renderer so that is can be accessed
self._renderer = None
# the group of 3d and 2d objects to render
self._displayed_pickable_objects = Group()
# the group of other objects (grid, trihedron etc.) that can't be selected
self._displayed_non_pickable_objects = Group()
# event manager/selection manager
self._picker = Picker(controlling=self._displayed_pickable_objects, event='mousedown')
self._current_shape_selection = None
self._current_mesh_selection = None
self._selection_color = format_color(232, 176, 36)
self._select_callbacks = [] # a list of all functions called after an object is selected
def click(value):
""" called whenever a shape or edge is clicked
"""
obj = value.owner.object
if self._current_mesh_selection is not None:
self._current_mesh_selection.material.color = self._current_selection_material_color
if obj is not None:
id_clicked = obj.name # the mesh id clicked
self._current_mesh_selection = obj
self._current_selection_material_color = obj.material.color
obj.material.color = self._selection_color
# get the shape from this mesh id
selected_shape = self._shapes[id_clicked]
html_value = "<b>Shape type:</b> %s<br>" % get_type_as_string(selected_shape)
html_value += "<b>Shape id:</b> %s<br>" % selected_shape
self.html.value = html_value
self._current_shape_selection = selected_shape
else:
self.html.value = "<b>Shape type:</b> None<br><b>Shape id:</b> None"
# then execute calbacks
for callback in self._select_callbacks:
callback(self._current_shape_selection)
self._picker.observe(click)
def register_select_callback(self, callback):
""" Adds a callback that will be called each time a shape is selected
"""
if not callable(callback):
raise AssertionError("You must provide a callable to register the callback")
else:
self._select_callbacks.append(callback)
def unregister_callback(self, callback):
""" Remove a callback from the callback list
"""
if not callback in self._select_callbacks:
raise AssertionError("This callback is not registered")
else:
self._select_callbacks.remove(callback)
def GetSelectedShape(self):
""" Returns the selected shape
"""
return self._current_shape_selection
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 DisplayShape(self,
shp, # the TopoDS_Shape to be displayed
shape_color=default_shape_color, # the default
render_edges=False,
edge_color=default_edge_color,
compute_uv_coords=False,
quality=1.0,
transparency=False,
opacity=1.,
topo_level='default',
update=False):
""" Displays a topods_shape in the renderer instance.
shp: the TopoDS_Shape to render
shape_color: the shape color, in html corm, eg '#abe000'
render_edges: optional, False by default. If True, compute and dislay all
edges as a linear interpolation of segments.
edge_color: optional, black by default. The color used for edge rendering,
in html form eg '#ff00ee'
compute_uv_coords: optional, false by default. If True, compute texture
coordinates (required if the shape has to be textured)
quality: optional, 1.0 by default. If set to something lower than 1.0,
mesh will be more precise. If set to something higher than 1.0,
mesh will be less precise, i.e. lower numer of triangles.
transparency: optional, False by default (opaque).
opacity: optional, float, by default to 1 (opaque). if transparency is set to True,
0. is fully opaque, 1. is fully transparent.
topo_level: "default" by default. The value should be either "compound", "shape", "vertex".
update: optional, False by default. If True, render all the shapes.
"""
if is_wire(shp) or is_edge(shp):
self.AddCurveToScene(shp, shape_color)
if topo_level != "default":
t = TopologyExplorer(shp)
map_type_and_methods = {"Solid": t.solids, "Face": t.faces, "Shell": t.shells,
"Compound": t.compounds, "Compsolid": t.comp_solids}
for subshape in map_type_and_methods[topo_level]():
self.AddShapeToScene(subshape, shape_color, render_edges, edge_color, compute_uv_coords, quality,
transparency, opacity)
else:
self.AddShapeToScene(shp, shape_color, render_edges, edge_color, compute_uv_coords, quality,
transparency, opacity)
if update:
self.Display()
def AddCurveToScene(self, shp, color):
""" shp is either a TopoDS_Wire or a TopodS_Edge.
"""
if is_edge(shp):
pnts = discretize_edge(shp)
elif is_wire(shp):
pnts = discretize_wire(shp)
np_edge_vertices = np.array(pnts, dtype=np.float32)
np_edge_indices = np.arange(np_edge_vertices.shape[0], dtype=np.uint32)
edge_geometry = BufferGeometry(attributes={
'position': BufferAttribute(np_edge_vertices),
'index' : BufferAttribute(np_edge_indices)
})
edge_material = LineBasicMaterial(color=color, linewidth=2, fog=True)
edge_lines = LineSegments(geometry=edge_geometry, material=edge_material)
# Add geometries to pickable or non pickable objects
self._displayed_pickable_objects.add(edge_lines)
def AddShapeToScene(self,
shp, # the TopoDS_Shape to be displayed
shape_color=default_shape_color, # the default
render_edges=False,
edge_color=default_edge_color,
compute_uv_coords=False,
quality=1.0,
transparency=False,
opacity=1.):
# first, compute the tesselation
tess = Tesselator(shp)
tess.Compute(uv_coords=compute_uv_coords,
compute_edges=render_edges,
mesh_quality=quality,
parallel=self._parallel)
# get vertices and normals
vertices_position = tess.GetVerticesPositionAsTuple()
number_of_triangles = tess.ObjGetTriangleCount()
number_of_vertices = len(vertices_position)
# number of vertices should be a multiple of 3
if number_of_vertices % 3 != 0:
raise AssertionError("Wrong number of vertices")
if number_of_triangles * 9 != number_of_vertices:
raise AssertionError("Wrong number of triangles")
# 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)}
if self._compute_normals_mode == NORMAL.SERVER_SIDE:
# get the normal list, converts to a numpy ndarray. This should not raise
# any issue, since normals have been computed by the server, and are available
# as a list of floats
np_normals = np.array(tess.GetNormalsAsTuple(), dtype='float32').reshape(-1, 3)
# quick check
if np_normals.shape != np_vertices.shape:
raise AssertionError("Wrong number of normals/shapes")
buffer_geometry_properties['normal'] = BufferAttribute(np_normals)
# build a BufferGeometry instance
shape_geometry = BufferGeometry(attributes=buffer_geometry_properties)
# if the client has to render normals, add the related js instructions
if self._compute_normals_mode == NORMAL.CLIENT_SIDE:
shape_geometry.exec_three_obj_method('computeVertexNormals')
# then a default material
shp_material = self._material(shape_color, transparent=transparency, opacity=opacity)
# create a mesh unique id
mesh_id = uuid.uuid4().hex
# finally create the mash
shape_mesh = Mesh(geometry=shape_geometry,
material=shp_material,
name=mesh_id)
# and to the dict of shapes, to have a mapping between meshes and shapes
self._shapes[mesh_id] = shp
# edge rendering, if set to True
edge_lines = None
if render_edges:
edges = list(map(lambda i_edge: [tess.GetEdgeVertex(i_edge, i_vert) for i_vert in range(tess.ObjEdgeGetVertexCount(i_edge))], range(tess.ObjGetEdgeCount())))
edges = list(filter(lambda edge: len(edge) == 2, edges))
np_edge_vertices = np.array(edges, dtype=np.float32).reshape(-1, 3)
np_edge_indices = np.arange(np_edge_vertices.shape[0], dtype=np.uint32)
edge_geometry = BufferGeometry(attributes={
'position': BufferAttribute(np_edge_vertices),
'index' : BufferAttribute(np_edge_indices)
})
edge_material = LineBasicMaterial(color=edge_color, linewidth=1)
edge_lines = LineSegments(geometry=edge_geometry, material=edge_material)
# Add geometries to pickable or non pickable objects
self._displayed_pickable_objects.add(shape_mesh)
if render_edges:
self._displayed_non_pickable_objects.add(edge_lines)
def _scale(self, vec):
r = self._bb.diagonal * 2.5
n = np.linalg.norm(vec)
new_vec = [v / n * r for v in vec]
return self._add(new_vec, self._bb.center)
def _add(self, vec1, vec2):
return list(v1 + v2 for v1, v2 in zip(vec1, vec2))
def _material(self, color, transparent=False, opacity=1.0):
material = CustomMaterial("standard")
material.color = color
material.clipping = True
material.side = "DoubleSide"
material.alpha = 0.7
material.polygonOffset = False
material.polygonOffsetFactor = 1
material.polygonOffsetUnits = 1
material.transparent = transparent
material.opacity = opacity
material.update("metalness", 0.3)
material.update("roughness", 0.8)
return material
def EraseAll(self):
self._shapes = {}
self._displayed_pickable_objects = Group()
self._current_shape_selection = None
self._current_mesh_selection = None
self._current_selection_material = None
self._renderer.scene = Scene(children=[])
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 _update(self):
self._controller.exec_three_obj_method('update')
def __repr__(self):
self.Display()
return ""