Simulate’s API is inspired by the great Kubric’s API. The user create a scene and add assets in it (objects, cameras, lights if needed). Once the scene is created you can save/share it and also render or do simulations using one of the backend rendering/simulation engines (at the moment Unity, Blender and Godot). The saving/sharing format is engine agnostic and using the industry standard glTF format for saving scenes.
Let’s do a quick exploration together.
We’ll use the default backend which is a simple
To install and contribute (from CONTRIBUTING.md)
Create a virtual env and then install the code style/quality tools as well as the code base locally
pip install --upgrade simulateBefore you merge a PR, fix the style (we use isort + black)
make styleThe Python API is located in src/simulate. It allows creation and loading of scenes, and sending commands to the backend.
The backend, currently just Unity, is located in integrations/Unity. This is currently a Unity editor project, which must be opened in Unity 2021.3.2f1. In the future, this will be built as an executable, and spawned by the Python API.
Loading a scene from a local file or the hub is done with Scene.create_from(), saving or pushing to the hub with scene.save() or scene.push_to_hub():
from simulate import Scene
scene = Scene.create_from('tests/test_assets/fixtures/Box.gltf') # either local (priority) or on the hub with full path to file
scene = Scene.create_from('simulate-tests/Box/glTF/Box.gltf', is_local=False) # Set priority to the hub file
scene.save('local_dir/file.gltf') # Save to a local file
scene.push_to_hub('simulate-tests/Debug/glTF/Box.gltf') # Save to the hub
Basic example of creating a scene with a plane and a sphere above it:
import simulate as sm
scene = sm.Scene()
scene += sm.Plane() + sm.Sphere(position=[0, 1, 0], radius=0.2)
>>> scene
>>> Scene(dimensionality=3, engine='PyVistaEngine')
>>> └── plane_01 (Plane - Mesh: 121 points, 100 cells)
>>> └── sphere_02 (Sphere - Mesh: 842 points, 870 cells)
scene.show()An object (as well as the Scene) is just a node in a tree provided with optional mesh (as pyvista.PolyData structure) and material and/or light, camera, agents special objects.
The following objects creation helpers are currently provided:
Object3D any object with a pyvista.PolyData mesh and/or materialPlaneSphereCapsuleCylinderBoxConeLineMultipleLinesTubePolygonRingText3DTriangleRectangleCircleStructuredGridMost of these objects can be visualized by running the following example:
python examples/basic/objects.py
Adding/removing objects:
+) operator (or alternatively the method .add(object)) will add an object as a child of a previous object.-) operator or the .remove(object) command..clear().Accessing objects:
name attribute at creation or automatically generated from the class name + creation counter)..get(name) or by navigating in the tree using the various tree_* attributes available on any node.Here are a couple of examples of manipulations:
# Add two copy of the sphere to the scene as children of the root node (using list will add all objects on the same level)
# Using `.copy()` will create a copy of an object (the copy doesn't have any parent or children)
scene += [scene.plane_01.sphere_02.copy(), scene.plane_01.sphere_02.copy()]
>>> scene
>>> Scene(dimensionality=3, engine='pyvista')
>>> ├── plane_01 (Plane - Mesh: 121 points, 100 cells)
>>> │ └── sphere_02 (Sphere - Mesh: 842 points, 870 cells)
>>> ├── sphere_03 (Sphere - Mesh: 842 points, 870 cells)
>>> └── sphere_04 (Sphere - Mesh: 842 points, 870 cells)
# Remove the last added sphere
>>> scene.remove(scene.sphere_04)
>>> Scene(dimensionality=3, engine='pyvista')
>>> ├── plane_01 (Plane - Mesh: 121 points, 100 cells)
>>> │ └── sphere_02 (Sphere - Mesh: 842 points, 870 cells)
>>> └── sphere_03 (Sphere - Mesh: 842 points, 870 cells)scene.sphere_03.scale(0.1)
print(scene.plane_01.position)
array([1., 0., 0.]) print(scene.sphere_03.scaling) array([0.1, 0.1, 0.1])
<h3 id="visualization-engine">Visualization engine</h3>
A default vizualization engine is provided with the vtk backend of `pyvista`.
Starting the vizualization engine can be done simply with `.show()`.scene.show()
You can find bridges to other rendering/simulation engines in the `integrations` directory.
<h1 id="reinforcement-learning-rl-with-simulate">Reinforcement Learning (RL) with Simulate</h1>
Simulate is designed to provide easy and scalable integration with reinforcement learning algorithms.
The core abstraction is through the [RLEnv](/docs/simulate/v0.0.2/en/api/rl_env#simulate.RLEnv) class that wraps a `Scene`.
The [RLEnv](/docs/simulate/v0.0.2/en/api/rl_env#simulate.RLEnv) allows an [Actuator](/docs/simulate/v0.0.2/en/api/actuators#simulate.Actuator) to be manipulated by an external agent or policy.
It is core to the design of Simulate that we are *not creating* Agents, but rather providing an interface for applications of machine learning and embodied AI.
The core API for RL applications can be seen below, where Simulate constrains the information that flows from the Scene to the external agent through an Actuator abstraction.
<p align="center">
<br>
<img src="https://user-images.githubusercontent.com/10695622/192663853-a7543091-8d45-4fba-b8dc-2b632d66a35f.png" width="500"/>
<br>
</p>
At release, we include a set of pre-designed `Actor`'s that can act or navigate a scene. An `Actor` inherits from an `Object3D` and has sensors, actuators, and action mappings.
<h3 id="tips">Tips</h3>
If you are running on GCP, remember to not install `pyvistaqt`, and if you did so, uninstall it in your environment, since QT doesn't work well on GCP.