A community-maintained Python framework for creating mathematical animations.
Small animations for a talk
Grant Sanderson646f733f3f31
diff --git a/old_projects/cba.py b/old_projects/cba.pynew file mode 100644index 000000000..7683dd9e4--- /dev/null+++ b/old_projects/cba.py@@ -0,0 +1,405 @@+from big_ol_pile_of_manim_imports import *+++class EnumerableSaveScene(Scene):+ def setup(self):+ self.save_count = 0++ def save_enumerated_image(self):+ file_path = self.file_writer.get_image_file_path()+ file_path = file_path.replace(+ ".png", "{:02}.png".format(self.save_count)+ )+ self.update_frame(ignore_skipping=True)+ image = self.get_image()+ image.save(file_path)+ self.save_count += 1+++class LayersOfAbstraction(EnumerableSaveScene):+ def construct(self):+ self.save_count = 0+ # self.add_title()+ self.show_layers()+ self.show_pairwise_relations()+ self.circle_certain_pairs()++ def add_title(self):+ title = TextMobject("Layers of abstraction")+ title.scale(1.5)+ title.to_edge(UP, buff=MED_SMALL_BUFF)+ line = Line(LEFT, RIGHT)+ line.set_width(FRAME_WIDTH)+ line.next_to(title, DOWN, SMALL_BUFF)++ self.add(title, line)++ def show_layers(self):+ layers = self.layers = self.get_layers()+ for layer in layers:+ self.add(layer[0])++ self.save_enumerated_image()+ for layer in layers:+ self.add(layer)+ self.save_enumerated_image()++ def show_pairwise_relations(self):+ p1, p2 = [l.get_left() for l in self.layers[2:4]]+ down_arrow = Arrow(p2, p1, path_arc=PI)+ down_words = TextMobject("``For example''")+ down_words.scale(0.8)+ down_words.next_to(down_arrow, LEFT)+ up_arrow = Arrow(p1, p2, path_arc=-PI)+ up_words = TextMobject("``In general''")+ up_words.scale(0.8)+ up_words.next_to(up_arrow, LEFT)++ VGroup(up_words, down_words).set_color(YELLOW)++ self.add(down_arrow, down_words)+ self.save_enumerated_image()+ self.remove(down_arrow, down_words)+ self.add(up_arrow, up_words)+ self.save_enumerated_image()+ self.remove(up_arrow, up_words)++ def circle_certain_pairs(self):+ layers = self.layers++ for l1, l2 in zip(layers, layers[1:]):+ group = VGroup(l1, l2)+ group.save_state()+ layers.save_state()+ layers.fade(0.75)+ rect = SurroundingRectangle(group)+ rect.set_stroke(YELLOW, 5)+ group.restore()+ self.add(rect)+ self.save_enumerated_image()+ self.remove(rect)+ layers.restore()++ #++ def get_layers(self):+ layers = VGroup(*[+ VGroup(Rectangle(height=1, width=5))+ for x in range(6)+ ])+ layers.arrange_submobjects(UP, buff=0)+ layers.set_stroke(GREY, 2)+ layers.set_sheen(1, UL)++ # Layer 0: Quantities+ triangle = Triangle().set_height(0.25)+ tri_dots = VGroup(*[Dot(v) for v in triangle.get_vertices()])+ dots_rect = VGroup(*[Dot() for x in range(12)])+ dots_rect.arrange_in_grid(3, 4, buff=SMALL_BUFF)+ for i, color in enumerate([RED, GREEN, BLUE]):+ dots_rect[i::4].set_color(color)+ pi_chart = VGroup(*[+ Sector(start_angle=a, angle=TAU / 3)+ for a in np.arange(0, TAU, TAU / 3)+ ])+ pi_chart.set_fill(opacity=0)+ pi_chart.set_stroke(WHITE, 2)+ pi_chart[0].set_fill(BLUE, 1)+ pi_chart.rotate(PI / 3)+ pi_chart.match_height(dots_rect)+ quantities = VGroup(tri_dots, dots_rect, pi_chart)+ quantities.arrange(RIGHT, buff=LARGE_BUFF)++ # Layer 1: Numbers+ numbers = VGroup(+ TexMobject("3"),+ TexMobject("3 \\times 4"),+ TexMobject("1 / 3"),+ )+ for number, quantity in zip(numbers, quantities):+ number.move_to(quantity)++ # Layer 2: Algebra+ algebra = VGroup(+ TexMobject("x^2 - 1 = (x + 1)(x - 1)")+ )+ algebra.set_width(layers.get_width() - MED_LARGE_BUFF)++ # Layer 3: Functions+ functions = VGroup(+ TexMobject("f(x) = 0"),+ TexMobject("\\frac{df}{dx}"),+ )+ functions.set_height(layers[0].get_height() - 2 * SMALL_BUFF)+ functions.arrange(RIGHT, buff=LARGE_BUFF)+ # functions.match_width(algebra)++ # Layer 4: Vector space+ t2c_map = {+ "\\textbf{v}": YELLOW,+ "\\textbf{w}": PINK,+ }+ vector_spaces = VGroup(+ TexMobject(+ "\\textbf{v} + \\textbf{w} ="+ "\\textbf{w} + \\textbf{v}",+ tex_to_color_map=t2c_map,+ ),+ TexMobject(+ "s(\\textbf{v} + \\textbf{w}) ="+ "s\\textbf{v} + s\\textbf{w}",+ tex_to_color_map=t2c_map,+ ),+ )+ vector_spaces.arrange(DOWN, buff=MED_SMALL_BUFF)+ vector_spaces.set_height(layers[0].get_height() - MED_LARGE_BUFF)+ v, w = vectors = VGroup(+ Vector([2, 1, 0], color=YELLOW),+ Vector([1, 2, 0], color=PINK),+ )+ vectors.add(DashedLine(v.get_end(), v.get_end() + w.get_vector()))+ vectors.add(DashedLine(w.get_end(), w.get_end() + v.get_vector()))+ vectors.match_height(vector_spaces)+ vectors.next_to(vector_spaces, RIGHT)+ vectors.set_stroke(width=2)+ # vector_spaces.add(vectors)++ inner_product = TexMobject(+ "\\langle f, g \\rangle ="+ "\\int f(x)g(x)dx"+ )+ inner_product.match_height(vector_spaces)+ inner_product.next_to(vector_spaces, RIGHT)+ vector_spaces.add(inner_product)++ # Layer 5: Categories+ dots = VGroup(Dot(UP), Dot(UR), Dot(RIGHT))+ arrows = VGroup(+ Arrow(dots[0], dots[1], buff=SMALL_BUFF),+ Arrow(dots[1], dots[2], buff=SMALL_BUFF),+ Arrow(dots[0], dots[2], buff=SMALL_BUFF),+ )+ arrows.set_stroke(width=2)+ arrow_labels = VGroup(+ TexMobject("m_1").next_to(arrows[0], UP, SMALL_BUFF),+ TexMobject("m_2").next_to(arrows[1], RIGHT, SMALL_BUFF),+ TexMobject("m_2 \\circ m_1").rotate(-45 * DEGREES).move_to(+ arrows[2]+ ).shift(MED_SMALL_BUFF * DL)+ )+ categories = VGroup(dots, arrows, arrow_labels)+ categories.set_height(layers[0].get_height() - MED_SMALL_BUFF)++ # Put it all together+ all_content = [+ quantities, numbers, algebra,+ functions, vector_spaces, categories,+ ]++ for layer, content in zip(layers, all_content):+ content.move_to(layer)+ layer.add(content)+ layer.content = content++ layer_titles = VGroup(*map(TextMobject, [+ "Quantities",+ "Numbers",+ "Algebra",+ "Functions",+ "Vector spaces",+ "Categories",+ ]))+ for layer, title in zip(layers, layer_titles):+ title.next_to(layer, RIGHT)+ layer.add(title)+ layer.title = title+ layers.titles = layer_titles++ layers.center()+ layers.to_edge(DOWN)+ layers.shift(0.5 * RIGHT)+ return layers+++class DifferenceOfSquares(Scene):+ def construct(self):+ squares = VGroup(*[+ VGroup(*[+ Square()+ for x in range(8)+ ]).arrange(RIGHT, buff=0)+ for y in range(8)+ ]).arrange(DOWN, buff=0)+ squares.set_height(4)+ squares.set_stroke(BLUE, 3)+ squares.set_fill(BLUE, 0.5)++ last_row_parts = VGroup()+ for row in squares[-3:]:+ row[-3:].set_color(RED)+ row[:-3].set_color(BLUE_B)+ last_row_parts.add(row[:-3])+ squares.to_edge(LEFT)++ arrow = Vector(RIGHT, color=WHITE)+ arrow.shift(1.5 * LEFT)+ squares.next_to(arrow, LEFT)++ new_squares = squares[:-3].copy()+ new_squares.next_to(arrow, RIGHT)+ new_squares.align_to(squares, UP)++ x1 = TexMobject("x").set_color(BLUE)+ x2 = x1.copy()+ x1.next_to(squares, UP)+ x2.next_to(squares, LEFT)+ y1 = TexMobject("y").set_color(RED)+ y2 = y1.copy()+ y1.next_to(squares[-2], RIGHT)+ y2.next_to(squares[-1][-2], DOWN)++ xpy = TexMobject("x", "+", "y")+ xmy = TexMobject("x", "-", "y")+ for mob in xpy, xmy:+ mob[0].set_color(BLUE)+ mob[2].set_color(RED)+ xpy.next_to(new_squares, UP)+ # xmy.rotate(90 * DEGREES)+ xmy.next_to(new_squares, RIGHT)+ xmy.to_edge(RIGHT)++ self.add(squares, x1, x2, y1, y2)+ self.play(+ ReplacementTransform(+ squares[:-3].copy().set_fill(opacity=0),+ new_squares+ ),+ ShowCreation(arrow),+ lag_ratio=0,+ )+ last_row_parts = last_row_parts.copy()+ last_row_parts.save_state()+ last_row_parts.set_fill(opacity=0)+ self.play(+ last_row_parts.restore,+ last_row_parts.rotate, -90 * DEGREES,+ last_row_parts.next_to, new_squares, RIGHT, {"buff": 0},+ lag_ratio=0,+ )+ self.play(Write(xmy), Write(xpy))+ self.wait()+++class Lightbulbs(EnumerableSaveScene):+ def construct(self):+ dots = VGroup(*[Dot() for x in range(4)])+ dots.set_height(0.5)+ dots.arrange(RIGHT, buff=2)+ dots.set_fill(opacity=0)+ dots.set_stroke(width=2, color=WHITE)+ dot_radius = dots[0].get_width() / 2++ connections = VGroup()+ for d1, d2 in it.product(dots, dots):+ line = Line(+ d1.get_center(),+ d2.get_center(),+ path_arc=30 * DEGREES,+ buff=dot_radius,+ color=YELLOW,+ )+ connections.add(line)++ lower_dots = dots[:3].copy()+ lower_dots.next_to(dots, DOWN, buff=2)+ lower_lines = VGroup(*[+ Line(d.get_center(), ld.get_center(), buff=dot_radius)+ for d, ld in it.product(dots, lower_dots[1:])+ ])+ lower_lines.match_style(connections)++ top_dot = dots[0].copy()+ top_dot.next_to(dots, UP, buff=2)++ top_lines = VGroup(*[+ Line(d.get_center(), top_dot.get_center(), buff=dot_radius)+ for d in dots+ ])+ top_lines.match_style(connections)++ self.add(dots)+ self.add(top_dot)+ self.save_enumerated_image()+ dots.set_fill(YELLOW, 1)+ self.save_enumerated_image()+ self.add(connections)+ self.save_enumerated_image()+ self.add(lower_dots)+ self.add(lower_lines)+ lower_dots[1:].set_fill(YELLOW, 1)+ self.save_enumerated_image()++ self.add(top_lines)+ connections.set_stroke(width=1)+ lower_lines.set_stroke(width=1)+ top_dot.set_fill(YELLOW, 1)+ self.save_enumerated_image()++ self.remove(connections)+ self.remove(top_lines)+ self.remove(lower_lines)+ dots.set_fill(opacity=0)+ lower_dots.set_fill(opacity=0)+++class LayersOfLightbulbs(Scene):+ CONFIG = {+ "random_seed": 1,+ }++ def construct(self):+ layers = VGroup()+ for x in range(6):+ n_dots = 5 + (x % 2)+ dots = VGroup(*[Dot() for x in range(n_dots)])+ dots.scale(2)+ dots.arrange(RIGHT, buff=MED_LARGE_BUFF)+ dots.set_stroke(WHITE, 2)+ for dot in dots:+ dot.set_fill(YELLOW, np.random.random())+ layers.add(dots)++ layers.arrange(UP, buff=LARGE_BUFF)++ lines = VGroup()+ for l1, l2 in zip(layers, layers[1:]):+ for d1, d2 in it.product(l1, l2):+ color = interpolate_color(+ YELLOW, GREEN, np.random.random()+ )+ line = Line(+ d1.get_center(),+ d2.get_center(),+ buff=(d1.get_width() / 2),+ color=color,+ stroke_width=2 * np.random.random(),+ )+ lines.add(line)++ self.add(layers, lines)+++class Test(Scene):+ def construct(self):+ # self.change_all_student_modes("hooray")+ # self.teacher.change("raise_right_hand")+ # self.look_at(3 * UP)+ randy = Randolph()+ randy.change("pondering")+ randy.set_height(6)+ randy.look(RIGHT)+ self.add(randy)+ # eq = TexMobject("143", "=", "11 \\cdot 13")+ # eq[0].set_color(YELLOW)+ # eq.scale(0.7)+ # self.add(eq)