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]