A community-maintained Python framework for creating mathematical animations.
Finished TalkThrough1DHeatGraph
Grant Sanderson4972c71190a0
diff --git a/active_projects/ode/part2/heat_equation.py b/active_projects/ode/part2/heat_equation.pyindex f56acbf83..7529c5286 100644--- a/active_projects/ode/part2/heat_equation.py+++ b/active_projects/ode/part2/heat_equation.py@@ -167,6 +167,7 @@ class BringTwoRodsTogether(Scene):"graph_x_min": 0,"graph_x_max": 10,"wait_time": 30,+ "default_n_rod_pieces": 20,"alpha": 1.0,}@@ -375,7 +376,9 @@ class BringTwoRodsTogether(Scene):d2y = ry - 2 * y + lyreturn d2y / (dx**2)- def get_rod(self, x_min, x_max, n_pieces=20):+ def get_rod(self, x_min, x_max, n_pieces=None):+ if n_pieces is None:+ n_pieces = self.default_n_rod_piecesaxes = self.axesline = Line(axes.c2p(x_min, 0), axes.c2p(x_max, 0))rod = VGroup(*[@@ -426,6 +429,16 @@ class ShowEvolvingTempGraphWithArrows(BringTwoRodsTogether):"alpha": 0.1,"n_arrows": 20,"wait_time": 30,+ "freq_amplitude_pairs": [+ (1, 1),+ (2, 1),+ (3, 0.5),+ (4, 0.3),+ (5, 0.3),+ (7, 0.2),+ (21, 0.1),+ (41, 0.05),+ ],}def construct(self):@@ -504,34 +517,442 @@ class ShowEvolvingTempGraphWithArrows(BringTwoRodsTogether):)#- def initial_function(self, x):+ def temp_func(self, x, t):new_x = TAU * x / 10return 50 + 20 * np.sum([- np.sin(new_x),- np.sin(2 * new_x),- 0.5 * np.sin(3 * new_x),- 0.3 * np.sin(4 * new_x),- 0.3 * np.sin(5 * new_x),- 0.2 * np.sin(7 * new_x),- 0.1 * np.sin(21 * new_x),- 0.05 * np.sin(41 * new_x),+ amp * np.sin(freq * new_x) *+ np.exp(-(self.alpha * freq**2) * t)+ for freq, amp in self.freq_amplitude_pairs])+ def initial_function(self, x, time=0):+ return self.temp_func(x, 0)+++class TalkThrough1DHeatGraph(ShowEvolvingTempGraphWithArrows, SpecialThreeDScene):+ CONFIG = {+ "freq_amplitude_pairs": [+ (1, 0.7),+ (2, 1),+ (3, 0.5),+ (4, 0.3),+ (5, 0.3),+ (7, 0.2),+ ],+ }-class TalkThrough1DHeatGraph(ShowEvolvingTempGraphWithArrows):def construct(self):self.add_axes()self.add_graph()self.add_rod()- #- def initial_function(self, x):- new_x = TAU * x / 10- return 50 + 20 * np.sum([- np.sin(new_x),- np.sin(2 * new_x),- 0.5 * np.sin(3 * new_x),- 0.3 * np.sin(4 * new_x),- 0.3 * np.sin(5 * new_x),- 0.2 * np.sin(7 * new_x),+ self.emphasize_graph()+ self.emphasize_rod()+ self.show_x_axis()+ self.show_changes_over_time()+ self.show_surface()++ def add_graph(self):+ self.graph = self.get_graph()+ self.add(self.graph)++ def emphasize_graph(self):+ graph = self.graph+ q_marks = VGroup(*[+ TexMobject("?").move_to(+ graph.point_from_proportion(a),+ UP,+ ).set_stroke(BLACK, 3, background=True)+ for a in np.linspace(0, 1, 20)+ ])++ self.play(LaggedStart(*[+ Succession(+ FadeInFromLarge(q_mark),+ FadeOutAndShift(q_mark, DOWN),+ )+ for q_mark in q_marks+ ]))+ self.wait()++ def emphasize_rod(self):+ alt_rod = self.get_rod(0, 10, 50)+ word = TextMobject("Rod")+ word.scale(2)+ word.next_to(alt_rod, UP, MED_SMALL_BUFF)++ self.play(+ LaggedStart(+ *[+ Rotating(piece, rate_func=smooth)+ for piece in alt_rod+ ],+ run_time=2,+ lag_ratio=0.01,+ ),+ Write(word)+ )+ self.remove(*alt_rod)+ self.wait()++ self.rod_word = word++ def show_x_axis(self):+ rod = self.rod+ axes = self.axes+ graph = self.graph+ x_axis = axes.x_axis+ x_numbers = x_axis.get_number_mobjects(*range(1, 11))+ x_label = TexMobject("x")+ x_label.next_to(x_axis.get_right(), UP)++ self.play(+ rod.set_opacity, 0.5,+ FadeInFrom(x_label, UL),+ LaggedStartMap(+ FadeInFrom, x_numbers,+ lambda m: (m, UP),+ )+ )+ self.wait()++ # Show x-values+ triangle = ArrowTip(+ start_angle=-90 * DEGREES,+ color=LIGHT_GREY,+ )+ x_tracker = ValueTracker(PI)+ get_x = x_tracker.get_value++ def get_x_point():+ return x_axis.n2p(get_x())++ def get_graph_point():+ return graph.point_from_proportion(+ inverse_interpolate(+ self.graph_x_min,+ self.graph_x_max,+ get_x(),+ )+ )++ triangle.add_updater(+ lambda t: t.next_to(get_x_point(), UP)+ )+ x_label = VGroup(+ TexMobject("x"),+ TexMobject("="),+ DecimalNumber(+ 0,+ num_decimal_places=3,+ include_background_rectangle=True,+ ).scale(0.9)+ )+ x_label.set_stroke(BLACK, 5, background=True)+ x_label.add_updater(lambda m: m[-1].set_value(get_x()))+ x_label.add_updater(lambda m: m.arrange(RIGHT, buff=SMALL_BUFF))+ x_label.add_updater(lambda m: m[-1].align_to(m[0], DOWN))+ x_label.add_updater(lambda m: m.next_to(triangle, UP, SMALL_BUFF))+ x_label.add_updater(lambda m: m.shift(SMALL_BUFF * RIGHT))+ rod_piece = always_redraw(+ lambda: self.get_rod(+ get_x() - 0.05, get_x() + 0.05,+ n_pieces=1,+ )+ )++ self.play(+ FadeInFrom(triangle, UP),+ FadeIn(x_label),+ FadeIn(rod_piece),+ FadeOut(self.rod_word),+ )+ for value in [np.exp(2), (np.sqrt(5) + 1) / 2]:+ self.play(x_tracker.set_value, value, run_time=2)+ self.wait()++ # Show graph+ v_line = always_redraw(+ lambda: DashedLine(+ get_x_point(),+ get_graph_point(),+ color=self.rod_point_to_color(get_x_point()),+ )+ )+ graph_dot = Dot()+ graph_dot.add_updater(+ lambda m: m.set_color(+ self.rod_point_to_color(m.get_center())+ )+ )+ graph_dot.add_updater(+ lambda m: m.move_to(get_graph_point())+ )+ t_label = TexMobject("T(", "x", ")")+ t_label.set_stroke(BLACK, 3, background=True)+ t_label.add_updater(+ lambda m: m.next_to(graph_dot, UR, buff=0)+ )++ self.add(v_line, rod_piece, x_label, triangle)+ self.play(+ TransformFromCopy(x_label[0], t_label[1]),+ FadeIn(t_label[0::2]),+ ShowCreation(v_line),+ GrowFromPoint(graph_dot, get_x_point()),+ )+ self.add(t_label)+ self.wait()+ self.play(+ x_tracker.set_value, TAU,+ run_time=5,+ )++ self.x_tracker = x_tracker+ self.graph_label_group = VGroup(+ v_line, rod_piece, triangle, x_label,+ graph_dot, t_label,+ )+ self.set_variables_as_attrs(*self.graph_label_group)++ def show_changes_over_time(self):+ graph = self.graph+ t_label = self.t_label+ new_t_label = TexMobject("T(", "x", ",", "t", ")")+ new_t_label.set_color_by_tex("t", YELLOW)+ new_t_label.match_updaters(t_label)++ self.setup_clock()+ clock = self.clock+ time_label = self.time_label+ time_group = self.time_group++ time = 5+ self.play(+ FadeIn(clock),+ FadeIn(time_group),+ )+ self.play(+ self.get_graph_time_change_animation(+ graph, time+ ),+ ClockPassesTime(clock),+ ChangeDecimalToValue(+ time_label, time,+ rate_func=linear,+ ),+ ReplacementTransform(+ t_label,+ new_t_label,+ rate_func=squish_rate_func(smooth, 0.5, 0.7),+ ),+ run_time=time+ )+ self.play(+ ShowCreationThenFadeAround(+ new_t_label.get_part_by_tex("t")+ ),+ )+ self.wait()+ self.play(+ FadeOut(clock),+ ChangeDecimalToValue(time_label, 0),+ VFadeOut(time_group),+ self.get_graph_time_change_animation(+ graph,+ new_time=0,+ ),+ run_time=1,+ rate_func=smooth,+ )++ self.graph_label_group.remove(t_label)+ self.graph_label_group.add(new_t_label)++ def show_surface(self):+ axes = self.axes+ graph = self.graph++ axes_copy = axes.deepcopy()++ # Time axis+ t_min = 0+ t_max = 10+ t_axis = NumberLine(+ x_min=t_min,+ x_max=t_max,+ )+ origin = axes.c2p(0, 0)+ t_axis.shift(origin - t_axis.n2p(0))+ t_axis.add_numbers(+ *range(1, t_max + 1),+ direction=UP,+ )+ time_label = TextMobject("Time")+ time_label.scale(1.5)+ time_label.next_to(t_axis, UP)+ t_axis.add(time_label)+ # t_axis.rotate(90 * DEGREES, LEFT, about_point=origin)+ t_axis.rotate(90 * DEGREES, UP, about_point=origin)++ # New parts of graph+ step = 0.25+ graph_slices = VGroup(*[+ self.get_graph(time=t).shift(+ t * IN+ )+ for t in np.arange(0, t_max + step, step)])+ graph_slices.set_stroke(width=1)++ # Input plane+ x_axis = self.axes.x_axis+ y = axes.c2p(0, 0)[1]+ surface_config = {+ "u_min": self.graph_x_min,+ "u_max": self.graph_x_max,+ "v_min": t_min,+ "v_max": t_max,+ "resolution": 20,+ }+ input_plane = ParametricSurface(+ lambda x, t: np.array([+ x_axis.n2p(x)[0],+ y,+ t_axis.n2p(t)[2],+ ]),+ **surface_config,+ )+ input_plane.set_style(+ fill_opacity=0.5,+ fill_color=BLUE_B,+ stroke_width=0.5,+ stroke_color=WHITE,+ )++ # Surface+ y_axis = axes.y_axis+ surface = ParametricSurface(+ lambda x, t: np.array([+ x_axis.n2p(x)[0],+ y_axis.n2p(self.temp_func(x, t))[1],+ t_axis.n2p(t)[2],+ ]),+ **surface_config,+ )+ surface.set_style(+ fill_opacity=0,+ stroke_width=0.5,+ stroke_color=WHITE,+ stroke_opacity=0.5,+ )++ # Rotate everything on screen and move camera+ # in such a way that it looks the same+ curr_group = Group(*self.get_mobjects())+ curr_group.clear_updaters()+ self.set_camera_orientation(+ phi=90 * DEGREES,+ )+ mobs = [+ curr_group,+ graph_slices,+ t_axis,+ input_plane,+ surface,+ ]+ for mob in mobs:+ self.orient_mobject_for_3d(mob)++ # Clean current mobjects+ self.x_label.set_stroke(BLACK, 2, background=True)+ self.x_label[-1][0].fade(1)++ self.move_camera(+ phi=80 * DEGREES,+ theta=-85 * DEGREES,+ added_anims=[+ Write(input_plane),+ Write(t_axis),+ FadeOut(self.graph_label_group),+ self.rod.set_opacity, 1,+ ]+ )+ self.begin_ambient_camera_rotation()+ self.add(*graph_slices, *self.get_mobjects())+ self.play(+ FadeIn(surface),+ LaggedStart(*[+ TransformFromCopy(graph, graph_slice)+ for graph_slice in graph_slices+ ])+ )+ self.wait(4)++ # Show slices+ self.axes = axes_copy # So get_graph works...++ def get_time_slice(t):+ new_slice = self.get_graph(t)+ new_slice.set_shade_in_3d(True)+ self.orient_mobject_for_3d(new_slice)+ new_slice.shift(t * UP)+ return new_slice++ graph.set_shade_in_3d(True)+ t_tracker = ValueTracker(0)+ graph.add_updater(lambda g: g.become(+ get_time_slice(t_tracker.get_value())+ ))++ self.play(+ t_tracker.set_value, 10,+ self.rod.shift, 10 * UP,+ ApplyMethod(+ graph_slices.set_stroke, {"opacity": 0.5},+ rate_func=squish_rate_func(smooth, 0, 0.2),+ ),+ run_time=10,+ rate_func=linear,+ )+ self.wait()++ #+ def get_graph(self, time=0):+ graph = self.axes.get_graph(+ lambda x: self.temp_func(x, time),+ x_min=self.graph_x_min,+ x_max=self.graph_x_max,+ step_size=self.step_size,+ )+ graph.time = time+ graph.color_using_background_image("VerticalTempGradient")+ return graph++ def get_graph_time_change_animation(self, graph, new_time, **kwargs):+ old_time = graph.time+ graph.time = new_time+ config = {+ "run_time": abs(new_time - old_time),+ "rate_func": linear,+ }+ config.update(kwargs)++ return UpdateFromAlphaFunc(+ graph,+ lambda g, a: g.become(+ self.get_graph(interpolate(+ old_time, new_time, a+ ))+ ),+ **config+ )++ def orient_mobject_for_3d(self, mob):+ mob.rotate(+ 90 * DEGREES,+ axis=RIGHT,+ about_point=ORIGIN+ )+ mob.shift(1 * DOWN)+ return mob