def __init__(self, width=1200, height=800, use_offscreen=True):
super(MeshViewer, self).__init__()
self.use_offscreen = use_offscreen
self.render_wireframe = False
self.mat_constructor = pyrender.MetallicRoughnessMaterial
self.trimesh_to_pymesh = pyrender.Mesh.from_trimesh
self.scene = pyrender.Scene(bg_color=colors['white'],
ambient_light=(0.3, 0.3, 0.3))
pc = pyrender.PerspectiveCamera(yfov=np.pi / 3.0,
aspectRatio=float(width) / height)
camera_pose = np.eye(4)
camera_pose[:3, 3] = np.array([0, 0, 2.5])
self.scene.add(pc, pose=camera_pose, name='pc-camera')
self.figsize = (width, height)
if self.use_offscreen:
self.viewer = pyrender.OffscreenRenderer(*self.figsize)
self.use_raymond_lighting(5.)
else:
self.viewer = pyrender.Viewer(self.scene,
use_raymond_lighting=True,
viewport_size=self.figsize,
cull_faces=False,
run_in_thread=True)
self.set_background_color(colors['white'])
def show(self, q=None, obstacles=None):
cfg = self.get_config(q)
# print(cfg)
fk = self.robot.link_fk(cfg=cfg)
scene = pyrender.Scene()
# adding robot to the scene
for tm in fk:
pose = fk[tm]
init_pose, link_mesh = self.get_link_mesh(tm)
mesh = pyrender.Mesh.from_trimesh(link_mesh, smooth=False)
scene.add(mesh, pose=np.matmul(pose, init_pose))
# adding base box to the scene
# table = box([0.5, 0.5, 0.01])
# table.apply_translation([0, 0, -0.1])
cam = pyrender.PerspectiveCamera(yfov=np.pi / 3.0, aspectRatio=1.414)
# nc = pyrender.Node(camera=cam, matrix=np.eye(4))
# scene.add_node(nc)
init_cam_pose = np.eye(4)
init_cam_pose[2, 3] = 2.5
scene.add(cam, pose=init_cam_pose)
# scene.add(pyrender.Mesh.from_trimesh(table))
# adding obstacles to the scene
for ob in obstacles:
scene.add(pyrender.Mesh.from_trimesh(ob, smooth=False))
pyrender.Viewer(scene, use_raymond_lighting=True)
def load_dynamic_contour(template_flame_path='None', contour_embeddings_path='None', static_embedding_path='None', angle=0):
template_mesh = Mesh(filename=template_flame_path)
contour_embeddings_path = contour_embeddings_path
dynamic_lmks_embeddings = np.load(contour_embeddings_path, allow_pickle=True, encoding='latin1').item()
lmk_face_idx_static, lmk_b_coords_static = load_static_embedding(static_embedding_path)
lmk_face_idx_dynamic = dynamic_lmks_embeddings['lmk_face_idx'][angle]
lmk_b_coords_dynamic = dynamic_lmks_embeddings['lmk_b_coords'][angle]
dynamic_lmks = mesh_points_by_barycentric_coordinates(template_mesh.v, template_mesh.f, lmk_face_idx_dynamic, lmk_b_coords_dynamic)
static_lmks = mesh_points_by_barycentric_coordinates(template_mesh.v, template_mesh.f, lmk_face_idx_static, lmk_b_coords_static)
total_lmks = np.vstack([dynamic_lmks, static_lmks])
# Visualization of the pose dependent contour on the template mesh
vertex_colors = np.ones([template_mesh.v.shape[0], 4]) * [0.3, 0.3, 0.3, 0.8]
tri_mesh = trimesh.Trimesh(template_mesh.v, template_mesh.f,
vertex_colors=vertex_colors)
mesh = pyrender.Mesh.from_trimesh(tri_mesh)
scene = pyrender.Scene()
scene.add(mesh)
sm = trimesh.creation.uv_sphere(radius=0.005)
sm.visual.vertex_colors = [0.9, 0.1, 0.1, 1.0]
tfs = np.tile(np.eye(4), (len(total_lmks), 1, 1))
tfs[:, :3, 3] = total_lmks
joints_pcl = pyrender.Mesh.from_trimesh(sm, poses=tfs)
scene.add(joints_pcl)
pyrender.Viewer(scene, use_raymond_lighting=True)
def show(self, q=None, obstacles=None, use_collision=False):
cfg = self.get_config(q)
#print(cfg)
if use_collision:
fk = self.robot.collision_trimesh_fk(cfg=cfg)
else:
fk = self.robot.visual_trimesh_fk(cfg=cfg)
scene = pyrender.Scene()
# adding robot to the scene
for tm in fk:
pose = fk[tm]
mesh = pyrender.Mesh.from_trimesh(tm, smooth=False)
scene.add(mesh, pose=pose)
# adding base box to the scene
table = cylinder(radius=0.7, height=0.02) #([0.5, 0.5, 0.02])
table.apply_translation([0, 0, -0.015])
table.visual.vertex_colors = [205, 243, 8, 255]
scene.add(pyrender.Mesh.from_trimesh(table))
# adding obstacles to the scene
for i, ob in enumerate(obstacles):
if i < len(obstacles) - 1:
ob.visual.vertex_colors = [255, 0, 0, 255]
else:
ob.visual.vertex_colors = [205, 243, 8, 255]
scene.add(pyrender.Mesh.from_trimesh(ob, smooth=False))
pyrender.Viewer(scene, use_raymond_lighting=True)
def test3():
model_path = 'data/models/basic/cow.obj'
scene = pyrender.Scene(ambient_light=white)
# load the cow model
tm = trimesh.load(model_path)
tm.visual.vertex_colors = np.random.uniform(
size=tm.visual.vertex_colors.shape)
tm.visual.face_colors = np.random.uniform(size=tm.visual.face_colors.shape)
mesh = pyrender.Mesh.from_trimesh(tm, smooth=False)
pose = np.eye(4)
x = 5
dist = [x, x, x]
pose[:3, 3] = dist
scene.add(mesh, pose=pose)
M = rotation_matrix(theta_x=90, theta_y=90)
tm.apply_transform(M)
mesh2 = pyrender.Mesh.from_trimesh(tm, smooth=False)
pose2 = np.eye(4)
pose2[:3, 3] = [-x for x in dist]
scene.add(mesh2, pose=pose2)
pyrender.Viewer(scene)
def show(self, cfg=None, use_collision=False):
"""Visualize the URDF in a given configuration.
Parameters
----------
cfg : dict or (n), float
A map from joints or joint names to configuration values for
each joint, or a list containing a value for each actuated joint
in sorted order from the base link.
If not specified, all joints are assumed to be in their default
configurations.
use_collision : bool
If True, the collision geometry is visualized instead of
the visual geometry.
"""
if use_collision:
fk = self.urdf.collision_trimesh_fk(cfg=cfg)
else:
fk = self.urdf.visual_trimesh_fk(cfg=cfg)
self.scene = pyrender.Scene()
self.nodes = []
for tm in fk:
pose = fk[tm]
mesh = pyrender.Mesh.from_trimesh(tm, smooth=False)
mesh_node = self.scene.add(mesh, pose=pose)
self.nodes.append(mesh_node)
self.viewer = pyrender.Viewer(self.scene, run_in_thread=True, use_raymond_lighting=True)
def view_mesh(mesh_filename, rotate_axis=[0, 0, 1]):
# mesh_filename = f'checkpoints/train_autoencoder/{recon}/{meshanme}.ply'
mesh = trimesh.load(mesh_filename)
mesh = pyrender.Mesh.from_trimesh(mesh)
scene = pyrender.Scene()
scene.add(mesh)
pyrender.Viewer(scene, use_raymond_lighting=True, rotate_axis=rotate_axis)
def run_gui(render_list, **kargs):
scene = scene_factory(render_list)
# call GUI
v = pyrender.Viewer(scene, use_raymond_lighting=True, **kargs)
# free resources
del v
return None
def start():
modelPartsViewer.renderMode = 0
modelPartsViewer.viewerModelIndex = 0
defaultModel = modelPartsViewer.models[modelPartsViewer.viewerModelIndex]
defaultScene = pyrender.Scene()
defaultCaption = getCaptionForModel(defaultModel,
modelPartsViewer.viewerModelIndex)
setSceneMeshes(defaultScene, defaultModel.parts)
pyrender.Viewer(defaultScene,
viewer_flags={'caption': defaultCaption},
registered_keys={
'd': viewNextModel,
'a': viewPrevModel,
's': viewPrevPart,
'w': viewNextPart,
'g': generateChairViewer,
'x': takeScreenshot,
'y': takePositiveScreenShot,
'n': takeNegativeScreenShot,
'e': evalCurrentChair,
'o': exportCurrentChair
},
use_raymond_lighting=True)
def __init__(self,
width=1200,
height=800,
body_color=(1.0, 1.0, 0.9, 1.0),
registered_keys=None):
super(MeshViewer, self).__init__()
if registered_keys is None:
registered_keys = dict()
self.mat_constructor = pyrender.MetallicRoughnessMaterial
self.mesh_constructor = trimesh.Trimesh
self.trimesh_to_pymesh = pyrender.Mesh.from_trimesh
self.transf = trimesh.transformations.rotation_matrix
self.body_color = body_color
self.scene = pyrender.Scene(bg_color=[0.0, 0.0, 0.0, 1.0],
ambient_light=(0.3, 0.3, 0.3))
pc = pyrender.PerspectiveCamera(yfov=np.pi / 3.0,
aspectRatio=float(width) / height)
camera_pose = np.eye(4)
camera_pose[:3, 3] = np.array([0, 0, 3])
self.scene.add(pc, pose=camera_pose)
self.viewer = pyrender.Viewer(self.scene,
use_raymond_lighting=True,
viewport_size=(width, height),
cull_faces=False,
run_in_thread=True,
registered_keys=registered_keys)
def get_landmarks(dynamic_lmks_embeddings,
lmk_face_idx_static,
lmk_b_coords_static,
vertices,
faces,
angle=0):
lmk_face_idx_dynamic = dynamic_lmks_embeddings['lmk_face_idx'][angle]
lmk_b_coords_dynamic = dynamic_lmks_embeddings['lmk_b_coords'][angle]
dynamic_lmks = mesh_points_by_barycentric_coordinates(
vertices, faces, lmk_face_idx_dynamic, lmk_b_coords_dynamic)
static_lmks = mesh_points_by_barycentric_coordinates(
vertices, faces, lmk_face_idx_static, lmk_b_coords_static)
total_lmks = np.vstack([dynamic_lmks, static_lmks])
# Visualization of the pose dependent contour on the template mesh
vertex_colors = np.ones([vertices.shape[0], 4]) * [0.3, 0.3, 0.3, 0.8]
tri_mesh = trimesh.Trimesh(vertices, faces, vertex_colors=vertex_colors)
mesh = pyrender.Mesh.from_trimesh(tri_mesh)
scene = pyrender.Scene()
scene.add(mesh)
sm = trimesh.creation.uv_sphere(radius=0.005)
sm.visual.vertex_colors = [0.9, 0.1, 0.1, 1.0]
tfs = np.tile(np.eye(4), (len(total_lmks), 1, 1))
tfs[:, :3, 3] = total_lmks
# print(total_lmks)
# print(len(total_lmks))
joints_pcl = pyrender.Mesh.from_trimesh(sm, poses=tfs)
scene.add(joints_pcl)
pyrender.Viewer(scene, use_raymond_lighting=True)
def main():
name = 's0_train'
dataset = get_dataset(name)
idx = 70
sample = dataset[idx]
scene_r = create_scene(sample, dataset.obj_file)
scene_v = create_scene(sample, dataset.obj_file)
print('Visualizing pose in camera view using pyrender renderer')
r = pyrender.OffscreenRenderer(viewport_width=dataset.w,
viewport_height=dataset.h)
im_render, _ = r.render(scene_r)
im_real = cv2.imread(sample['color_file'])
im_real = im_real[:, :, ::-1]
im = 0.33 * im_real.astype(np.float32) + 0.67 * im_render.astype(
np.float32)
im = im.astype(np.uint8)
print('Close the window to continue.')
plt.imshow(im)
plt.tight_layout()
plt.show()
print('Visualizing pose using pyrender 3D viewer')
pyrender.Viewer(scene_v)
def show_urdf_transform_manager(tm, frame, collision_objects=False,
visuals=False):
"""Render URDF file with pyrender.
Parameters
----------
tm : UrdfTransformManager
Transformation manager
frame : str
Base frame for rendering
collision_objects : bool, optional (default: False)
Render collision objects
visuals : bool, optional (default: False)
Render visuals
"""
scene = pr.Scene()
if collision_objects:
if hasattr(tm, "collision_objects"):
_add_objects(scene, tm.collision_objects)
if visuals:
if hasattr(tm, "visuals"):
_add_objects(scene, tm.visuals)
pr.Viewer(scene, use_raymond_lighting=True)
def view_smpl_model(smplx_model, model_output, plotting_module='pyrender', plot_joints=False):
vertices = model_output.vertices.detach().cpu().numpy().squeeze()
joints = model_output.joints.detach().cpu().numpy().squeeze()
if plotting_module == 'pyrender':
import pyrender
import trimesh
vertex_colors = np.ones([vertices.shape[0], 4]) * [0.3, 0.3, 0.3, 0.8]
tri_mesh = trimesh.Trimesh(vertices, smplx_model.faces,
vertex_colors=vertex_colors)
mesh = pyrender.Mesh.from_trimesh(tri_mesh)
scene = pyrender.Scene()
scene.add(mesh)
if plot_joints:
sm = trimesh.creation.uv_sphere(radius=0.005)
sm.visual.vertex_colors = [0.9, 0.1, 0.1, 1.0]
tfs = np.tile(np.eye(4), (len(joints), 1, 1))
tfs[:, :3, 3] = joints
joints_pcl = pyrender.Mesh.from_trimesh(sm, poses=tfs)
scene.add(joints_pcl)
pyrender.Viewer(scene, use_raymond_lighting=True)
def display(mesh, light=None, camera=None):
scene = pyrender.Scene(ambient_light=white)
scene.add(mesh)
if light:
scene.add(light)
if camera:
scene.add(camera)
pyrender.Viewer(scene)
def view_points(points, dists):
import pyrender
colors = numpy.zeros(points.shape)
colors[dists < 0, 2] = 1
colors[dists > 0, 0] = 1
cloud = pyrender.Mesh.from_points(points, colors=colors)
scene = pyrender.Scene()
scene.add(cloud)
viewer = pyrender.Viewer(scene, use_raymond_lighting=True, point_size=2)
def run_gui_pyrmesh(pyr_meshes, point_size=10):
scene = generateSceneWithPyrenderMeshes(pyr_meshes)
v = pyrender.Viewer(
scene,
use_raymond_lighting=True,
point_size=point_size,
refresh_rate=60,
)
del v
def prediction_animation(real_traj,
pred_traj,
loop_time,
urdf_path='robots/right_hand_relative.urdf',
real_color=np.array([71, 107, 107, 255]),
pred_color_cmap=matplotlib.cm.get_cmap('tab10'),
background_color=np.array([1.0, 1.0, 1.0]),
title="Hand Motion Prediction",
hand_offset=0.2,
reverse=True):
scene, origin, node_map, real_hand, pred_hands, pred_trajectories, times, fps = setup_animation_scene(
real_traj=real_traj,
pred_traj=pred_traj,
hand_offset=hand_offset,
loop_time=loop_time,
urdf_path=urdf_path,
real_color=real_color,
pred_color_cmap=pred_color_cmap,
background_color=background_color,
reverse=reverse)
# Pop the visualizer asynchronously
v = pyrender.Viewer(
scene,
run_in_thread=True,
use_raymond_lighting=True,
window_title=title,
use_perspective_cam=False,
view_center=origin[:3, 3] +
np.array([(hand_offset * (len(pred_trajectories) + 1)) / 2, 0, 0.04]))
# Now, run our loop
i = 0
while v.is_active:
real_cfg = {k: real_traj[k][i] for k in real_traj}
pred_cfgs = [{k: pred_traj[k][i]
for k in pred_traj} for pred_traj in pred_trajectories]
i = (i + 1) % len(times)
fk_real = real_hand.visual_trimesh_fk(cfg=real_cfg)
fk_preds = [
pred_hand.visual_trimesh_fk(cfg=pred_cfg)
for pred_hand, pred_cfg in zip(pred_hands, pred_cfgs)
]
v.render_lock.acquire()
for real_mesh in fk_real:
real_pose = fk_real[real_mesh]
node_map[real_mesh].matrix = real_pose
for fk_pred in fk_preds:
for pred_mesh in fk_pred:
pred_pose = fk_pred[pred_mesh]
node_map[pred_mesh].matrix = pred_pose
v.render_lock.release()
time.sleep(1.0 / fps)
def animate(self, q_traj=None, obstacles=None):
import time
fps = 10.0
cfgs = [self.get_config(q) for q in q_traj]
# Create the scene
fk = self.robot.visual_trimesh_fk(cfg=cfgs[0])
node_map = {}
init_pose_map = {}
scene = pyrender.Scene()
for tm in fk:
pose = fk[tm]
mesh = pyrender.Mesh.from_trimesh(tm, smooth=False)
node = scene.add(mesh, pose=pose)
node_map[tm] = node
# adding base box to the scene
#table = cylinder(radius=0.7, height=0.02) #([0.5, 0.5, 0.02])
#table.apply_translation([0, 0, -0.015])
#table.visual.vertex_colors = [205, 243, 8, 255]
#scene.add(pyrender.Mesh.from_trimesh(table))
cam = pyrender.PerspectiveCamera(yfov=np.pi / 3.0, aspectRatio=1.414)
init_cam_pose = np.eye(4)
init_cam_pose[2, 3] = 2.5
scene.add(cam, pose=init_cam_pose)
# adding obstacles to the scene
for i, ob in enumerate(obstacles):
if i < len(obstacles) - 1:
ob.visual.vertex_colors = [255, 0, 0, 255]
else:
ob.visual.vertex_colors = [205, 243, 8, 255]
scene.add(pyrender.Mesh.from_trimesh(ob, smooth=False))
# Pop the visualizer asynchronously
v = pyrender.Viewer(scene,
run_in_thread=True,
use_raymond_lighting=True)
time.sleep(1.0)
# Now, run our loop
i = 0
while v.is_active:
cfg = cfgs[i]
fk = self.robot.visual_trimesh_fk(cfg=cfg)
if i < len(cfgs) - 1:
i += 1
else:
i = 0
time.sleep(1.0)
v.render_lock.acquire()
for mesh in fk:
pose = fk[mesh]
node_map[mesh].matrix = pose
v.render_lock.release()
time.sleep(1.0 / fps)
def render_mesh(filepath):
filepath = filepath[0][0]
if filepath[0] != '/':
filepath = 'dataset/' + filepath #[:filepath.index('.')]+'_processed.off'
fuze_trimesh = trimesh.load(filepath)
mesh = pyrender.Mesh.from_trimesh(fuze_trimesh)
scene = pyrender.Scene()
scene.add(mesh)
pyrender.Viewer(scene, use_raymond_lighting=True)
def rendering(mat):
pcd = open3d.geometry.PointCloud()
pcd.points = open3d.utility.Vector3dVector(mat["verts"])
pcd.normals = open3d.utility.Vector3dVector(mat["normal_vec"])
# pcd.estimate_normals()
# estimate radius for rolling ball
distances = pcd.compute_nearest_neighbor_distance()
avg_dist = np.mean(distances)
radius = 1.5 * avg_dist
mesh = open3d.geometry.TriangleMesh.create_from_point_cloud_ball_pivoting(
pcd, open3d.utility.DoubleVector([radius, radius * 5])
)
# mesh, density = open3d.geometry.TriangleMesh.create_from_point_cloud_poisson(pcd)
# create the triangular mesh with the vertices and faces from open3d
tri_mesh = trimesh.Trimesh(
np.asarray(mesh.vertices),
np.asarray(mesh.triangles),
vertex_normals=np.asarray(mesh.vertex_normals),
process=False,
)
# tri_mesh.export("test.stl")
# tri_mesh.convex.is_convex(tri_mesh)
mesh = pyrender.Mesh.from_trimesh(tri_mesh, smooth=False)
# mesh = pyrender.Mesh.from_points(pcd.points, normals=pcd.normals)
center = np.zeros(3)
# center = (mat["verts"].min(axis=0) + mat["verts"].max(axis=0)) / 2
# center[1] = mat["verts"][:, 1].min() + 10
center[1] = -5
center[2] = mat["verts"][:, 2].min()
# compose scene
scene = pyrender.Scene(ambient_light=[0.1, 0.1, 0.1], bg_color=[0.7, 0.7, 0.7])
camera = pyrender.PerspectiveCamera(yfov=np.pi / 4.0)
# camera = pyrender.IntrinsicsCamera(1, 1, 0, 0)
# light = pyrender.DirectionalLight(color=[1, 1, 1], intensity=1)
light = pyrender.PointLight(color=[1.0, 1.0, 1.0], intensity=2.5e3)
scene.add(mesh, pose=np.eye(4))
scene.add(light, pose=[[1, 0, 0, center[0]], [0, 1, 0, center[1]], [0, 0, -1, center[2] - 20], [0, 0, 0, 1]])
scene.add(camera, pose=[[1, 0, 0, center[0]], [0, -1, 0, center[1]], [0, 0, -1, center[2] - 40], [0, 0, 0, 1]])
# render scene
# r = pyrender.OffscreenRenderer(800, 768)
# color, _ = r.render(scene)
# r.delete()
pyrender.Viewer(scene)
return color
def plot3d(pc):
colors = np.zeros(pc.shape)
colors[:,1] = 0.85
cloud = pyrender.Mesh.from_points(pc, colors=colors)
scene = pyrender.Scene()
scene.add(cloud)
viewer = pyrender.Viewer(scene, use_raymond_lighting=True, point_size=2.5)
viewer.close_external()
def show_sdf_point_cloud(points, sdf):
import pyrender
colors = np.zeros(points.shape)
colors[sdf < 0, 2] = 1
colors[sdf > 0, 0] = 1
cloud = pyrender.Mesh.from_points(points, colors=colors)
scene = pyrender.Scene()
scene.add(cloud)
viewer = pyrender.Viewer(scene, use_raymond_lighting=True, point_size=2)
def render(obj):
import pyrender, os
m = pyrender.Mesh.from_trimesh(obj.mesh, smooth=False)
scene = pyrender.Scene(ambient_light=[0.1, 0.1, 0.1, 0.1])
light = pyrender.PointLight(intensity=500)
scene.add(m)
#scene.add(light)
pyrender.Viewer(scene)
def create_scene(self, off_screen=False, ego_view=True, pose=None):
""" Creates a scene with the robot and a camera
Parameters
----------
off_screen : bool, optional
False for showing and displaying the robot, by default False
ego_view : bool, optional
True for ego view, false for observer camera, by default True
"""
if pose is None:
if ego_view:
pose = [[0, 0.5, -0.35, 0.2], [-1, 0, 0, 0.0],
[0, 0.35, 0.5, 1.5], [0, 0, 0, 1]]
else:
pose = [[0, 0, 1, 1.5], [1, 0, 0, 0.0], [0, 1, 0, 1.2],
[0, 0, 0, 1]]
node_map = {}
self.scene = pyrender.Scene()
fk = self.get_robot_trimesh()
for tm in self.get_robot_trimesh():
pose = fk[tm]
mesh = pyrender.Mesh.from_trimesh(tm, smooth=False)
node = self.scene.add(mesh, pose=pose)
self.r_node_map[tm] = node
if off_screen:
if ego_view:
camera = pyrender.IntrinsicsCamera(400, 400, 1920 / 2,
1080 / 2)
light = pyrender.DirectionalLight(color=[1, 1, 1],
intensity=2e3)
'''
self.scene.add(camera, pose=[[ 0, 0.5, -0.87, 0.2],
[ -1, 0, 0, 0.0],
[ 0, 0.87, 0.5, 1.5],
[ 0, 0, 0, 1]])'''
self.scene.add(camera, pose=pose)
self.scene.add(light, pose=np.eye(4))
else:
camera = pyrender.IntrinsicsCamera(800, 800, 1920 / 2,
1080 / 2)
light = pyrender.DirectionalLight(color=[1, 1, 1],
intensity=2e3)
self.scene.add(camera, pose=pose)
self.scene.add(light, pose=np.eye(4))
self.rend = pyrender.OffscreenRenderer(1920, 1080)
logger.debug("renderer initialised: " + str(self.rend))
else:
self.viewer = pyrender.Viewer(self.scene,
use_raymond_lighting=True,
run_in_thread=True)
def visualize_smpl():
smpl_file = 'assets/neutral_smpl.pkl'
with open(smpl_file, 'rb') as fh:
smpl = pickle.load(fh, encoding='latin1')
# Form the scene, with smoothing turned on.
tm = trimesh.Trimesh(vertices=smpl['v_template'], faces=smpl['f'])
mesh = pyrender.Mesh.from_trimesh(tm, smooth=True)
scene = pyrender.Scene()
scene.add(mesh)
pyrender.Viewer(scene, use_raymond_lighting=True)
def renderVertices(vertices):
mesh = pyrender.Mesh.from_points([[v[0], v[1], -1.0] for v in vertices])
cam = pyrender.OrthographicCamera(xmag=ORTHO_CAM[0], ymag=ORTHO_CAM[1])
pos = np.eye(4)
scene = pyrender.Scene()
scene.add(mesh)
scene.add(cam, pose=pos)
pyrender.Viewer(scene,
VIEWPORT_SIZE,
all_wireframe=True,
cull_faces=False,
use_perspective_cam=False)
def show_meshes(meshes, angle_x=-0.7854, angle_y=0, angle_z=0.31416,
ax=None, resolution=(1200, 1200), interactive=False):
if ax is None:
fig, ax = plt.subplots(1, 1)
scene = pyrender.Scene(ambient_light=[0.0, 0.0, 0.0],
bg_color=[1.0, 1.0, 1.0], )
for mesh in meshes:
mesh = mesh.copy()
re = trimesh.transformations.euler_matrix(angle_x, angle_y, angle_z, 'rxyz')
mesh.apply_transform(re)
scene.add(pyrender.Mesh.from_trimesh(mesh))
camera = pyrender.PerspectiveCamera(yfov=np.pi / 4.0, aspectRatio=1.0)
camera_pose = np.eye(4)
camera_pose[:3, 3] = [0, 0, 240]
scene.add(camera, pose=camera_pose)
ligth_poses = [np.array([[-0.000, -0.866, 0.500, 0.],
[ 1.000, -0.000, -0.000, 0.],
[ 0.000, 0.500, 0.866, 0.],
[ 0.000, 0.000, 0.000, 1.]]),
np.array([[ 0.866, 0.433, -0.250, 0.],
[-0.500, 0.750, -0.433, 0.],
[ 0.000, 0.500, 0.866, 0.],
[ 0.000, 0.000, 0.000, 1.]]),
np.array([[-0.866, 0.433, -0.250, 0.],
[-0.500, -0.750, 0.433, 0.],
[ 0.000, 0.500, 0.866, 0.],
[ 0.000, 0.000, 0.000, 1.]])]
for pose in ligth_poses:
light = pyrender.DirectionalLight(color=[1.0, 1.0, 1.0],
intensity=1.0)
scene.add(light, pose=pose)
if interactive:
pyrender.Viewer(scene, use_raymond_lighting=True)
else:
r = pyrender.OffscreenRenderer(*resolution)
color, depth = r.render(scene)
if ax is None:
fig, ax = plt.subplots(1, 1, figsize=(10, 10))
ax.axis('off')
ind_ax0 = np.where(np.any(np.any(color != 255, axis=2), axis=1))[0]
ind_ax1 = np.where(np.any(np.any(color != 255, axis=2), axis=0))[0]
ax.imshow(color[ind_ax0[0]:(ind_ax0[-1]+1), ind_ax1[0]:(ind_ax1[-1]+1), :])
return ax
def setup_viewer(self):
render_flags = {
"shadows": True,
}
viewer_flags = {
"window_title": "Pyrender Bullet GUI",
}
viewer = pyrender.Viewer(self._scene,
viewport_size=(1600, 900),
run_in_thread=True,
render_flags=render_flags,
viewer_flags=viewer_flags)
self._viewer = viewer
def display(mesh, grasps, quality_s=None):
scene = dex.DexScene(ambient_light=[0.02, 0.02, 0.02],
bg_color=[1.0, 1.0, 1.0])
scene.add_obj(mesh)
if quality_s is None:
quality_s = [1] * len(grasps)
for g, q in zip(grasps, quality_s):
c = q * np.array([255, 0, -255]) + np.array([0, 0, 255])
c = np.concatenate((c, [255]))
c = c.astype(int)
scene.add_grasp(g, color=c)
scene.add_grasp_center(g)
pyrender.Viewer(scene, use_raymond_lighting=True)
