Skip to content

armgit / manim

Public Imported from GitHub
0

A community-maintained Python framework for creating mathematical animations.

Beginning heat equation solution animations

Grant Sandersone6eb4dd94f5e
diff --git a/active_projects/ode/all_part3_scenes.py b/active_projects/ode/all_part3_scenes.py
new file mode 100644
index 000000000..32be5c04b
--- /dev/null
+++ b/active_projects/ode/all_part3_scenes.py
@@ -0,0 +1,13 @@
+from active_projects.ode.part3.staging import *
+from active_projects.ode.part3.temperature_graphs import *
+
+
+OUTPUT_DIRECTORY = "ode/part3"
+SCENES_IN_ORDER = [
+ FourierSeriesIllustraiton,
+ FourierNameIntro,
+ CircleAnimationOfF,
+ LastChapterWrapper,
+ ThreeMainObservations,
+ SimpleSinExpGraph,
+]
diff --git a/active_projects/ode/part2/fourier_series.py b/active_projects/ode/part2/fourier_series.py
index 28460f734..e9544f4cc 100644
--- a/active_projects/ode/part2/fourier_series.py
+++ b/active_projects/ode/part2/fourier_series.py
@@ -527,7 +527,7 @@ class FourierNDQ(FourierOfTrebleClef):
def get_shape(self):
path = VMobject()
- shape = TexMobject("Hayley")
+ shape = TexMobject("NDQ")
for sp in shape.family_members_with_points():
path.append_points(sp.points)
return path
diff --git a/active_projects/ode/part3/staging.py b/active_projects/ode/part3/staging.py
new file mode 100644
index 000000000..a91de197d
--- /dev/null
+++ b/active_projects/ode/part3/staging.py
@@ -0,0 +1,427 @@
+from manimlib.imports import *
+
+from active_projects.ode.part2.fourier_series import FourierOfTrebleClef
+
+
+class FourierNameIntro(Scene):
+ def construct(self):
+ self.show_two_titles()
+ self.transition_to_image()
+ self.show_paper()
+
+ def show_two_titles(self):
+ lt = TextMobject("Fourier", "Series")
+ rt = TextMobject("Fourier", "Transform")
+ lt_variants = VGroup(
+ TextMobject("Complex", "Fourier Series"),
+ TextMobject("Discrete", "Fourier Series"),
+ )
+ rt_variants = VGroup(
+ TextMobject("Discrete", "Fourier Transform"),
+ TextMobject("Fast", "Fourier Transform"),
+ TextMobject("Quantum", "Fourier Transform"),
+ )
+
+ titles = VGroup(lt, rt)
+ titles.scale(1.5)
+ for title, vect in (lt, LEFT), (rt, RIGHT):
+ title.move_to(vect * FRAME_WIDTH / 4)
+ title.to_edge(UP)
+
+ for title, variants in (lt, lt_variants), (rt, rt_variants):
+ title.save_state()
+ title.target = title.copy()
+ title.target.scale(1 / 1.5, about_edge=RIGHT)
+ for variant in variants:
+ variant.move_to(title.target, UR)
+ variant[0].set_color(YELLOW)
+
+ v_line = Line(UP, DOWN)
+ v_line.set_height(FRAME_HEIGHT)
+ v_line.set_stroke(WHITE, 2)
+
+ self.play(
+ FadeInFrom(lt, RIGHT),
+ ShowCreation(v_line)
+ )
+ self.play(
+ FadeInFrom(rt, LEFT),
+ )
+ # Edit in images of circle animations
+ # and clips from FT video
+
+ # for title, variants in (rt, rt_variants), (lt, lt_variants):
+ for title, variants in [(rt, rt_variants)]:
+ # Maybe do it for left variant, maybe not...
+ self.play(
+ MoveToTarget(title),
+ FadeInFrom(variants[0][0], LEFT)
+ )
+ for v1, v2 in zip(variants, variants[1:]):
+ self.play(
+ FadeOutAndShift(v1[0], UP),
+ FadeInFrom(v2[0], DOWN),
+ run_time=0.5,
+ )
+ self.wait(0.5)
+ self.play(
+ Restore(title),
+ FadeOut(variants[-1][0])
+ )
+ self.wait()
+
+ self.titles = titles
+ self.v_line = v_line
+
+ def transition_to_image(self):
+ titles = self.titles
+ v_line = self.v_line
+
+ image = ImageMobject("Joseph Fourier")
+ image.set_height(5)
+ image.to_edge(LEFT)
+
+ frame = Rectangle()
+ frame.replace(image, stretch=True)
+
+ name = TextMobject("Joseph", "Fourier")
+ fourier_part = name.get_part_by_tex("Fourier")
+ fourier_part.set_color(YELLOW)
+ F_sym = fourier_part[0]
+ name.match_width(image)
+ name.next_to(image, DOWN)
+
+ self.play(
+ ReplacementTransform(v_line, frame),
+ FadeIn(image),
+ FadeIn(name[0]),
+ *[
+ ReplacementTransform(
+ title[0].deepcopy(),
+ name[1]
+ )
+ for title in titles
+ ],
+ titles.scale, 0.65,
+ titles.arrange, DOWN,
+ titles.next_to, image, UP,
+ )
+ self.wait()
+
+ big_F = F_sym.copy()
+ big_F.set_fill(opacity=0)
+ big_F.set_stroke(WHITE, 2)
+ big_F.set_height(3)
+ big_F.move_to(midpoint(
+ image.get_right(),
+ RIGHT_SIDE,
+ ))
+ big_F.shift(DOWN)
+ equivalence = VGroup(
+ fourier_part.copy().scale(1.25),
+ TexMobject("\\Leftrightarrow").scale(1.5),
+ TextMobject("Break down into\\\\pure frequencies"),
+ )
+ equivalence.arrange(RIGHT)
+ equivalence.move_to(big_F)
+ equivalence.to_edge(UP)
+
+ self.play(
+ FadeIn(big_F),
+ TransformFromCopy(fourier_part, equivalence[0]),
+ Write(equivalence[1:]),
+ )
+ self.wait(3)
+ self.play(FadeOut(VGroup(big_F, equivalence)))
+
+ self.image = image
+ self.name = name
+
+ def show_paper(self):
+ image = self.image
+ paper = ImageMobject("Fourier paper")
+ paper.match_height(image)
+ paper.next_to(image, RIGHT, MED_LARGE_BUFF)
+
+ date = TexMobject("1822")
+ date.next_to(paper, DOWN)
+ date_rect = SurroundingRectangle(date)
+ date_rect.scale(0.3)
+ date_rect.set_color(RED)
+ date_rect.shift(1.37 * UP + 0.08 * LEFT)
+ date_arrow = Arrow(
+ date_rect.get_bottom(),
+ date.get_top(),
+ buff=SMALL_BUFF,
+ color=date_rect.get_color(),
+ )
+
+ heat_rect = SurroundingRectangle(
+ TextMobject("CHALEUR")
+ )
+ heat_rect.set_color(RED)
+ heat_rect.scale(0.6)
+ heat_rect.move_to(
+ paper.get_top() +
+ 1.22 * DOWN + 0.37 * RIGHT
+ )
+ heat_word = TextMobject("Heat")
+ heat_word.scale(1.5)
+ heat_word.next_to(paper, UP)
+ heat_word.shift(paper.get_width() * RIGHT)
+ heat_arrow = Arrow(
+ heat_rect.get_top(),
+ heat_word.get_left(),
+ buff=0.1,
+ path_arc=-60 * DEGREES,
+ color=heat_rect.get_color(),
+ )
+
+ self.play(FadeInFrom(paper, LEFT))
+ self.play(
+ ShowCreation(date_rect),
+ )
+ self.play(
+ GrowFromPoint(date, date_arrow.get_start()),
+ ShowCreation(date_arrow),
+ )
+ self.wait(3)
+
+ # Insert animation of circles/sine waves
+ # approximating a square wave
+
+ self.play(
+ ShowCreation(heat_rect),
+ )
+ self.play(
+ GrowFromPoint(heat_word, heat_arrow.get_start()),
+ ShowCreation(heat_arrow),
+ )
+ self.wait(3)
+
+
+class FourierSeriesIllustraiton(Scene):
+ CONFIG = {
+ "n_range": range(1, 31, 2),
+ }
+
+ def construct(self):
+ n_range = self.n_range
+
+ axes1 = Axes(
+ number_line_config={
+ "include_tip": False,
+ },
+ x_axis_config={
+ "tick_frequency": 1 / 4,
+ "unit_size": 4,
+ },
+ x_min=0,
+ x_max=1,
+ y_min=-1,
+ y_max=1,
+ )
+ axes2 = axes1.copy()
+ step_func = axes2.get_graph(
+ lambda x: (1 if x < 0.5 else -1),
+ discontinuities=[0.5],
+ color=YELLOW,
+ stroke_width=3,
+ )
+ dot = Dot(axes2.c2p(0.5, 0), color=step_func.get_color())
+ dot.scale(0.5)
+ step_func.add(dot)
+ axes2.add(step_func)
+
+ arrow = Arrow(LEFT, RIGHT, color=WHITE)
+ VGroup(axes1, arrow, axes2).arrange(RIGHT).shift(UP)
+
+ def generate_nth_func(n):
+ return lambda x: (4 / n / PI) * np.sin(TAU * n * x)
+
+ def generate_kth_partial_sum_func(k):
+ return lambda x: np.sum([
+ generate_nth_func(n)(x)
+ for n in n_range[:k]
+ ])
+
+ sine_graphs = VGroup(*[
+ axes1.get_graph(generate_nth_func(n))
+ for n in n_range
+ ])
+ sine_graphs.set_stroke(width=3)
+ sine_graphs.set_color_by_gradient(
+ BLUE, GREEN, RED, YELLOW, PINK,
+ BLUE, GREEN, RED, YELLOW, PINK,
+ )
+
+ partial_sums = VGroup(*[
+ axes1.get_graph(generate_kth_partial_sum_func(k + 1))
+ for k in range(len(n_range))
+ ])
+ partial_sums.match_style(sine_graphs)
+
+ sum_tex = TexMobject(
+ "\\frac{4}{\\pi}"
+ "\\sum_{1, 3, 5, \\dots}"
+ "\\frac{1}{n} \\sin(2\\pi \\cdot n \\cdot x)"
+ )
+ sum_tex.next_to(partial_sums, DOWN, buff=0.7)
+ eq = TexMobject("=")
+ step_tex = TexMobject(
+ """
+ 1 \\quad \\text{if $x < 0.5$} \\\\
+ 0 \\quad \\text{if $x = 0.5$} \\\\
+ -1 \\quad \\text{if $x > 0.5$} \\\\
+ """
+ )
+ lb = Brace(step_tex, LEFT, buff=SMALL_BUFF)
+ step_tex.add(lb)
+ step_tex.next_to(axes2, DOWN, buff=MED_LARGE_BUFF)
+ eq.move_to(midpoint(
+ step_tex.get_left(),
+ sum_tex.get_right()
+ ))
+
+ rects = it.chain(
+ [
+ SurroundingRectangle(sum_tex[0][i])
+ for i in [4, 6, 8]
+ ],
+ it.cycle([None])
+ )
+
+ self.add(axes1, arrow, axes2)
+ self.add(step_func)
+ self.add(sum_tex, eq, step_tex)
+
+ curr_partial_sum = axes1.get_graph(lambda x: 0)
+ curr_partial_sum.set_stroke(width=1)
+ for sine_graph, partial_sum, rect in zip(sine_graphs, partial_sums, rects):
+ anims1 = [
+ ShowCreation(sine_graph)
+ ]
+ partial_sum.set_stroke(BLACK, 4, background=True)
+ anims2 = [
+ curr_partial_sum.set_stroke,
+ {"width": 1, "opacity": 0.5},
+ curr_partial_sum.set_stroke,
+ {"width": 0, "background": True},
+ ReplacementTransform(
+ sine_graph, partial_sum,
+ remover=True
+ ),
+ ]
+ if rect:
+ rect.match_style(sine_graph)
+ anims1.append(ShowCreation(rect))
+ anims2.append(FadeOut(rect))
+ self.play(*anims1)
+ self.play(*anims2)
+ curr_partial_sum = partial_sum
+
+
+class CircleAnimationOfF(FourierOfTrebleClef):
+ CONFIG = {
+ "height": 3,
+ "n_circles": 200,
+ "run_time": 10,
+ "arrow_config": {
+ "tip_length": 0.1,
+ "stroke_width": 2,
+ }
+ }
+
+ def get_shape(self):
+ path = VMobject()
+ shape = TexMobject("F")
+ for sp in shape.family_members_with_points():
+ path.append_points(sp.points)
+ return path
+
+
+class LastChapterWrapper(Scene):
+ def construct(self):
+ full_rect = FullScreenFadeRectangle(
+ fill_color=DARK_GREY,
+ fill_opacity=1,
+ )
+ rect = ScreenRectangle(height=6)
+ rect.set_stroke(WHITE, 2)
+ rect.set_fill(BLACK, 1)
+ title = TextMobject("Last chapter")
+ title.scale(2)
+ title.to_edge(UP)
+ rect.next_to(title, DOWN)
+
+ self.add(full_rect)
+ self.play(
+ FadeIn(rect),
+ Write(title, run_time=2),
+ )
+ self.wait()
+
+
+class ThreeMainObservations(Scene):
+ def construct(self):
+ fourier = ImageMobject("Joseph Fourier")
+ fourier.set_height(5)
+ fourier.to_corner(DR)
+ fourier.shift(LEFT)
+ bubble = ThoughtBubble(
+ direction=RIGHT,
+ height=3,
+ width=4,
+ )
+ bubble.move_tip_to(fourier.get_corner(UL) + 0.5 * DR)
+
+ observations = VGroup(
+ TextMobject(
+ "1)",
+ # "Sine waves",
+ # "H",
+ # "Heat equation",
+ ),
+ TextMobject(
+ "2)",
+ # "Linearity"
+ ),
+ TextMobject(
+ "3)",
+ # "Any$^{*}$ function is\\\\",
+ # "a sum of sine waves",
+ ),
+ )
+ # heart = SuitSymbol("hearts")
+ # heart.replace(observations[0][2])
+ # observations[0][2].become(heart)
+ # observations[0][1].add(happiness)
+ # observations[2][2].align_to(
+ # observations[2][1], LEFT,
+ # )
+
+ observations.arrange(
+ DOWN,
+ aligned_edge=LEFT,
+ buff=LARGE_BUFF,
+ )
+ observations.set_height(FRAME_HEIGHT - 2)
+ observations.to_corner(UL, buff=LARGE_BUFF)
+
+ self.add(fourier)
+ self.play(ShowCreation(bubble))
+ self.wait()
+ self.play(LaggedStart(*[
+ TransformFromCopy(bubble, observation)
+ for observation in observations
+ ], lag_ratio=0.2))
+ self.play(
+ FadeOut(fourier),
+ FadeOut(bubble),
+ )
+ self.wait()
+
+
+class NewSceneName(Scene):
+ def construct(self):
+ pass
diff --git a/active_projects/ode/part3/temperature_graphs.py b/active_projects/ode/part3/temperature_graphs.py
new file mode 100644
index 000000000..35f1b4721
--- /dev/null
+++ b/active_projects/ode/part3/temperature_graphs.py
@@ -0,0 +1,261 @@
+from manimlib.imports import *
+
+
+class TemperatureGraphScene(SpecialThreeDScene):
+ CONFIG = {
+ "axes_config": {
+ "x_min": 0,
+ "x_max": TAU,
+ "y_min": 0,
+ "y_max": 10,
+ "z_min": -3,
+ "z_max": 3,
+ "x_axis_config": {
+ "tick_frequency": TAU / 8,
+ "include_tip": False,
+ },
+ "num_axis_pieces": 1,
+ },
+ "default_graph_style": {
+ "stroke_width": 2,
+ "stroke_color": WHITE,
+ "background_image_file": "VerticalTempGradient",
+ },
+ "default_surface_style": {
+ "fill_opacity": 0.1,
+ "checkerboard_colors": [LIGHT_GREY],
+ "stroke_width": 0.5,
+ "stroke_color": WHITE,
+ "stroke_opacity": 0.5,
+ },
+ }
+
+ def get_three_d_axes(self, include_labels=True):
+ axes = ThreeDAxes(**self.axes_config)
+ axes.set_stroke(width=2)
+
+ # Add number labels
+ # TODO?
+
+ # Add axis labels
+ if include_labels:
+ x_label = TexMobject("x")
+ x_label.next_to(axes.x_axis.get_right(), DOWN)
+ axes.x_axis.add(x_label)
+
+ t_label = TextMobject("Time")
+ t_label.rotate(90 * DEGREES, OUT)
+ t_label.next_to(axes.y_axis.get_top(), DL)
+ axes.y_axis.add(t_label)
+
+ temp_label = TextMobject("Temperature")
+ temp_label.rotate(90 * DEGREES, RIGHT)
+ temp_label.next_to(axes.z_axis.get_zenith(), RIGHT)
+ axes.z_axis.add(temp_label)
+
+ # Adjust axis orinetations
+ axes.x_axis.rotate(
+ 90 * DEGREES, RIGHT,
+ about_point=axes.c2p(0, 0, 0),
+ )
+ axes.y_axis.rotate(
+ 90 * DEGREES, UP,
+ about_point=axes.c2p(0, 0, 0),
+ )
+
+ # Add xy-plane
+ surface_config = {
+ "u_min": 0,
+ "u_max": axes.x_max,
+ "v_min": 0,
+ "v_max": axes.y_max,
+ "resolution": (16, 10),
+ }
+ axes.surface_config = surface_config
+ input_plane = ParametricSurface(
+ lambda x, t: axes.c2p(x, t, 0),
+ # lambda x, t: np.array([x, t, 0]),
+ **surface_config,
+ )
+ input_plane.set_style(
+ fill_opacity=0.5,
+ fill_color=BLUE_B,
+ stroke_width=0.5,
+ stroke_color=WHITE,
+ )
+
+ axes.input_plane = input_plane
+
+ return axes
+
+ def get_initial_state_graph(self, axes, func, **kwargs):
+ config = dict()
+ config.update(self.default_graph_style)
+ config.update(kwargs)
+ return ParametricFunction(
+ lambda x: axes.c2p(
+ x, 0, func(x)
+ ),
+ t_min=axes.x_min,
+ t_max=axes.x_max,
+ **config,
+ )
+
+ def get_surface(self, axes, func, **kwargs):
+ config = dict()
+ config.update(axes.surface_config)
+ config.update(self.default_surface_style)
+ config.update(kwargs)
+ return ParametricSurface(
+ lambda x, t: axes.c2p(
+ x, t, func(x, t)
+ ),
+ **config
+ )
+
+ def orient_three_d_mobject(self, mobject,
+ phi=85 * DEGREES,
+ theta=-80 * DEGREES):
+ mobject.rotate(-90 * DEGREES - theta, OUT)
+ mobject.rotate(phi, LEFT)
+ return mobject
+
+
+class SimpleSinExpGraph(TemperatureGraphScene):
+ def construct(self):
+ axes = self.get_three_d_axes()
+ sine_graph = self.get_sine_graph(axes)
+ sine_exp_surface = self.get_sine_exp_surface(axes)
+
+ self.set_camera_orientation(
+ phi=80 * DEGREES,
+ theta=-80 * DEGREES,
+ )
+ self.camera.frame_center.shift(3 * RIGHT)
+ self.begin_ambient_camera_rotation(rate=0.01)
+
+ self.add(axes)
+ self.play(ShowCreation(sine_graph))
+ self.play(UpdateFromAlphaFunc(
+ sine_exp_surface,
+ lambda m, a: m.become(
+ self.get_sine_exp_surface(axes, v_max=a * 10)
+ ),
+ run_time=3
+ ))
+ self.wait(20)
+
+ #
+ def sin_exp(self, x, t, A=2, omega=1, k=0.25):
+ return A * np.sin(omega * x) * np.exp(-k * (omega**2) * t)
+
+ def get_sine_graph(self, axes, **config):
+ return self.get_initial_state_graph(
+ axes,
+ lambda x: self.sin_exp(x, 0),
+ **config
+ )
+
+ def get_sine_exp_surface(self, axes, **config):
+ return self.get_surface(
+ axes,
+ lambda x, t: self.sin_exp(x, t),
+ **config
+ )
+
+
+class AddMultipleSolutions(SimpleSinExpGraph):
+ CONFIG = {
+ "axes_config": {
+ "x_axis_config": {
+ "unit_size": 0.7,
+ },
+ }
+ }
+
+ def construct(self):
+ axes1, axes2, axes3 = all_axes = VGroup(*[
+ self.get_three_d_axes(
+ include_labels=False,
+ )
+ for x in range(3)
+ ])
+ all_axes.scale(0.5)
+ self.orient_three_d_mobject(all_axes)
+
+ As = [1.5, 1.5]
+ omegas = [1, 2]
+ ks = [0.25, 0.01]
+ quads = [
+ (axes1, [As[0]], [omegas[0]], [ks[0]]),
+ (axes2, [As[1]], [omegas[1]], [ks[1]]),
+ (axes3, As, omegas, ks),
+ ]
+
+ for axes, As, omegas, ks in quads:
+ graph = self.get_initial_state_graph(
+ axes,
+ lambda x: np.sum([
+ self.sin_exp(x, 0, A, omega, k)
+ for A, omega, k in zip(As, omegas, ks)
+ ])
+ )
+ surface = self.get_surface(
+ axes,
+ lambda x, t: np.sum([
+ self.sin_exp(x, t, A, omega)
+ for A, omega in zip(As, omegas)
+ ])
+ )
+ surface.sort(lambda p: -p[2])
+
+ axes.add(surface, graph)
+ axes.graph = graph
+ axes.surface = surface
+
+ self.set_camera_orientation(distance=100)
+ plus = TexMobject("+").scale(2)
+ equals = TexMobject("=").scale(2)
+ group = VGroup(
+ axes1, plus, axes2, equals, axes3,
+ )
+ group.arrange(RIGHT, buff=SMALL_BUFF)
+
+ for axes in all_axes:
+ checkmark = TexMobject("\\checkmark")
+ checkmark.set_color(GREEN)
+ checkmark.scale(2)
+ checkmark.next_to(axes, UP)
+ checkmark.shift(0.7 * DOWN)
+ axes.checkmark = checkmark
+
+ self.add(axes1, axes2)
+ self.play(
+ LaggedStart(
+ Write(axes1.surface),
+ Write(axes2.surface),
+ ),
+ LaggedStart(
+ FadeInFrom(axes1.checkmark, DOWN),
+ FadeInFrom(axes2.checkmark, DOWN),
+ ),
+ lag_ratio=0.2,
+ run_time=1,
+ )
+ self.wait()
+ self.play(Write(plus))
+ self.play(
+ Transform(
+ axes1.copy().set_fill(opacity=0),
+ axes3
+ ),
+ Transform(
+ axes2.copy().set_fill(opacity=0),
+ axes3
+ ),
+ FadeInFrom(equals, LEFT)
+ )
+ self.play(
+ FadeInFrom(axes3.checkmark, DOWN),
+ )
+ self.wait()