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
assert number_of_vertices % 3 == 0
assert number_of_triangles * 9 == number_of_vertices
# 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
assert np_normals.shape == np_vertices.shape
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 = MeshPhongMaterial(color=shape_color,
polygonOffset=True,
polygonOffsetFactor=1,
polygonOffsetUnits=1,
shininess=0.9,
transparent=transparency,
opacity=opacity,
side='DoubleSide')
# 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 AddShapeToScene(
self,
shp,
shape_color=None, # the default
render_edges=False,
edge_color=None,
vertex_color=None,
quality=1.0,
transparency=False,
opacity=1.):
# first, compute the tesselation
tess = Tesselator(shp)
tess.Compute(compute_edges=render_edges,
mesh_quality=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')
# 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)
# and to the dict of shapes, to have a mapping between meshes and shapes
mesh_id = "%s" % uuid.uuid4().hex
self._shapes[mesh_id] = shp
# finally create the mesh
shape_mesh = Mesh(geometry=shape_geometry,
material=shp_material,
name=mesh_id)
# edge rendering, if set to True
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())))
edge_list = _flatten(list(map(_explode, edges)))
lines = LineSegmentsGeometry(positions=edge_list)
mat = LineMaterial(linewidth=1, color=edge_color)
edge_lines = LineSegments2(lines, mat)
self._displayed_non_pickable_objects.add(edge_lines)
return shape_mesh
try:
import numpy as np
HAVE_NUMPY = True
except ImportError:
HAVE_NUMPY = False
# create the shape
box_s = BRepPrimAPI_MakeBox(10, 20, 30).Shape()
# compute the tesselation
tess = Tesselator(box_s)
tess.Compute()
# get vertices
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 returned by the teselator")
if number_of_triangles * 9 != number_of_vertices:
raise AssertionError("wrong number of triangles returned by the teselator")
# get normals
normals = tess.GetNormalsAsTuple()
number_of_normals = len(normals)
if not number_of_normals == number_of_vertices:
raise AssertionError("wrong number of normals returned by the tesselator")
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)