stillleben.Scene class

Typical usage

import stillleben as sl
sl.init()

# Load & instantiate meshes
mesh = sl.Mesh('my_mesh.gltf')
objectA = sl.Object(mesh)
objectB = sl.Object(mesh)

# Setup the scene
scene = sl.Scene((1920,1080))
scene.add_object(objectA)
scene.add_object(objectB)

Methods

def add_object(self, object: Object) -> None

Adds an object to the scene.

def camera_pose(self, /) -> at::Tensor

Retrieve current camera pose (see set_camera_pose()).

def camera_to_world(self, poseInCamera: at::Tensor) -> at::Tensor

Transform a pose from camera coordinates to world coordinates.

def check_collisions(self, /) -> None

Checks the scene for collisions. The results will be available in Object.separation.

def choose_random_camera_pose(self, /) -> None

Choose a random camera pose in the upper hemisphere (Z up) under the constraint that all objects in the scene should be within the camera frustum.

def choose_random_light_direction(self, /) -> None

Choose a random light direction.

def choose_random_light_position(self, /) -> None

Choose a random light position.

def deserialize(self, str: str, cache: MeshCache = None) -> None

Deserialize the scene from a string

def find_noncolliding_pose(self, object: Object, sampler: str = 'random', max_iterations: int = 10, **kwargs) -> bool

Finds a non-colliding random pose for an object. The object should already have been added using add_object().

def load_physics(self, /) -> None

Load physics meshes

def load_visual(self, /) -> None

Load visual meshes

def min_dist_for_object_diameter(self, diameter: float) -> float

Calculates the minimum Z distance from the camera to have an object of diameter diameter fully visible in the camera frustrum.

def place_object_randomly(self, diameter: float, min_size_factor: float = 0.4000000059604645) -> at::Tensor

Generates a random pose for an object of given diameter.

def projection_matrix(self, /) -> at::Tensor

Return the currently used OpenGL projection matrix.

def remove_object(self, object: Object) -> None

Removes an object from the scene.

def serialize(self, /) -> str

Serialize the scene to a string

def set_camera_hfov(self, hfov: float) -> None

Set camera intrinsics from horizontal FOV.

def set_camera_intrinsics(self, fx: float, fy: float, cx: float, cy: float) -> None

Set camera intrinsics directly.

def set_camera_look_at(self, position: at::Tensor, look_at: at::Tensor, up: at::Tensor = tensor([0., 0., 1.])) -> None

Sets the camera pose within the scene using lookAt parameters.

def set_camera_pose(self, pose: at::Tensor) -> None

Set the camera pose within the scene.

def set_camera_projection(self, P: at::Tensor) -> None

Set the camera intrinsics from a 4x4 matrix.

def simulate(self, dt: float) -> None

Runs the physics simulation for a single timestep of size dt.

def simulate_tabletop_scene(self, vis_cb: typing.Callable[[int], None] = None) -> None

Arrange the objects as if they were standing on a supporting surface. This also calls choose_random_camera_pose().

Special methods

def __init__(self, viewport_size: typing.Tuple[int, int]) -> None

Constructor

Properties

ambient_light: at::Tensor get set

The color & intensity of the ambient light. This is a float tensor of size 3 (linear sRGB), which determines general ambient radiance.

background_color: at::Tensor get set

The background color (RGBA, float, range 0-1). The default is white.

background_image: Texture get set

The background image. If None (default), the background color (see background_color) is used.

background_plane_pose: at::Tensor get set

Pose of the background plane (plane normal is in +Z direction)

background_plane_size: at::Tensor get set

Size of the background plane in local X/Y directions

background_plane_texture: Texture2D get set

Texture of the background plane

light_colors: at::Tensor get set

Colors of all lights in linear sRGB. Note that the color directly determines radiance, so you might have to increase colors beyond 1.0 or they might be too dark.

light_directions: at::Tensor get set

Directions of all lights in world coordinates. This is a N x 3 float tensor. All lights are assumed to be point lights at infinite distance, casting light in the specified direction.

light_map: LightMap get set

Light map used for image-based lighting.

light_position: at::Tensor get set

The light position in world coordinates. This is a float tensor of size 3. This is a shortcut for the position of the first light (see light_directions).

manual_exposure: float get set

Manual exposure.

objects: typing.List[Object] get

All objects added to the scene.

viewport: typing.Tuple[int, int] get

The current viewport size (W,H) as set in the constructor.

Method documentation

Property documentation