PythonのMatplotlibで3Dアニメーション（3次元GIF）を作成する方法

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from mpl_toolkits.mplot3d import Axes3D # 3Dプロットのために必要

def make_animation(data_frames, filename="animation.gif"):
    """
    3Dデータをアニメーション（GIF）として作成し保存する関数。

    :param data_frames: 各フレームの3D座標 (X, Y, Z) のリスト。
                        例: [[X_frame1, Y_frame1, Z_frame1], [X_frame2, Y_frame2, Z_frame2], ...]
    :param filename: 保存するGIFファイルのパス。
    """
    print("フレームを生成中...")

    fig = plt.figure(figsize=(8, 6)) # 図のサイズを指定
    ax = fig.add_subplot(111, projection='3d')

    # 軸ラベルの設定
    ax.set_xlabel('X-axis')
    ax.set_ylabel('Y-axis')
    ax.set_zlabel('Z-axis')

    # 軸の範囲をデータに合わせて自動調整、または手動で設定
    # ax.set_xlim(-500, 500) # 例
    # ax.set_ylim(-3, 3)
    # ax.set_zlim(-3, 3)

    ims = [] # 各フレームのArtistオブジェクトを格納するリスト

    for i, (X, Y, Z) in enumerate(data_frames):
        # プログレスバー表示
        progress = (i + 1) * 100 / len(data_frames)
        print(f"\r進捗: {progress:.1f}%", end="")

        # 3Dプロット。marker='o' で点を表示、linestyle='None' で線を表示しない
        # im = ax.plot(X, Y, Z, marker="o", color="red", linestyle='None')
        # plot()はリストを返すので、ims.append(im[0])のように要素を取り出す
        im, = ax.plot(X, Y, Z, marker="o", color="red", linestyle='None') # カンマでアンパック

        ims.append([im]) # ArtistAnimationはリストのリストを期待する

    print("\nアニメーションを生成中...")

    # アニメーションの作成
    # fig: アニメーションの対象となるFigureオブジェクト
    # ims: 各フレームのArtistオブジェクトのリスト
    # interval: フレーム間の遅延時間（ミリ秒）
    # blit: Trueにすると、変更された部分のみを再描画し高速化（ただし、複雑な3Dプロットでは問題を起こす可能性あり）
    ani = animation.ArtistAnimation(fig, ims, interval=50, blit=False)

    # アニメーションの保存
    # writer: アニメーションを保存するためのライター。'ffmpeg' や 'imagemagick' などが必要になる場合がある。
    # fps: フレーム/秒
    ani.save(filename, writer='pillow', fps=20) # 'pillow' は追加のライブラリ不要でGIF保存可能

    print(f"アニメーションを {filename} に保存しました。")
    plt.show() # アニメーションを表示

def main():
    # サンプルデータの生成
    # 時刻tに応じてsin波とcos波が変化する3D軌跡
    t = np.linspace(0, 20 * np.pi, 500) # 0から20πまで500点

    data_frames = []
    for i in range(len(t)):
        # 各フレームで1点だけプロットする例
        X_val = t[i] / (20 * np.pi) * 5 # X軸は時間経過で変化
        Y_val = np.sin(t[i])
        Z_val = np.cos(t[i])
        data_frames.append([[X_val], [Y_val], [Z_val]]) # 各要素をリストにする

    make_animation(data_frames, filename="sin_cos_3d_animation.gif")

if __name__ == '__main__':
  main()

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

t = np.linspace(0, 8 * np.pi, 150)
x = t / (8 * np.pi) * 5
y = np.sin(t)
z = np.cos(t)

fig = plt.figure(figsize=(6, 4.5))
ax = fig.add_subplot(111, projection="3d")
ax.set_xlim(0, 5)
ax.set_ylim(-1.2, 1.2)
ax.set_zlim(-1.2, 1.2)

(trail,) = ax.plot([], [], [], color="tab:red", lw=1.5)
(head,) = ax.plot([], [], [], color="tab:red", marker="o", linestyle="None")


def update(i):
    # 変更が必要な Artist のプロパティだけを更新する
    trail.set_data(x[: i + 1], y[: i + 1])
    trail.set_3d_properties(z[: i + 1])
    head.set_data([x[i]], [y[i]])
    head.set_3d_properties([z[i]])
    # blit=True のときはここで返した Artist だけが再描画対象になる
    return trail, head


ani = animation.FuncAnimation(fig, update, frames=len(t), interval=40, blit=False)
ani.save("funcanimation_demo.gif", writer="pillow", fps=20)

# matplotlib/animation.py (Animation.save 内、抜粋)
for data in zip(*[a.new_saved_frame_seq() for a in all_anim]):
    for anim, d in zip(all_anim, data):
        # TODO: See if turning off blit is really necessary
        anim._draw_next_frame(d, blit=False)
    writer.grab_frame(**savefig_kwargs)

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from PIL import Image, ImageSequence


def make_gif(blit, filename):
    fig = plt.figure(figsize=(4, 4))
    ax = fig.add_subplot(111, projection="3d")
    (line,) = ax.plot([0], [0], [0], marker="o", color="red")

    def update(i):
        line.set_data([np.cos(i / 5)], [np.sin(i / 5)])
        line.set_3d_properties([0])
        ax.view_init(elev=20, azim=i * 10)  # フレームごとに視点を回転
        return (line,)

    ani = animation.FuncAnimation(fig, update, frames=6, blit=blit, interval=200)
    ani.save(filename, writer="pillow", fps=2)
    plt.close(fig)


make_gif(True, "blit_true.gif")
make_gif(False, "blit_false.gif")


def frames_of(path):
    im = Image.open(path)
    return [np.array(f.convert("RGB")) for f in ImageSequence.Iterator(im)]


f_true = frames_of("blit_true.gif")
f_false = frames_of("blit_false.gif")
identical = all(np.array_equal(a, b) for a, b in zip(f_true, f_false))
print(f"blit=True と blit=False で保存された {len(f_true)} フレームがすべて一致: {identical}")

blit=True と blit=False で保存された 6 フレームがすべて一致: True

import os
import time
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
import matplotlib.animation as animation

# システムに ffmpeg がないため、imageio-ffmpeg 同梱のバイナリを指定する
import imageio_ffmpeg

matplotlib.rcParams["animation.ffmpeg_path"] = imageio_ffmpeg.get_ffmpeg_exe()


def build_animation(n_frames, dpi):
    t = np.linspace(0, 8 * np.pi, n_frames)
    x, y, z = t / (8 * np.pi) * 5, np.sin(t), np.cos(t)

    fig = plt.figure(figsize=(6, 4.5), dpi=dpi)
    ax = fig.add_subplot(111, projection="3d")
    ax.set_xlim(0, 5)
    ax.set_ylim(-1.2, 1.2)
    ax.set_zlim(-1.2, 1.2)
    (trail,) = ax.plot([], [], [], color="tab:red", lw=1.5)
    (head,) = ax.plot([], [], [], color="tab:red", marker="o", linestyle="None")

    def update(i):
        trail.set_data(x[: i + 1], y[: i + 1])
        trail.set_3d_properties(z[: i + 1])
        head.set_data([x[i]], [y[i]])
        head.set_3d_properties([z[i]])
        return trail, head

    return fig, animation.FuncAnimation(fig, update, frames=n_frames, interval=40)


for n_frames in (60, 150, 300):
    fig, ani = build_animation(n_frames, dpi=100)
    t0 = time.perf_counter()
    ani.save(f"gif_{n_frames}.gif", writer="pillow", fps=20)
    gif_time = time.perf_counter() - t0
    gif_size = os.path.getsize(f"gif_{n_frames}.gif") / 1024
    plt.close(fig)

    fig, ani = build_animation(n_frames, dpi=100)
    t0 = time.perf_counter()
    ani.save(f"mp4_{n_frames}.mp4", writer=animation.FFMpegWriter(fps=20, codec="libx264"))
    mp4_time = time.perf_counter() - t0
    mp4_size = os.path.getsize(f"mp4_{n_frames}.mp4") / 1024
    plt.close(fig)

    print(
        f"frames={n_frames:4d}  GIF: {gif_size:8.1f} KB / {gif_time:5.2f} s   "
        f"MP4: {mp4_size:8.1f} KB / {mp4_time:5.2f} s   "
        f"size ratio(GIF/MP4)={gif_size / mp4_size:5.1f}x"
    )

frames=  60  GIF:    358.1 KB /  1.64 s   MP4:     31.5 KB /  0.72 s   size ratio(GIF/MP4)= 11.4x
frames= 150  GIF:    637.5 KB /  4.03 s   MP4:     41.3 KB /  1.77 s   size ratio(GIF/MP4)= 15.4x
frames= 300  GIF:   1088.7 KB /  7.97 s   MP4:     74.4 KB /  3.61 s   size ratio(GIF/MP4)= 14.6x

import gc
import tracemalloc
import numpy as np

N_POINTS = 200  # 1フレームあたりの点数


def peak_mb_accumulate_all(n_frames, seed=123):
    """NG例: 全フレーム分のデータを先にリストへためてからアニメーション化"""
    tracemalloc.start()
    rng = np.random.default_rng(seed)
    frames = []
    for _ in range(n_frames):
        X = rng.normal(size=N_POINTS)
        Y = rng.normal(size=N_POINTS)
        Z = rng.normal(size=N_POINTS)
        frames.append((X, Y, Z))  # ここで全フレームを保持し続ける
    _, peak = tracemalloc.get_traced_memory()
    tracemalloc.stop()
    del frames
    gc.collect()
    return peak / 1e6


def peak_mb_on_the_fly(n_frames, seed=123):
    """OK例: update関数の中でその場でフレームを生成し、使い終わったら破棄する"""
    tracemalloc.start()
    rng = np.random.default_rng(seed)
    peak_seen = 0
    for _ in range(n_frames):
        X = rng.normal(size=N_POINTS)
        Y = rng.normal(size=N_POINTS)
        Z = rng.normal(size=N_POINTS)
        _, peak = tracemalloc.get_traced_memory()
        peak_seen = max(peak_seen, peak)
        # X, Y, Z はここでスコープを抜けて破棄される
    tracemalloc.stop()
    return peak_seen / 1e6


for n_frames in (500, 1000, 2000, 4000, 8000, 16000):
    list_mb = peak_mb_accumulate_all(n_frames)
    fly_mb = peak_mb_on_the_fly(n_frames)
    print(
        f"n_frames={n_frames:6d}  "
        f"事前リスト蓄積: {list_mb:8.3f} MB  "
        f"逐次生成: {fly_mb:8.4f} MB  "
        f"比率: {list_mb / fly_mb:8.1f}倍"
    )

n_frames=   500  事前リスト蓄積:    3.476 MB  逐次生成:   0.0088 MB  比率:    395.3倍
n_frames=  1000  事前リスト蓄積:    5.218 MB  逐次生成:   0.0087 MB  比率:    596.7倍
n_frames=  2000  事前リスト蓄積:   10.433 MB  逐次生成:   0.0087 MB  比率:   1193.2倍
n_frames=  4000  事前リスト蓄積:   20.866 MB  逐次生成:   0.0087 MB  比率:   2386.3倍
n_frames=  8000  事前リスト蓄積:   41.732 MB  逐次生成:   0.0087 MB  比率:   4772.6倍
n_frames= 16000  事前リスト蓄積:   83.465 MB  逐次生成:   0.0087 MB  比率:   9545.4倍

import gc
import weakref
import matplotlib.pyplot as plt
import matplotlib.animation as animation


def make_animation_without_keeping_reference():
    fig, ax = plt.subplots()
    (line,) = ax.plot([], [])

    def update(i):
        line.set_data([0, 1], [0, i])
        return (line,)

    ani = animation.FuncAnimation(fig, update, frames=20, interval=10)
    # ani をローカル変数として返さず weakref だけ返す
    # -> 関数を抜けた時点で ani への強参照がどこにも残らない
    return weakref.ref(ani), fig


ani_ref, fig = make_animation_without_keeping_reference()
gc.collect()
print("参照を保持しないまま gc.collect() した後も生存しているか:", ani_ref() is not None)

参照を保持しないまま gc.collect() した後も生存しているか: False

UserWarning: Animation was deleted without rendering anything. This is most likely
not intended. To prevent deletion, assign the Animation to a variable, e.g. `anim`,
that exists until you output the Animation using `plt.show()` or `anim.save()`.