A community-maintained Python framework for creating mathematical animations.
Some of the first scenes for diffyq part4
Grant Sanderson2f6be9a389e2
diff --git a/active_projects/ode/all_part4_scenes.py b/active_projects/ode/all_part4_scenes.pyindex f548a9170..7e95486fb 100644--- a/active_projects/ode/all_part4_scenes.py+++ b/active_projects/ode/all_part4_scenes.py@@ -1,9 +1,15 @@from active_projects.ode.part4.staging import *+from active_projects.ode.part4.fourier_series_scenes import *+from active_projects.ode.part4.pi_creature_scenes import *OUTPUT_DIRECTORY = "ode/part4"SCENES_IN_ORDER = [ComplexFourierSeriesExample,-+ ComplexFourierSeriesExampleEnd,+ FourierSeriesExampleWithRectForZoom,+ ZoomedInFourierSeriesExample,+ RelationToOtherVideos,+ WhyWouldYouCare,# Oldies# FourierSeriesIllustraiton,diff --git a/active_projects/ode/part2/fourier_series.py b/active_projects/ode/part2/fourier_series.pyindex 523581cff..6a85ebfcf 100644--- a/active_projects/ode/part2/fourier_series.py+++ b/active_projects/ode/part2/fourier_series.py@@ -35,10 +35,20 @@ class FourierCirclesScene(Scene):self.slow_factor_tracker = ValueTracker(self.slow_factor)+ self.vector_clock = ValueTracker(0)+ self.vector_clock.add_updater(+ lambda m, dt: m.increment_value(+ self.get_slow_factor() * dt+ )+ )+ self.add(self.vector_clock)def get_slow_factor(self):return self.slow_factor_tracker.get_value()+ def get_vector_time(self):+ return self.vector_clock.get_value()+#def get_freqs(self):n = self.n_vectors@@ -79,7 +89,10 @@ class FourierCirclesScene(Scene):def get_rotating_vector(self, coefficient, freq, center_func):vector = Vector(RIGHT, **self.vector_config)vector.scale(abs(coefficient))- phase = np.log(coefficient).imag+ if abs(coefficient) == 0:+ phase = 0+ else:+ phase = np.log(coefficient).imagvector.rotate(phase, about_point=ORIGIN)vector.freq = freqvector.phase = phase@@ -89,8 +102,9 @@ class FourierCirclesScene(Scene):return vectordef update_vector(self, vector, dt):- vector.rotate(- self.get_slow_factor() * vector.freq * dt * TAU+ time = self.get_vector_time()+ vector.set_angle(+ vector.phase + time * vector.freq * TAU)vector.shift(vector.center_func() - vector.get_start()@@ -111,14 +125,14 @@ class FourierCirclesScene(Scene):def get_circle(self, vector, color=BLUE):circle = Circle(color=color, **self.circle_config)- circle.vector = vector- vector.circle = circle+ circle.center_func = vector.get_start+ circle.radius_func = vector.get_lengthcircle.add_updater(self.update_circle)return circledef update_circle(self, circle):- circle.set_width(2 * circle.vector.get_length())- circle.move_to(circle.vector.get_start())+ circle.set_width(2 * circle.radius_func())+ circle.move_to(circle.center_func())return circledef get_vector_sum_path(self, vectors, color=YELLOW):@@ -147,7 +161,8 @@ class FourierCirclesScene(Scene):broken_path.curr_time = 0def update_path(path, dt):- alpha = path.curr_time * self.get_slow_factor()+ # alpha = path.curr_time * self.get_slow_factor()+ alpha = self.get_vector_time()n_curves = len(path)for a, sp in zip(np.linspace(0, 1, n_curves), path):b = alpha - a@@ -295,34 +310,49 @@ class FourierOfPiSymbol(FourierCirclesScene):"n_vectors": 51,"center_point": ORIGIN,"slow_factor": 0.1,- "run_time": 30,+ "n_cycles": 1,"tex": "\\pi","start_drawn": False,+ "max_circle_stroke_width": 1,}def construct(self):+ self.add_vectors_circles_path()+ for n in range(self.n_cycles):+ self.run_one_cycle()++ def add_vectors_circles_path(self):path = self.get_path()coefs = self.get_coefficients_of_path(path)-vectors = self.get_rotating_vectors(coefficients=coefs)circles = self.get_circles(vectors)self.set_decreasing_stroke_widths(circles)# approx_path = self.get_vector_sum_path(circles)drawn_path = self.get_drawn_path(vectors)if self.start_drawn:- drawn_path.curr_time = 1 / self.slow_factor+ self.vector_clock.increment_value(1)self.add(path)self.add(vectors)self.add(circles)self.add(drawn_path)- self.wait(self.run_time)++ self.vectors = vectors+ self.circles = circles+ self.path = path+ self.drawn_path = drawn_path++ def run_one_cycle(self):+ time = 1 / self.slow_factor+ self.wait(time)def set_decreasing_stroke_widths(self, circles):+ mcsw = self.max_circle_stroke_widthfor k, circle in zip(it.count(1), circles):circle.set_stroke(width=max(- 1 / np.sqrt(k),- 1,+ # mcsw / np.sqrt(k),+ mcsw / k,+ mcsw,))return circlesdiff --git a/active_projects/ode/part3/temperature_graphs.py b/active_projects/ode/part3/temperature_graphs.pyindex 539a43e87..2ed445b5a 100644--- a/active_projects/ode/part3/temperature_graphs.py+++ b/active_projects/ode/part3/temperature_graphs.py@@ -31,6 +31,7 @@ class TemperatureGraphScene(SpecialThreeDScene):"stroke_color": WHITE,"stroke_opacity": 0.5,},+ "temp_text": "Temperature",}def get_three_d_axes(self, include_labels=True, include_numbers=False, **kwargs):@@ -103,7 +104,7 @@ class TemperatureGraphScene(SpecialThreeDScene):t_label.next_to(axes.y_axis.get_end(), UP)axes.y_axis.label = t_label- temp_label = TextMobject("Temperature")+ temp_label = TextMobject(self.temp_text)temp_label.rotate(90 * DEGREES, RIGHT)temp_label.next_to(axes.z_axis.get_zenith(), RIGHT)axes.z_axis.label = temp_labeldiff --git a/active_projects/ode/part4/fourier_series_scenes.py b/active_projects/ode/part4/fourier_series_scenes.pynew file mode 100644index 000000000..d2ea6feeb--- /dev/null+++ b/active_projects/ode/part4/fourier_series_scenes.py@@ -0,0 +1,242 @@+from manimlib.imports import *++from active_projects.ode.part2.fourier_series import FourierOfTrebleClef+++class ComplexFourierSeriesExample(FourierOfTrebleClef):+ CONFIG = {+ "file_name": "EighthNote",+ "run_time": 10,+ "n_vectors": 200,+ "n_cycles": 2,+ "max_circle_stroke_width": 0.75,+ "drawing_height": 5,+ "center_point": DOWN,+ "top_row_y": 3,+ "top_row_label_y": 2,+ "top_row_x_spacing": 1.75,+ "top_row_copy_scale_factor": 0.9,+ "start_drawn": False,+ }++ def construct(self):+ self.add_vectors_circles_path()+ self.add_top_row(self.vectors, self.circles)+ self.write_title()+ self.highlight_vectors_one_by_one()+ self.change_shape()++ def write_title(self):+ title = TextMobject("Complex\\\\Fourier series")+ title.scale(1.5)+ title.to_edge(LEFT)+ title.match_y(self.path)++ self.wait(5)+ self.play(FadeInFromDown(title))+ self.wait(2)+ self.title = title++ def highlight_vectors_one_by_one(self):+ # Don't know why these vectors can't get copied.+ # That seems like a problem that will come up again.+ labels = self.top_row[-1]+ next_anims = []+ for vector, circle, label in zip(self.vectors, self.circles, labels):+ # v_color = vector.get_color()+ c_color = circle.get_color()+ c_stroke_width = circle.get_stroke_width()++ rect = SurroundingRectangle(label, color=PINK)+ self.play(+ # vector.set_color, PINK,+ circle.set_stroke, RED, 3,+ FadeIn(rect),+ *next_anims+ )+ self.wait()+ next_anims = [+ # vector.set_color, v_color,+ circle.set_stroke, c_color, c_stroke_width,+ FadeOut(rect),+ ]+ self.play(*next_anims)++ def change_shape(self):+ # path_mob = TexMobject("\\pi")+ path_mob = SVGMobject("Nail_And_Gear")+ new_path = path_mob.family_members_with_points()[0]+ new_path.set_height(4)+ new_path.move_to(self.path, DOWN)+ new_path.shift(0.5 * UP)+ new_coefs = self.get_coefficients_of_path(new_path)+ new_vectors = self.get_rotating_vectors(+ coefficients=new_coefs+ )+ new_drawn_path = self.get_drawn_path(new_vectors)++ self.vector_clock.set_value(0)+ self.vector_clock.suspend_updating(0)++ vectors = self.vectors+ anims = []++ for vect, new_vect in zip(vectors, new_vectors):+ new_vect.update()+ new_vect.clear_updaters()++ line = Line(stroke_width=0)+ line.put_start_and_end_on(*vect.get_start_and_end())+ anims.append(ApplyMethod(+ line.put_start_and_end_on,+ *new_vect.get_start_and_end()+ ))+ vect.freq = new_vect.freq+ vect.phase = new_vect.phase+ vect.coefficient = new_vect.coefficient++ vect.line = line+ vect.add_updater(+ lambda v: v.put_start_and_end_on(+ *v.line.get_start_and_end()+ )+ )+ anims += [+ FadeOut(self.drawn_path)+ ]++ self.play(*anims, run_time=3)+ self.vector_clock.resume_updating()+ for vect in self.vectors:+ vect.remove_updater(vect.updaters[-1])++ self.add(new_drawn_path)+ for n in range(self.n_cycles):+ self.run_one_cycle()++ #+ def get_path(self):+ path = super().get_path()+ path.set_height(self.drawing_height)+ path.to_edge(DOWN)+ return path++ def add_top_row(self, vectors, circles, max_freq=3):+ self.top_row = self.get_top_row(+ vectors, circles, max_freq+ )+ self.add(self.top_row)++ def get_top_row(self, vectors, circles, max_freq=3):+ vector_copies = VGroup()+ circle_copies = VGroup()+ for vector, circle in zip(vectors, circles):+ if vector.freq > max_freq:+ break+ vcopy = vector.copy()+ vcopy.clear_updaters()+ ccopy = circle.copy()+ ccopy.clear_updaters()+ ccopy.original = circle+ vcopy.original = vector++ vcopy.center_point = np.array([+ vector.freq * self.top_row_x_spacing,+ self.top_row_y,+ 0+ ])+ ccopy.center_point = vcopy.center_point+ vcopy.add_updater(self.update_top_row_vector_copy)+ ccopy.add_updater(self.update_top_row_circle_copy)+ vector_copies.add(vcopy)+ circle_copies.add(ccopy)++ dots = VGroup(*[+ TexMobject("\\dots").next_to(+ circle_copies, direction,+ MED_LARGE_BUFF,+ )+ for direction in [LEFT, RIGHT]+ ])+ labels = self.get_top_row_labels(vector_copies)+ return VGroup(+ vector_copies,+ circle_copies,+ dots,+ labels,+ )++ def update_top_row_vector_copy(self, vcopy):+ vcopy.become(vcopy.original)+ vcopy.scale(self.top_row_copy_scale_factor)+ vcopy.shift(vcopy.center_point - vcopy.get_start())+ return vcopy++ def update_top_row_circle_copy(self, ccopy):+ ccopy.become(ccopy.original)+ ccopy.scale(self.top_row_copy_scale_factor)+ ccopy.move_to(ccopy.center_point)+ return ccopy++ def get_top_row_labels(self, vector_copies):+ labels = VGroup()+ for vector_copy in vector_copies:+ freq = vector_copy.freq+ label = Integer(freq)+ label.move_to(np.array([+ freq * self.top_row_x_spacing,+ self.top_row_label_y,+ 0+ ]))+ labels.add(label)+ return labels+++class ComplexFourierSeriesExampleEnd(ExternallyAnimatedScene):+ pass+++class FourierSeriesExampleWithRectForZoom(ComplexFourierSeriesExample):+ CONFIG = {+ "n_vectors": 100,+ "slow_factor": 0.01,+ "rect_scale_factor": 0.15,+ "parametric_function_step_size": 0.0001,+ "start_drawn": True,+ }++ def construct(self):+ self.add_vectors_circles_path()+ self.circles.set_stroke(opacity=0.5)+ rect = self.get_rect()+ rect.set_height(self.rect_scale_factor * FRAME_HEIGHT)+ rect.add_updater(lambda m: m.move_to(+ center_of_mass([+ v.get_end()+ for v in self.vectors+ ])+ ))+ self.add(rect)+ self.run_one_cycle()++ def get_rect(self):+ return ScreenRectangle(+ color=WHITE,+ stroke_width=2,+ )+++class ZoomedInFourierSeriesExample(FourierSeriesExampleWithRectForZoom, MovingCameraScene):+ CONFIG = {+ "vector_config": {+ "max_tip_length_to_length_ratio": 0.15,+ "tip_length": 0.05,+ }+ }++ def setup(self):+ ComplexFourierSeriesExample.setup(self)+ MovingCameraScene.setup(self)++ def get_rect(self):+ return self.camera_framediff --git a/active_projects/ode/part4/pi_creature_scenes.py b/active_projects/ode/part4/pi_creature_scenes.pynew file mode 100644index 000000000..69ef9d321--- /dev/null+++ b/active_projects/ode/part4/pi_creature_scenes.py@@ -0,0 +1,22 @@+from manimlib.imports import *+++class WhyWouldYouCare(TeacherStudentsScene):+ def construct(self):+ self.student_says(+ "Who cares!",+ target_mode="sassy",+ student_index=2,+ added_anims=[self.teacher.change, "guilty"],+ )+ self.wait()+ self.play(+ RemovePiCreatureBubble(self.students[2]),+ self.teacher.change, "raise_right_hand",+ self.get_student_changes(+ "pondering", "erm", "thinking",+ look_at_arg=self.screen,+ )+ )+ self.look_at(self.screen)+ self.wait(5)diff --git a/active_projects/ode/part4/staging.py b/active_projects/ode/part4/staging.pyindex 4d6c5e443..0e16ca07c 100644--- a/active_projects/ode/part4/staging.py+++ b/active_projects/ode/part4/staging.py@@ -1,30 +1,345 @@from manimlib.imports import *+from active_projects.ode.part3.temperature_graphs import TemperatureGraphScene+from active_projects.ode.part2.wordy_scenes import WriteHeatEquationTemplate-from active_projects.ode.part2.fourier_series import FourierOfTrebleClef+class RelationToOtherVideos(Scene):+ CONFIG = {+ "camera_config": {+ "background_color": DARK_GREY,+ },+ }++ def construct(self):+ # Show three videos+ videos = self.get_video_thumbnails()+ brace = Brace(videos, UP)+ text = TextMobject("Heat equation")+ text.scale(2)+ text.next_to(brace, UP)++ self.play(+ LaggedStartMap(+ FadeInFrom, videos,+ lambda m: (m, LEFT),+ lag_ratio=0.4,+ run_time=2,+ ),+ GrowFromCenter(brace),+ FadeInFromDown(text),+ )+ self.wait()+ group = Group(text, brace, videos)++ # Show Fourier thinking+ fourier = ImageMobject("Joseph Fourier")+ fourier.set_height(4)+ fourier.to_edge(RIGHT)+ group.generate_target()+ group.target.to_edge(DOWN)+ fourier.align_to(group.target[0], DOWN)+ bubble = ThoughtBubble(+ direction=RIGHT,+ width=3,+ height=2,+ fill_opacity=0.5,+ stroke_color=WHITE,+ )+ bubble[-1].shift(0.25 * DOWN + 0.5 * LEFT)+ bubble[:-1].rotate(20 * DEGREES)+ for mob in bubble[:-1]:+ mob.rotate(-20 * DEGREES)+ bubble.move_tip_to(+ fourier.get_corner(UL) + DOWN+ )+ bubble.to_edge(UP, buff=SMALL_BUFF)++ self.play(+ MoveToTarget(group),+ FadeInFrom(fourier, LEFT)+ )+ self.play(Write(bubble, run_time=1))+ self.wait()++ # Discount first two+ first_two = videos[:2]+ first_two.generate_target()+ first_two.target.scale(0.5)+ first_two.target.to_corner(DL)+ new_brace = Brace(first_two.target, UP)++ self.play(+ # fourier.scale, 0.8,+ fourier.match_x, new_brace,+ fourier.to_edge, UP,+ MoveToTarget(first_two),+ Transform(brace, new_brace),+ text.scale, 0.7,+ text.next_to, new_brace, UP,+ FadeOutAndShift(bubble, LEFT),+ )+ self.play(+ videos[2].scale, 1.7,+ videos[2].to_corner, UR,+ )+ self.wait()-class ComplexFourierSeriesExample(FourierOfTrebleClef):+ #+ def get_video_thumbnails(self):+ thumbnails = Group(+ ImageMobject("diffyq_part2_thumbnail"),+ ImageMobject("diffyq_part3_thumbnail"),+ ImageMobject("diffyq_part4_thumbnail"),+ )+ for thumbnail in thumbnails:+ thumbnail.set_height(4)+ thumbnail.add(SurroundingRectangle(+ thumbnail,+ color=WHITE,+ stroke_width=2,+ buff=0+ ))+ thumbnails.arrange(RIGHT, buff=LARGE_BUFF)+ thumbnails.set_width(FRAME_WIDTH - 1)+ return thumbnails+++class ShowLinearity(WriteHeatEquationTemplate, TemperatureGraphScene):CONFIG = {- "file_name": "TrebleClef",- "run_time": 10,- # "n_vectors": 10,- "drawing_height": 5,- "center_point": DOWN,- "top_row_vector_y": 3,- "top_row_x_spacing": 1,+ "temp_text": "Temp",+ "alpha": 0.1,+ "axes_config": {+ "z_max": 2,+ "z_min": -2,+ "z_axis_config": {+ "tick_frequency": 0.5,+ "unit_size": 1.5,+ },+ },+ "default_surface_config": {+ "resolution": (16, 16)+ # "resolution": (4, 4)+ },+ "freqs": [2, 5],}+ def setup(self):+ TemperatureGraphScene.setup(self)+ WriteHeatEquationTemplate.setup(self)+def construct(self):- pass+ self.init_camera()+ self.add_three_graphs()+ self.show_words()+ self.add_function_labels()+ self.change_scalars()++ def init_camera(self):+ self.camera.set_distance(1000)++ def add_three_graphs(self):+ axes_group = self.get_axes_group()+ axes0, axes1, axes2 = axes_group+ freqs = self.freqs+ scalar_trackers = Group(+ ValueTracker(1),+ ValueTracker(1),+ )+ graphs = VGroup(+ self.get_graph(axes0, [freqs[0]], [scalar_trackers[0]]),+ self.get_graph(axes1, [freqs[1]], [scalar_trackers[1]]),+ self.get_graph(axes2, freqs, scalar_trackers),+ )++ plus = TexMobject("+").scale(2)+ equals = TexMobject("=").scale(2)+ plus.move_to(midpoint(+ axes0.get_right(),+ axes1.get_left(),+ ))+ equals.move_to(midpoint(+ axes1.get_right(),+ axes2.get_left(),+ ))++ self.add(axes_group)+ self.add(graphs)+ self.add(plus)+ self.add(equals)++ self.axes_group = axes_group+ self.graphs = graphs+ self.scalar_trackers = scalar_trackers+ self.plus = plus+ self.equals = equals++ def show_words(self):+ equation = self.get_d1_equation()+ name = TextMobject("Heat equation")+ name.next_to(equation, DOWN)+ name.set_color_by_gradient(RED, YELLOW)+ group = VGroup(equation, name)+ group.to_edge(UP)++ shift_val = 0.5 * RIGHT++ arrow = Vector(1.5 * RIGHT)+ arrow.move_to(group)+ arrow.shift(shift_val)+ linear_word = TextMobject("``Linear''")+ linear_word.scale(2)+ linear_word.next_to(arrow, RIGHT)++ self.add(group)+ self.wait()+ self.play(+ ShowCreation(arrow),+ group.next_to, arrow, LEFT+ )+ self.play(FadeInFrom(linear_word, LEFT))+ self.wait()++ def add_function_labels(self):+ axes_group = self.axes_group+ graphs = self.graphs++ solution_labels = VGroup()+ for axes in axes_group:+ label = TextMobject("Solution", "$\\checkmark$")+ label.set_color_by_tex("checkmark", GREEN)+ label.next_to(axes, DOWN)+ solution_labels.add(label)++ kw = {+ "tex_to_color_map": {+ "T_1": BLUE,+ "T_2": GREEN,+ }+ }+ T1 = TexMobject("a", "T_1", **kw)+ T2 = TexMobject("b", "T_2", **kw)+ T_sum = TexMobject("T_1", "+", "T_2", **kw)+ T_sum_with_scalars = TexMobject(+ "a", "T_1", "+", "b", "T_2", **kw+ )++ T1.next_to(graphs[0], UP)+ T2.next_to(graphs[1], UP)+ T_sum.next_to(graphs[2], UP)+ T_sum.shift(SMALL_BUFF * DOWN)+ T_sum_with_scalars.move_to(T_sum)++ a_brace = Brace(T1[0], UP, buff=SMALL_BUFF)+ b_brace = Brace(T2[0], UP, buff=SMALL_BUFF)+ s1_decimal = DecimalNumber()+ s1_decimal.match_color(T1[1])+ s1_decimal.next_to(a_brace, UP, SMALL_BUFF)+ s1_decimal.add_updater(lambda m: m.set_value(+ self.scalar_trackers[0].get_value()+ ))+ s2_decimal = DecimalNumber()+ s2_decimal.match_color(T2[1])+ s2_decimal.next_to(b_brace, UP, SMALL_BUFF)+ s2_decimal.add_updater(lambda m: m.set_value(+ self.scalar_trackers[1].get_value()+ ))++ self.play(+ FadeInFrom(T1[1], DOWN),+ FadeInFrom(solution_labels[0], UP),+ )+ self.play(+ FadeInFrom(T2[1], DOWN),+ FadeInFrom(solution_labels[1], UP),+ )+ self.wait()+ self.play(+ TransformFromCopy(T1[1], T_sum[0]),+ TransformFromCopy(T2[1], T_sum[2]),+ TransformFromCopy(self.plus, T_sum[1]),+ *[+ Transform(+ graph.copy().set_fill(opacity=0),+ graphs[2].copy().set_fill(opacity=0),+ remover=True+ )+ for graph in graphs[:2]+ ]+ )+ self.wait()+ self.play(FadeInFrom(solution_labels[2], UP))+ self.wait()++ # Show constants+ self.play(+ FadeIn(T1[0]),+ FadeIn(T2[0]),+ FadeIn(a_brace),+ FadeIn(b_brace),+ FadeIn(s1_decimal),+ FadeIn(s2_decimal),+ FadeOut(T_sum),+ FadeIn(T_sum_with_scalars),+ )++ def change_scalars(self):+ s1, s2 = self.scalar_trackers++ kw = {+ "run_time": 2,+ }+ for graph in self.graphs:+ graph.resume_updating()+ self.play(s2.set_value, -0.5, **kw)+ self.play(s1.set_value, -0.2, **kw)+ self.play(s2.set_value, 1.5, **kw)+ self.play(s1.set_value, 1.2)+ self.play(s2.set_value, 0.3)+ self.wait()++ #+ def get_axes_group(self):+ axes_group = VGroup(*[+ self.get_axes()+ for x in range(3)+ ])+ axes_group.arrange(RIGHT, buff=2)+ axes_group.set_width(FRAME_WIDTH - 1)+ axes_group.to_edge(DOWN, buff=1)+ return axes_group++ def get_axes(self):+ axes = self.get_three_d_axes()+ # axes.input_plane.set_fill(opacity=0)+ # axes.input_plane.set_stroke(width=0.5)+ # axes.add(axes.input_plane)+ self.orient_three_d_mobject(axes)+ axes.rotate(-5 * DEGREES, UP)+ axes.set_width(4)+ axes.x_axis.label.next_to(+ axes.x_axis.get_end(), DOWN,+ buff=2 * SMALL_BUFF+ )+ return axes++ def get_graph(self, axes, freqs, scalar_trackers):+ L = axes.x_max+ a = self.alpha- def get_path(self):- path = super().get_path()- path.set_height(self.drawing_height)- path.to_edge(DOWN)- return path+ def func(x, t):+ scalars = [st.get_value() for st in scalar_trackers]+ return np.sum([+ s * np.cos(k * x) * np.exp(-a * (k**2) * t)+ for freq, s in zip(freqs, scalars)+ for k in [freq * PI / L]+ ])- def get_top_row_vector_copies(self, vectors, max_freq=3):- pass+ def get_surface_graph_group():+ return VGroup(+ self.get_surface(axes, func),+ self.get_time_slice_graph(axes, func, t=0),+ )- def get_top_row_vector_labels(self):- pass+ result = always_redraw(get_surface_graph_group)+ result.suspend_updating()+ return result