A community-maintained Python framework for creating mathematical animations.
ContrastXChangesToTChanges
Grant Sandersond50b2c0e3b60
diff --git a/active_projects/ode/all_part2_scenes.py b/active_projects/ode/all_part2_scenes.pyindex f67ac7170..718d0c9ec 100644--- a/active_projects/ode/all_part2_scenes.py+++ b/active_projects/ode/all_part2_scenes.py@@ -37,6 +37,7 @@ ALL_SCENE_CLASSES = [TalkThrough1DHeatGraph,ShowCubeFormation,CompareInputsOfGeneralCaseTo1D,+ ContrastXChangesToTChanges,TransitionToTempVsTime,ShowNewton,ShowCupOfWater,diff --git a/active_projects/ode/part2/heat_equation.py b/active_projects/ode/part2/heat_equation.pyindex 00a263913..9f0fcbb99 100644--- a/active_projects/ode/part2/heat_equation.py+++ b/active_projects/ode/part2/heat_equation.py@@ -539,6 +539,8 @@ class TalkThrough1DHeatGraph(ShowEvolvingTempGraphWithArrows, SpecialThreeDScene(5, 0.3),(7, 0.2),],+ "surface_resolution": 20,+ "graph_slice_step": 0.5,}def construct(self):@@ -777,7 +779,7 @@ class TalkThrough1DHeatGraph(ShowEvolvingTempGraphWithArrows, SpecialThreeDScenet_max = 10axes_copy = axes.deepcopy()- original_axes = self.axes+ self.original_axes = self.axes# Set rod final statefinal_graph = self.get_graph(t_max)@@ -808,7 +810,7 @@ class TalkThrough1DHeatGraph(ShowEvolvingTempGraphWithArrows, SpecialThreeDScenet_axis.rotate(90 * DEGREES, UP, about_point=origin)# New parts of graph- step = 0.25+ step = self.graph_slice_stepgraph_slices = VGroup(*[self.get_graph(time=t).shift(t * IN@@ -826,7 +828,7 @@ class TalkThrough1DHeatGraph(ShowEvolvingTempGraphWithArrows, SpecialThreeDScene"u_max": self.graph_x_max,"v_min": t_min,"v_max": t_max,- "resolution": 20,+ "resolution": self.surface_resolution,}input_plane = ParametricSurface(lambda x, t: np.array([@@ -854,7 +856,8 @@ class TalkThrough1DHeatGraph(ShowEvolvingTempGraphWithArrows, SpecialThreeDScene**surface_config,)surface.set_style(- fill_opacity=0,+ fill_opacity=0.1,+ fill_color=LIGHT_GREY,stroke_width=0.5,stroke_color=WHITE,stroke_opacity=0.5,@@ -932,12 +935,12 @@ class TalkThrough1DHeatGraph(ShowEvolvingTempGraphWithArrows, SpecialThreeDSceneself.orient_mobject_for_3d(final_rod)final_rod.shift(10 * UP)kw = {"run_time": 10, "rate_func": linear}+ self.rod.save_state()self.play(ApplyMethod(t_tracker.set_value, 10, **kw),Transform(self.rod, final_rod, **kw),ApplyMethod(slicing_plane.shift, 10 * UP, **kw),)- graph.clear_updaters()self.wait()self.set_variables_as_attrs(@@ -946,8 +949,8 @@ class TalkThrough1DHeatGraph(ShowEvolvingTempGraphWithArrows, SpecialThreeDScenesurface,graph_slices,slicing_plane,+ t_tracker,)- self.axes = original_axes#def get_graph(self, time=0):@@ -989,29 +992,200 @@ class TalkThrough1DHeatGraph(ShowEvolvingTempGraphWithArrows, SpecialThreeDScenereturn mob-class TransitionToTempVsTime(TalkThrough1DHeatGraph):+class ContrastXChangesToTChanges(TalkThrough1DHeatGraph):+ CONFIG = {+ # "surface_resolution": 5,+ # "graph_slice_step": 1,+ }+def construct(self):+ self.catchup_with_last_scene()+ self.emphasize_dimensions_of_input_space()+ self.reset_time_to_zero()++ self.show_changes_with_x()+ self.show_changes_with_t()++ def catchup_with_last_scene(self):self.force_skipping()- # super().construct()self.add_axes()self.add_graph()self.add_rod()- # self.emphasize_graph()- # self.emphasize_rod()self.rod_word = Point()self.show_x_axis()- # self.show_changes_over_time()self.show_surface()self.revert_to_original_skipping_status()- axes = self.axes+ def emphasize_dimensions_of_input_space(self):+ plane = self.input_plane+ plane_copy = plane.copy()+ plane_copy.set_color(BLUE_E)++ plane_copy1 = plane_copy.copy()+ plane_copy1.stretch(0.01, 1, about_edge=DOWN)+ plane_copy0 = plane_copy1.copy()+ plane_copy0.stretch(0, 0, about_edge=LEFT)++ words = TextMobject("2d input\\\\space")+ words.scale(2)+ words.move_to(plane.get_center() + SMALL_BUFF * OUT)++ self.play(+ Write(words),+ self.camera.phi_tracker.set_value, 60 * DEGREES,+ self.camera.theta_tracker.set_value, -95 * DEGREES,+ run_time=1+ )+ self.play(+ ReplacementTransform(plane_copy0, plane_copy1)+ )+ self.play(+ ReplacementTransform(plane_copy1, plane_copy)+ )+ self.wait(2)+ self.play(FadeOut(plane_copy))++ self.input_plane_words = words++ def reset_time_to_zero(self):+ self.play(+ self.t_tracker.set_value, 0,+ VFadeOut(self.slicing_plane),+ Restore(self.rod),+ )++ def show_changes_with_x(self):+ alpha_tracker = ValueTracker(0)+ line = always_redraw(+ lambda: self.get_tangent_line(+ self.graph, alpha_tracker.get_value(),+ )+ )++ self.stop_ambient_camera_rotation()+ self.play(+ ShowCreation(line),+ FadeOut(self.input_plane_words),+ self.camera.phi_tracker.set_value, 80 * DEGREES,+ self.camera.theta_tracker.set_value, -90 * DEGREES,+ )+ self.play(+ alpha_tracker.set_value, 0.425,+ run_time=5,+ rate_func=bezier([0, 0, 1, 1]),+ )++ # Show dx and dT+ p0 = line.point_from_proportion(0.3)+ p2 = line.point_from_proportion(0.7)+ p1 = np.array([p2[0], *p0[1:]])+ dx_line = DashedLine(p0, p1)+ dT_line = DashedLine(p1, p2)+ dx = TexMobject("dx")+ dT = TexMobject("dT")+ VGroup(dx, dT).scale(0.7)+ VGroup(dx, dT).rotate(90 * DEGREES, RIGHT)+ dx.next_to(dx_line, IN, SMALL_BUFF)+ dT.next_to(dT_line, RIGHT, SMALL_BUFF)++ self.play(+ ShowCreation(dx_line),+ FadeInFrom(dx, LEFT)+ )+ self.wait()+ self.play(+ ShowCreation(dT_line),+ FadeInFrom(dT, IN)+ )+ self.wait()+ self.play(*map(FadeOut, [+ line, dx_line, dT_line, dx, dT,+ ]))++ def show_changes_with_t(self):+ slices = self.graph_slices+ slice_alpha = 0.075+ graph = VMobject()+ graph.set_points_smoothly([+ gs.point_from_proportion(slice_alpha)+ for gs in slices+ ])+ graph.color_using_background_image("VerticalTempGradient")+ graph.set_shade_in_3d(True)++ alpha_tracker = ValueTracker(0)+ line = always_redraw(+ lambda: self.get_tangent_line(+ graph, alpha_tracker.get_value(),+ )+ )++ self.play(+ self.camera.theta_tracker.set_value, -10 * DEGREES,+ self.camera.frame_center.shift, 5 * LEFT,+ )++ self.play(+ ShowCreation(+ graph.copy(),+ remover=True+ ),+ VFadeIn(line),+ ApplyMethod(+ alpha_tracker.set_value, 1,+ run_time=8,+ )+ )+ self.add(graph)++ self.begin_ambient_camera_rotation(-0.02)+ self.camera.frame_center.add_updater(+ lambda m, dt: m.shift(0.05 * dt * RIGHT)+ )++ self.play(FadeOut(line))+ self.wait(30) # Let rotate++ self.t_graph = graph++ #+ def get_tangent_line(self, graph, alpha, d_alpha=0.001, length=2):+ if alpha < 1 - d_alpha:+ a1 = alpha+ a2 = alpha + d_alpha+ else:+ a1 = alpha - d_alpha+ a2 = alpha++ p1 = graph.point_from_proportion(a1)+ p2 = graph.point_from_proportion(a2)+ line = Line(p1, p2, color=WHITE)+ line.scale(+ length / line.get_length()+ )+ line.move_to(p1)+ return line+++class TransitionToTempVsTime(ContrastXChangesToTChanges):+ CONFIG = {+ # "surface_resolution": 5,+ # "graph_slice_step": 1,+ }++ def construct(self):+ self.catchup_with_last_scene()++ axes = self.original_axest_axis = self.t_axisy_axis = axes.y_axisx_axis = axes.x_axis+ for mob in self.get_mobjects():+ mob.clear_updaters()self.stop_ambient_camera_rotation()self.move_camera(phi=90 * DEGREES,@@ -1030,8 +1204,9 @@ class TransitionToTempVsTime(TalkThrough1DHeatGraph):self.graph,self.x_numbers,self.x_axis_label,+ self.t_graph,)),- self.camera.frame_center.shift, 5 * LEFT,+ self.camera.frame_center.move_to, 5 * LEFT,])self.play(@@ -1045,12 +1220,32 @@ class TransitionToTempVsTime(TalkThrough1DHeatGraph):)self.wait()+ def catchup_with_last_scene(self):+ self.force_skipping()++ self.add_axes()+ self.add_graph()+ self.add_rod()++ self.rod_word = Point()+ self.show_x_axis()+ self.show_surface()++ self.emphasize_dimensions_of_input_space()+ self.reset_time_to_zero()++ self.show_changes_with_x()+ self.show_changes_with_t()++ self.revert_to_original_skipping_status()+class ShowNewtonsLawGraph(Scene):CONFIG = {"k": 0.2,"initial_water_temp": 80,"room_temp": 20,+ "delta_T_color": YELLOW,}def construct(self):@@ -1105,17 +1300,20 @@ class ShowNewtonsLawGraph(Scene):water_arrow = Vector(LEFT, color=WHITE)water_arrow.next_to(water_dot, RIGHT, SMALL_BUFF)water_words = TextMobject(- "Initial water temperature"+ "Initial water\\\\temperature")+ water_words.scale(0.7)water_words.next_to(water_arrow, RIGHT)room_words = TextMobject("Room temperature")+ room_words.scale(0.7)room_words.next_to(room_line, DOWN, SMALL_BUFF)self.play(FadeInFrom(water_dot, RIGHT),GrowArrow(water_arrow),Write(water_words),+ run_time=1,)self.play(ShowCreation(room_line))self.play(FadeInFromDown(room_words))@@ -1149,14 +1347,117 @@ class ShowNewtonsLawGraph(Scene):water_dot.get_center(),stroke_width=0,))- brace = Brace(brace_line, RIGHT, SMALL_BUFF)- brace.add_updater(lambda b: b.match_height(brace_line))- brace.add_updater(lambda b: b.next_to(brace_line, RIGHT, SMALL_BUFF))+ brace = always_redraw(+ lambda: Brace(+ brace_line, RIGHT, buff=SMALL_BUFF+ )+ )++ delta_T = TexMobject("\\Delta T")+ delta_T.set_color(self.delta_T_color)+ delta_T.add_updater(lambda m: m.next_to(+ brace, RIGHT, SMALL_BUFF+ ))- self.add(graph)+ self.add(brace_line)+ self.play(+ GrowFromCenter(brace),+ Write(delta_T),+ )+ self.play(+ ShowCreation(graph),+ UpdateFromFunc(+ water_dot,+ lambda m: m.move_to(graph.get_end())+ ),+ run_time=10,+ rate_func=linear,+ )+ self.wait()++ self.graph = graph+ self.brace = brace+ self.delta_T = delta_Tdef show_equation(self):- pass+ delta_T = self.delta_T++ equation = TexMobject(+ "{d ({\\Delta T}) \\over dt} = -k \\cdot {\\Delta T}",+ tex_to_color_map={+ "{\\Delta T}": self.delta_T_color,+ "-k": WHITE,+ "=": WHITE,+ }+ )+ equation.to_corner(UR)+ equation.shift(LEFT)++ delta_T_parts = equation.get_parts_by_tex("\\Delta T")+ eq_i = equation.index_of_part_by_tex("=")+ deriv = equation[:eq_i]+ prop_to = equation.get_part_by_tex("-k")+ parts = VGroup(deriv, prop_to, delta_T_parts[1])++ words = TextMobject(+ "Rate of change",+ "is proportional to",+ "itself",+ )+ words.scale(0.7)+ words.next_to(equation, DOWN)+ colors = [BLUE, WHITE, YELLOW]+ for part, word, color in zip(parts, words, colors):+ part.word = word+ word.set_color(color)+ word.save_state()+ words[0].next_to(parts[0], DOWN)++ self.play(+ TransformFromCopy(+ VGroup(delta_T),+ delta_T_parts,+ ),+ Write(VGroup(*filter(+ lambda p: p not in delta_T_parts,+ equation+ )))+ )++ rects = VGroup()+ for part in parts:+ rect = SurroundingRectangle(+ part,+ color=part.word.get_color(),+ buff=SMALL_BUFF,+ stroke_width=2,+ )+ anims = [+ ShowCreation(rect),+ FadeIn(part.word),+ ]+ if part is parts[1]:+ anims.append(Restore(words[0]))+ self.play(*anims)+ rects.add(rect)++ self.play(FadeOut(rects, lag_ratio=0.2))++ self.equation = equation+ self.equation_words = wordsdef talk_through_examples(self):+ dot = self.water_dot+ graph = self.graph++ self.play(+ MoveAlongPath(+ dot, graph,+ rate_func=lambda t: smooth(1 - t),+ run_time=2,+ )+ )++ #+ def get_slope_line(self, graph, x):pass