Skip to content

armgit / manim

Public Imported from GitHub
0

A community-maintained Python framework for creating mathematical animations.

Finished triangle moduli space scene

Grant Sandersoneb03a56dfc0e
diff --git a/active_projects/moduli.py b/active_projects/moduli.py
new file mode 100644
index 000000000..d726275ef
--- /dev/null
+++ b/active_projects/moduli.py
@@ -0,0 +1,906 @@
+from manimlib.imports import *
+
+
+class TriangleModuliSpace(Scene):
+ CONFIG = {
+ "camera_config": {
+ "background_image": "chalkboard",
+ },
+ "degen_color": GREEN_D,
+ "x1_color": GREEN_B,
+ "y1_color": RED,
+ "x_eq_y_color": YELLOW,
+ "right_color": TEAL,
+ "obtuse_color": PINK,
+ "acute_color": GREEN,
+ "triangle_fill_opacity": 0.5,
+ "random_seed": 0,
+ "example_triangle_width": 6,
+ }
+
+ def setup(self):
+ self.plane = NumberPlane(
+ axis_config={
+ "unit_size": 2,
+ }
+ )
+
+ def construct(self):
+ # self.show_meaning_of_similar()
+ self.show_xy_rule()
+
+ def show_meaning_of_similar(self):
+ # Setup titles
+ title = TextMobject("Space", " of all ", "trianlges")
+ title.scale(1.5)
+ title.to_edge(UP)
+
+ subtitle = TextMobject("up to similarity.")
+ subtitle.scale(1.5)
+ subtitle.next_to(title, DOWN, MED_SMALL_BUFF)
+
+ question = TextMobject("What ", "is ", "a\\\\", "moduli ", "space", "?")
+ question.scale(2)
+
+ # Setup all triangles
+ all_triangles, tri_classes = self.get_triangles_and_classes()
+ tri_classes[2][1].scale(0.5)
+ tri_classes[2][1].scalar *= 0.5
+
+ all_triangles.to_edge(DOWN)
+
+ # Triangles pop up...
+ self.play(
+ LaggedStartMap(FadeInFromDown, question),
+ )
+ self.wait()
+
+ self.play(
+ ReplacementTransform(
+ question.get_part_by_tex("space"),
+ title.get_part_by_tex("Space"),
+ ),
+ FadeOut(question[:-2]),
+ FadeOut(question[-1]),
+ FadeIn(title[1:]),
+ LaggedStartMap(
+ DrawBorderThenFill, all_triangles,
+ rate_func=bezier([0, 0, 1.5, 1, 1]),
+ run_time=5,
+ lag_ratio=0.05,
+ )
+ )
+ self.wait()
+
+ # ...Then divide into classes
+ tri_classes.generate_target()
+ colors = Color(BLUE).range_to(Color(RED), len(tri_classes))
+ for group, color in zip(tri_classes.target, colors):
+ group.arrange(DOWN)
+ group.set_color(color)
+ tri_classes.target.arrange(RIGHT, buff=1.25, aligned_edge=UP)
+ tri_classes.target.scale(0.85)
+ tri_classes.target.to_corner(DL)
+ max_width = max([tc.get_width() for tc in tri_classes.target])
+ height = tri_classes.target.get_height() + 0.5
+ rects = VGroup(*[
+ Rectangle(
+ height=height,
+ width=max_width + 0.25,
+ stroke_width=2,
+ ).move_to(tri_class, UP)
+ for tri_class in tri_classes.target
+ ])
+ rects.shift(MED_SMALL_BUFF * UP)
+
+ # Dumb shifts
+ # tri_classes.target[1][2].shift(0.25 * UP)
+ tri_classes.target[2].scale(0.9, about_edge=UP)
+ tri_classes.target[2][2].shift(0.2 * UP)
+ tri_classes.target[3][0].shift(0.5 * DOWN)
+ tri_classes.target[3][1].shift(1.0 * DOWN)
+ tri_classes.target[3][2].shift(1.2 * DOWN)
+ tri_classes.target[4][1:].shift(0.7 * UP)
+
+ # Dots
+ per_class_dots = VGroup(*[
+ TexMobject("\\vdots").move_to(
+ tri_class
+ ).set_y(rects.get_bottom()[1] + 0.4)
+ for tri_class in tri_classes.target
+ ])
+ all_class_dots = TexMobject("\\dots").next_to(
+ rects, RIGHT, MED_SMALL_BUFF,
+ )
+
+ self.play(
+ FadeInFromDown(subtitle),
+ MoveToTarget(tri_classes),
+ )
+ self.play(
+ LaggedStartMap(FadeIn, rects),
+ Write(per_class_dots),
+ Write(all_class_dots),
+ )
+ self.wait(2)
+
+ # Similar
+
+ tri1 = tri_classes[2][1]
+ tri2 = tri_classes[2][2]
+ tri1.save_state()
+ tri2.save_state()
+
+ sim_sign = TexMobject("\\sim")
+ sim_sign.set_width(1)
+ sim_sign.move_to(midpoint(rects.get_top(), TOP))
+ sim_sign.shift(0.25 * DOWN)
+
+ similar_word = TextMobject("Similar")
+ similar_word.scale(1.5)
+ similar_word.move_to(sim_sign)
+ similar_word.to_edge(UP)
+
+ self.play(
+ FadeOutAndShift(VGroup(title, subtitle), UP),
+ tri1.next_to, sim_sign, LEFT, 0.75,
+ tri2.next_to, sim_sign, RIGHT, 0.75,
+ )
+ self.play(
+ FadeInFromDown(sim_sign),
+ Write(similar_word, run_time=1)
+ )
+ self.wait()
+
+ # Move into place
+ tri1_copy = tri1.copy()
+ self.play(
+ tri1_copy.next_to, tri2,
+ RIGHT, LARGE_BUFF,
+ path_arc=90 * DEGREES,
+ )
+ self.play(Rotate(tri1_copy, tri2.angle - tri1.angle))
+ self.play(tri1_copy.scale, tri2.scalar / tri1.scalar)
+ self.play(
+ tri1_copy.move_to, tri2,
+ )
+ tri1_copy.set_color(YELLOW)
+ self.play(
+ FadeOut(tri1_copy),
+ rate_func=rush_from,
+ )
+ self.wait(2)
+
+ # Show non-similar example
+ not_similar_word = TextMobject("Not ", "Similar")
+ not_similar_word.scale(1.5)
+ not_similar_word.move_to(similar_word)
+ not_similar_word.set_color(RED)
+
+ sim_cross = Line(DL, UR)
+ sim_cross.set_color(RED)
+ sim_cross.match_width(sim_sign)
+ sim_cross.move_to(sim_sign)
+ sim_cross.set_stroke(BLACK, 5, background=True)
+
+ tri3 = tri_classes[1][2]
+ tri3.save_state()
+ tri3.generate_target()
+ tri3.target.move_to(tri2, LEFT)
+
+ tri1_copy = tri1.copy()
+
+ self.play(
+ Restore(tri2),
+ MoveToTarget(tri3),
+ )
+ self.play(
+ ReplacementTransform(
+ similar_word[0],
+ not_similar_word[1],
+ ),
+ GrowFromCenter(not_similar_word[0]),
+ ShowCreation(sim_cross),
+ )
+ self.play(tri1_copy.move_to, tri3)
+ self.play(Rotate(tri1_copy, 90 * DEGREES))
+ self.play(
+ tri1_copy.match_height, tri3,
+ tri1_copy.move_to, tri3, RIGHT,
+ )
+ self.play(WiggleOutThenIn(tri1_copy, n_wiggles=10))
+ self.play(FadeOut(tri1_copy))
+
+ self.wait()
+
+ # Back to classes
+ new_title = TextMobject("Space of all\\\\", "Similarity classes")
+ new_title.scale(1.5)
+ new_title[1].set_color(YELLOW)
+ new_title.to_edge(UP)
+ new_title_underline = Line(LEFT, RIGHT)
+ new_title_underline.match_width(new_title[1])
+ new_title_underline.match_color(new_title[1])
+ new_title_underline.next_to(new_title, DOWN, buff=0.05)
+
+ self.play(
+ Restore(tri1),
+ Restore(tri2),
+ Restore(tri3),
+ FadeOut(not_similar_word),
+ FadeOut(sim_sign),
+ FadeOut(sim_cross),
+ FadeInFrom(new_title[1], UP),
+ )
+ self.play(
+ ShowCreationThenDestruction(new_title_underline),
+ LaggedStartMap(
+ ApplyMethod, rects,
+ lambda m: (m.set_stroke, YELLOW, 5),
+ rate_func=there_and_back,
+ run_time=1,
+ )
+ )
+ self.wait()
+ self.play(Write(new_title[0]))
+ self.wait()
+
+ # Show abstract space
+ blob = ThoughtBubble()[-1]
+ blob.set_height(2)
+ blob.to_corner(UR)
+
+ dots = VGroup(*[
+ Dot(color=tri.get_color()).move_to(
+ self.get_triangle_x(tri) * RIGHT +
+ self.get_triangle_y(tri) * UP,
+ )
+ for tri_class in tri_classes
+ for tri in tri_class[0]
+ ])
+ dots.space_out_submobjects(2)
+ dots.move_to(blob)
+
+ self.play(
+ DrawBorderThenFill(blob),
+ new_title.shift, LEFT,
+ )
+
+ self.play(LaggedStart(
+ *[
+ ReplacementTransform(
+ tri_class.copy().set_fill(opacity=0),
+ dot
+ )
+ for tri_class, dot in zip(tri_classes, dots)
+ ],
+ run_time=3,
+ lag_ratio=0.3,
+ ))
+
+ # Isolate one triangle
+
+ tri = tri_classes[0][0]
+ verts = tri.get_vertices()
+ angle = PI + angle_of_vector(verts[1] - verts[2])
+
+ self.play(
+ tri.rotate, -angle,
+ tri.set_width, self.example_triangle_width,
+ tri.center,
+ FadeOut(tri_classes[0][1:]),
+ FadeOut(tri_classes[1:]),
+ FadeOut(rects),
+ FadeOut(per_class_dots),
+ FadeOut(all_class_dots),
+ FadeOut(blob),
+ FadeOut(dots),
+ FadeOut(new_title),
+ )
+
+ self.triangle = tri
+
+ def show_xy_rule(self):
+ unit_factor = 4.0
+
+ if hasattr(self, "triangle"):
+ triangle = self.triangle
+ else:
+ triangle = self.get_triangles_and_classes()[0][0]
+ verts = triangle.get_vertices()
+ angle = PI + angle_of_vector(verts[1] - verts[2])
+ triangle.rotate(-angle)
+ triangle.set_width(self.example_triangle_width)
+ triangle.center()
+ self.add(triangle)
+
+ side_trackers = VGroup(*[Line() for x in range(3)])
+ side_trackers.set_stroke(width=0, opacity=0)
+ side_trackers.triangle = triangle
+
+ def update_side_trackers(st):
+ verts = st.triangle.get_vertices()
+ st[0].put_start_and_end_on(verts[0], verts[1])
+ st[1].put_start_and_end_on(verts[1], verts[2])
+ st[2].put_start_and_end_on(verts[2], verts[0])
+
+ side_trackers.add_updater(update_side_trackers)
+
+ def get_length_labels():
+ result = VGroup()
+ for line in side_trackers:
+ vect = normalize(line.get_vector())
+ perp_vect = rotate_vector(vect, -90 * DEGREES)
+ perp_vect = np.round(perp_vect, 1)
+ label = DecimalNumber(line.get_length() / unit_factor)
+ label.move_to(line.get_center())
+ label.next_to(line.get_center(), perp_vect, buff=0.15)
+ result.add(label)
+ return result
+
+ side_labels = always_redraw(get_length_labels)
+
+ b_label, c_label, a_label = side_labels
+ b_side, c_side, a_side = side_trackers
+
+ # Rescale
+ self.add(side_trackers)
+ self.play(LaggedStartMap(FadeIn, side_labels, lag_ratio=0.3, run_time=1))
+ self.add(side_labels)
+ self.wait()
+ self.play(triangle.set_width, unit_factor)
+ self.play(ShowCreationThenFadeAround(c_label))
+ self.wait()
+
+ # Label x and y
+ x_label = TexMobject("x")
+ y_label = TexMobject("y")
+ xy_labels = VGroup(x_label, y_label)
+ xy_labels.scale(1.5)
+
+ x_color = self.x1_color
+ y_color = self.y1_color
+
+ x_label[0].set_color(x_color)
+ y_label[0].set_color(y_color)
+
+ # side_labels.clear_updaters()
+ for var, num, vect in zip(xy_labels, [b_label, a_label], [DR, DL]):
+ buff = 0.15
+ var.move_to(num, vect)
+ var.brace = Brace(num, UP)
+ var.brace.num = num
+ var.brace.add_updater(
+ lambda m: m.next_to(m.num, UP, buff=buff)
+ )
+ var.add_updater(
+ lambda m: m.next_to(m.brace, UP, buff=buff)
+ )
+
+ var.suspend_updating()
+ var.brace.suspend_updating()
+ self.play(
+ FadeInFrom(var, DOWN),
+ Write(var.brace, run_time=1),
+ # MoveToTarget(num)
+ )
+ self.wait()
+
+ # Show plane
+ to_move = VGroup(
+ triangle,
+ side_labels,
+ x_label,
+ x_label.brace,
+ y_label,
+ y_label.brace,
+ )
+
+ axes = Axes(
+ x_min=-0.25,
+ x_max=1.5,
+ y_min=-0.25,
+ y_max=1.5,
+ number_line_config={
+ "tick_frequency": 0.25,
+ "unit_size": 3,
+ }
+ )
+ x_axis = axes.x_axis
+ y_axis = axes.y_axis
+
+ x_axis.add(TexMobject("x", color=x_color).next_to(x_axis, RIGHT))
+ y_axis.add(TexMobject("y", color=y_color).next_to(y_axis, UP))
+
+ for axis, vect in [(x_axis, DOWN), (y_axis, LEFT)]:
+ axis.add_numbers(
+ 0.5, 1.0,
+ number_config={"num_decimal_places": 1},
+ direction=vect,
+ )
+
+ axes.to_corner(DR, buff=LARGE_BUFF)
+
+ self.play(
+ to_move.to_corner, UL, {"buff": LARGE_BUFF},
+ to_move.shift, MED_LARGE_BUFF * DOWN,
+ Write(axes),
+ )
+
+ # Show coordinates
+ coords = VGroup(b_label.copy(), a_label.copy())
+
+ x_coord, y_coord = coords
+ x_coord.add_updater(lambda m: m.set_value(b_side.get_length() / unit_factor))
+ y_coord.add_updater(lambda m: m.set_value(a_side.get_length() / unit_factor))
+
+ def get_coord_values():
+ return [c.get_value() for c in coords]
+
+ def get_ms_point():
+ return axes.c2p(*get_coord_values())
+
+ dot = always_redraw(
+ lambda: triangle.copy().set_width(0.1).move_to(get_ms_point())
+ )
+
+ y_line = always_redraw(
+ lambda: DashedLine(
+ x_axis.n2p(x_coord.get_value()),
+ get_ms_point(),
+ color=y_color,
+ stroke_width=1,
+ )
+ )
+ x_line = always_redraw(
+ lambda: DashedLine(
+ y_axis.n2p(y_coord.get_value()),
+ get_ms_point(),
+ color=x_color,
+ stroke_width=1,
+ )
+ )
+
+ coord_label = TexMobject("(", "0.00", ",", "0.00", ")")
+ cl_buff = 0
+ coord_label.next_to(dot, UR, buff=cl_buff)
+ for i, coord in zip([1, 3], coords):
+ coord.generate_target()
+ coord.target.replace(coord_label[i], dim_to_match=0)
+ coord_label[i].set_opacity(0)
+
+ self.play(
+ MoveToTarget(x_coord),
+ MoveToTarget(y_coord),
+ FadeIn(coord_label),
+ ReplacementTransform(triangle.copy().set_fill(opacity=0), dot),
+ )
+ coord_label.add(*coords)
+ coord_label.add_updater(lambda m: m.next_to(dot, UR, buff=cl_buff))
+ self.add(x_label, y_label, dot)
+ self.play(
+ ShowCreation(x_line),
+ ShowCreation(y_line),
+ )
+ self.wait()
+
+ # Adjust triangle
+ tip_tracker = VectorizedPoint(triangle.points[0])
+
+ def update_triangle(tri):
+ point = tip_tracker.get_location()
+ tri.points[0] = point
+ tri.points[-1] = point
+ tri.make_jagged()
+
+ triangle.add_updater(update_triangle)
+
+ self.add(tip_tracker)
+ self.play(tip_tracker.shift, 0.5 * LEFT + 1.0 * UP)
+ self.play(tip_tracker.shift, 2.0 * DOWN)
+ self.play(tip_tracker.shift, 1.5 * RIGHT)
+ self.play(tip_tracker.shift, 1.0 * LEFT + 1.0 * UP)
+ self.wait()
+
+ # Show box
+ t2c = {"x": x_color, "y": y_color}
+ ineq1 = TexMobject("0", "\\le ", "x", "\\le", "1", tex_to_color_map=t2c)
+ ineq2 = TexMobject("0", "\\le ", "y", "\\le", "1", tex_to_color_map=t2c)
+
+ ineqs = VGroup(ineq1, ineq2)
+ ineqs.scale(1.5)
+ ineqs.arrange(DOWN, buff=MED_LARGE_BUFF)
+ ineqs.next_to(triangle, DOWN, buff=1.5)
+
+ box = Square(
+ fill_color=DARK_GREY,
+ fill_opacity=0.75,
+ stroke_color=LIGHT_GREY,
+ stroke_width=2,
+ )
+ box.replace(Line(axes.c2p(0, 0), axes.c2p(1, 1)))
+ box_outline = box.copy()
+ box_outline.set_fill(opacity=0)
+ box_outline.set_stroke(YELLOW, 3)
+
+ self.add(box, axes, x_line, y_line, coord_label, dot)
+ self.play(
+ FadeIn(box),
+ LaggedStartMap(FadeInFromDown, ineqs)
+ )
+ self.play(
+ ShowCreationThenFadeOut(box_outline)
+ )
+ self.wait()
+
+ # x >= y slice
+ region = Polygon(
+ axes.c2p(0, 0),
+ axes.c2p(1, 0),
+ axes.c2p(1, 1),
+ fill_color=GREY_BROWN,
+ fill_opacity=0.75,
+ stroke_color=GREY_BROWN,
+ stroke_width=2,
+ )
+ region_outline = region.copy()
+ region_outline.set_fill(opacity=0)
+ region_outline.set_stroke(YELLOW, 3)
+
+ x_eq_y_line = Line(axes.c2p(0, 0), axes.c2p(1, 1))
+ x_eq_y_line.set_stroke(self.x_eq_y_color, 2)
+ x_eq_y_label = TexMobject("x=y", tex_to_color_map=t2c)
+ x_eq_y_label.next_to(x_eq_y_line.get_end(), LEFT, MED_LARGE_BUFF)
+ x_eq_y_label.shift(0.75 * DL)
+
+ ineq = TexMobject("0", "\\le", "y", "\\le", "x", "\\le", "1")
+ ineq.set_color_by_tex("x", x_color)
+ ineq.set_color_by_tex("y", y_color)
+ ineq.scale(1.5)
+ ineq.move_to(ineqs, LEFT)
+
+ self.add(region, axes, x_line, y_line, coord_label, dot)
+ self.play(
+ FadeIn(region),
+ ShowCreation(x_eq_y_line),
+ # FadeInFromDown(x_eq_y_label),
+ Transform(ineq1[:2], ineq[:2], remover=True),
+ Transform(ineq1[2:], ineq[4:], remover=True),
+ Transform(ineq2[:4], ineq[:4], remover=True),
+ Transform(ineq2[4:], ineq[6:], remover=True),
+ )
+ self.add(ineq)
+ self.play(ShowCreationThenFadeOut(region_outline))
+ self.wait()
+
+ # x + y <= 1 slice
+ xpy1_line = Line(axes.c2p(0, 1), axes.c2p(1, 0))
+ xpy1_line.set_stroke(GREEN, 2)
+ xpy1_label = TexMobject("x+y=1", tex_to_color_map=t2c)
+ xpy1_label.next_to(xpy1_line.get_start(), RIGHT, MED_LARGE_BUFF)
+ xpy1_label.shift(0.75 * DR)
+
+ xpy1_ineq = TexMobject("1 \\le x + y", tex_to_color_map=t2c)
+ xpy1_ineq.scale(1.5)
+ xpy1_ineq.next_to(ineq, DOWN, buff=MED_LARGE_BUFF)
+
+ ms_region = Polygon(
+ axes.c2p(1, 0),
+ axes.c2p(0.5, 0.5),
+ axes.c2p(1, 1),
+ fill_color=BLUE_E,
+ fill_opacity=0.75,
+ stroke_width=0,
+ )
+ ms_outline = ms_region.copy()
+ ms_outline.set_fill(opacity=0)
+ ms_outline.set_stroke(YELLOW, 2)
+
+ tt_line = Line(DOWN, UP, color=WHITE)
+ tt_line.set_height(0.25)
+ tt_line.add_updater(lambda m: m.move_to(tip_tracker))
+
+ self.play(
+ ShowCreation(xpy1_line),
+ # FadeInFrom(xpy1_label, DOWN),
+ FadeInFrom(xpy1_ineq, UP)
+ )
+ self.wait()
+ self.play(
+ tip_tracker.set_y, triangle.get_bottom()[1] + 0.01,
+ FadeIn(tt_line),
+ )
+ self.wait()
+
+ self.add(ms_region, axes, x_line, y_line, coord_label, dot)
+ self.play(
+ FadeIn(ms_region),
+ region.set_fill, DARK_GREY,
+ )
+ self.wait()
+
+ # Move tip around
+ self.play(
+ tip_tracker.shift, UP + RIGHT,
+ FadeOut(tt_line),
+ )
+ self.wait()
+ self.play(tip_tracker.shift, 0.5 * DOWN + LEFT, run_time=2)
+ self.wait()
+ self.play(tip_tracker.shift, UP + 0.7 * LEFT, run_time=2)
+ self.wait()
+ equilateral_point = triangle.get_bottom() + unit_factor * 0.5 * np.sqrt(3) * UP
+ self.play(
+ tip_tracker.move_to,
+ equilateral_point,
+ run_time=2,
+ )
+ self.wait()
+
+ # Label as moduli space
+ ms_words = TextMobject("Moduli\\\\", "Space")
+ ms_words.scale(1.5)
+ ms_words.next_to(ms_region, RIGHT, buff=0.35)
+ ms_arrow = Arrow(
+ ms_words[1].get_corner(DL),
+ ms_region.get_center(),
+ path_arc=-90 * DEGREES,
+ buff=0.1,
+ )
+ # ms_arrow.rotate(-10 * DEGREES)
+ ms_arrow.shift(0.1 * RIGHT)
+ ms_arrow.scale(0.95)
+
+ self.play(
+ FadeInFrom(ms_words, LEFT),
+ )
+ self.play(ShowCreation(ms_arrow))
+ self.wait()
+
+ # Show right triangles
+ alpha = np.arcsin(0.8)
+ vect = rotate_vector(0.6 * unit_factor * LEFT, -alpha)
+ new_tip = triangle.get_corner(DR) + vect
+
+ elbow = VMobject()
+ elbow.start_new_path(RIGHT)
+ elbow.add_line_to(UR)
+ elbow.add_line_to(UP)
+
+ elbow.rotate(3 * TAU / 4 - alpha, about_point=ORIGIN)
+ elbow.scale(0.2, about_point=ORIGIN)
+ elbow.shift(new_tip)
+
+ elbow_circle = Circle()
+ elbow_circle.replace(elbow)
+ elbow_circle.scale(3)
+ elbow_circle.move_to(new_tip)
+ elbow_circle.set_stroke(self.right_color, 3)
+
+ right_words = TextMobject("Right triangle")
+ right_words.scale(1.5)
+ right_words.set_color(self.right_color)
+ right_words.next_to(triangle, DOWN, buff=1.5)
+
+ ineqs = VGroup(ineq, xpy1_ineq)
+
+ self.play(
+ tip_tracker.move_to, new_tip,
+ FadeOut(ms_words),
+ FadeOut(ms_arrow),
+ )
+ self.play(
+ ShowCreation(elbow),
+ FadeInFrom(right_words, UP),
+ FadeOutAndShift(ineqs, DOWN),
+ )
+ self.play(
+ ShowCreationThenFadeOut(elbow_circle),
+ )
+
+ # Show circular arc
+ pythag_eq = TexMobject("x^2 + y^2", "=", "1", tex_to_color_map=t2c)
+ pythag_eq.scale(1.5)
+ pythag_eq.next_to(right_words, DOWN, buff=MED_LARGE_BUFF)
+
+ arc = Arc(
+ start_angle=90 * DEGREES,
+ angle=-90 * DEGREES,
+ color=self.right_color,
+ )
+ arc.replace(box)
+
+ self.play(
+ FadeInFrom(pythag_eq, UP),
+ )
+ self.add(arc, arc)
+ self.play(ShowCreation(arc))
+ self.wait()
+
+ # Acute region
+ arc_piece = VMobject()
+ arc_piece.pointwise_become_partial(arc, 0.5, 1.0)
+
+ acute_region = VMobject()
+ acute_region.start_new_path(axes.c2p(1, 1))
+ acute_region.add_line_to(arc_piece.get_start())
+ acute_region.append_vectorized_mobject(arc_piece)
+ acute_region.add_line_to(axes.c2p(1, 1))
+ acute_region.set_fill(self.acute_color, 1)
+ acute_region.set_stroke(width=0)
+
+ obtuse_region = VMobject()
+ obtuse_region.start_new_path(axes.c2p(1, 0))
+ obtuse_region.add_line_to(axes.c2p(0.5, 0.5))
+ obtuse_region.add_line_to(arc_piece.get_start())
+ obtuse_region.append_vectorized_mobject(arc_piece)
+ obtuse_region.set_fill(self.obtuse_color, 1)
+ obtuse_region.set_stroke(width=0)
+
+ acute_words = TextMobject("Acute triangle")
+ acute_words.set_color(self.acute_color)
+ obtuse_words = TextMobject("Obtuse triangle")
+ obtuse_words.set_color(self.obtuse_color)
+ for words in [acute_words, obtuse_words]:
+ words.scale(1.5)
+ words.move_to(right_words)
+
+ eq = pythag_eq[-2]
+ gt = TexMobject(">").replace(eq)
+ gt.set_color(self.acute_color)
+ lt = TexMobject("<").replace(eq)
+ lt.set_color(self.obtuse_color)
+
+ self.add(acute_region, coord_label, x_line, y_line, xpy1_line, x_eq_y_line, dot)
+ self.play(
+ tip_tracker.shift, 0.5 * UP,
+ coord_label.set_opacity, 0,
+ FadeOut(elbow),
+ FadeIn(acute_region),
+ FadeOutAndShift(right_words, UP),
+ FadeOutAndShift(eq, UP),
+ FadeInFrom(acute_words, DOWN),
+ FadeInFrom(gt, DOWN),
+ )
+ self.wait()
+ self.play(tip_tracker.shift, 0.5 * RIGHT)
+ self.wait()
+ self.add(obtuse_region, coord_label, x_line, y_line, xpy1_line, x_eq_y_line, dot)
+ self.play(
+ tip_tracker.shift, 1.5 * DOWN,
+ FadeIn(obtuse_region),
+ FadeOutAndShift(acute_words, DOWN),
+ FadeOutAndShift(gt, DOWN),
+ FadeInFrom(obtuse_words, UP),
+ FadeInFrom(lt, UP),
+ )
+ self.wait()
+ self.play(tip_tracker.shift, 0.5 * LEFT)
+ self.play(tip_tracker.shift, 0.5 * DOWN)
+ self.play(tip_tracker.shift, 0.5 * RIGHT)
+ self.play(tip_tracker.shift, 0.5 * UP)
+ self.wait()
+
+ # Ambient changes
+ self.play(
+ FadeOut(obtuse_words),
+ FadeOut(pythag_eq[:-2]),
+ FadeOut(pythag_eq[-1]),
+ FadeOut(lt),
+ )
+ self.play(
+ tip_tracker.move_to, equilateral_point + 0.25 * DL,
+ path_arc=30 * DEGREES,
+ run_time=8,
+ )
+
+ #
+ def get_triangles_and_classes(self):
+ original_triangles = VGroup(*[
+ self.get_random_triangle()
+ for x in range(5)
+ ])
+ original_triangles.submobjects[4] = self.get_random_triangle() # Hack
+ all_triangles = VGroup()
+ tri_classes = VGroup()
+ for triangle in original_triangles:
+ all_triangles.add(triangle)
+ tri_class = VGroup()
+ tri_class.add(triangle)
+ for x in range(2):
+ tri_copy = triangle.copy()
+ angle = TAU * np.random.random()
+ scalar = 0.25 + 1.5 * np.random.random()
+
+ tri_copy.rotate(angle - tri_copy.angle)
+ tri_copy.angle = angle
+ tri_copy.scale(scalar / tri_copy.scalar)
+ tri_copy.scalar = scalar
+
+ all_triangles.add(tri_copy)
+ tri_class.add(tri_copy)
+ tri_classes.add(tri_class)
+
+ colors = Color(BLUE).range_to(Color(RED), len(all_triangles))
+ for triangle, color in zip(all_triangles, colors):
+ # triangle.set_color(random_bright_color())
+ triangle.set_color(color)
+
+ all_triangles.shuffle()
+ all_triangles.arrange_in_grid(3, 5, buff=MED_LARGE_BUFF)
+ all_triangles.set_height(6)
+ sf = 1.25
+ all_triangles.stretch(sf, 0)
+ for triangle in all_triangles:
+ triangle.stretch(1 / sf, 0)
+ # all_triangles.next_to(title, DOWN)
+ all_triangles.to_edge(DOWN, LARGE_BUFF)
+
+ return all_triangles, tri_classes
+
+ def get_random_triangle(self, x=None, y=None):
+ y = np.random.random()
+ x = y + np.random.random()
+ if x + y <= 1:
+ diff = 1 - (x + y)
+ x += diff
+ y += diff
+ tri = self.get_triangle(x, y)
+ tri.angle = TAU * np.random.random()
+ tri.scalar = 0.25 + np.random.random() * 1.5
+
+ tri.rotate(tri.angle)
+ tri.scale(tri.scalar)
+ return tri
+
+ def get_triangle(self, x, y):
+ # Enforce assumption that x > y
+ if y > x:
+ raise Exception("Please ensure x >= y. Thank you.")
+ plane = self.plane
+
+ # Heron
+ s = (1 + x + y) / 2.0
+ area = np.sqrt(s * (s - 1.0) * (s - x) * (s - y))
+ beta = np.arcsin(2 * area / x)
+ tip_point = RIGHT + rotate_vector(x * LEFT, -beta)
+
+ color = self.get_triangle_color(x, y)
+ return Polygon(
+ plane.c2p(0, 0),
+ plane.c2p(1, 0),
+ plane.c2p(*tip_point[:2]),
+ color=color,
+ fill_opacity=self.triangle_fill_opacity,
+ )
+
+ def get_triangle_color(self, x, y):
+ epsilon = 1e-4
+ if x + y == 1:
+ return self.x_eq_y_color
+ elif x == 1:
+ return self.x1_color
+ elif y == 1:
+ return self.y1_color
+ elif np.abs(x**2 + y**2 - 1) < epsilon:
+ return self.right_color
+ elif x**2 + y**2 < 1:
+ return self.obtuse_color
+ elif x**2 + y**2 > 1:
+ return self.acute_color
+ assert(False) # Should not get here
+
+ def get_triangle_xy(self, triangle):
+ A, B, C = triangle.get_start_anchors()[:3]
+ a = get_norm(B - C)
+ b = get_norm(C - A)
+ c = get_norm(A - B)
+ sides = np.array(sorted([a, b, c]))
+ sides = sides / np.max(sides)
+ return sides[1], sides[0]
+
+ def get_triangle_x(self, triangle):
+ return self.get_triangle_xy(triangle)[0]
+
+ def get_triangle_y(self, triangle):
+ return self.get_triangle_xy(triangle)[1]