Skip to content

armgit / manim

Public Imported from GitHub
0

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.py
new file mode 100644
index 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)