Skip to content

armgit / manim

Public Imported from GitHub
0

A community-maintained Python framework for creating mathematical animations.

6.1 KB
Raw Blame
import sys
from pathlib import Path

import av
import numpy as np
import pytest

from manim import DR, Circle, Create, Scene, Star, tempconfig
from manim.utils.commands import capture, get_video_metadata


class StarScene(Scene):
    def construct(self):
        circle = Circle(fill_opacity=1, color="#ff0000")
        circle.to_corner(DR).shift(DR)
        self.add(circle)
        star = Star()
        self.play(Create(star))
        click_path = (
            Path(__file__).parent.parent.parent
            / "docs"
            / "source"
            / "_static"
            / "click.wav"
        )
        self.add_sound(click_path)
        self.wait()


@pytest.mark.slow
@pytest.mark.parametrize(
    "transparent",
    [False, True],
)
def test_gif_writing(config, tmp_path, transparent):
    output_filename = f"gif_{'transparent' if transparent else 'opaque'}"
    with tempconfig(
        {
            "media_dir": tmp_path,
            "quality": "low_quality",
            "format": "gif",
            "transparent": transparent,
            "output_file": output_filename,
        }
    ):
        StarScene().render()

    video_path = tmp_path / "videos" / "480p15" / f"{output_filename}.gif"
    assert video_path.exists()
    metadata = get_video_metadata(video_path)
    # reported duration + avg_frame_rate is slightly off for gifs
    del metadata["duration"], metadata["avg_frame_rate"]
    target_metadata = {
        "width": 854,
        "height": 480,
        "nb_frames": "30",
        "codec_name": "gif",
        "pix_fmt": "bgra",
    }
    assert metadata == target_metadata

    with av.open(video_path) as container:
        first_frame = next(container.decode(video=0))
        frame_format = "argb" if transparent else "rgb24"
        first_frame = first_frame.to_ndarray(format=frame_format)

    target_rgba_corner = (
        np.array([0, 255, 255, 255], dtype=np.uint8)
        if transparent
        else np.array([0, 0, 0], dtype=np.uint8)
    )
    np.testing.assert_array_equal(first_frame[0, 0], target_rgba_corner)

    target_rgba_center = (
        np.array([255, 255, 0, 0])  # components (A, R, G, B)
        if transparent
        else np.array([255, 0, 0], dtype=np.uint8)
    )
    np.testing.assert_allclose(first_frame[-1, -1], target_rgba_center, atol=5)


@pytest.mark.slow
@pytest.mark.parametrize(
    ("format", "transparent", "codec", "pixel_format"),
    [
        ("mp4", False, "h264", "yuv420p"),
        ("mov", False, "h264", "yuv420p"),
        ("mov", True, "qtrle", "argb"),
        ("webm", False, "vp9", "yuv420p"),
        ("webm", True, "vp9", "yuv420p"),
    ],
)
def test_codecs(config, tmp_path, format, transparent, codec, pixel_format):
    output_filename = f"codec_{format}_{'transparent' if transparent else 'opaque'}"
    with tempconfig(
        {
            "media_dir": tmp_path,
            "quality": "low_quality",
            "format": format,
            "transparent": transparent,
            "output_file": output_filename,
        }
    ):
        StarScene().render()

    video_path = tmp_path / "videos" / "480p15" / f"{output_filename}.{format}"
    assert video_path.exists()
    metadata = get_video_metadata(video_path)
    target_metadata = {
        "width": 854,
        "height": 480,
        "nb_frames": "30",
        "duration": "2.000000",
        "avg_frame_rate": "15/1",
        "codec_name": codec,
        "pix_fmt": pixel_format,
    }
    assert metadata == target_metadata

    with av.open(video_path) as container:
        if transparent and format == "webm":
            from av.codec.context import CodecContext

            context = CodecContext.create("libvpx-vp9", "r")
            packet = next(container.demux(video=0))
            first_frame = context.decode(packet)[0].to_ndarray(format="argb")
        else:
            first_frame = next(container.decode(video=0)).to_ndarray()

        has_samples = [
            np.any(frame.to_ndarray()) for frame in container.decode(audio=0)
        ]
        assert any(has_samples), "All audio samples are zero, this is not intended"

    target_rgba_corner = (
        np.array([0, 0, 0, 0]) if transparent else np.array(16, dtype=np.uint8)
    )
    np.testing.assert_array_equal(first_frame[0, 0], target_rgba_corner)

    target_rgba_center = (
        np.array([255, 255, 0, 0])  # components (A, R, G, B)
        if transparent
        else np.array(240, dtype=np.uint8)
    )
    np.testing.assert_allclose(first_frame[-1, -1], target_rgba_center, atol=5)


def test_scene_with_non_raw_or_wav_audio(config, manim_caplog):
    class SceneWithMP3(Scene):
        def construct(self):
            file_path = Path(__file__).parent / "click.mp3"
            self.add_sound(file_path)
            self.wait()

    SceneWithMP3().render()
    assert "click.mp3 to .wav" in manim_caplog.text


@pytest.mark.slow
def test_unicode_partial_movie(config, tmpdir, simple_scenes_path):
    # Characters that failed for a user on Windows
    # due to its weird default encoding.
    unicode_str = "三角函数"

    scene_name = "SquareToCircle"
    command = [
        sys.executable,
        "-m",
        "manim",
        "--media_dir",
        str(tmpdir / unicode_str),
        str(simple_scenes_path),
        scene_name,
    ]

    _, err, exit_code = capture(command)
    assert exit_code == 0, err


@pytest.mark.parametrize(
    ("vorbis_modes", "expected"),
    [({"r", "w"}, "libvorbis"), ({"r"}, "libopus"), (set(), "libopus")],
    ids=["encoder-available", "decoder-only", "missing"],
)
def test_webm_audio_codec_checks_encoder_availability(
    monkeypatch, vorbis_modes, expected
):
    from manim.scene import scene_file_writer

    available = {"libopus", "vorbis", "aac"}
    if vorbis_modes:
        available.add("libvorbis")
    monkeypatch.setattr(av, "codecs_available", available)
    calls = []

    def codec(name, mode):
        calls.append((name, mode))
        if mode not in vorbis_modes:
            raise ValueError("libvorbis encoder is unavailable")
        return object()

    monkeypatch.setattr(av.codec, "Codec", codec)
    assert scene_file_writer._webm_audio_codec() == expected
    assert calls == [("libvorbis", "w")]