Manim Scene

A scene is a general name used to name an output interfacing object used in Manim. A ~~Scene~~ object is the fundamental element used in Manim as a dummy scene container with base scene manipulating functions. A ~~Scene~~ object focuses only on the aesthetic design of ~~Mobject~~ objects in a ~~Scene~~ object.

Codes in Scene.py

Available codes defined in manimlib.scene.scene.py

Two classes, ~~Scene~~ and ~~EndSceneEarlyException~~ are defined.

Import

The import defined in manimlib.scene.scene.py:

import inspect
import random
import warnings
import platform

from tqdm import tqdm as ProgressDisplay
import numpy as np

from manimlib.animation.animation import Animation
from manimlib.animation.creation import Write
from manimlib.animation.transform import MoveToTarget, ApplyMethod
from manimlib.camera.camera import Camera
from manimlib.constants import *
from manimlib.container.container import Container
from manimlib.mobject.mobject import Mobject
from manimlib.mobject.svg.tex_mobject import TextMobject
from manimlib.scene.scene_file_writer import SceneFileWriter
from manimlib.utils.iterables import list_update

Class Scene(Container)

class manimlib.scene.scene.Scene(Container)version 19Dec2019

Configuration of Scene

The configuration of a ~~Scene~~ defined in manimlib.scene.scene.py:

    CONFIG = {
        "camera_class": Camera,
        "camera_config": {},
        "file_writer_config": {},
        "skip_animations": False,
        "always_update_mobjects": False,
        "random_seed": 0,
        "start_at_animation_number": None,
        "end_at_animation_number": None,
        "leave_progress_bars": False,
    }

Functions

Functions defined in class ~~Scene~~ are

def __init__(self, **kwargs)
def setup(self)
- pass
def tear_down(self)
- pass
def construct(self)
- pass
def __str__(self)
def print_end_message(self)
def set_variables_as_attrs(self, *objects, **newly_named_objects)
def get_attrs(self, *keys)
# Only these methods should touch the camera
def set_camera(self, camera)
def get_frame(self)
def get_image(self)
def set_camera_pixel_array(self, pixel_array)
def set_camera_background(self, background)
def reset_camera(self)
def capture_mobjects_in_camera(self, mobjects, **kwargs)
def update_frame( self, mobjects=None, background=None, include_submobjects=True, ignore_skipping=True, **kwargs)
def freeze_background(self)
###
def update_mobjects(self, dt)
def should_update_mobjects(self)
###
def get_time(self)
def increment_time(self, d_time)
###
def get_top_level_mobjects(self)
- def is_top_level(mobject)
def get_mobject_family_members(self)
def add(self, *mobjects)
def add_mobjects_among(self, values)
def remove(self, *mobjects)
def restructure_mobjects(self, to_remove, mobject_list_name="mobjects", extract_families=True)
def get_restructured_mobject_list(self, mobjects, to_remove)
- def add_safe_mobjects_from_list(list_to_examine, set_to_remove)
#TODO, remove this, and calls to this
def add_foreground_mobjects(self, *mobjects)
def add_foreground_mobject(self, mobject)
def remove_foreground_mobjects(self, *to_remove)
def remove_foreground_mobject(self, mobject)
def bring_to_front(self, *mobjects)
def bring_to_back(self, *mobjects)
def clear(self)
def get_mobjects(self)
def get_mobject_copies(self)
def get_moving_mobjects(self, *animations)
def get_time_progression(self, run_time, n_iterations=None, override_skip_animations=False)
def get_run_time(self, animations)
def get_animation_time_progression(self, animations)
def compile_play_args_to_animation_list(self, *args, **kwargs)
- def compile_method(state)
def update_skipping_status(self)
def handle_play_like_call(func)
- def wrapper(self, *args, **kwargs)
def begin_animations(self, animations)
def progress_through_animations(self, animations)
def finish_animations(self, animations)
@handle_play_like_call
- def play(self, *args, **kwargs)
def idle_stream(self)
def clean_up_animations(self, *animations)
def get_mobjects_from_last_animation(self)
def get_wait_time_progression(self, duration, stop_condition)
@handle_play_like_call
- def wait(self, duration=DEFAULT_WAIT_TIME, stop_condition=None)
def wait_until(self, stop_condition, max_time=60)
def force_skipping(self)
def revert_to_original_skipping_status(self)
def add_frames(self, *frames)
def add_sound(self, sound_file, time_offset=0, gain=None, **kwargs)
def show_frame(self)
#TODO, this doesn't belong in Scene, but should be part of some more specialized subclass optimized for livestreaming
def tex(self, latex)