def _prepare_render(self, engine, frame_size):
"""Load renderer
"""
if engine == 'tiny':
self._renderer = None
elif engine == 'egl':
egl = pkgutil.get_loader('eglRenderer')
if (egl):
self._client.loadPlugin(egl.get_filename(),
"_eglRendererPlugin")
else:
self._client.loadPlugin("eglRendererPlugin")
self._renderer = None
elif engine == 'panda3d':
from pybullet_rendering.render.panda3d import Renderer
renderer = Renderer(MSAA_samples=4)
renderer.return_to_bullet = False
plugin = RenderingPlugin(self._client, renderer)
self._renderer = renderer
elif engine == 'pyrender':
from pybullet_rendering.render.pyrender import Renderer
renderer = Renderer()
renderer.return_to_bullet = False
plugin = RenderingPlugin(self._client, renderer)
self._renderer = renderer
class BaseTestCase(unittest.TestCase):
def setUp(self):
self.client = BulletClient(pb.DIRECT)
self.client.setAdditionalSearchPath(pybullet_data.getDataPath())
self.render = RendererMock()
self.plugin = RenderingPlugin(self.client, self.render)
def tearDown(self):
self.plugin.unload()
self.client.disconnect()
def run_test(num_frames, frame_size, engine, fps_out):
"""Compute fps of a specific engine."""
client = BulletClient(pb.DIRECT)
client.setAdditionalSearchPath(pybullet_data.getDataPath())
# load renderer
if 'tiny' == engine:
pass
elif 'egl' == engine:
egl = pkgutil.get_loader('eglRenderer')
client.loadPlugin(egl.get_filename(), "_eglRendererPlugin")
elif 'panda3d' == engine:
RenderingPlugin(client, P3dRenderer(multisamples=4))
elif 'pyrender' == engine:
RenderingPlugin(client, PyrRenderer(platform='egl'))
# sample scene
table = client.loadURDF("table/table.urdf",
flags=pb.URDF_USE_MATERIAL_COLORS_FROM_MTL)
client.resetBasePositionAndOrientation(table, [0.4, 0.04, -0.7],
[0, 0, 0, 1])
kuka = client.loadSDF("kuka_iiwa/kuka_with_gripper2.sdf")[0]
client.resetBasePositionAndOrientation(kuka, [0.0, 0.0, 0.0], [0, 0, 0, 1])
client.resetJointState(kuka, 3, -1.57)
proj_mat = pb.computeProjectionMatrixFOV(fov=60,
aspect=1.0,
nearVal=0.1,
farVal=10)
view_mat = pb.computeViewMatrixFromYawPitchRoll((0.4, 0, 0), 2.0, 0, -40,
0, 2)
# warming up
_, _, color, depth, mask = client.getCameraImage(*frame_size,
projectionMatrix=proj_mat,
viewMatrix=view_mat)
if engine in ('tiny', 'egl'):
depth = depth_from_zbuffer(depth, 0.1, 10.0)
img = Image.fromarray(color[:, :, :3])
img.save(f'color_{engine}.png')
img = Image.fromarray(((depth / depth.max()) * 255).astype(np.uint8))
img.save(f'depth_{engine}.png')
img = Image.fromarray(mask.astype(np.uint16))
img.save(f'mask_{engine}.png')
# compute fps
start = timer()
for _ in range(num_frames):
client.getCameraImage(*frame_size,
projectionMatrix=proj_mat,
viewMatrix=view_mat)
end = timer()
fps_out.value = num_frames / (end - start)
def __init__(self):
BaseRenderer.__init__(self) # <- important
ShowBase.__init__(self)
client = BulletClient(pb.DIRECT)
client.setAdditionalSearchPath(pybullet_data.getDataPath())
self.client = client
# bind external renderer
plugin = RenderingPlugin(client, self)
# setup scene
self.nodes = {}
self.camLens.setNearFar(3, 7)
self.camLens.setFilmSize(Vec2(0.030, 0.030))
self.render.setAntialias(AntialiasAttrib.MAuto)
self.render.setDepthOffset(1)
self.render.setShaderAuto()
self.setupScene(client)
self.setupLights()
# setup filters
if args.ambient_occlusion:
filters = CommonFilters(self.win, self.cam)
filters.setAmbientOcclusion()
# setup periodic tasks
self.time = 0
self.taskMgr.add(self.spinCameraTask, "SpinCameraTask")
self.taskMgr.add(self.stepSimulationTask, "StepSimulationTask")
if args.debug:
self.oobe()
def __init__(self, client: BulletClient) -> None:
BaseRenderer.__init__(self)
self.return_to_bullet = False
self.client = client
self.plugin = RenderingPlugin(client, self)
self._scene = pyrender.Scene(
ambient_light=np.array([0.5, 0.5, 0.5, 1.]))
# self._light = PbLightNode(self._scene)
# self._camera = PbCameraNode(self._scene)
self._node_dict = OrderedDict()
self._loader = Loader()
self._flags = pyrender.RenderFlags.RGBA
self._color, self._depth = None, None
self.setup_viewer()
def __init__(self):
BaseRenderer.__init__(self) # <- important
client = BulletClient(pb.DIRECT)
client.setAdditionalSearchPath(pybullet_data.getDataPath())
self.client = client
# bind external renderer
plugin = RenderingPlugin(client, self)
# setup scene
self.nodes = {}
self.render = vtk.vtkRenderer()
self.renWin = vtk.vtkRenderWindow()
self.renWin.AddRenderer(self.render)
colors = vtk.vtkNamedColors()
self.render.SetBackground(colors.GetColor3d("cobalt_green"))
self.setupScene(client)
# self.setupLights()
self.time = 0
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(self.renWin)
# Enable user interface interactor
iren.Initialize()
iren.AddObserver('TimerEvent', self.stepSimulationTask)
iren.CreateRepeatingTimer(50)
self.iren = iren
camera = self.render.GetActiveCamera()
camera.SetPosition([0, -3, 3])
# camera.SetFocalPoint(v)
# camera.SetViewUp(v)
camera.SetViewAngle(40)
def setUp(self):
self.client = BulletClient(pb.DIRECT)
self.client.setAdditionalSearchPath(pybullet_data.getDataPath())
self.render = RendererMock()
self.plugin = RenderingPlugin(self.client, self.render)
self.random = np.random.RandomState(77)
def test_keep_reference(self):
client = BulletClient(pb.DIRECT)
RenderingPlugin(client, RendererMock())
gc.collect()
_ = client.getCameraImage(16, 16)
def test_load_nonempty_world(self):
client = BulletClient(pb.DIRECT)
client.loadURDF("table/table.urdf")
with self.assertRaises(AssertionError):
RenderingPlugin(client, RendererMock())