from big_ol_pile_of_manim_imports import *


def q_mult(q1, q2):
    w1, x1, y1, z1 = q1
    w2, x2, y2, z2 = q2
    w = w1 * w2 - x1 * x2 - y1 * y2 - z1 * z2
    x = w1 * x2 + x1 * w2 + y1 * z2 - z1 * y2
    y = w1 * y2 + y1 * w2 + z1 * x2 - x1 * z2
    z = w1 * z2 + z1 * w2 + x1 * y2 - y1 * x2
    return np.array([w, x, y, z])


def stereo_project_point(point, axis=0, r=1, max_norm=10000):
    point = fdiv(point * r, point[axis] + r)
    point[axis] = 0
    norm = get_norm(point)
    if norm > max_norm:
        point *= max_norm / norm
    return point


def stereo_project(mobject, axis=0, r=1, outer_r=10, **kwargs):
    epsilon = 1
    for submob in mobject.family_members_with_points():
        points = submob.points
        n = len(points)
        for i in range(n):
            if points[i, axis] == -r:
                js = it.chain(
                    range(i + 1, n),
                    range(i - 1, -1, -1)
                )
                for j in js:
                    if points[j, axis] == -r:
                        continue
                    else:
                        vect = points[j] - points[i]
                        points[i] += epsilon * vect
                        break
        submob.apply_function(
            lambda p: stereo_project_point(p, axis, r, **kwargs)
        )

        # If all points are outside a certain range, this
        # shouldn't be displayed
        norms = np.apply_along_axis(get_norm, 1, submob.points)
        if np.all(norms > outer_r):
            # TODO, instead set opacity?
            # submob.points[:, :] = 0
            submob.set_fill(opacity=0)
            submob.set_stroke(opacity=0)

    return mobject


class Linus(VGroup):
    CONFIG = {
        "body_config": {
            "stroke_width": 15,
            "stroke_color": LIGHT_GREY,
            "sheen": 0.4,
        },
        "height": 2,
    }

    def __init__(self, **kwargs):
        VGroup.__init__(self, **kwargs)
        self.body = self.get_body_line()
        self.eyes = Eyes(self.body)

        self.add(self.body, self.eyes)
        self.set_height(self.height)
        self.center()

    def change_mode(self, mode, thing_to_look_at=None):
        self.eyes.change_mode(mode, thing_to_look_at)
        if mode == "sad":
            self.become_squiggle()
        elif mode == "confused":
            self.become_squiggle(factor=-0.1)
        elif mode == "pleading":
            self.become_squiggle(factor=0.3)
        else:
            self.become_line()
        return self

    def change(self, *args, **kwargs):
        self.change_mode(*args, **kwargs)
        return self

    def look_at(self, thing_to_look_at=None):
        self.eyes.look_at(thing_to_look_at)
        return self

    def blink(self):
        self.eyes.blink()
        return self

    def get_squiggle(self, factor=0.2):
        sine_curve = FunctionGraph(
            lambda x: factor * np.sin(x),
            x_min=0, x_max=TAU,
        )
        sine_curve.rotate(TAU / 4)
        sine_curve.match_style(self.body)
        sine_curve.match_height(self.body)
        sine_curve.move_to(self.body, UP)
        return sine_curve

    def get_body_line(self, **kwargs):
        config = dict(self.body_config)
        config.update(kwargs)
        line = Line(ORIGIN, 1.5 * UP, **config)
        if hasattr(self, "body"):
            line.match_style(self.body)
            line.match_height(self.body)
            line.move_to(self.body, UP)
        return line

    def become_squiggle(self, **kwargs):
        self.body.become(self.get_squiggle(**kwargs))
        return self

    def become_line(self, **kwargs):
        self.body.become(self.get_body_line(**kwargs))
        return self

    def copy(self):
        return self.deepcopy()


class Felix(PiCreature):
    CONFIG = {
        "color": GREEN_D
    }


class PushPin(SVGMobject):
    CONFIG = {
        "file_name": "push_pin",
        "height": 0.5,
        "sheen": 0.7,
        "fill_color": GREY,
    }

    def __init__(self, **kwargs):
        SVGMobject.__init__(self, **kwargs)
        self.rotate(20 * DEGREES)

    def pin_to(self, point):
        self.move_to(point, DR)


class Hand(SVGMobject):
    CONFIG = {
        "file_name": "pinch_hand",
        "height": 0.5,
        "sheen": 0.2,
        "fill_color": ORANGE,
    }

    def __init__(self, **kwargs):
        SVGMobject.__init__(self, **kwargs)
        # self.rotate(30 * DEGREES)
        self.add(VectorizedPoint().next_to(self, UP, buff=0.17))


class CheckeredCircle(Circle):
    CONFIG = {
        "n_pieces": 16,
        "colors": [BLUE_E, BLUE_C],
        "stroke_width": 5,
    }

    def __init__(self, **kwargs):
        Circle.__init__(self, **kwargs)
        pieces = self.get_pieces(self.n_pieces)
        self.points = np.zeros((0, 3))
        self.add(*pieces)
        n_colors = len(self.colors)
        for i, color in enumerate(self.colors):
            self[i::n_colors].set_color(color)


class StereoProjectedSphere(Sphere):
    CONFIG = {
        "stereo_project_config": {
            "axis": 2,
        },
        "max_r": 32,
        "max_width": FRAME_WIDTH,
        "max_height": FRAME_WIDTH,
        "max_depth": FRAME_WIDTH,
        "radius": 1,
    }

    def __init__(self, rotation_matrix=None, **kwargs):
        digest_config(self, kwargs)
        if rotation_matrix is None:
            rotation_matrix = np.identity(3)
        self.rotation_matrix = rotation_matrix

        self.stereo_project_config["r"] = self.radius
        ParametricSurface.__init__(
            self, self.post_projection_func, **kwargs
        )
        self.submobjects.sort(
            key=lambda m: -m.get_width()
        )
        self.fade_far_out_submobjects()

    def post_projection_func(self, u, v):
        point = self.radius * Sphere.func(self, u, v)
        rot_point = np.dot(point, self.rotation_matrix.T)
        result = stereo_project_point(
            rot_point, **self.stereo_project_config
        )
        epsilon = 1e-4
        if np.any(np.abs(result) == np.inf) or np.any(np.isnan(result)):
            return self.func(u + epsilon, v)
        return result

    def fade_far_out_submobjects(self, **kwargs):
        max_r = kwargs.get("max_r", self.max_r)
        max_width = kwargs.get("max_width", self.max_width)
        max_height = kwargs.get("max_height", self.max_height)
        max_depth = kwargs.get("max_depth", self.max_depth)
        for submob in self.submobjects:
            violations = [
                np.any(np.apply_along_axis(get_norm, 1, submob.get_anchors()) > max_r),
                submob.get_width() > max_width,
                submob.get_height() > max_height,
                submob.get_depth() > max_depth
            ]
            if any(violations):
                # self.remove(submob)
                submob.fade(1)
        return self


class StereoProjectedSphereFromHypersphere(StereoProjectedSphere):
    CONFIG = {
        "stereo_project_config": {
            "axis": 0,
        },
        "radius": 2,
        "multiply_from_right": False,
    }

    def __init__(self, quaternion=None, null_axis=0, **kwargs):
        if quaternion is None:
            quaternion = np.array([1, 0, 0, 0])
        self.quaternion = quaternion
        self.null_axis = null_axis
        ParametricSurface.__init__(self, self.q_mult_projection_func, **kwargs)
        self.fade_far_out_submobjects()

    def q_mult_projection_func(self, u, v):
        point = list(Sphere.func(self, u, v))
        point.insert(self.null_axis, 0)
        if self.multiply_from_right:
            post_q_mult = q_mult(point, self.quaternion)
        else:
            post_q_mult = q_mult(self.quaternion, point)
        projected = list(self.radius * stereo_project_point(
            post_q_mult, **self.stereo_project_config
        ))
        if np.any(np.abs(projected) == np.inf):
            return self.func(u + 0.001, v)
        ignored_axis = self.stereo_project_config["axis"]
        projected.pop(ignored_axis)
        return np.array(projected)


class StereoProjectedCircleFromHypersphere(CheckeredCircle):
    CONFIG = {
        "n_pieces": 48,
        "radius": 2,
        "max_length": 3 * FRAME_WIDTH,
        "max_r": 50,
        "basis_vectors": [
            [1, 0, 0, 0],
            [0, 1, 0, 0],
        ],
        "multiply_from_right": False,
    }

    def __init__(self, quaternion=None, **kwargs):
        CheckeredCircle.__init__(self, **kwargs)
        if quaternion is None:
            quaternion = [1, 0, 0, 0]
        self.quaternion = quaternion
        self.pre_positioning_matrix = self.get_pre_positioning_matrix()
        self.apply_function(self.projection)
        self.remove_large_pieces()
        self.set_shade_in_3d(True)

    def get_pre_positioning_matrix(self):
        v1, v2 = [np.array(v) for v in self.basis_vectors]
        v1 = normalize(v1)
        v2 = v2 - np.dot(v1, v2) * v1
        v2 = normalize(v2)
        return np.array([v1, v2]).T

    def projection(self, point):
        q1 = self.quaternion
        q2 = np.dot(self.pre_positioning_matrix, point[:2]).flatten()
        if self.multiply_from_right:
            new_q = q_mult(q2, q1)
        else:
            new_q = q_mult(q1, q2)
        projected = stereo_project_point(
            new_q, axis=0, r=self.radius,
        )
        if np.any(projected == np.inf) or np.any(np.isnan(projected)):
            epsilon = 1e-6
            return self.projection(rotate_vector(point, epsilon))
        return projected[1:]

    def remove_large_pieces(self):
        for piece in self:
            length = get_norm(piece.points[0] - piece.points[-1])
            violations = [
                length > self.max_length,
                get_norm(piece.get_center()) > self.max_r,
            ]
            if any(violations):
                piece.fade(1)


class QuaternionTracker(ValueTracker):
    CONFIG = {
        "force_unit": True,
        "dim": 4,
    }

    def __init__(self, four_vector=None, **kwargs):
        Mobject.__init__(self, **kwargs)
        if four_vector is None:
            four_vector = np.array([1, 0, 0, 0])
        self.set_value(four_vector)
        if self.force_unit:
            self.add_updater(lambda q: q.normalize())

    def set_value(self, vector):
        self.points = np.array(vector).reshape((1, 4))
        return self

    def get_value(self):
        return self.points[0]

    def normalize(self):
        self.set_value(normalize(
            self.get_value(),
            fall_back=np.array([1, 0, 0, 0])
        ))
        return self


class RubiksCube(VGroup):
    CONFIG = {
        "colors": [
            "#FFD500",  # Yellow
            "#C41E3A",  # Orange
            "#009E60",  # Green
            "#FF5800",  # Red
            "#0051BA",  # Blue
            "#FFFFFF"   # White
        ],
    }

    def __init__(self, **kwargs):
        digest_config(self, kwargs)
        vectors = [OUT, RIGHT, UP, LEFT, DOWN, IN]
        faces = [
            self.create_face(color, vector)
            for color, vector in zip(self.colors, vectors)
        ]
        VGroup.__init__(self, *it.chain(*faces), **kwargs)
        self.set_shade_in_3d(True)

    def create_face(self, color, vector):
        squares = VGroup(*[
            self.create_square(color)
            for x in range(9)
        ])
        squares.arrange_in_grid(
            3, 3,
            buff=0
        )
        squares.set_width(2)
        squares.move_to(OUT, OUT)
        squares.apply_matrix(z_to_vector(vector))
        return squares

    def create_square(self, color):
        square = Square(
            stroke_width=3,
            stroke_color=BLACK,
            fill_color=color,
            fill_opacity=1,
            side_length=1,
        )
        square.flip()
        return square
        # back = square.copy()
        # back.set_fill(BLACK, 0.85)
        # back.set_stroke(width=0)
        # back.shift(0.5 * IN)
        # return VGroup(square, back)

    def get_face(self, vect):
        self.sort(lambda p: np.dot(p, vect))
        return self[-(12 + 9):]


# Abstract scenes


class ManyNumberSystems(Scene):
    def construct(self):
        # Too much dumb manually positioning in here...
        title = Title("Number systems")
        name_location_color_example_tuples = [
            ("Reals", [-4, 2, 0], YELLOW, "1.414"),
            ("Complex numbers", [4, 0, 0], BLUE, "2 + i"),
            ("Quaternions", [0, 2, 0], PINK, "2 + 7i + 1j + 8k"),
            ("Rationals", [3, -2, 0], RED, "1 \\over 3"),
            ("p-adic numbers", [-2, -2, 0], GREEN, "\\overline{142857}2"),
            ("Octonions", [-3, 0, 0], LIGHT_GREY, "3e_1 - 2.3e_2 + \\dots + 1.6e_8"),
        ]
        systems = VGroup()
        for name, location, color, ex in name_location_color_example_tuples:
            system = TextMobject(name)
            system.set_color(color)
            system.move_to(location)
            example = TexMobject(ex)
            example.next_to(system, DOWN)
            system.add(example)
            systems.add(system)
        R_label, C_label, H_label = systems[:3]

        number_line = NumberLine(x_min=-3, x_max=3)
        number_line.add_numbers()
        number_line.shift(0.25 * FRAME_WIDTH * LEFT)
        number_line.shift(0.5 * DOWN)
        R_example_dot = Dot(number_line.number_to_point(1.414))
        plane = ComplexPlane(x_radius=3.5, y_radius=2.5)
        plane.add_coordinates()
        plane.shift(0.25 * FRAME_WIDTH * RIGHT)
        plane.shift(0.5 * DOWN)
        C_example_dot = Dot(plane.coords_to_point(2, 1))

        self.add(title)
        self.play(FadeInFromLarge(H_label))
        self.play(LaggedStartMap(
            FadeInFromLarge, VGroup(*it.chain(systems[:2], systems[3:])),
            lambda m: (m, 4)
        ))
        self.wait()
        self.add(number_line, plane, systems)
        self.play(
            R_label.move_to, 0.25 * FRAME_WIDTH * LEFT + 2 * UP,
            C_label.move_to, 0.25 * FRAME_WIDTH * RIGHT + 2 * UP,
            H_label.move_to, 0.75 * FRAME_WIDTH * RIGHT + 2 * UP,
            FadeOutAndShift(systems[3:], 2 * DOWN),
            Write(number_line),
            Write(plane),
            GrowFromCenter(R_example_dot),
            R_label[-1].next_to, R_example_dot, UP,
            GrowFromCenter(C_example_dot),
            C_label[-1].next_to, C_example_dot, UR, SMALL_BUFF,
            C_label[-1].shift, 0.4 * LEFT,
        )
        number_line.add(R_example_dot)
        plane.add(C_example_dot)
        self.wait(2)
        self.play(LaggedStartMap(
            ApplyMethod,
            VGroup(
                H_label,
                VGroup(plane, C_label),
                VGroup(number_line, R_label),
            ),
            lambda m: (m.shift, 0.5 * FRAME_WIDTH * LEFT),
            lag_ratio=0.8,
        ))
        randy = Randolph(height=1.5)
        randy.next_to(plane, RIGHT)
        randy.to_edge(DOWN)
        self.play(
            randy.change, "maybe", H_label,
            VFadeIn(randy),
        )
        self.play(Blink(randy))
        self.play(randy.change, "confused", H_label.get_top())
        self.wait()


class RotationsIn3d(SpecialThreeDScene):
    def construct(self):
        self.set_camera_orientation(**self.get_default_camera_position())
        self.begin_ambient_camera_rotation(rate=0.02)
        sphere = self.get_sphere()
        vectors = VGroup(*[
            Vector(u * v, color=color).next_to(sphere, u * v, buff=0)
            for v, color in zip(
                [RIGHT, UP, OUT],
                [GREEN, RED, BLUE],
            )
            for u in [-1, 1]
        ])
        vectors.set_shade_in_3d(True)
        sphere.add(vectors)

        self.add(self.get_axes())
        self.add(sphere)
        angle_axis_pairs = [
            (90 * DEGREES, RIGHT),
            (120 * DEGREES, UR),
            (-45 * DEGREES, OUT),
            (60 * DEGREES, IN + DOWN),
            (90 * DEGREES, UP),
            (30 * DEGREES, UP + OUT + RIGHT),
        ]
        for angle, axis in angle_axis_pairs:
            self.play(Rotate(
                sphere, angle,
                axis=axis,
                run_time=2,
            ))
            self.wait()


class IntroduceHamilton(Scene):
    def construct(self):
        hamilton = ImageMobject("Hamilton", height=6)
        hamilton.to_corner(UL)
        shamrock = SVGMobject(file_name="shamrock")
        shamrock.set_height(1)
        shamrock.set_color("#009a49")
        shamrock.set_fill(opacity=0.25)
        shamrock.next_to(hamilton.get_corner(UL), DR)
        shamrock.align_to(hamilton, UP)
        hamilton_name = TextMobject(
            "William Rowan Hamilton"
        )
        hamilton_name.match_width(hamilton)
        hamilton_name.next_to(hamilton, DOWN)

        quote = TextMobject(
            """\\huge ...Every morning in the early part of the above-cited
            month, on my coming down to breakfast, your (then)
            little brother William Edwin, and yourself, used to
            ask me,""",
            "``Well, Papa, can you multiply triplets''?",
            """Whereto I was always obliged to reply, with a sad
            shake of the head: ``No, I can only add and subtract
            them.''...""",
            alignment=""
        )
        quote.set_color_by_tex("Papa", YELLOW)
        quote = VGroup(*it.chain(*quote))
        quote.set_width(FRAME_WIDTH - hamilton.get_width() - 2)
        quote.to_edge(RIGHT)
        quote_rect = SurroundingRectangle(quote, buff=MED_SMALL_BUFF)
        quote_rect.set_stroke(WHITE, 2)
        quote_rect.stretch(1.1, 1)
        quote_label = TextMobject(
            "August 5, 1865 Letter\\\\from Hamilton to his son"
        )
        quote_label.next_to(quote_rect, UP)
        quote_label.set_color(BLUE)
        VGroup(quote, quote_rect, quote_label).to_edge(UP)

        plaque = ImageMobject("BroomBridgePlaque")
        plaque.set_width(FRAME_WIDTH / 2)
        plaque.to_edge(LEFT)
        plaque.shift(UP)
        equation = TexMobject(
            "i^2 = j^2 = k^2 = ijk = -1",
            tex_to_color_map={"i": GREEN, "j": RED, "k": BLUE}
        )
        equation_rect = Rectangle(width=3.25, height=0.7)
        equation_rect.move_to(3.15 * LEFT + 0.25 * DOWN)
        equation_rect.set_color(WHITE)
        equation_arrow = Vector(DOWN)
        equation_arrow.match_color(equation_rect)
        equation_arrow.next_to(equation_rect, DOWN)
        equation.next_to(equation_arrow, DOWN)

        self.play(
            FadeInFromDown(hamilton),
            Write(hamilton_name),
        )
        self.play(DrawBorderThenFill(shamrock))
        self.wait()

        self.play(
            LaggedStartMap(
                FadeIn, quote,
                lag_ratio=0.2,
                run_time=4
            ),
            FadeInFromDown(quote_label),
            ShowCreation(quote_rect)
        )
        self.wait(3)
        self.play(
            ApplyMethod(
                VGroup(hamilton, shamrock, hamilton_name).to_edge, RIGHT,
                run_time=2,
                rate_func=squish_rate_func(smooth, 0.5, 1),
            ),
            LaggedStartMap(
                FadeOutAndShiftDown, VGroup(*it.chain(
                    quote, quote_rect, quote_label
                ))
            )
        )
        self.wait()
        self.play(FadeIn(plaque))
        self.play(
            ShowCreation(equation_rect),
            GrowArrow(equation_arrow)
        )
        self.play(ReplacementTransform(
            equation.copy().replace(equation_rect).fade(1),
            equation
        ))
        self.wait()


class QuaternionHistory(Scene):
    CONFIG = {
        "names_and_quotes": [
            (
                "Oliver Heaviside",
                """\\huge ``As far as the vector analysis I required was
                concerned, the quaternion was not only not
                required, but was a positive evil of no
                inconsiderable magnitude.''"""
            ),
            (
                "Lord Kelvin",
                """\\huge ``Quaternions... though beautifully \\\\ ingenious,
                have been an unmixed evil to those who have
                touched them in any way, including Clerk Maxwell.''"""
            ),
        ]
    }

    def construct(self):
        self.show_dot_product_and_cross_product()
        self.teaching_students_quaternions()
        self.show_anti_quaternion_quote()
        self.mad_hatter()

    def show_dot_product_and_cross_product(self):
        date = TexMobject("1843")
        date.scale(2)
        date.to_edge(UP)

        t2c = self.t2c = {
            "x_1": GREEN,
            "x_2": GREEN,
            "y_1": RED,
            "y_2": RED,
            "z_1": BLUE,
            "z_2": BLUE,
        }

        def get_colored_tex_mobject(tex):
            return TexMobject(tex, tex_to_color_map=t2c)

        v1, v2 = [
            Matrix([
                ["{}_{}".format(c, i)]
                for c in "xyz"
            ], element_to_mobject=get_colored_tex_mobject)
            for i in (1, 2)
        ]
        dot_rhs = get_colored_tex_mobject(
            "x_1 x_2 + y_1 y_2 + z_1 z_2",
        )
        cross_rhs = Matrix([
            ["y_1 z_2 - z_1 y_2"],
            ["z_1 x_2 - x_1 z_2"],
            ["x_1 y_2 - y_1 x_2"],
        ], element_to_mobject=get_colored_tex_mobject)

        dot_product = VGroup(
            v1.copy(), TexMobject("\\cdot").scale(2),
            v2.copy(), TexMobject("="),
            dot_rhs
        )
        cross_product = VGroup(
            v1.copy(), TexMobject("\\times"),
            v2.copy(), TexMobject("="),
            cross_rhs
        )
        for product in dot_product, cross_product:
            product.arrange(RIGHT, buff=2 * SMALL_BUFF)
            product.set_height(1.5)
        dot_product.next_to(date, DOWN, buff=MED_LARGE_BUFF)
        dot_product.to_edge(LEFT, buff=LARGE_BUFF)
        cross_product.next_to(
            dot_product, DOWN,
            buff=MED_LARGE_BUFF,
            aligned_edge=LEFT,
        )

        self.play(FadeInFrom(dot_product, 2 * RIGHT))
        self.play(FadeInFrom(cross_product, 2 * LEFT))
        self.wait()
        self.play(FadeInFromDown(date))
        self.play(ApplyMethod(dot_product.fade, 0.7))
        self.play(ApplyMethod(cross_product.fade, 0.7))
        self.wait()
        self.play(
            FadeOutAndShift(dot_product, 2 * LEFT),
            FadeOutAndShift(cross_product, 2 * RIGHT),
        )

        self.date = date

    def teaching_students_quaternions(self):
        hamilton = ImageMobject("Hamilton")
        hamilton.set_height(4)
        hamilton.pixel_array = hamilton.pixel_array[:, ::-1, :]
        hamilton.to_corner(UR)
        hamilton.shift(MED_SMALL_BUFF * DOWN)

        colors = color_gradient([BLUE_E, GREY_BROWN, BLUE_B], 7)
        random.shuffle(colors)
        students = VGroup(*[
            PiCreature(color=color)
            for color in colors
        ])
        students.set_height(2)
        students.arrange(RIGHT)
        students.set_width(FRAME_WIDTH - hamilton.get_width() - 1)
        students.to_corner(DL)

        equation = TexMobject("""
            (x_1 i + y_1 j + z_1 k)
            (x_2 i + y_2 j + z_2 k)
            =
            (-x_1 x_2 - y_1 y_2 - z_1 z_2) +
            (y_1 z_2 - z_1 y_2)i +
            (z_1 x_2 - x_1 z_2)j +
            (x_1 y_2 - y_1 x_2)k
        """, tex_to_color_map=self.t2c)
        equation.set_width(FRAME_WIDTH - 1)
        equation.to_edge(UP, buff=MED_SMALL_BUFF)

        images = Group()
        image_labels = VGroup()
        images_with_labels = Group()
        names = ["Peter Tait", "Robert Ball", "Macfarlane Alexander"]
        for name in names:
            image = ImageMobject(name)
            image.set_height(3)
            label = TextMobject(name)
            label.scale(0.5)
            label.next_to(image, DOWN)
            image.label = label
            image_labels.add(label)
            images.add(image)
            images_with_labels.add(Group(image, label))
        images_with_labels.arrange(RIGHT)
        images_with_labels.next_to(hamilton, LEFT, LARGE_BUFF)
        images_with_labels.shift(MED_LARGE_BUFF * DOWN)
        society_title = TextMobject("Quaternion society")
        society_title.next_to(images, UP, MED_LARGE_BUFF, UP)

        def blink_wait(n_loops):
            for x in range(n_loops):
                self.play(Blink(random.choice(students)))
                self.wait(random.random())

        self.play(
            FadeInFromDown(hamilton),
            Write(
                self.date,
                rate_func=lambda t: smooth(1 - t),
                remover=True
            )
        )
        self.play(LaggedStartMap(
            FadeInFrom, students,
            lambda m: (m, LEFT),
        ))
        self.play(
            LaggedStartMap(
                ApplyMethod, students,
                lambda pi: (
                    pi.change,
                    random.choice(["confused", "maybe", "erm"]),
                    3 * LEFT + 2 * UP,
                ),
            ),
            Write(equation),
        )
        blink_wait(3)
        self.play(
            LaggedStartMap(FadeInFromDown, images),
            LaggedStartMap(FadeInFromLarge, image_labels),
            Write(society_title)
        )
        blink_wait(3)
        self.play(
            FadeOutAndShift(hamilton, RIGHT),
            LaggedStartMap(
                FadeOutAndShift, images_with_labels,
                lambda m: (m, UP)
            ),
            FadeOutAndShift(students, DOWN),
            FadeOut(society_title),
            run_time=1
        )

        self.equation = equation

    def show_anti_quaternion_quote(self):
        group = self.get_dissenter_images_quotes_and_names()
        images, quotes, names = group
        self.play(
            LaggedStartMap(FadeInFromDown, images),
            LaggedStartMap(FadeInFromLarge, names),
            lag_ratio=0.75,
            run_time=2,
        )
        for quote in quotes:
            self.play(LaggedStartMap(
                FadeIn, VGroup(*quote.family_members_with_points()),
                lag_ratio=0.3
            ))
            self.wait()
        self.play(FadeOut(images_with_quotes))

    def mad_hatter(self):
        title = TextMobject(
            "Lewis Carroll's", "``Alice in wonderland''"
        )
        title.to_edge(UP, buff=LARGE_BUFF)
        author_brace = Brace(title[0], DOWN)
        aka = TextMobject("a.k.a. Mathematician Charles Dodgson")
        aka.scale(0.8)
        aka.set_color(BLUE)
        aka.next_to(author_brace, DOWN)

        quote = TextMobject(
            """
                ``Why, you might just as well say that\\\\
                ‘I see what I eat’ is the same thing as\\\\
                ‘I eat what I see’!''
            """,
            tex_to_color_map={
                "I see what I eat": BLUE,
                "I eat what I see": YELLOW,
            },
            alignment=""
        )
        quote.to_edge(UP, buff=LARGE_BUFF)

        hatter = PiCreature(color=RED, mode="surprised")
        hat = SVGMobject(file_name="hat")
        hat_back = hat.copy()
        hat_back[0].remove(*[
            sm for sm in hat_back[0] if sm.is_subpath
        ])
        hat_back.set_fill(DARK_GREY)
        hat.add_to_back(hat_back)
        hat.set_height(1.25)
        hat.next_to(hatter.body, UP, buff=-MED_SMALL_BUFF)
        hatter.add(hat)
        hatter.look(DL)
        hatter.pupils[1].save_state()
        hatter.look(UL)
        hatter.pupils[1].restore()
        hatter.set_height(2)

        hare = SVGMobject(file_name="bunny")
        mouse = SVGMobject(file_name="mouse")
        for mob in hare, mouse:
            mob.set_color(LIGHT_GREY)
            mob.set_sheen(0.2, UL)
            mob.set_height(1.5)

        characters = VGroup(hatter, hare, mouse)
        for mob, p in zip(characters, [UP, DL, DR]):
            mob.move_to(p)
        hare.shift(MED_SMALL_BUFF * LEFT)

        characters.space_out_submobjects(1.5)
        characters.to_edge(DOWN)

        def change_single_place(char, **kwargs):
            i = characters.submobjects.index(char)
            target = characters[(i + 1) % 3]
            return ApplyMethod(
                char.move_to, target,
                path_arc=-90 * DEGREES,
                **kwargs
            )

        def get_change_places():
            return LaggedStartMap(
                change_single_place, characters,
                lag_ratio=0.6
            )

        self.play(
            Write(title),
            LaggedStartMap(FadeInFromDown, characters)
        )
        self.play(
            get_change_places(),
            GrowFromCenter(author_brace),
            FadeIn(aka)
        )
        for x in range(4):
            self.play(get_change_places())
        self.play(
            FadeOutAndShift(VGroup(title, author_brace, aka)),
            FadeInFromDown(quote),
        )
        self.play(get_change_places())
        self.play(
            get_change_places(),
            VFadeOut(characters, run_time=2)
        )
        self.remove(characters)
        self.wait()

    #
    def get_dissenter_images_quotes_and_names(self):
        names_and_quotes = self.names_and_quotes
        images = Group()
        quotes = VGroup()
        names = VGroup()
        images_with_quotes = Group()
        for name, quote_text in names_and_quotes:
            image = Group(ImageMobject(name))
            image.set_height(4)
            label = TextMobject(name)
            label.next_to(image, DOWN)
            names.add(label)
            quote = TextMobject(
                quote_text,
                tex_to_color_map={
                    "positive evil": RED,
                    "unmixed evil": RED,
                },
                alignment=""
            )
            quote.scale(0.3)
            quote.next_to(image, UP)
            images.add(image)
            quotes.add(quote)
            images_with_quotes.add(Group(image, label, quote))

        images_with_quotes.arrange(RIGHT, buff=LARGE_BUFF)
        images_with_quotes.to_edge(DOWN, MED_LARGE_BUFF)
        return Group(images, quotes, names)


class QuaternionRotationOverlay(Scene):
    def construct(self):
        equations = VGroup(
            TexMobject(
                "p", "\\rightarrow",
                "{}",
                "{}",
                "\\left(q_1",
                "p",
                "q_1^{-1}\\right)",
                "{}",
                "{}",
            ),
            TexMobject(
                "p", "\\rightarrow",
                "{}",
                "\\left(q_2",
                "\\left(q_1",
                "p",
                "q_1^{-1}\\right)",
                "q_2^{-1}\\right)",
                "{}",
            ),
            TexMobject(
                "p", "\\rightarrow",
                "\\left(q_3",
                "\\left(q_2",
                "\\left(q_1",
                "p",
                "q_1^{-1}\\right)",
                "q_2^{-1}\\right)",
                "q_3^{-1}\\right)",
            ),
        )
        for equation in equations:
            equation.set_color_by_tex_to_color_map({
                "1": GREEN, "2": RED, "3": BLUE,
            })
            equation.set_color_by_tex("rightarrow", WHITE)
            equation.to_corner(UL)

        equation = equations[0].copy()
        self.play(Write(equation))
        self.wait()
        for new_equation in equations[1:]:
            self.play(
                Transform(equation, new_equation)
            )
            self.wait(2)


class RotateCubeThreeTimes(SpecialThreeDScene):
    def construct(self):
        cube = RubiksCube()
        cube.set_fill(opacity=0.8)
        cube.set_stroke(width=1)
        randy = Randolph(mode="pondering")
        randy.set_height(cube.get_height() - 2 * SMALL_BUFF)
        randy.move_to(cube.get_edge_center(OUT))
        randy.set_fill(opacity=0.8)
        # randy.set_shade_in_3d(True)
        cube.add(randy)
        axes = self.get_axes()

        self.add(axes, cube)
        self.move_camera(
            phi=70 * DEGREES,
            theta=-140 * DEGREES,
        )
        self.begin_ambient_camera_rotation(rate=0.02)
        self.wait(2)
        self.play(Rotate(cube, TAU / 4, RIGHT, run_time=3))
        self.wait(2)
        self.play(Rotate(cube, TAU / 4, UP, run_time=3))
        self.wait(2)
        self.play(Rotate(cube, -TAU / 3, np.ones(3), run_time=3))
        self.wait(7)


class QuantumSpin(Scene):
    def construct(self):
        title = Title("Two-state system")

        electron = Dot(color=BLUE)
        electron.set_height(1)
        electron.set_sheen(0.3, UL)
        electron.set_fill(opacity=0.8)
        kwargs = {
            "path_arc": PI,
        }
        curved_arrows = VGroup(
            Arrow(RIGHT, LEFT, **kwargs),
            Arrow(LEFT, RIGHT, **kwargs),
        )
        curved_arrows.set_color(LIGHT_GREY)
        curved_arrows.set_stroke(width=2)

        y_arrow = Vector(UP)
        y_arrow.set_color(RED)

        y_ca = curved_arrows.copy()
        y_ca.rotate(70 * DEGREES, LEFT)
        y_group = VGroup(y_ca[0], y_arrow, electron.copy(), y_ca[1])

        x_arrow = y_arrow.copy().rotate(90 * DEGREES, IN, about_point=ORIGIN)
        x_arrow.set_color(GREEN)
        x_ca = curved_arrows.copy()
        x_ca.rotate(70 * DEGREES, UP)
        x_group = VGroup(x_ca[0], x_arrow, electron.copy(), x_ca[1])

        z_ca = curved_arrows.copy()
        z_group = VGroup(electron.copy(), z_ca, Dot(color=BLUE))

        groups = VGroup(x_group, y_group, z_group)
        groups.arrange(RIGHT, buff=1.5)
        groups.move_to(UP)

        y_ca.rotation = Rotating(
            y_ca, axis=rotate_vector(OUT, 70 * DEGREES, LEFT)
        )
        x_ca.rotation = Rotating(
            x_ca, axis=rotate_vector(OUT, 70 * DEGREES, UP)
        )
        z_ca.rotation = Rotating(z_ca, axis=OUT)
        rotations = [ca.rotation for ca in [x_ca, y_ca, z_ca]]

        matrices = VGroup(
            Matrix([["0", "1"], ["1", "0"]]),
            Matrix([["0", "-i"], ["i", "0"]]),
            Matrix([["1", "0"], ["0", "-1"]]),
        )
        for matrix, group in zip(matrices, groups):
            matrix.next_to(group, DOWN)
        for matrix in matrices[1:]:
            matrix.align_to(matrices[0], DOWN)

        self.add(title, groups)
        self.play()
        self.play(
            LaggedStartMap(FadeInFromDown, matrices, run_time=3),
            *rotations
        )
        for x in range(2):
            self.play(*rotations)


class HereWeTackle4d(TeacherStudentsScene):
    def construct(self):
        titles = VGroup(
            TextMobject(
                "This video:\\\\",
                "Quaternions in 4d"
            ),
            TextMobject(
                "Next video:\\\\",
                "Quaternions acting on 3d"
            )
        )
        for title in titles:
            title.move_to(self.hold_up_spot, DOWN)
        titles[0].set_color(YELLOW)

        self.play(
            self.teacher.change, "raise_right_hand",
            FadeInFromDown(titles[0]),
            self.get_student_changes("confused", "horrified", "sad")
        )
        self.look_at(self.screen)
        self.wait()
        self.change_student_modes(
            "erm", "thinking", "pondering",
            look_at_arg=self.screen
        )
        self.wait(3)
        self.change_student_modes(
            "pondering", "confused", "happy"
        )
        self.look_at(self.screen)
        self.wait(3)
        self.play(
            self.teacher.change, "hooray",
            FadeInFrom(titles[1]),
            ApplyMethod(
                titles[0].shift, 2 * UP,
                rate_func=squish_rate_func(smooth, 0.2, 1)
            )
        )
        self.change_all_student_modes("hooray")
        self.play(self.teacher.change, "happy")
        self.look_at(self.screen)
        self.wait(3)
        self.change_student_modes("pondering", "happy", "thinking")
        self.wait(4)


class TableOfContents(Scene):
    def construct(self):
        chapters = VGroup(
            TextMobject(
                "\\underline{Chapter 1}\\\\", "Linus the Linelander"
            ),
            TextMobject(
                "\\underline{Chapter 2}\\\\", "Felix the Flatlander"
            ),
            TextMobject(
                "\\underline{Chapter 3}\\\\", " You, the 3d-lander"
            ),
        )
        for chapter in chapters:
            chapter.space_out_submobjects(1.5)
        chapters.arrange(
            DOWN, buff=1.5, aligned_edge=LEFT
        )
        chapters.to_edge(LEFT)

        for chapter in chapters:
            self.play(FadeInFromDown(chapter))
            self.wait(2)
        for chapter in chapters:
            chapters.save_state()
            other_chapters = VGroup(*[
                c for c in chapters if c is not chapter
            ])
            self.play(
                chapter.set_width, 0.5 * FRAME_WIDTH,
                chapter.center,
                other_chapters.fade, 1
            )
            self.wait(3)
            self.play(chapters.restore)


class IntroduceLinusTheLinelander(Scene):
    def construct(self):
        self.introduce_linus()
        self.show_real_number_line()
        self.look_at_complex_plane()

    def introduce_linus(self):
        linus = Linus()
        linus.move_to(3 * LEFT)
        name = TextMobject("Linus the Linelander")
        name.next_to(linus, DR, buff=MED_LARGE_BUFF)
        arrow = Arrow(name.get_top(), linus.get_right())

        self.play(FadeInFromDown(linus))
        self.play(
            Write(name),
            GrowArrow(arrow),
            linus.change, "gracious", name,
        )
        self.play(
            linus.become_squiggle, {"factor": -0.1},
        )
        self.play(Blink(linus))
        self.wait()

        self.name_text = name
        self.name_arrow = arrow
        self.linus = linus

    def show_real_number_line(self):
        linus = self.linus
        number_line = NumberLine()
        number_line.add_numbers()
        number_line.to_edge(UP)

        algebra = VGroup(
            TexMobject("3 \\cdot 4 = 12"),
            TexMobject("3 + 4 = 7"),
            TexMobject("(-2) \\cdot 3 = -6"),
        )
        algebra.arrange(DOWN)
        algebra.next_to(number_line, DOWN, LARGE_BUFF)
        algebra.shift(3 * RIGHT)

        self.play(
            ShowCreation(number_line),
            linus.look_at, number_line
        )
        self.play(
            LaggedStartMap(FadeInFromDown, number_line.numbers),
            LaggedStartMap(ShowCreation, number_line.tick_marks),
            linus.change, "happy"
        )
        self.play(
            LaggedStartMap(FadeInFromDown, algebra),
            linus.look_at, algebra
        )
        self.play(Blink(linus))
        self.wait()

        self.algebra = algebra

    def look_at_complex_plane(self):
        linus = self.linus
        to_fade = VGroup(
            self.name_text,
            self.name_arrow,
            self.algebra,
        )
        frame = ScreenRectangle()
        frame.set_width(8)
        frame.to_corner(DR)

        q_marks = VGroup(*[
            TexMobject("?").shift(
                random.random() * RIGHT,
                random.random() * UP,
            )
            for x in range(50)
        ])
        q_marks.next_to(linus.body, UP, buff=0)
        q_marks.set_color_by_gradient(BLUE, GREEN, YELLOW)
        random.shuffle(q_marks.submobjects)
        q_marks_anim = LaggedStartMap(
            FadeIn, q_marks,
            run_time=15,
            rate_func=there_and_back,
            lag_ratio=0.1
        )
        q_marks_continual = turn_animation_into_updater(q_marks_anim)

        self.play(
            FadeOut(to_fade),
            ShowCreation(frame),
            linus.look_at, frame
        )
        self.add(q_marks_continual)
        self.play(linus.change_mode, "confused")
        self.wait()
        self.play(Blink(linus))
        self.play(linus.change, "confused", frame.get_bottom())
        self.wait()
        self.play(linus.change, "sad", frame.get_center())
        self.wait(10)


class ShowComplexMultiplicationExamples(Scene):
    CONFIG = {
        "plane_config": {
            "x_radius": 9,
            "y_radius": 9,
            "stroke_width": 3,
        },
        "background_plane_config": {
            "color": LIGHT_GREY,
            "secondary_color": DARK_GREY,
            "stroke_width": 0.5,
            "stroke_opacity": 0.5,
            "secondary_line_ratio": 0,
        }
    }

    def construct(self):
        self.add_planes()
        z_tuples = [
            (complex(2, 1), "2 + i", UP),
            (complex(5, 2), "5 + 2i", LEFT),
            (
                complex(-np.sqrt(2) / 2, np.sqrt(2) / 2),
                "-\\frac{\\sqrt{2}}{2} + \\frac{\\sqrt{2}}{2} i",
                LEFT,
            ),
            (complex(-4, 1.5), "-4 + 1.5i", RIGHT),
            (complex(3, 0), "3 + 0i", UP),
            (complex(4, -3), "4 + -3i", UP),
        ]

        for z, z_tex, label_vect in z_tuples:
            self.show_multiplication(z, z_tex, label_vect)

    def add_planes(self, include_title=True):
        plane = ComplexPlane(**self.plane_config)
        self.plane = plane
        background_plane = ComplexPlane(**self.background_plane_config)
        background_plane.add_coordinates()
        self.background_plane = background_plane

        self.add(background_plane)
        self.add(plane)

        if include_title:
            title = TextMobject("Complex plane")
            title.scale(1.5)
            title.to_corner(UL, buff=MED_LARGE_BUFF)
            title.shift(SMALL_BUFF * UR)
            self.title = title
            self.add_foreground_mobjects(title)

    def show_multiplication(self, z, z_tex, label_vect):
        z_color = WHITE
        plane = self.plane
        new_plane = plane.deepcopy()
        real_tex, imag_tex = z_tex.split("+")
        label = TexMobject(
            "\\text{Multiply by}\\\\",
            real_tex, "+", imag_tex,
            alignment="",
        )
        label[1].set_color(GREEN)
        label[3].set_color(RED)
        label.scale(1.2)

        h_line = Line(
            plane.number_to_point(0),
            plane.number_to_point(z.real),
            color=GREEN,
            stroke_width=5,
        )
        v_line = Line(
            plane.number_to_point(z.real),
            plane.number_to_point(z),
            color=RED,
            stroke_width=5,
        )
        lines = VGroup(h_line, v_line)

        z_point = plane.number_to_point(z)
        z_dot = Dot(z_point)
        z_dot.set_color(z_color)
        label[1:].next_to(z_dot, label_vect)
        label[0].next_to(label[1:], UP)
        for mob in label:
            label.add_to_back(BackgroundRectangle(mob))

        one_dot = Dot(plane.number_to_point(1))
        one_dot.set_color(YELLOW)
        for dot in z_dot, one_dot:
            dot.save_state()
            dot.scale(5)
            dot.set_fill(opacity=0)
            dot.set_stroke(width=1, opacity=0.5)
        to_fade_out = VGroup(
            plane, label, lines, z_dot, one_dot
        )

        self.play(
            ShowCreation(lines),
            FadeInFromDown(label),
            Restore(z_dot),
        )
        self.play(Restore(one_dot))
        angle = np.log(z).imag
        self.play(
            one_dot.move_to, z_dot,
            plane.apply_complex_function, lambda w: z * w,
            path_arc=angle,
            run_time=3
        )
        self.wait()
        self.play(
            FadeOut(to_fade_out),
            FadeIn(new_plane),
        )
        self.plane = new_plane


class DefineComplexNumbersPurelyAlgebraically(Scene):
    def construct(self):
        self.add_linus()
        self.add_title()
        self.show_example_number()
        self.show_multiplication()
        self.emphsize_result_has_same_form()

    def add_linus(self):
        linus = self.linus = Linus()
        linus.move_to(3 * LEFT)

    def add_title(self):
        title = self.title = Title(
            "No spatial reasoning, just symbols"
        )
        self.play(
            FadeInFromDown(title[:-1]),
            ShowCreation(title[-1]),
            self.linus.look_at, title
        )

    def show_example_number(self):
        linus = self.linus

        number = TexMobject("2.35", "+", "3.14", "i")
        number.next_to(self.title, DOWN, buff=1.5)
        number.shift(3 * RIGHT)
        real, imag = number[0], number[2]
        real_brace = Brace(real, UP)
        imag_brace = Brace(imag, DOWN)
        real_label = real_brace.get_text("Some real number")
        imag_label = imag_brace.get_text("Some other real number")
        VGroup(real, real_label).set_color(GREEN)
        VGroup(imag, imag_label).set_color(RED)

        i = number[-1]
        i_def = TexMobject("i", "^2", "=", "-1")
        i_def.next_to(
            self.title, DOWN,
            buff=MED_LARGE_BUFF,
            aligned_edge=LEFT,
        )
        i_def_rect = SurroundingRectangle(i_def, color=YELLOW, buff=MED_SMALL_BUFF)
        definition_label = TextMobject("Definition")
        definition_label.next_to(i_def_rect, DOWN)
        definition_label.match_color(i_def_rect)

        self.play(Write(number, run_time=1))
        self.play(
            GrowFromCenter(real_brace),
            LaggedStartMap(FadeIn, real_label),
            linus.change, "confused", number,
            run_time=1
        )
        self.wait()
        self.play(
            GrowFromCenter(imag_brace),
            LaggedStartMap(FadeIn, imag_label),
            run_time=1
        )
        self.play(Blink(linus))
        self.play(
            linus.change, "erm", i_def,
            ReplacementTransform(
                i.copy(), i_def[0],
                path_arc=-30 * DEGREES
            ),
            FadeIn(i_def_rect),
            FadeIn(definition_label),
        )
        self.play(Write(i_def[1:]))
        self.wait()
        self.play(Blink(linus))

        self.to_fade = VGroup(
            real_brace, real_label,
            imag_brace, imag_label,
        )
        self.number = number

    def show_multiplication(self):
        linus = self.linus
        to_fade = self.to_fade
        z1 = self.number

        z2 = TexMobject("4", "+", "5", "i")
        z2.match_style(z1)

        for z in z1, z2:
            lp, rp = z.parens = TexMobject("()")
            lp.next_to(z, LEFT, SMALL_BUFF)
            rp.next_to(z, RIGHT, SMALL_BUFF)
            z.real = z[0]
            z.imag = z[2:]
            for part in z.real, z.imag:
                part.targets = [part.copy(), part.copy()]

        z1.generate_target()
        product = VGroup(
            VGroup(z1.target, z1.parens),
            VGroup(z2, z2.parens),
        )
        product.arrange(RIGHT, SMALL_BUFF)
        product.move_to(2 * RIGHT + 2 * UP)

        foil = VGroup(*map(TextMobject, [
            "First", "Outside", "Inside", "Last",
        ]))
        foil.arrange(
            DOWN, buff=MED_SMALL_BUFF,
            aligned_edge=LEFT
        )
        foil.scale(1.25)
        for word in foil:
            word[0].set_color(BLUE)
        foil.move_to(product).to_edge(DOWN, LARGE_BUFF)

        def get_cdot():
            return TexMobject("\\cdot")

        def get_lp():
            return TexMobject("(")

        def get_rp():
            return TexMobject(")")

        def get_plus():
            return TexMobject("+")

        expansion = VGroup(
            z1.real.targets[0], get_cdot(), z2.real.targets[0], get_plus(),
            z1.real.targets[1], get_cdot(), z2.imag.targets[0], get_plus(),
            z1.imag.targets[0], get_cdot(), z2.real.targets[1], get_plus(),
            z1.imag.targets[1], get_cdot(), z2.imag.targets[1],
        )
        expansion.arrange(RIGHT, buff=0.15)
        expansion.next_to(product, DOWN, buff=LARGE_BUFF)
        expansion_parts = VGroup(*[
            expansion[4 * i: 4 * i + 3]
            for i in range(4)
        ])
        expansion_part_braces = VGroup(*[
            Brace(part, DOWN) for part in expansion_parts
        ])
        for word, brace in zip(foil, expansion_part_braces):
            word.next_to(brace, DOWN)

        final_prouct = VGroup(
            get_lp(),
            z1[0].copy(), get_cdot(), z2[0].copy(),
            TexMobject("-"),
            z1[2].copy(), get_cdot(), z2[2].copy(),
            get_rp(), get_plus(),
            get_lp(),
            z1[0].copy(), get_cdot(), z2[2].copy(),
            get_plus(),
            z1[2].copy(), get_cdot(), z2[0].copy(),
            get_rp(), TexMobject("i")
        )
        final_prouct.arrange(RIGHT, buff=0.15)
        final_prouct.next_to(expansion, DOWN, buff=2)
        final_arrows = VGroup()
        for i, brace in zip([1, 11, 15, 5], expansion_part_braces):
            target = final_prouct[i:i + 3]
            if i == 5:
                arrow = Line(
                    brace.get_bottom() + SMALL_BUFF * DOWN,
                    target.get_top() + MED_SMALL_BUFF * UP,
                )
                arrow.points[1] = arrow.points[0] + DOWN
                arrow.points[2] = arrow.points[3] + UP
                tip = RegularPolygon(3, start_angle=-100 * DEGREES)
                tip.set_height(0.2)
                tip.set_stroke(width=0)
                tip.set_fill(WHITE, opacity=1)
                tip.move_to(arrow.get_end())
                arrow.add(tip)
            else:
                arrow = Arrow(
                    brace.get_bottom(),
                    target.get_top(),
                )
            final_arrows.add(arrow)
        final_arrows.set_stroke(BLACK, width=6, background=True)

        # Move example number into product
        self.play(
            FadeOut(to_fade),
            MoveToTarget(z1),
            FadeIn(z1.parens),
            FadeInFromDown(z2),
            FadeIn(z2.parens),
            linus.change, "happy", product,
        )
        self.wait()

        # Show distribution
        pairs = list(it.product([z1.real, z1.imag], [z2.real, z2.imag]))
        for i in range(4):
            left, right = pair = VGroup(*pairs[i])
            word = foil[i]
            dot = expansion[4 * i + 1]
            plus = expansion[4 * i + 3] if i < 3 else VMobject()
            brace = expansion_part_braces[i]

            self.play(pair.shift, 0.5 * DOWN)
            self.play(
                FadeIn(dot),
                GrowFromCenter(brace),
                FadeInFromDown(word),
                linus.move_to, 4 * LEFT + DOWN,
                *[
                    ReplacementTransform(
                        part.copy(),
                        part.targets.pop(0)
                    )
                    for part in pair
                ]
            )
            self.play(
                pair.shift, 0.5 * UP,
                FadeIn(plus)
            )
        self.play(Blink(linus))

        self.play(
            FadeOut(foil),
            FadeInFromDown(final_prouct),
            linus.look_at, final_prouct,
        )
        self.play(
            LaggedStartMap(ShowCreation, final_arrows),
            run_time=3,
        )
        self.play(linus.change, "confused")
        self.wait()

        self.final_prouct = final_prouct

    def emphsize_result_has_same_form(self):
        final_product = self.final_prouct
        real = final_product[1:1 + 7]
        imag = final_product[11:11 + 7]

        real_brace = Brace(real, DOWN)
        real_label = real_brace.get_text("Some real number")
        real_label.set_color(GREEN)
        imag_brace = Brace(imag, DOWN)
        imag_label = imag_brace.get_text(
            "Some other \\\\ real number"
        )
        imag_label.set_color(RED)
        braces = VGroup(real_brace, imag_brace)
        labels = VGroup(real_label, imag_label)
        self.play(
            LaggedStartMap(GrowFromCenter, braces),
            LaggedStartMap(Write, labels),
        )
        self.wait()


class TextbookQuaternionDefinition(TeacherStudentsScene):
    CONFIG = {
        "random_seed": 1,
    }

    def construct(self):
        equation = TexMobject(
            """
            (w_1 + x_1 i + y_1 j + z_1 k)
            (w_2 + x_2 i + y_2 j + z_2 k) =
            &(w_1 w_2 - x_1 x_2 - y_1 y_2 - z_1 z_2) \\, +\\\\
            &(w_1 x_2 + x_1 w_2 + y_1 z_2 - z_1 y_2)i \\, +\\\\
            &(w_1 y_2 + y_1 w_2 + z_1 x_2 - x_1 z_2)j \\, +\\\\
            &(w_1 z_2 + z_1 w_2 + x_1 y_2 - y_1 x_2)k \\\\
            """,
            tex_to_color_map={
                "w_1": YELLOW,
                "w_2": YELLOW,
                "x_1": GREEN,
                "x_2": GREEN,
                "y_1": RED,
                "y_2": RED,
                "z_1": BLUE,
                "z_2": BLUE,
            }
        )
        equation.set_width(FRAME_WIDTH - 1)
        equation.to_edge(UP)

        defining_products = VGroup(*[
            TexMobject(
                tex,
                tex_to_color_map={
                    "i": GREEN,
                    "j": RED,
                    "k": BLUE,
                }
            )
            for tex in [
                "i^2 = j^2 = k^2 = -1",
                "ij = -ji = k",
                "ki = -ik = j",
                "jk = -kj = i",
            ]
        ])
        defining_products.arrange(DOWN)
        defining_products.next_to(self.students, UP, LARGE_BUFF)
        def_rect = SurroundingRectangle(defining_products)

        self.play(
            LaggedStartMap(FadeInFromDown, defining_products),
            self.get_student_changes(*3 * ["confused"]),
            self.teacher.change, "raise_right_hand",
        )
        self.play(ShowCreation(def_rect))
        self.play(
            Write(equation, run_time=4, lag_ratio=0.2),
            self.get_student_changes(
                "horrified", "pleading", "sick",
                equation
            ),
            self.teacher.change, "erm", equation,
        )
        self.blink()
        self.look_at(equation.get_corner(UL))
        self.blink()
        self.look_at(equation.get_corner(UR))
        self.play(self.teacher.change, "sassy", equation)
        self.wait(2)
        self.change_all_student_modes("pondering")
        self.look_at(equation)
        self.wait()
        self.play(self.teacher.change, "thinking", equation)
        self.wait(8)


class ProblemsWhereComplexNumbersArise(Scene):
    def construct(self):
        text = "Problems where complex numbers are surprisingly useful"
        title = TextMobject(*text.split(" "))
        title.to_edge(UP)
        title.set_color(BLUE)
        underline = Line(LEFT, RIGHT)
        underline.set_width(title.get_width() + 0.5)
        underline.next_to(title, DOWN)

        problems = VGroup(
            TextMobject(
                "Integer solutions to\\\\ $a^2 + b^2 = c^2$",
                alignment=""
            ),
            TextMobject(
                "Understanding\\\\",
                "$1 - \\frac{1}{3} + \\frac{1}{5} - \\frac{1}{7} + \\cdots" +
                "=\\frac{\\pi}{4}$",
                alignment="",
            ),
            TextMobject("Frequency analysis")
        )
        problems.arrange(
            DOWN, buff=LARGE_BUFF, aligned_edge=LEFT
        )
        for problem in problems:
            problems.add(Dot().next_to(problem[0], LEFT))
        problems.next_to(underline, DOWN, buff=MED_LARGE_BUFF)
        problems.to_edge(LEFT)
        v_dots = TexMobject("\\vdots")
        v_dots.scale(2)
        v_dots.next_to(problems, DOWN, aligned_edge=LEFT)

        self.add(problems, v_dots)
        self.play(
            ShowCreation(underline),
            LaggedStartMap(FadeInFromDown, title, lag_ratio=0.5),
            run_time=3
        )
        self.wait()


class WalkThroughComplexMultiplication(ShowComplexMultiplicationExamples):
    CONFIG = {
        "z": complex(2, 3),
        "w": complex(1, -1),
        "z_color": YELLOW,
        "w_color": PINK,
        "product_color": RED,
    }

    def construct(self):
        self.add_planes(include_title=False)
        self.introduce_z_and_w()
        self.show_action_on_all_complex_numbers()

    def introduce_z_and_w(self):
        # Tolerating code repetition here in case I want
        # to specialize behavior for z or w...
        plane = self.plane
        origin = plane.number_to_point(0)

        z_point = plane.number_to_point(self.z)
        z_dot = Dot(z_point)
        z_line = Line(origin, z_point)
        z_label = VGroup(
            TexMobject("z="),
            DecimalNumber(self.z, num_decimal_places=0)
        )
        z_label.arrange(
            RIGHT, buff=SMALL_BUFF,
        )
        z_label.next_to(z_dot, UP, buff=SMALL_BUFF)
        z_label.set_color(self.z_color)
        z_label.add_background_rectangle()
        VGroup(z_line, z_dot).set_color(self.z_color)

        w_point = plane.number_to_point(self.w)
        w_dot = Dot(w_point)
        w_line = Line(origin, w_point)
        w_label = VGroup(
            TexMobject("w="),
            DecimalNumber(self.w, num_decimal_places=0)
        )
        w_label.arrange(RIGHT, buff=SMALL_BUFF)
        w_label.next_to(w_dot, DOWN, buff=SMALL_BUFF)
        w_label.set_color(self.w_color)
        w_label.add_background_rectangle()
        VGroup(w_line, w_dot).set_color(self.w_color)

        VGroup(
            z_label[1], w_label[1]
        ).shift(0.25 * SMALL_BUFF * DOWN)

        product = TexMobject("z", "\\cdot", "w")
        z_sym, w_sym = product[0], product[2]
        z_sym.set_color(self.z_color)
        w_sym.set_color(self.w_color)
        product.scale(2)
        product.to_corner(UL)
        product.add_background_rectangle()

        self.add(
            z_line, z_label,
            w_line, w_label,
        )
        self.play(LaggedStartMap(
            FadeInFromLarge, VGroup(z_dot, w_dot),
            lambda m: (m, 5),
            lag_ratio=0.8,
            run_time=1.5
        ))
        self.play(
            ReplacementTransform(z_label[1][0].copy(), z_sym)
        )
        self.add(product[:-1])
        self.play(
            ReplacementTransform(w_label[1][0].copy(), w_sym),
            FadeInFrom(product[2], LEFT),
            FadeIn(product[0]),
        )
        self.wait()

        self.set_variables_as_attrs(
            product,
            z_point, w_point,
            z_dot, w_dot,
            z_line, w_line,
        )

    def show_action_on_all_complex_numbers(self):
        plane = self.plane
        plane.save_state()
        origin = plane.number_to_point(0)
        z = self.z
        angle = np.log(z).imag
        product_tex = self.product[1:]
        z_sym, cdot, w_sym = product_tex

        product = self.z * self.w
        product_point = plane.number_to_point(product)
        product_dot = Dot(product_point)
        product_line = Line(origin, product_point)
        for mob in product_line, product_dot:
            mob.set_color(self.product_color)

        rect = SurroundingRectangle(VGroup(z_sym, cdot))
        rect.set_fill(BLACK, opacity=1)
        func_words = TextMobject("Function on the plane")
        func_words.next_to(
            rect, DOWN,
            buff=MED_SMALL_BUFF,
            aligned_edge=LEFT,
        )
        func_words.set_color(self.z_color)

        sparkly_plane = VGroup()
        for line in plane.family_members_with_points():
            if self.camera.is_in_frame(line):
                for piece in line.get_pieces(10):
                    p1, p2 = piece.get_pieces(2)
                    p1.rotate(PI)
                    pair = VGroup(p1, p2)
                    pair.scale(0.3)
                    sparkly_plane.add(pair)
        sparkly_plane.sort(
            lambda p: 0.1 * get_norm(p) + random.random()
        )
        sparkly_plane.set_color_by_gradient(YELLOW, RED, PINK, BLUE)
        sparkly_plane.set_stroke(width=4)

        pin = PushPin()
        pin.move_to(origin, DR)

        one_dot = Dot(plane.number_to_point(1))
        one_dot.set_fill(WHITE)
        one_dot.set_stroke(BLACK, 1)
        hand = Hand()
        hand.move_to(plane.number_to_point(1), LEFT)

        zero_eq = TexMobject("z \\cdot 0 = 0")
        one_eq = TexMobject("z \\cdot 1 = z")
        equations = VGroup(zero_eq, one_eq)
        equations.arrange(DOWN)
        equations.scale(1.5)
        for eq in equations:
            eq.add_background_rectangle()
        equations.next_to(func_words, DOWN)
        equations.to_edge(LEFT)

        product_label = VGroup(
            TexMobject("z \\cdot w ="),
            DecimalNumber(product, num_decimal_places=0)
        )
        product_label.arrange(RIGHT)
        product_label[0].shift(0.025 * DOWN)
        product_label.next_to(product_dot, UP, SMALL_BUFF)
        product_label.add_background_rectangle()

        big_rect = Rectangle(
            height=4,
            width=6,
            fill_color=BLACK,
            fill_opacity=0.9,
            stroke_width=0,
        )
        big_rect.to_corner(UL, buff=0)

        self.add(big_rect, product_tex, rect, z_sym, cdot)
        self.play(
            FadeIn(big_rect),
            ShowCreation(rect),
            Write(func_words),
            run_time=1
        )
        self.play(
            ReplacementTransform(
                self.w_line.copy(), product_line,
            ),
            ReplacementTransform(
                self.w_dot.copy(), product_dot,
            ),
            path_arc=angle,
            run_time=3
        )
        self.wait()
        self.play(FadeOut(VGroup(product_line, product_dot)))
        self.play(LaggedStartMap(
            ShowCreationThenDestruction, sparkly_plane,
            lag_ratio=0.5,
            run_time=2
        ))
        self.play(
            plane.apply_complex_function, lambda w: z * w,
            Transform(self.w_line, product_line),
            Transform(self.w_dot, product_dot),
            path_arc=angle,
            run_time=9,
            rate_func=lambda t: there_and_back_with_pause(t, 2 / 9)
        )
        self.wait()
        self.play(FadeInFrom(pin, UL))
        self.play(Write(zero_eq))
        self.play(
            FadeInFromLarge(one_dot),
            FadeInFrom(hand, UR)
        )
        self.play(Write(one_eq))
        self.wait()
        self.play(
            plane.apply_complex_function, lambda w: z * w,
            ReplacementTransform(self.w_line.copy(), product_line),
            ReplacementTransform(self.w_dot.copy(), product_dot),
            one_dot.move_to, self.z_point,
            hand.move_to, self.z_point, LEFT,
            path_arc=angle,
            run_time=4,
        )
        self.play(Write(product_label))


class ShowUnitCircleActions(ShowComplexMultiplicationExamples):
    CONFIG = {
        "random_seed": 0,
        "plane_config": {
            "secondary_line_ratio": 0,
        }
    }

    def construct(self):
        self.add_planes(include_title=False)
        self.show_unit_circle_actions()

    def show_unit_circle_actions(self):
        plane = self.plane
        origin = plane.number_to_point(0)
        one_point = plane.number_to_point(1)
        one_dot = Dot(one_point)
        one_dot.set_fill(WHITE)
        one_dot.set_stroke(BLACK, 1)
        plane.add(one_dot)

        pin = PushPin()
        pin.move_to(origin, DR)
        hand = Hand()
        update_hand = UpdateFromFunc(
            hand, lambda m: m.move_to(one_dot.get_center(), LEFT)
        )

        circle = Circle(
            color=YELLOW,
            radius=get_norm(one_point - origin)
        )

        self.add(circle)
        self.add(pin, one_dot)
        self.add_foreground_mobjects(hand)

        title = TextMobject(
            "Numbers on the unit circle",
            "$\\rightarrow$", "pure rotation."
        )
        title.set_width(FRAME_WIDTH - 1)
        title.to_edge(UP, buff=MED_SMALL_BUFF)
        title.add_background_rectangle(buff=SMALL_BUFF)
        self.add_foreground_mobjects(title)
        self.background_plane.coordinate_labels.submobjects.pop(-1)

        n_angles = 12
        angles = list(np.linspace(-PI, PI, n_angles + 2)[1:-1])
        random.shuffle(angles)

        for angle in angles:
            plane.save_state()
            temp_plane = plane.copy()

            z = np.exp(complex(0, angle))
            if angle is angles[0]:
                z_label = DecimalNumber(
                    z, num_decimal_places=2,
                )
                z_label.set_stroke(BLACK, width=11, background=True)
                z_label_rect = BackgroundRectangle(z_label)
                z_label_rect.set_fill(opacity=0)
            z_point = plane.number_to_point(z)
            z_arrow = Arrow(2.5 * z_point, z_point, buff=SMALL_BUFF)
            z_dot = Dot(z_point)
            z_label_start_center = z_label.get_center()
            z_label.next_to(
                z_arrow.get_start(),
                np.sign(z_arrow.get_start()[1]) * UP,
            )
            z_label_end_center = z_label.get_center()
            z_group = VGroup(z_arrow, z_dot, z_label)
            z_group.set_color(GREEN)
            z_group.add_to_back(z_label_rect)
            z_arrow.set_stroke(BLACK, 1)
            z_dot.set_stroke(BLACK, 1)

            if angle is angles[0]:
                self.play(
                    FadeInFromDown(z_label_rect),
                    FadeInFromDown(z_label),
                    GrowArrow(z_arrow),
                    FadeInFromLarge(z_dot),
                )
            else:
                alpha_tracker = ValueTracker(0)
                self.play(
                    ReplacementTransform(old_z_dot, z_dot),
                    ReplacementTransform(old_z_arrow, z_arrow),
                    UpdateFromFunc(
                        z_label_rect,
                        lambda m: m.replace(z_label)
                    ),
                    ChangeDecimalToValue(
                        z_label, z,
                        position_update_func=lambda m: m.move_to(
                            interpolate(
                                z_label_start_center,
                                z_label_end_center,
                                alpha_tracker.get_value()
                            )
                        )
                    ),
                    alpha_tracker.set_value, 1,
                    # hand.move_to, one_point, LEFT
                )
            old_z_dot = z_dot
            old_z_arrow = z_arrow
            VGroup(old_z_arrow, old_z_dot)
            self.play(
                Rotate(plane, angle, run_time=2),
                update_hand,
                Animation(z_group),
            )
            self.wait()
            self.add(temp_plane, z_group)
            self.play(
                FadeOut(plane),
                FadeOut(hand),
                FadeIn(temp_plane),
            )
            plane.restore()
            self.remove(temp_plane)
            self.add(plane, *z_group)


class IfYouNeedAWarmUp(TeacherStudentsScene):
    def construct(self):
        screen = self.screen
        screen.set_height(4)
        screen.to_corner(UL)
        self.add(screen)

        self.teacher_says(
            "If you need \\\\ a warm up",
            bubble_kwargs={"width": 3.5, "height": 3},
        )
        self.change_all_student_modes(
            "pondering", look_at_arg=screen,
        )
        self.wait(3)
        self.play(RemovePiCreatureBubble(self.teacher))
        self.wait(3)


class LinusThinksAboutStretching(Scene):
    def construct(self):
        linus = Linus()
        top_line = NumberLine(color=GREY)
        top_line.to_edge(UP)
        top_line.add_numbers()

        linus.move_to(3 * LEFT + DOWN)

        self.add(linus, top_line)

        scalars = [3, 0.5, 2]

        for scalar in scalars:
            lower_line = NumberLine(
                x_min=-14,
                x_max=14,
                color=BLUE
            )
            lower_line.next_to(top_line, DOWN, MED_LARGE_BUFF)
            lower_line.numbers = lower_line.get_number_mobjects()
            for number in lower_line.numbers:
                number.add_updater(lambda m: m.next_to(
                    lower_line.number_to_point(m.get_value()),
                    DOWN, MED_SMALL_BUFF,
                ))
            lower_line.save_state()
            lower_line.numbers.save_state()
            self.add(lower_line, *lower_line.numbers)

            words = TextMobject("Multiply by {}".format(scalar))
            words.next_to(lower_line.numbers, DOWN)

            self.play(
                ApplyMethod(
                    lower_line.stretch, scalar, 0,
                    run_time=2
                ),
                # LaggedStartMap(FadeIn, words, run_time=1),
                FadeInFromLarge(words, 1.0 / scalar),
                linus.look_at, top_line.number_to_point(scalar)
            )
            self.play(Blink(linus))
            self.play(
                FadeOut(lower_line),
                FadeOut(lower_line.numbers),
                FadeOut(words),
                FadeIn(lower_line.saved_state, remover=True),
                FadeIn(lower_line.numbers.saved_state, remover=True),
                linus.look_at, top_line.number_to_point(0)
            )
        self.play(linus.change, "confused", DOWN + RIGHT)
        self.wait(2)
        self.play(Blink(linus))
        self.wait(2)


class LinusReactions(Scene):
    def construct(self):
        linus = Linus()
        for mode in "confused", "sad", "erm", "angry", "pleading":
            self.play(linus.change, mode, 2 * RIGHT)
            self.wait()
            self.play(Blink(linus))
            self.wait()


class OneDegreeOfFreedomForRotation(Scene):
    def construct(self):
        circle = CheckeredCircle(radius=2, stroke_width=10)
        r_line = Line(circle.get_center(), circle.get_right())
        moving_r_line = r_line.copy()
        right_dot = Dot(color=WHITE)
        right_dot.move_to(circle.get_right())
        circle.add(moving_r_line, right_dot)
        center_dot = Dot(color=WHITE)

        def get_angle():
            return moving_r_line.get_angle() % TAU

        angle_label = Integer(0, unit="^\\circ")
        angle_label.scale(2)
        angle_label.add_updater(
            lambda m: m.set_value(get_angle() / DEGREES)
        )
        angle_label.add_updater(
            lambda m: m.next_to(circle, UP, MED_LARGE_BUFF)
        )

        def get_arc():
            return Arc(
                angle=get_angle(),
                radius=0.5,
                color=LIGHT_GREY,
            )

        arc = get_arc()
        arc.add_updater(lambda m: m.become(get_arc()))

        self.add(circle, center_dot, r_line, angle_label, arc)
        angles = IntroduceStereographicProjection.CONFIG.get(
            "example_angles"
        )
        for angle in angles:
            self.play(Rotate(circle, angle, run_time=4))
            self.wait()


class StereographicProjectionTitle(Scene):
    def construct(self):
        title = TextMobject("Stereographic projection")
        final_title = title.copy()
        final_title.set_width(10)
        final_title.to_edge(UP)

        title.rotate(-90 * DEGREES)
        title.next_to(RIGHT, RIGHT, SMALL_BUFF)
        title.apply_complex_function(np.exp)
        title.rotate(90 * DEGREES)
        title.set_height(6)
        title.to_edge(UP)

        self.play(Write(title))
        self.play(Transform(title, final_title, run_time=2))
        self.wait()


class IntroduceStereographicProjection(MovingCameraScene):
    CONFIG = {
        "n_sample_points": 16,
        "circle_config": {
            "n_pieces": 16,
            "radius": 2,
            "stroke_width": 7,
        },
        "example_angles": [
            30 * DEGREES,
            120 * DEGREES,
            240 * DEGREES,
            80 * DEGREES,
            -60 * DEGREES,
            135 * DEGREES,
        ]
    }

    def construct(self):
        self.setup_plane()
        self.draw_lines()
        self.describe_individual_points()
        self.remind_that_most_points_are_not_projected()

    def setup_plane(self):
        self.plane = self.get_plane()
        self.circle = self.get_circle()
        self.circle_shadow = self.get_circle_shadow()

        self.add(self.plane)
        self.add(self.circle_shadow)
        self.add(self.circle)

    def draw_lines(self):
        plane = self.plane
        circle = self.circle
        circle.save_state()
        circle.generate_target()
        self.project_mobject(circle.target)

        circle_points = self.get_sample_circle_points()
        dots = VGroup(*[Dot(p) for p in circle_points])
        dots.set_sheen(-0.2, DR)
        dots.set_stroke(DARK_GREY, 2, background=True)
        arrows = VGroup()
        for dot in dots:
            dot.scale(0.75)
            dot.generate_target()
            dot.target.move_to(
                self.project(dot.get_center())
            )
            arrow = Arrow(
                dot.get_center(),
                dot.target.get_center(),
            )
            arrows.add(arrow)
        neg_one_point = plane.number_to_point(-1)
        neg_one_dot = Dot(neg_one_point)
        neg_one_dot.set_fill(YELLOW)

        lines = self.get_lines()

        special_index = self.n_sample_points // 2 + 1
        line = lines[special_index]
        dot = dots[special_index]
        arrow = arrows[special_index]
        dot_target_outline = dot.target.copy()
        dot_target_outline.set_stroke(RED, 2)
        dot_target_outline.set_fill(opacity=0)
        dot_target_outline.scale(1.5)

        v_line = Line(UP, DOWN)
        v_line.set_height(FRAME_HEIGHT)
        v_line.set_stroke(RED, 5)

        self.play(LaggedStartMap(FadeInFromLarge, dots))
        self.play(FadeInFromLarge(neg_one_dot))
        self.add(lines, neg_one_dot, dots)
        self.play(LaggedStartMap(ShowCreation, lines))
        self.wait()
        self.play(
            lines.set_stroke, {"width": 0.5},
            line.set_stroke, {"width": 4},
        )
        self.play(ShowCreation(dot_target_outline))
        self.play(ShowCreationThenDestruction(v_line))
        self.play(MoveToTarget(dot))
        self.wait()
        self.play(
            lines.set_stroke, {"width": 1},
            FadeOut(dot_target_outline),
            MoveToTarget(circle),
            *map(MoveToTarget, dots),
            run_time=2,
        )
        self.wait()

        self.lines = lines
        self.dots = dots

    def describe_individual_points(self):
        plane = self.plane
        one_point, zero_point, i_point, neg_i_point, neg_one_point = [
            plane.number_to_point(n)
            for n in [1, 0, complex(0, 1), complex(0, -1), -1]
        ]
        i_pin = PushPin()
        i_pin.pin_to(i_point)
        neg_i_pin = PushPin()
        neg_i_pin.pin_to(neg_i_point)

        dot = Dot()
        dot.set_stroke(RED, 3)
        dot.set_fill(opacity=0)
        dot.scale(1.5)
        dot.move_to(one_point)

        arc1 = Arc(angle=TAU / 4, radius=2)
        arc2 = Arc(
            angle=85 * DEGREES, radius=2,
            start_angle=TAU / 4,
        )
        arc3 = Arc(
            angle=-85 * DEGREES, radius=2,
            start_angle=-TAU / 4,
        )
        VGroup(arc1, arc2, arc3).set_stroke(RED)

        frame = self.camera_frame
        frame_height_tracker = ValueTracker(frame.get_height())
        frame_height_growth = frame_height_tracker.add_updater(
            lambda m, dt: m.set_value(m.get_value + 0.5 * dt)
        )

        neg_one_tangent = VGroup(
            Line(ORIGIN, UP),
            Line(ORIGIN, DOWN),
        )
        neg_one_tangent.set_height(25)
        neg_one_tangent.set_stroke(YELLOW, 5)
        neg_one_tangent.move_to(neg_one_point)

        self.play(ShowCreation(dot))
        self.wait()
        self.play(dot.move_to, zero_point)
        self.wait()
        dot.move_to(i_point)
        self.play(ShowCreation(dot))
        self.play(FadeInFrom(i_pin, UL))
        self.wait()
        self.play(
            dot.move_to, neg_i_point,
            path_arc=-60 * DEGREES
        )
        self.play(FadeInFrom(neg_i_pin, UL))
        self.wait()
        self.play(
            dot.move_to, one_point,
            path_arc=-60 * DEGREES
        )
        frame.add_updater(
            lambda m: m.set_height(frame_height_tracker.get_value())
        )

        triplets = [
            (arc1, i_point, TAU / 4),
            (arc2, neg_one_point, TAU / 4),
            (arc3, neg_one_point, -TAU / 4),
        ]
        for arc, point, path_arc in triplets:
            self.play(
                ShowCreation(arc),
                dot.move_to, point, path_arc=path_arc,
                run_time=2
            )
            self.wait()
            self.play(
                ApplyFunction(self.project_mobject, arc, run_time=2)
            )
            self.wait()
            self.play(FadeOut(arc))
            self.wait()
            if arc is arc1:
                self.add(frame, frame_height_growth)
            elif arc is arc2:
                self.play(dot.move_to, neg_i_point)
        self.wait(2)
        self.play(*map(ShowCreation, neg_one_tangent))
        self.wait()
        self.play(FadeOut(neg_one_tangent))
        self.wait(2)
        frame.clear_updaters()
        self.play(
            frame.set_height, FRAME_HEIGHT,
            self.lines.set_stroke, {"width": 0.5},
            FadeOut(self.dots),
            FadeOut(dot),
            run_time=2,
        )

    def remind_that_most_points_are_not_projected(self):
        plane = self.plane
        circle = self.circle

        sample_values = [0, complex(1, 1), complex(-2, -1)]
        sample_points = [
            plane.number_to_point(value)
            for value in sample_values
        ]
        sample_dots = VGroup(*[Dot(p) for p in sample_points])
        sample_dots.set_fill(GREEN)

        self.play(
            FadeOut(self.lines),
            Restore(circle),
        )

        for value, dot in zip(sample_values, sample_dots):
            cross = Cross(dot)
            cross.scale(2)
            label = Integer(value)
            if value is sample_values[1]:
                label.next_to(dot, UL, SMALL_BUFF)
            else:
                label.next_to(dot, UR, SMALL_BUFF)
            self.play(
                FadeInFromLarge(dot, 3),
                FadeInFromDown(label)
            )
            self.play(ShowCreation(cross))
            self.play(*map(FadeOut, [dot, cross, label]))
        self.wait()
        self.play(
            FadeIn(self.lines),
            MoveToTarget(circle, run_time=2),
        )
        self.wait()

    # Helpers
    def get_plane(self):
        plane = ComplexPlane(
            unit_size=2,
            color=GREY,
            secondary_color=DARK_GREY,
            x_radius=FRAME_WIDTH,
            y_radius=FRAME_HEIGHT,
            stroke_width=2,
        )
        plane.add_coordinates()
        return plane

    def get_circle(self):
        circle = CheckeredCircle(
            **self.circle_config
        )
        circle.set_stroke(width=7)
        return circle

    def get_circle_shadow(self):
        circle_shadow = CheckeredCircle(
            **self.circle_config
        )
        circle_shadow.set_stroke(opacity=0.65)
        return circle_shadow

    def get_sample_circle_points(self):
        plane = self.plane
        n = self.n_sample_points
        rotater = 1
        if hasattr(self, "circle_shadow"):
            point = self.circle_shadow[0].points[0]
            rotater = complex(*point[:2])
            rotater /= abs(rotater)
        numbers = [
            rotater * np.exp(complex(0, TAU * x / n))
            for x in range(-(n // 2) + 1, n // 2)
        ]
        return [
            plane.number_to_point(number)
            for number in numbers
        ]

    def get_lines(self):
        plane = self.plane
        neg_one_point = plane.number_to_point(-1)
        circle_points = self.get_sample_circle_points()

        lines = VGroup(*[
            Line(neg_one_point, point)
            for point in circle_points
        ])
        for line in lines:
            length = line.get_length()
            line.scale(20 / length, about_point=neg_one_point)
            line.set_stroke(YELLOW, np.clip(length, 0, 1))
        return lines

    def project(self, point):
        return stereo_project_point(point, axis=0, r=2)

    def project_mobject(self, mobject):
        return stereo_project(mobject, axis=0, r=2, outer_r=6)


class IntroduceStereographicProjectionLinusView(IntroduceStereographicProjection):
    def construct(self):
        self.describe_individual_points()
        self.point_at_infinity()
        self.show_90_degree_rotation()
        self.talk_through_90_degree_rotation()
        self.show_four_rotations()
        self.show_example_angles()

    def describe_individual_points(self):
        plane = self.plane = self.get_plane()
        circle = self.circle = self.get_circle()
        linus = self.linus = self.get_linus()

        angles = np.arange(-135, 180, 45) * DEGREES
        sample_numbers = [
            np.exp(complex(0, angle))
            for angle in angles
        ]
        sample_points = [
            plane.number_to_point(number)
            for number in sample_numbers
        ]
        projected_sample_points = [
            self.project(point)
            for point in sample_points
        ]
        dots = VGroup(*[Dot() for x in range(8)])
        dots.set_fill(WHITE)
        dots.set_stroke(BLACK, 1)

        def generate_dot_updater(circle_piece):
            return lambda d: d.move_to(circle_piece.points[0])

        for dot, piece in zip(dots, circle[::(len(circle) // 8)]):
            dot.add_updater(generate_dot_updater(piece))

        stot = "(\\sqrt{2} / 2)"
        labels_tex = [
            "-{}-{}i".format(stot, stot),
            "-i",
            "{}-{}i".format(stot, stot),
            "1",
            "{}+{}i".format(stot, stot),
            "i",
            "-{}+{}i".format(stot, stot),
        ]
        labels = VGroup(*[TexMobject(tex) for tex in labels_tex])
        vects = it.cycle([RIGHT, RIGHT])
        arrows = VGroup()
        for label, point, vect in zip(labels, projected_sample_points, vects):
            arrow = Arrow(vect, ORIGIN)
            arrow.next_to(point, vect, 2 * SMALL_BUFF)
            arrows.add(arrow)
            label.set_stroke(width=0, background=True)
            if stot in label.get_tex_string():
                label.set_height(0.5)
            else:
                label.set_height(0.5)
                label.set_stroke(WHITE, 2, background=True)
            label.next_to(arrow, vect, SMALL_BUFF)

        frame = self.camera_frame
        frame.set_height(12)

        self.add(linus)
        self.add(circle, *dots)
        self.play(
            ApplyFunction(self.project_mobject, circle),
            run_time=2
        )
        self.play(linus.change, "confused")
        self.wait()
        for i in [1, 0]:
            self.play(
                LaggedStartMap(GrowArrow, arrows[i::2]),
                LaggedStartMap(Write, labels[i::2])
            )
            self.play(Blink(linus))

        self.dots = dots

    def point_at_infinity(self):
        circle = self.circle
        linus = self.linus

        label = TextMobject(
            "$-1$ is \\\\ at $\\pm \\infty$"
        )
        label.scale(1.5)
        label.next_to(circle, LEFT, buff=1.25)
        arrows = VGroup(*[
            Vector(3 * v + 0.0 * RIGHT).next_to(label, v, buff=MED_LARGE_BUFF)
            for v in [UP, DOWN]
        ])
        arrows.set_color(YELLOW)

        self.play(
            Write(label),
            linus.change, "awe", label,
            *map(GrowArrow, arrows)
        )

        self.neg_one_label = VGroup(label, arrows)

    def show_90_degree_rotation(self):
        angle_tracker = ValueTracker(0)
        circle = self.circle
        linus = self.linus
        hand = Hand()
        hand.flip()
        one_dot = self.dots[0]
        hand.add_updater(
            lambda h: h.move_to(one_dot.get_center(), RIGHT)
        )

        def update_circle(circle):
            angle = angle_tracker.get_value()
            new_circle = self.get_circle()
            new_circle.rotate(angle)
            self.project_mobject(new_circle)
            circle.become(new_circle)

        circle.add_updater(update_circle)

        self.play(
            FadeIn(hand),
            one_dot.set_fill, RED,
        )
        for angle in 90 * DEGREES, 0:
            self.play(
                ApplyMethod(
                    angle_tracker.set_value, angle,
                    run_time=3,
                ),
                linus.change, "confused", hand
            )
            self.wait()
            self.play(Blink(linus))

        self.hand = hand
        self.angle_tracker = angle_tracker

    def talk_through_90_degree_rotation(self):
        linus = self.linus
        dots = self.dots
        one_dot = dots[0]
        i_dot = dots[2]
        neg_i_dot = dots[-2]

        kwargs1 = {
            "path_arc": -90 * DEGREES,
            "buff": SMALL_BUFF,
        }
        kwargs2 = dict(kwargs1)
        kwargs2["path_arc"] = -40 * DEGREES
        arrows = VGroup(
            Arrow(one_dot, i_dot, **kwargs1),
            Arrow(i_dot, 6 * UP + LEFT, **kwargs2),
            Arrow(6 * DOWN + LEFT, neg_i_dot, **kwargs2),
            Arrow(neg_i_dot, one_dot, **kwargs1)
        )
        arrows.set_stroke(WHITE, 3)
        one_to_i, i_to_neg_1, neg_one_to_neg_i, neg_i_to_one = arrows

        for arrow in arrows:
            self.play(
                ShowCreation(arrow),
                linus.look_at, arrow
            )
            self.wait(2)

        self.arrows = arrows

    def show_four_rotations(self):
        angle_tracker = self.angle_tracker
        linus = self.linus
        hand = self.hand
        linus.add_updater(lambda l: l.look_at(hand))
        linus.add_updater(lambda l: l.eyes.next_to(l.body, UP, 0))

        for angle in np.arange(TAU / 4, 5 * TAU / 4, TAU / 4):
            self.play(
                ApplyMethod(
                    angle_tracker.set_value, angle,
                    run_time=3,
                ),
            )
            self.wait()
        self.play(FadeOut(self.arrows))

    def show_example_angles(self):
        angle_tracker = self.angle_tracker
        angle_tracker.set_value(0)

        for angle in self.example_angles:
            self.play(
                ApplyMethod(
                    angle_tracker.set_value, angle,
                    run_time=4,
                ),
            )
            self.wait()

    #
    def get_linus(self):
        linus = Linus()
        linus.move_to(3 * RIGHT)
        linus.to_edge(DOWN)
        linus.look_at(ORIGIN)
        return linus


class ShowRotationUnderStereographicProjection(IntroduceStereographicProjection):
    def construct(self):
        self.setup_plane()
        self.apply_projection()
        self.show_90_degree_rotation()
        self.talk_through_90_degree_rotation()
        self.show_four_rotations()
        self.show_example_angles()

    def apply_projection(self):
        plane = self.plane
        circle = self.circle
        neg_one_point = plane.number_to_point(-1)
        neg_one_dot = Dot(neg_one_point)
        neg_one_dot.set_fill(YELLOW)

        lines = always_redraw(self.get_lines)

        def generate_dot_updater(circle_piece):
            return lambda d: d.move_to(circle_piece.points[0])

        for circ, color in [(self.circle_shadow, RED), (self.circle, WHITE)]:
            for piece in circ[::(len(circ) // 8)]:
                dot = Dot(color=color)
                dot.set_fill(opacity=circ.get_stroke_opacity())
                dot.add_updater(generate_dot_updater(piece))
                self.add(dot)

        self.add(lines, neg_one_dot)
        self.play(*map(ShowCreation, lines))
        self.play(
            ApplyFunction(self.project_mobject, circle),
            lines.set_stroke, {"width": 0.5},
            run_time=2
        )
        self.play(
            self.camera_frame.set_height, 12,
            run_time=2
        )
        self.wait()

    def show_90_degree_rotation(self):
        circle = self.circle
        circle_shadow = self.circle_shadow

        def get_rotated_one_point():
            return circle_shadow[0].points[0]

        def get_angle():
            return angle_of_vector(get_rotated_one_point())

        self.get_angle = get_angle

        one_dot = Dot(color=RED)
        one_dot.add_updater(
            lambda m: m.move_to(get_rotated_one_point())
        )
        hand = Hand()
        hand.move_to(one_dot.get_center(), LEFT)

        def update_circle(circle):
            new_circle = self.get_circle()
            new_circle.rotate(get_angle())
            self.project_mobject(new_circle)
            circle.become(new_circle)

        circle.add_updater(update_circle)

        self.add(one_dot, hand)
        hand.add_updater(
            lambda h: h.move_to(one_dot.get_center(), LEFT)
        )
        self.play(
            FadeInFrom(hand, RIGHT),
            FadeInFromLarge(one_dot, 3),
        )
        for angle in 90 * DEGREES, -90 * DEGREES:
            self.play(
                Rotate(circle_shadow, angle, run_time=3),
            )
            self.wait(2)

    def talk_through_90_degree_rotation(self):
        plane = self.plane
        points = [
            plane.number_to_point(z)
            for z in [1, complex(0, 1), -1, complex(0, -1)]
        ]
        arrows = VGroup()
        for p1, p2 in adjacent_pairs(points):
            arrow = Arrow(
                p1, p2, path_arc=180 * DEGREES,
            )
            arrow.set_stroke(LIGHT_GREY, width=3)
            arrow.tip.set_fill(LIGHT_GREY)
            arrows.add(arrow)

        for arrow in arrows:
            self.play(ShowCreation(arrow))
            self.wait(2)

        self.arrows = arrows

    def show_four_rotations(self):
        circle_shadow = self.circle_shadow
        for x in range(4):
            self.play(
                Rotate(circle_shadow, TAU / 4, run_time=3)
            )
            self.wait()
        self.play(FadeOut(self.arrows))

    def show_example_angles(self):
        circle_shadow = self.circle_shadow
        angle_label = Integer(0, unit="^\\circ")
        angle_label.scale(1.5)
        angle_label.next_to(
            circle_shadow.get_top(), UR,
        )

        self.play(FadeInFromDown(angle_label))
        self.add(angle_label)
        for angle in self.example_angles:
            d_angle = angle - self.get_angle()
            self.play(
                Rotate(circle_shadow, d_angle),
                ChangingDecimal(
                    angle_label,
                    lambda a: (self.get_angle() % TAU) / DEGREES
                ),
                run_time=4
            )
            self.wait()


class WriteITimesW(Scene):
    def construct(self):
        mob = TexMobject("i", "\\cdot", "w")
        mob[0].set_color(GREEN)
        mob.scale(3)
        self.play(Write(mob))
        self.wait()


class IntroduceFelix(PiCreatureScene, SpecialThreeDScene):
    def setup(self):
        PiCreatureScene.setup(self)
        SpecialThreeDScene.setup(self)

    def construct(self):
        self.introduce_felix()
        self.add_plane()
        self.show_in_three_d()

    def introduce_felix(self):
        felix = self.felix = self.pi_creature

        arrow = Vector(DL, color=WHITE)
        arrow.next_to(felix, UR)

        label = TextMobject("Felix the Flatlander")
        label.next_to(arrow.get_start(), UP)

        self.add(felix)
        self.play(
            felix.change, "wave_1", label,
            Write(label),
            GrowArrow(arrow),
        )
        self.play(Blink(felix))
        self.play(felix.change, "thinking", label)

        self.to_fade = VGroup(label, arrow)

    def add_plane(self):
        plane = NumberPlane(y_radius=10)
        axes = self.get_axes()
        to_fade = self.to_fade
        felix = self.felix

        self.add(axes, plane, felix)
        self.play(
            ShowCreation(axes),
            ShowCreation(plane),
            FadeOut(to_fade),
        )
        self.wait()

        self.plane = plane
        self.axes = axes

    def show_in_three_d(self):
        felix = self.pi_creature
        plane = self.plane
        axes = self.axes

        # back_plane = Rectangle().replace(plane, stretch=True)
        # back_plane.shade_in_3d = True
        # back_plane.set_fill(LIGHT_GREY, opacity=0.5)
        # back_plane.set_sheen(1, UL)
        # back_plane.shift(SMALL_BUFF * IN)
        # back_plane.set_stroke(width=0)
        # back_plane = ParametricSurface(
        #     lambda u, v: u * RIGHT + v * UP
        # )
        # back_plane.replace(plane, stretch=True)
        # back_plane.set_stroke(width=0)
        # back_plane.set_fill(LIGHT_GREY, opacity=0.5)

        sphere = self.get_sphere()
        # sphere.set_fill(BLUE_E, 0.5)

        self.move_camera(
            phi=70 * DEGREES,
            theta=-110 * DEGREES,
            added_anims=[FadeOut(plane)],
            run_time=2
        )
        self.begin_ambient_camera_rotation()
        self.add(axes, sphere)
        self.play(
            Write(sphere),
            felix.change, "confused"
        )
        self.wait()

        axis_angle_pairs = [
            (RIGHT, 90 * DEGREES),
            (OUT, 45 * DEGREES),
            (UR + OUT, 120 * DEGREES),
            (RIGHT, 90 * DEGREES),
        ]
        for axis, angle in axis_angle_pairs:
            self.play(Rotate(
                sphere, angle=angle, axis=axis,
                run_time=2,
            ))
        self.wait(2)

    #
    def create_pi_creature(self):
        return Felix().move_to(4 * LEFT + 2 * DOWN)


class IntroduceThreeDNumbers(SpecialThreeDScene):
    CONFIG = {
        "camera_config": {
            "exponential_projection": False,
        }
    }

    def construct(self):
        self.add_third_axis()
        self.reorient_axes()
        self.show_example_number()

    def add_third_axis(self):
        plane = ComplexPlane(
            y_radius=FRAME_WIDTH / 4,
            unit_size=2,
            secondary_line_ratio=1,
        )
        plane.add_coordinates()
        title = TextMobject("Complex Plane")
        title.scale(1.8)
        title.add_background_rectangle()
        title.to_corner(UL, buff=MED_SMALL_BUFF)

        real_line = Line(LEFT, RIGHT).set_width(FRAME_WIDTH)
        imag_line = Line(DOWN, UP).set_height(FRAME_HEIGHT)
        real_line.set_color(YELLOW)
        imag_line.set_color(RED)

        for label in plane.coordinate_labels:
            label.remove(label.background_rectangle)
            label.shift(SMALL_BUFF * IN)
            self.add_fixed_orientation_mobjects(label)
        reals = plane.coordinate_labels[:7]
        imags = plane.coordinate_labels[7:]

        self.add(plane, title)
        for line, group in (real_line, reals), (imag_line, imags):
            line.set_stroke(width=5)
            self.play(
                ShowCreationThenDestruction(line),
                LaggedStartMap(
                    Indicate, group,
                    rate_func=there_and_back,
                    color=line.get_color(),
                ),
                run_time=2,
            )

        self.plane = plane
        self.title = title

    def reorient_axes(self):
        z_axis = NumberLine(unit_size=2)
        z_axis.rotate(90 * DEGREES, axis=DOWN)
        z_axis.rotate(90 * DEGREES, axis=OUT)
        z_axis.set_color(WHITE)
        z_axis_top = Line(
            z_axis.number_to_point(0),
            z_axis.get_end(),
        )
        z_axis_top.match_style(z_axis)

        z_unit_line = Line(
            z_axis.number_to_point(0),
            z_axis.number_to_point(1),
            color=RED,
            stroke_width=5
        )

        j_labels = VGroup(
            TexMobject("-2j"),
            TexMobject("-j"),
            TexMobject("j"),
            TexMobject("2j"),
        )
        for label, num in zip(j_labels, [-2, -1, 1, 2]):
            label.next_to(z_axis.number_to_point(num), RIGHT, MED_SMALL_BUFF)
            self.add_fixed_orientation_mobjects(label)

        plane = self.plane

        colored_ = Line(LEFT, RIGHT).set_width(FRAME_WIDTH)
        y_line = Line(DOWN, UP).set_height(FRAME_WIDTH)
        z_line = Line(IN, OUT).set_depth(FRAME_WIDTH)
        colored_.set_stroke(GREEN, 5)
        y_line.set_stroke(RED, 5)
        z_line.set_stroke(YELLOW, 5)
        colored_coord_lines = VGroup(colored_, y_line, z_line)

        coord_lines = VGroup(
            plane.axes[0], plane.axes[1], z_axis,
        )
        for i1, i2 in [(0, 2), (1, 0), (2, 1)]:
            coord_lines[i1].target = coord_lines[i2].copy()

        new_title = TextMobject("Imaginary plane")
        new_title.replace(self.title)
        new_title.move_to(self.title)

        self.add(z_axis, plane, z_axis_top)
        self.move_camera(
            phi=70 * DEGREES,
            theta=-80 * DEGREES,
            added_anims=[
                plane.set_stroke, {"opacity": 0.5},
            ],
            run_time=2,
        )
        self.begin_ambient_camera_rotation(rate=0.02)
        self.wait()
        self.play(FadeInFrom(j_labels, IN))
        z_axis.add(j_labels)
        self.play(
            ShowCreationThenDestruction(z_unit_line),
            run_time=2
        )
        self.wait(4)

        group = VGroup(*it.chain(plane.coordinate_labels, j_labels))
        for label in group:
            label.generate_target()
            axis = np.ones(3)
            label.target.rotate_about_origin(-120 * DEGREES, axis=axis)
            label.target.rotate(120 * DEGREES, axis=axis)
        for y, label in zip([-2, -1, 1, 2], j_labels):
            label.target.scale(0.65)
            label.target.next_to(
                2 * y * UP, RIGHT, 2 * SMALL_BUFF
            )
        self.remove(z_axis_top)
        self.play(
            LaggedStartMap(MoveToTarget, group, lag_ratio=0.8),
            LaggedStartMap(MoveToTarget, coord_lines, lag_ratio=0.8),
            FadeOut(self.title),
            FadeIn(new_title),
            run_time=3
        )
        self.add(z_axis_top)
        self.wait(3)
        for line, wait in zip(colored_coord_lines, [False, True, True]):
            self.play(
                ShowCreationThenDestruction(line),
                run_time=2
            )
            if wait:
                self.wait()

    def show_example_number(self):
        x, y, z = coords = 2 * np.array([1.5, -1, 1.25])
        dot = Sphere(radius=0.05)
        dot.set_fill(LIGHT_GREY)
        dot.move_to(coords)
        point_line = Line(ORIGIN, coords)
        point_line.set_stroke(WHITE, 1)

        z_line = Line(ORIGIN, z * OUT)
        x_line = Line(z_line.get_end(), z_line.get_end() + x * RIGHT)
        y_line = Line(x_line.get_end(), x_line.get_end() + y * UP)

        x_line.set_stroke(GREEN, 5)
        y_line.set_stroke(RED, 5)
        z_line.set_stroke(YELLOW, 5)
        lines = VGroup(z_line, x_line, y_line)

        number_label = TexMobject(
            str(z / 2), "+", str(x / 2), "i", "+", str(y / 2), "j",
            tex_to_color_map={
                str(z / 2): YELLOW,
                str(x / 2): GREEN,
                str(y / 2): RED,
            }
        )
        number_label.next_to(ORIGIN, RIGHT, LARGE_BUFF)
        number_label.to_edge(UP)

        self.add_fixed_in_frame_mobjects(number_label)
        self.play(
            ShowCreation(point_line),
            FadeInFrom(dot, -coords),
            FadeInFromDown(number_label)
        )
        self.wait()
        for num, line in zip([z, x, y], lines):
            tex = number_label.get_part_by_tex(str(num / 2))
            rect = SurroundingRectangle(tex)
            rect.set_color(WHITE)

            self.add_fixed_in_frame_mobjects(rect)
            self.play(
                ShowCreation(line),
                ShowCreationThenDestruction(rect),
                run_time=2
            )
            self.remove_fixed_in_frame_mobjects(rect)
            self.wait()
        self.wait(15)


class MentionImpossibilityOf3dNumbers(TeacherStudentsScene):
    def construct(self):
        equations = VGroup(
            TexMobject("ij = ?"),
            TexMobject("ji = ?"),
        )
        equations.arrange(RIGHT, buff=LARGE_BUFF)
        equations.scale(1.5)
        equations.to_edge(UP)
        self.add(equations)

        why = TextMobject("Why not?")
        why.next_to(self.students[1], UP)

        self.teacher_says(
            "Such 3d numbers \\\\ have no good \\\\ multiplication rule",
            bubble_kwargs={"width": 4, "height": 3},
        )
        self.change_all_student_modes("confused")
        self.wait(2)
        self.play(
            self.students[1].change, "maybe",
            FadeInFromLarge(why),
        )
        self.wait(4)


class SphereExamplePointsDecimal(Scene):
    CONFIG = {
        "point_rotation_angle_axis_pairs": [
            (45 * DEGREES, DOWN),
            (120 * DEGREES, OUT),
            (35 * DEGREES, rotate_vector(RIGHT, 30 * DEGREES)),
            (90 * DEGREES, IN),
        ]
    }

    def construct(self):
        decimals = VGroup(*[
            DecimalNumber(
                0,
                num_decimal_places=3,
                color=color,
                include_sign=True,
                edge_to_fix=RIGHT,
            )
            for color in [YELLOW, GREEN, RED]
        ])
        number_label = VGroup(
            decimals[0], TexMobject("+"),
            decimals[1], TexMobject("i"), TexMobject("+"),
            decimals[2], TexMobject("j"),
        )
        number_label.arrange(RIGHT, buff=SMALL_BUFF)
        number_label.to_corner(UL)

        point = VectorizedPoint(OUT)

        def generate_decimal_updater(decimal, index):
            shifted_i = (index - 1) % 3
            decimal.add_updater(lambda d: d.set_value(
                point.get_location()[shifted_i]
            ))
            return decimal

        for i, decimal in enumerate(decimals):
            self.add(generate_decimal_updater(decimal, i))

        decimal_braces = VGroup()
        for decimal, char in zip(decimals, "wxy"):
            brace = Brace(decimal, DOWN, buff=SMALL_BUFF)
            label = brace.get_tex(char, buff=SMALL_BUFF)
            label.match_color(decimal)
            brace.add(label)
            decimal_braces.add(brace)

        equation = TexMobject(
            "w^2 + x^2 + y^2 = 1",
            tex_to_color_map={
                "w": YELLOW,
                "x": GREEN,
                "y": RED,
            }
        )
        equation.next_to(decimal_braces, DOWN, MED_LARGE_BUFF)

        self.add(number_label)
        self.add(decimal_braces)
        self.add(equation)

        pairs = self.point_rotation_angle_axis_pairs
        for angle, axis in pairs:
            self.play(
                Rotate(point, angle, axis=axis, about_point=ORIGIN),
                run_time=2
            )
            self.wait()


class TwoDStereographicProjection(IntroduceFelix):
    CONFIG = {
        "camera_config": {
            "exponential_projection": False,
        },
        "sphere_sample_point_u_range": np.arange(
            0, PI, PI / 16,
        ),
        "sphere_sample_point_v_range": np.arange(
            0, TAU, TAU / 16,
        ),
        "n_sample_rotation_cycles": 2,
        "lift_labels": True,
    }

    def construct(self):
        self.add_parts()
        self.talk_through_sphere()
        self.draw_projection_lines()
        self.show_point_at_infinity()
        self.show_a_few_rotations()

    def add_parts(self, run_time=1):
        felix = self.felix = self.pi_creature
        felix.shift(1.5 * DL)
        axes = self.axes = self.get_axes()
        sphere = self.sphere = self.get_sphere()

        c2p = axes.coords_to_point
        labels = self.labels = VGroup(
            TexMobject("i").next_to(c2p(1, 0, 0), DR, SMALL_BUFF),
            TexMobject("-i").next_to(c2p(-1, 0, 0), DL, SMALL_BUFF),
            TexMobject("j").next_to(c2p(0, 1, 0), UL, SMALL_BUFF),
            TexMobject("-j").next_to(c2p(0, -1, 0), DL, SMALL_BUFF),
            TexMobject("1").rotate(
                90 * DEGREES, RIGHT,
            ).next_to(c2p(0, 0, 1), RIGHT + OUT, SMALL_BUFF),
            TexMobject("-1").rotate(
                90 * DEGREES, RIGHT,
            ).next_to(c2p(0, 0, -1), RIGHT + IN, SMALL_BUFF),
        )
        if self.lift_labels:
            for sm in labels[:4].family_members_with_points():
                sm.add(VectorizedPoint(
                    0.25 * DOWN + 0.25 * OUT
                ))
        labels.set_stroke(width=0, background=True)
        for submob in labels.get_family():
            submob.shade_in_3d = True

        self.add(felix, axes, sphere, labels)
        self.move_camera(
            **self.get_default_camera_position(),
            run_time=run_time
        )
        self.begin_ambient_camera_rotation(rate=0.01)
        self.play(
            felix.change, "pondering", sphere,
            run_time=run_time,
        )

    def talk_through_sphere(self):
        point = VectorizedPoint(OUT)
        arrow = Vector(IN, shade_in_3d=True)
        arrow.set_fill(PINK)
        arrow.set_stroke(BLACK, 1)

        def get_dot():
            dot = Sphere(radius=0.05, u_max=PI / 2)
            dot.set_fill(PINK)
            dot.set_stroke(width=0)
            dot.move_to(2.05 * OUT)
            dot.apply_matrix(
                z_to_vector(normalize(point.get_location())),
                about_point=ORIGIN
            )
            return dot

        dot = get_dot()
        dot.add_updater(
            lambda d: d.become(get_dot())
        )

        def update_arrow(arrow):
            target_point = 2.1 * point.get_location()
            rot_matrix = np.dot(
                z_to_vector(normalize(target_point)),
                np.linalg.inv(
                    z_to_vector(normalize(-arrow.get_vector()))
                )
            )
            arrow.apply_matrix(rot_matrix)
            arrow.shift(target_point - arrow.get_end())
            return arrow
        arrow.add_updater(update_arrow)

        self.add(self.sphere, dot, arrow)
        pairs = SphereExamplePointsDecimal.CONFIG.get(
            "point_rotation_angle_axis_pairs"
        )
        for angle, axis in pairs:
            self.play(
                Rotate(point, angle, axis=axis, about_point=ORIGIN),
                run_time=2
            )
            self.wait()
        self.play(FadeOut(dot), FadeOut(arrow))

    def draw_projection_lines(self):
        sphere = self.sphere
        axes = self.axes
        radius = sphere.get_width() / 2

        neg_one_point = axes.coords_to_point(0, 0, -1)
        neg_one_dot = Dot(
            neg_one_point,
            color=YELLOW,
            shade_in_3d=True
        )

        xy_plane = StereoProjectedSphere(
            u_max=15 * PI / 16,
            **self.sphere_config
        )
        xy_plane.set_fill(WHITE, 0.25)
        xy_plane.set_stroke(width=0)

        point_mob = VectorizedPoint(2 * OUT)
        point_mob.add_updater(
            lambda m: m.move_to(radius * normalize(m.get_center()))
        )
        point_mob.move_to([1, -1, 1])
        point_mob.update(0)

        def get_projection_line(sphere_point):
            to_sphere = Line(neg_one_point, sphere_point)
            to_plane = Line(
                sphere_point,
                self.project_point(sphere_point)
            )
            line = VGroup(to_sphere, to_plane)
            line.set_stroke(YELLOW, 3)
            for submob in line:
                submob.shade_in_3d = True
            return line

        def get_sphere_dot(sphere_point):
            dot = Dot()
            dot.set_shade_in_3d(True)
            dot.set_fill(PINK)
            dot.shift(OUT)
            dot.apply_matrix(
                z_to_vector(sphere_point),
                about_point=ORIGIN,
            )
            dot.move_to(1.01 * sphere_point)
            dot.add(VectorizedPoint(5 * sphere_point))
            return dot

        def get_projection_dot(sphere_point):
            projection = self.project_point(sphere_point)
            dot = Dot(projection, shade_in_3d=True)
            dot.add(VectorizedPoint(dot.get_center() + 0.1 * OUT))
            dot.set_fill(WHITE)
            return dot

        point = point_mob.get_location()
        dot = get_sphere_dot(point)
        line = get_projection_line(point)
        projection_dot = get_projection_dot(point)

        sample_points = [
            radius * sphere.func(u, v)
            for u in self.sphere_sample_point_u_range
            for v in self.sphere_sample_point_v_range
        ]

        lines = VGroup(*[get_projection_line(p) for p in sample_points])
        lines.set_stroke(width=1)
        north_lines = lines[:len(lines) // 2]
        south_lines = lines[len(lines) // 2:]

        self.add(xy_plane, sphere)
        self.play(Write(xy_plane))
        self.wait(2)
        self.play(sphere.set_fill, BLUE_E, 0.5)
        self.play(FadeInFromLarge(dot))
        self.play(
            FadeIn(neg_one_dot),
            ShowCreation(line),
        )
        self.wait(2)
        self.play(ReplacementTransform(
            dot.copy(), projection_dot
        ))

        def get_point():
            return 2 * normalize(point_mob.get_location())

        dot.add_updater(
            lambda d: d.become(get_sphere_dot(get_point()))
        )
        line.add_updater(
            lambda l: l.become(get_projection_line(get_point()))
        )
        projection_dot.add_updater(
            lambda d: d.become(get_projection_dot(get_point()))
        )

        self.play(
            point_mob.move_to,
            radius * normalize(np.array([1, -1, -1])),
            run_time=3
        )
        self.move_camera(
            theta=-150 * DEGREES,
            run_time=3
        )
        self.add(axes, sphere, xy_plane, dot, line)
        for point in np.array([-2, 1, -0.5]), np.array([-0.01, -0.01, 1]):
            self.play(
                point_mob.move_to,
                radius * normalize(point),
                run_time=3
            )
        self.wait(2)

        # Project norther hemisphere
        north_hemisphere = self.get_sphere()
        n = len(north_hemisphere)
        north_hemisphere.remove(*north_hemisphere[n // 2:])
        north_hemisphere.generate_target()
        self.project_mobject(north_hemisphere.target)
        north_hemisphere.set_fill(opacity=0.8)

        self.play(
            LaggedStartMap(ShowCreation, north_lines),
            FadeIn(north_hemisphere)
        )
        self.play(
            MoveToTarget(north_hemisphere),
            run_time=3,
            rate_func=lambda t: smooth(0.99 * t)
        )
        self.play(FadeOut(north_lines))
        self.wait(2)

        # Unit circle
        circle = Sphere(
            radius=2.01,
            u_min=PI / 2 - 0.01,
            u_max=PI / 2 + 0.01,
            resolution=(1, 24),
        )
        for submob in circle:
            submob.add(VectorizedPoint(1.5 * submob.get_center()))
        circle.set_fill(YELLOW)
        circle_path = Circle(radius=2)
        circle_path.rotate(-90 * DEGREES)

        self.play(FadeInFromLarge(circle))
        self.play(point_mob.move_to, circle_path.points[0])
        self.play(MoveAlongPath(point_mob, circle_path, run_time=6))
        self.move_camera(
            phi=0,
            theta=-90 * DEGREES,
            rate_func=there_and_back_with_pause,
            run_time=6,
        )
        self.play(point_mob.move_to, OUT)
        self.wait()

        # Southern hemisphere
        south_hemisphere = self.get_sphere()
        n = len(south_hemisphere)
        south_hemisphere.remove(*south_hemisphere[:n // 2])
        south_hemisphere.remove(
            *south_hemisphere[-sphere.resolution[1]:]
        )
        south_hemisphere.generate_target()
        self.project_mobject(south_hemisphere.target)
        south_hemisphere.set_fill(opacity=0.8)
        south_hemisphere.target[-sphere.resolution[1] // 2:].set_fill(
            opacity=0
        )

        self.play(
            LaggedStartMap(ShowCreation, south_lines),
            FadeIn(south_hemisphere)
        )
        self.play(
            MoveToTarget(south_hemisphere),
            FadeOut(south_lines),
            FadeOut(xy_plane),
            run_time=3,
            rate_func=lambda t: smooth(0.99 * t)
        )
        self.wait(3)

        self.projected_sphere = VGroup(
            north_hemisphere,
            south_hemisphere,
        )
        self.equator = circle
        self.point_mob = point_mob

    def show_point_at_infinity(self):
        points = list(compass_directions(
            12, start_vect=rotate_vector(RIGHT, 3.25 * DEGREES)
        ))
        points.pop(7)
        points.pop(2)
        arrows = VGroup(*[
            Arrow(6 * p, 11 * p)
            for p in points
        ])
        arrows.set_fill(RED)
        arrows.set_stroke(RED, 5)
        neg_ones = VGroup(*[
            TexMobject("-1").next_to(arrow.get_start(), -p)
            for p, arrow in zip(points, arrows)
        ])
        neg_ones.set_stroke(width=0, background=True)

        sphere_arcs = VGroup()
        for angle in np.arange(0, TAU, TAU / 12):
            arc = Arc(PI, radius=2)
            arc.set_stroke(RED)
            arc.rotate(PI / 2, axis=DOWN, about_point=ORIGIN)
            arc.rotate(angle, axis=OUT, about_point=ORIGIN)
            sphere_arcs.add(arc)
        sphere_arcs.set_stroke(RED)

        self.play(
            LaggedStartMap(GrowArrow, arrows),
            LaggedStartMap(Write, neg_ones)
        )
        self.wait(3)
        self.play(
            FadeOut(self.projected_sphere),
            FadeOut(arrows),
            FadeOut(neg_ones),
        )
        for x in range(2):
            self.play(
                ShowCreationThenDestruction(
                    sphere_arcs,
                    lag_ratio=0,
                    run_time=3,
                )
            )

    def show_a_few_rotations(self):
        sphere = self.sphere
        felix = self.felix
        point_mob = self.point_mob
        point_mob.add_updater(
            lambda m: m.move_to(sphere.get_all_points()[0])
        )
        coord_point_mobs = VGroup(
            VectorizedPoint(RIGHT),
            VectorizedPoint(UP),
            VectorizedPoint(OUT),
        )
        for pm in coord_point_mobs:
            pm.shade_in_3d = True

        def get_rot_matrix():
            return np.array([
                pm.get_location()
                for pm in coord_point_mobs
            ]).T

        def get_projected_sphere():
            result = StereoProjectedSphere(
                get_rot_matrix(),
                max_r=10,
                **self.sphere_config,
            )
            result.set_fill(opacity=0.2)
            result.fade_far_out_submobjects(max_r=32)
            for submob in result:
                if submob.get_center()[1] < -11:
                    submob.fade(1)
            return result

        projected_sphere = get_projected_sphere()
        projected_sphere.add_updater(
            lambda m: m.become(get_projected_sphere())
        )

        def get_projected_equator():
            equator = CheckeredCircle(
                n_pieces=24,
                radius=2,
            )
            for submob in equator.get_family():
                submob.shade_in_3d = True
            equator.set_stroke(YELLOW, 5)
            equator.apply_matrix(get_rot_matrix())
            self.project_mobject(equator)
            return equator

        projected_equator = get_projected_equator()
        projected_equator.add_updater(
            lambda m: m.become(get_projected_equator())
        )

        self.add(sphere, projected_sphere)
        self.move_camera(phi=60 * DEGREES)
        self.play(
            sphere.set_fill_by_checkerboard,
            BLUE_E, BLUE_D, {"opacity": 0.8},
            FadeIn(projected_sphere)
        )
        sphere.add(coord_point_mobs)
        sphere.add(self.equator)
        self.add(projected_equator)
        pairs = self.get_sample_rotation_angle_axis_pairs()
        for x in range(self.n_sample_rotation_cycles):
            for angle, axis in pairs:
                self.play(
                    Rotate(
                        sphere, angle=angle, axis=axis,
                        about_point=ORIGIN,
                        run_time=3,
                    ),
                    felix.change, "confused",
                )
                self.wait()

        self.projected_sphere = projected_sphere

    #
    def project_mobject(self, mobject):
        return stereo_project(mobject, axis=2, r=2, outer_r=20)

    def project_point(self, point):
        return stereo_project_point(point, axis=2, r=2)

    def get_sample_rotation_angle_axis_pairs(self):
        return SphereExamplePointsDecimal.CONFIG.get(
            "point_rotation_angle_axis_pairs"
        )


class FelixViewOfProjection(TwoDStereographicProjection):
    CONFIG = {}

    def construct(self):
        self.add_axes()
        self.show_a_few_rotations()

    def add_axes(self):
        axes = Axes(
            number_line_config={
                "unit_size": 2,
                "color": WHITE,
            }
        )
        labels = VGroup(
            TexMobject("i"),
            TexMobject("-i"),
            TexMobject("j"),
            TexMobject("-j"),
            TexMobject("1"),
        )
        coords = [(1, 0), (-1, 0), (0, 1), (0, -1), (0, 0)]
        vects = [DOWN, DOWN, RIGHT, RIGHT, 0.25 * DR]
        for label, coords, vect in zip(labels, coords, vects):
            point = axes.coords_to_point(*coords)
            label.next_to(point, vect, buff=MED_SMALL_BUFF)

        self.add(axes, labels)
        self.pi_creature.change("confused")

    def show_a_few_rotations(self):
        felix = self.pi_creature
        coord_point_mobs = VGroup([
            VectorizedPoint(point)
            for point in [RIGHT, UP, OUT]
        ])

        def get_rot_matrix():
            return np.array([
                pm.get_location()
                for pm in coord_point_mobs
            ]).T

        def get_projected_sphere():
            return StereoProjectedSphere(
                get_rot_matrix(),
                **self.sphere_config,
            )

        def get_projected_equator():
            equator = Circle(radius=2, num_anchors=24)
            equator.set_stroke(YELLOW, 5)
            equator.apply_matrix(get_rot_matrix())
            self.project_mobject(equator)
            return equator

        projected_sphere = get_projected_sphere()
        projected_sphere.add_updater(
            lambda m: m.become(get_projected_sphere())
        )

        equator = get_projected_equator()
        equator.add_updater(
            lambda m: m.become(get_projected_equator())
        )

        dot = Dot(color=PINK)
        dot.add_updater(
            lambda d: d.move_to(
                self.project_point(
                    np.dot(2 * OUT, get_rot_matrix().T)
                )
            )
        )
        hand = Hand()
        hand.add_updater(
            lambda h: h.move_to(dot.get_center(), LEFT)
        )
        felix.add_updater(lambda f: f.look_at(dot))

        self.add(projected_sphere)
        self.add(equator)
        self.add(dot)
        self.add(hand)

        pairs = self.get_sample_rotation_angle_axis_pairs()
        for x in range(self.n_sample_rotation_cycles):
            for angle, axis in pairs:
                self.play(
                    Rotate(
                        coord_point_mobs, angle=angle, axis=axis,
                        about_point=ORIGIN,
                        run_time=3,
                    ),
                )
                self.wait()


class ShowRotationsJustWithReferenceCircles(TwoDStereographicProjection):
    CONFIG = {
        "flat_view": False,
    }

    def construct(self):
        self.add_parts(run_time=1)
        self.begin_ambient_camera_rotation(rate=0.03)
        self.edit_parts()
        self.show_1i_circle()
        self.show_1j_circle()
        self.show_random_circle()
        self.show_rotations()

    def edit_parts(self):
        sphere = self.sphere
        axes = self.axes
        axes.set_stroke(width=1)
        xy_plane = StereoProjectedSphere(u_max=15 * PI / 16)
        xy_plane.set_fill(WHITE, 0.2)
        xy_plane.set_stroke(width=0, opacity=0)

        self.add(xy_plane, sphere)
        self.play(
            FadeIn(xy_plane),
            sphere.set_fill, BLUE_E, {"opacity": 0.2},
            sphere.set_stroke, {"width": 0.1, "opacity": 0.5}
        )

    def show_1i_circle(self):
        axes = self.axes

        circle = self.get_circle(GREEN_E, GREEN)
        circle.rotate(TAU / 4, RIGHT)
        circle.rotate(TAU / 4, DOWN)

        projected = self.get_projected_circle(circle)

        labels = VGroup(*map(TexMobject, ["0", "2i", "3i"]))
        labels.set_shade_in_3d(True)
        if self.flat_view:
            labels.fade(1)
        for label, x in zip(labels, [0, 2, 3]):
            label.next_to(
                axes.coords_to_point(x, 0, 0), DR, SMALL_BUFF
            )

        self.play(ShowCreation(circle, run_time=3))
        self.wait()
        self.play(ReplacementTransform(
            circle.copy(), projected,
            run_time=3
        ))
        # self.axes.x_axis.pieces.set_stroke(width=0)
        self.wait(7)
        self.move_camera(
            phi=60 * DEGREES,
        )
        self.play(
            LaggedStartMap(
                FadeInFrom, labels,
                lambda m: (m, UP)
            )
        )
        self.wait(2)
        self.play(FadeOut(labels))

        self.one_i_circle = circle
        self.projected_one_i_circle = projected

    def show_1j_circle(self):
        circle = self.get_circle(RED_E, RED)
        circle.rotate(TAU / 4, DOWN)

        projected = self.get_projected_circle(circle)

        self.move_camera(theta=-170 * DEGREES)
        self.play(ShowCreation(circle, run_time=3))
        self.wait()
        self.play(ReplacementTransform(
            circle.copy(), projected, run_time=3
        ))
        # self.axes.y_axis.pieces.set_stroke(width=0)
        self.wait(3)

        self.one_j_circle = circle
        self.projected_one_j_circle = projected

    def show_random_circle(self):
        sphere = self.sphere

        circle = self.get_circle(BLUE_E, BLUE)
        circle.set_width(2 * sphere.radius * np.sin(30 * DEGREES))
        circle.shift(sphere.radius * np.cos(30 * DEGREES) * OUT)
        circle.rotate(150 * DEGREES, UP, about_point=ORIGIN)

        projected = self.get_projected_circle(circle)

        self.play(ShowCreation(circle, run_time=2))
        self.wait()
        self.play(ReplacementTransform(
            circle.copy(), projected,
            run_time=2
        ))
        self.wait(3)
        self.play(
            FadeOut(circle),
            FadeOut(projected),
        )

    def show_rotations(self):
        sphere = self.sphere
        c1i = self.one_i_circle
        pc1i = self.projected_one_i_circle
        c1j = self.one_j_circle
        pc1j = self.projected_one_j_circle
        cij = self.get_circle(YELLOW_E, YELLOW)
        pcij = self.get_projected_circle(cij)

        circles = VGroup(c1i, c1j, cij)
        x_axis = self.axes.x_axis
        y_axis = self.axes.y_axis

        arrow = Arrow(
            2 * RIGHT, 2 * UP,
            buff=SMALL_BUFF,
            path_arc=PI,
        )
        arrow.set_stroke(LIGHT_GREY, 3)
        arrow.tip.set_fill(LIGHT_GREY)
        arrows = VGroup(arrow, *[
            arrow.copy().rotate(angle, about_point=ORIGIN)
            for angle in np.arange(TAU / 4, TAU, TAU / 4)
        ])
        arrows.rotate(TAU / 4, RIGHT, about_point=ORIGIN)
        arrows.rotate(TAU / 2, OUT, about_point=ORIGIN)
        arrows.rotate(TAU / 4, UP, about_point=ORIGIN)
        arrows.space_out_submobjects(1.2)

        self.play(FadeInFromLarge(cij))
        sphere.add(circles)

        pc1i.add_updater(
            lambda c: c.become(self.get_projected_circle(c1i))
        )
        pc1j.add_updater(
            lambda c: c.become(self.get_projected_circle(c1j))
        )
        pcij.add_updater(
            lambda c: c.become(self.get_projected_circle(cij))
        )
        self.add(pcij)

        # About j-axis
        self.play(ShowCreation(arrows, run_time=3, rate_func=linear))
        self.wait(3)
        for x in range(2):
            y_axis.pieces.set_stroke(width=1)
            self.play(
                Rotate(sphere, 90 * DEGREES, axis=UP),
                run_time=4,
            )
            y_axis.pieces.set_stroke(width=0)
            self.wait(2)

        # About i axis
        self.move_camera(theta=-45 * DEGREES)
        self.play(Rotate(arrows, TAU / 4, axis=OUT))
        self.wait(2)
        for x in range(2):
            x_axis.pieces.set_stroke(width=1)
            self.play(
                Rotate(sphere, -90 * DEGREES, axis=RIGHT),
                run_time=4,
            )
            x_axis.pieces.set_stroke(width=0)
            self.wait(2)
        self.wait(2)

        # About real axis
        self.move_camera(
            theta=-135 * DEGREES,
            added_anims=[FadeOut(arrows)]
        )
        self.ambient_camera_rotation.rate = 0.01
        for x in range(2):
            x_axis.pieces.set_stroke(width=1)
            y_axis.pieces.set_stroke(width=1)
            self.play(
                Rotate(sphere, 90 * DEGREES, axis=OUT),
                run_time=4,
            )
            # x_axis.pieces.set_stroke(width=0)
            # y_axis.pieces.set_stroke(width=0)
            self.wait(2)

    #
    def get_circle(self, *colors):
        sphere = self.sphere
        circle = CheckeredCircle(colors=colors, n_pieces=48)
        circle.set_shade_in_3d(True)
        circle.match_width(sphere)
        if self.flat_view:
            circle[::2].fade(1)

        return circle

    def get_projected_circle(self, circle):
        result = circle.deepcopy()
        self.project_mobject(result)
        result[::2].fade(1)
        for sm in result:
            if sm.get_width() > FRAME_WIDTH:
                sm.fade(1)
            if sm.get_height() > FRAME_HEIGHT:
                sm.fade(1)
        return result


class ReferernceSpheresFelixView(ShowRotationsJustWithReferenceCircles):
    CONFIG = {
        "flat_view": True,
        "lift_labels": False,
    }

    def add_parts(self, **kwargs):
        ShowRotationsJustWithReferenceCircles.add_parts(self, **kwargs)
        one = TexMobject("1")
        one.next_to(ORIGIN, DR, SMALL_BUFF)
        self.add(one)

    def get_default_camera_position(self):
        return {}

    def move_camera(self, **kwargs):
        kwargs["phi"] = 0
        kwargs["theta"] = -90 * DEGREES
        ShowRotationsJustWithReferenceCircles.move_camera(self, **kwargs)

    def begin_ambient_camera_rotation(self, rate):
        self.ambient_camera_rotation = VectorizedPoint()

    def capture_mobjects_in_camera(self, mobjects, **kwargs):
        mobs_on_xy = [
            sm
            for sm in self.camera.extract_mobject_family_members(
                mobjects, only_those_with_points=True
            )
            if abs(sm.get_center()[2]) < 0.001
        ]
        return Scene.capture_mobjects_in_camera(self, mobs_on_xy, **kwargs)


class IntroduceQuaternions(Scene):
    def construct(self):
        self.compare_three_number_systems()
        self.mention_four_perpendicular_axes()
        self.bring_back_complex()
        self.show_components_of_quaternion()

    def compare_three_number_systems(self):
        numbers = self.get_example_numbers()
        labels = VGroup(
            TextMobject("Complex number"),
            TextMobject("Not-actually-a-number-system 3d number"),
            TextMobject("Quaternion"),
        )

        for number, label in zip(numbers, labels):
            label.next_to(number, UP, aligned_edge=LEFT)

            self.play(
                FadeInFromDown(number),
                Write(label),
            )
            self.play(ShowCreationThenFadeAround(
                number[2:],
                surrounding_rectangle_config={"color": BLUE}
            ))
            self.wait()

        shift_size = FRAME_HEIGHT / 2 - labels[2].get_top()[1] - MED_LARGE_BUFF
        self.play(
            numbers.shift, shift_size * UP,
            labels.shift, shift_size * UP,
        )

        self.numbers = numbers
        self.labels = labels

    def mention_four_perpendicular_axes(self):
        number = self.numbers[2]
        three_axes = VGroup(*[
            self.get_simple_axes(label, color)
            for label, color in zip(
                ["i", "j", "k"],
                [GREEN, RED, BLUE],
            )
        ])
        three_axes.arrange(RIGHT, buff=LARGE_BUFF)
        three_axes.next_to(number, DOWN, LARGE_BUFF)

        self.play(LaggedStartMap(FadeInFromLarge, three_axes))
        self.wait(2)

        self.three_axes = three_axes

    def bring_back_complex(self):
        numbers = self.numbers
        labels = self.labels
        numbers[0].move_to(numbers[1], LEFT)
        labels[0].move_to(labels[1], LEFT)
        numbers.remove(numbers[1])
        labels.remove(labels[1])

        group = VGroup(numbers, labels)
        self.play(
            group.to_edge, UP,
            FadeOutAndShift(self.three_axes, DOWN)
        )
        self.wait()

    def show_components_of_quaternion(self):
        quat = self.numbers[-1]
        real_part = quat[0]
        imag_part = quat[2:]
        real_brace = Brace(real_part, DOWN)
        imag_brace = Brace(imag_part, DOWN)
        real_word = TextMobject("Real \\\\ part")
        imag_word = TextMobject("Imaginary \\\\ part")
        scalar_word = TextMobject("Scalar \\\\ part")
        vector_word = TextMobject("``Vector'' \\\\ part")
        for word in real_word, scalar_word:
            word.next_to(real_brace, DOWN, SMALL_BUFF)
        for word in imag_word, vector_word:
            word.next_to(imag_brace, DOWN, SMALL_BUFF)
        braces = VGroup(real_brace, imag_brace)
        VGroup(scalar_word, vector_word).set_color(YELLOW)

        self.play(
            LaggedStartMap(GrowFromCenter, braces),
            LaggedStartMap(
                FadeInFrom, VGroup(real_word, imag_word),
                lambda m: (m, UP)
            )
        )
        self.wait()
        self.play(
            FadeOutAndShift(real_word, DOWN),
            FadeInFrom(scalar_word, DOWN),
        )
        self.wait(2)
        self.play(ChangeDecimalToValue(real_part, 0))
        self.wait()
        self.play(
            FadeOutAndShift(imag_word, DOWN),
            FadeInFrom(vector_word, DOWN)
        )
        self.wait(2)

    #
    def get_example_numbers(self):
        number_2d = VGroup(
            DecimalNumber(3.14),
            TexMobject("+"),
            DecimalNumber(1.59),
            TexMobject("i")
        )
        number_3d = VGroup(
            DecimalNumber(2.65),
            TexMobject("+"),
            DecimalNumber(3.58),
            TexMobject("i"),
            TexMobject("+"),
            DecimalNumber(9.79),
            TexMobject("j"),
        )
        number_4d = VGroup(
            DecimalNumber(3.23),
            TexMobject("+"),
            DecimalNumber(8.46),
            TexMobject("i"),
            TexMobject("+"),
            DecimalNumber(2.64),
            TexMobject("j"),
            TexMobject("+"),
            DecimalNumber(3.38),
            TexMobject("k"),
        )
        numbers = VGroup(number_2d, number_3d, number_4d)
        for number in numbers:
            number.arrange(RIGHT, buff=SMALL_BUFF)
            for part in number:
                if isinstance(part, TexMobject):
                    # part.set_color_by_tex_to_color_map({
                    #     "i": GREEN,
                    #     "j": RED,
                    #     "k": BLUE,
                    # })
                    if part.get_tex_string() == "j":
                        part.shift(0.5 * SMALL_BUFF * DL)
            number[2].set_color(GREEN)
            if len(number) > 5:
                number[5].set_color(RED)
            if len(number) > 8:
                number[8].set_color(BLUE)
        numbers.arrange(
            DOWN, buff=2, aligned_edge=LEFT
        )
        numbers.center()
        numbers.shift(LEFT)
        return numbers

    def get_simple_axes(self, label, color):
        axes = Axes(
            x_min=-2.5,
            x_max=2.5,
            y_min=-2.5,
            y_max=2.5,
        )
        axes.set_height(2.5)
        label_mob = TexMobject(label)
        label_mob.set_color(color)
        label_mob.next_to(axes.coords_to_point(0, 1.5), RIGHT, SMALL_BUFF)
        reals_label_mob = TextMobject("Reals")
        reals_label_mob.next_to(
            axes.coords_to_point(1, 0), DR, SMALL_BUFF
        )
        axes.add(label_mob, reals_label_mob)
        return axes


class SimpleImaginaryQuaternionAxes(SpecialThreeDScene):
    def construct(self):
        self.three_d_axes_config.update({
            "number_line_config": {"unit_size": 2},
            "x_min": -2,
            "x_max": 2,
            "y_min": -2,
            "y_max": 2,
            "z_min": -1.25,
            "z_max": 1.25,
        })
        axes = self.get_axes()
        labels = VGroup(*[
            TexMobject(tex).set_color(color)
            for tex, color in zip(
                ["i", "j", "k"],
                [GREEN, RED, BLUE]
            )
        ])
        labels[0].next_to(axes.coords_to_point(1, 0, 0), DOWN + IN, SMALL_BUFF)
        labels[1].next_to(axes.coords_to_point(0, 1, 0), RIGHT, SMALL_BUFF)
        labels[2].next_to(axes.coords_to_point(0, 0, 1), RIGHT, SMALL_BUFF)

        self.add(axes)
        self.add(labels)
        for label in labels:
            self.add_fixed_orientation_mobjects(label)

        self.move_camera(**self.get_default_camera_position())
        self.begin_ambient_camera_rotation(rate=0.05)
        self.wait(15)


class ShowDotProductCrossProductFromOfQMult(Scene):
    def construct(self):
        v_tex = "\\vec{\\textbf{v}}"
        product = TexMobject(
            "(", "w_1", "+",
            "x_1", "i", "+", "y_1", "j", "+", "z_1", "k", ")"
            "(", "w_2", "+",
            "x_2", "i", "+", "y_2", "j", "+", "z_2", "k", ")",
            "=",
            "(w_1", ",", v_tex + "_1", ")",
            "(w_2", ",", v_tex + "_2", ")",
            "="
        )
        product.set_width(FRAME_WIDTH - 1)

        i1 = product.index_of_part_by_tex("x_1")
        i2 = product.index_of_part_by_tex(")")
        i3 = product.index_of_part_by_tex("x_2")
        i4 = product.index_of_part_by_tex("z_2") + 2
        vector_parts = [product[i1:i2], product[i3:i4]]

        vector_defs = VGroup()
        braces = VGroup()
        for i, vp in zip(it.count(1), vector_parts):
            brace = Brace(vp, UP)
            vector = Matrix([
                ["x_" + str(i)],
                ["y_" + str(i)],
                ["z_" + str(i)],
            ])
            colors = [GREEN, RED, BLUE]
            for mob, color in zip(vector.get_entries(), colors):
                mob.set_color(color)
            group = VGroup(
                TexMobject("{}_{} = ".format(v_tex, i)),
                vector,
            )
            group.arrange(RIGHT, SMALL_BUFF)
            group.next_to(brace, UP)

            braces.add(brace)
            vector_defs.add(group)

        result = TexMobject(
            "\\left(", "w_1", "w_2",
            "-", v_tex + "_1", "\\cdot", v_tex, "_2", ",\\,",
            "w_1", v_tex + "_2", "+", "w_2", v_tex + "_1",
            "+", "{}_1 \\times {}_2".format(v_tex, v_tex),
            "\\right)"
        )
        result.match_width(product)
        result.next_to(product, DOWN, LARGE_BUFF)
        for mob in product, result:
            mob.set_color_by_tex_to_color_map({
                "w": YELLOW,
                "x": GREEN,
                "y": RED,
                "z": BLUE,
            })
            mob.set_color_by_tex(v_tex, WHITE)

        self.add(product)
        self.add(braces)
        self.add(vector_defs)
        self.play(LaggedStartMap(FadeInFromLarge, result))
        self.wait()


class ShowComplexMagnitude(ShowComplexMultiplicationExamples):
    def construct(self):
        self.add_planes()
        plane = self.plane
        tex_to_color_map = {
            "a": YELLOW,
            "b": GREEN,
        }

        z = complex(3, 2)
        z_point = plane.number_to_point(z)
        z_dot = Dot(z_point)
        z_dot.set_color(PINK)
        z_line = Line(plane.number_to_point(0), z_point)
        z_line.set_stroke(WHITE, 2)
        z_label = TexMobject(
            "z", "=", "a", "+", "b", "i",
            tex_to_color_map=tex_to_color_map
        )
        z_label.add_background_rectangle()
        z_label.next_to(z_dot, UR, buff=SMALL_BUFF)
        z_norm_label = TexMobject("||z||")
        z_norm_label.add_background_rectangle()
        z_norm_label.next_to(ORIGIN, UP, SMALL_BUFF)
        z_norm_label.rotate(z_line.get_angle(), about_point=ORIGIN)
        z_norm_label.shift(z_line.get_center())

        h_line = Line(
            plane.number_to_point(0),
            plane.number_to_point(z.real),
            stroke_color=YELLOW,
            stroke_width=5,
        )
        v_line = Line(
            plane.number_to_point(z.real),
            plane.number_to_point(z),
            stroke_color=GREEN,
            stroke_width=5,
        )

        z_norm_equation = TexMobject(
            "||z||", "=", "\\sqrt", "{a^2", "+", "b^2", "}",
            tex_to_color_map=tex_to_color_map
        )
        z_norm_equation.set_background_stroke(width=0)
        z_norm_equation.add_background_rectangle()
        z_norm_equation.next_to(z_label, UP)

        self.add(z_line, h_line, v_line, z_dot, z_label)
        self.play(ShowCreation(z_line))
        self.play(FadeInFromDown(z_norm_label))
        self.wait()
        self.play(
            FadeIn(z_norm_equation[0]),
            FadeIn(z_norm_equation[2:]),
            TransformFromCopy(
                z_norm_label[1:],
                VGroup(z_norm_equation[1]),
            ),
        )
        self.wait()


class BreakUpQuaternionMultiplicationInParts(Scene):
    def construct(self):
        q1_color = MAROON_B
        q2_color = YELLOW

        product = TexMobject(
            "q_1", "\\cdot", "q_2", "=",
            "\\left(", "{q_1", "\\over", "||", "q_1", "||}", "\\right)",
            "||", "q_1", "||", "\\cdot", "q_2",
        )
        product.set_color_by_tex("q_1", q1_color)
        product.set_color_by_tex("q_2", q2_color)
        lhs = product[:3]
        scale_part = product[-5:]
        rotate_part = product[4:-5]
        lhs_rect = SurroundingRectangle(lhs)
        lhs_rect.set_color(YELLOW)
        lhs_words = TextMobject("Quaternion \\\\ multiplication")
        lhs_words.next_to(lhs_rect, UP, LARGE_BUFF)
        scale_brace = Brace(scale_part, UP)
        rotate_brace = Brace(rotate_part, DOWN)
        scale_words = TextMobject("Scale", "$q_2$")
        scale_words.set_color_by_tex("q_2", q2_color)
        scale_words.next_to(scale_brace, UP)
        rotate_words = TextMobject("Apply special \\\\ 4d rotation")
        rotate_words.next_to(rotate_brace, DOWN)

        norm_equation = TexMobject(
            "||", "q_1", "||", "=",
            "||", "w_1", "+",
            "x_1", "i", "+",
            "y_1", "j", "+",
            "z_1", "k", "||", "=",
            "\\sqrt",
            "{w_1^2", "+",
            "x_1^2", "+",
            "y_1^2", "+",
            "z_1^2", "}",
        )
        # norm_equation.set_color_by_tex_to_color_map({
        #     "w": YELLOW,
        #     "x": GREEN,
        #     "y": RED,
        #     "z": BLUE,
        # })
        norm_equation.set_color_by_tex("q_1", q1_color)
        norm_equation.to_edge(UP)
        norm_equation.set_background_stroke(width=0)

        line1 = Line(ORIGIN, 0.5 * LEFT + 3 * UP)
        line2 = Line(ORIGIN, UR)
        zero_dot = Dot()
        zero_label = TexMobject("0")
        zero_label.next_to(zero_dot, DOWN, SMALL_BUFF)
        q1_dot = Dot(line1.get_end())
        q2_dot = Dot(line2.get_end())
        q1_label = TexMobject("q_1").next_to(q1_dot, UP, SMALL_BUFF)
        q2_label = TexMobject("q_2").next_to(q2_dot, UR, SMALL_BUFF)
        VGroup(q1_dot, q1_label).set_color(q1_color)
        VGroup(q2_dot, q2_label).set_color(q2_color)
        dot_group = VGroup(
            line1, line2, q1_dot, q2_dot, q1_label, q2_label,
            zero_dot, zero_label,
        )
        dot_group.set_height(3)
        dot_group.center()
        dot_group.to_edge(LEFT)

        q1_dot.add_updater(lambda d: d.move_to(line1.get_end()))
        q1_label.add_updater(lambda l: l.next_to(q1_dot, UP, SMALL_BUFF))
        q2_dot.add_updater(lambda d: d.move_to(line2.get_end()))
        q2_label.add_updater(lambda l: l.next_to(q2_dot, UR, SMALL_BUFF))

        self.add(norm_equation)
        self.wait()
        self.play(
            FadeInFromDown(lhs),
            Write(dot_group),
        )
        self.add(*dot_group)
        self.add(
            VGroup(line2, q2_dot, q2_label).copy().fade(0.5)
        )
        self.play(
            ShowCreation(lhs_rect),
            FadeIn(lhs_words)
        )
        self.play(FadeOut(lhs_rect))
        self.wait()
        self.play(
            TransformFromCopy(lhs, product[3:]),
            # FadeOut(lhs_words)
        )
        self.play(
            GrowFromCenter(scale_brace),
            Write(scale_words),
        )
        self.play(
            line2.scale, 2, {"about_point": line2.get_start()}
        )
        self.wait()
        self.play(
            GrowFromCenter(rotate_brace),
            FadeInFrom(rotate_words, UP),
        )
        self.play(
            Rotate(
                line2, -line1.get_angle(),
                about_point=line2.get_start(),
                run_time=3
            )
        )
        self.wait()

        # Ask
        randy = Randolph(height=2)
        randy.flip()
        randy.next_to(rotate_words, RIGHT)
        randy.to_edge(DOWN)
        q_marks = TexMobject("???")
        random.shuffle(q_marks.submobjects)
        q_marks.next_to(randy, UP)
        self.play(
            FadeIn(randy)
        )
        self.play(
            randy.change, "confused", rotate_words,
            ShowCreationThenFadeAround(rotate_words),
        )
        self.play(LaggedStartMap(
            FadeInFrom, q_marks,
            lambda m: (m, LEFT),
            lag_ratio=0.8,
        ))
        self.play(Blink(randy))
        self.wait(2)


class SphereProjectionsWrapper(Scene):
    def construct(self):
        rect_rows = VGroup(*[
            VGroup(*[
                ScreenRectangle(height=3)
                for x in range(3)
            ]).arrange(RIGHT, buff=LARGE_BUFF)
            for y in range(2)
        ]).arrange(DOWN, buff=2 * LARGE_BUFF)
        rect_rows.set_width(FRAME_WIDTH - 1)

        sphere_labels = VGroup(
            TextMobject("Circle in 2d"),
            TextMobject("Sphere in 3d"),
            TextMobject("Hypersphere in 4d"),
        )
        for label, rect in zip(sphere_labels, rect_rows[0]):
            label.next_to(rect, UP)

        projected_labels = VGroup(
            TextMobject("Sterographically projected \\\\ circle in 1d"),
            TextMobject("Sterographically projected \\\\ sphere in 2d"),
            TextMobject("Sterographically projected \\\\ hypersphere in 3d"),
        )
        for label, rect in zip(projected_labels, rect_rows[1]):
            label.match_width(rect)
            label.next_to(rect, UP)

        q_marks = TexMobject("???")
        q_marks.scale(2)
        q_marks.move_to(rect_rows[0][2])

        self.add(rect_rows)
        for l1, l2 in zip(sphere_labels, projected_labels):
            added_anims = []
            if l1 is sphere_labels[2]:
                added_anims.append(FadeIn(q_marks))
            self.play(FadeIn(l1), *added_anims)
            self.play(FadeIn(l2))
            self.wait()


class HypersphereStereographicProjection(SpecialThreeDScene):
    CONFIG = {
        # "fancy_dot": False,
        "fancy_dot": True,
        "initial_quaternion_sample_values": [
            [0, 1, 0, 0],
            [-1, 1, 0, 0],
            [0, 0, 1, 1],
            [0, 1, -1, 1],
        ],
        "unit_labels_scale_factor": 1,
    }

    def construct(self):
        self.setup_axes()
        self.introduce_quaternion_label()
        self.show_one()
        self.show_unit_sphere()
        self.show_quaternions_with_nonzero_real_part()
        self.emphasize_only_units()
        self.show_reference_spheres()

    def setup_axes(self):
        axes = self.axes = self.get_axes()
        axes.set_stroke(width=1)
        self.add(axes)
        self.move_camera(
            **self.get_default_camera_position(),
            run_time=0
        )
        self.begin_ambient_camera_rotation(rate=0.01)

    def introduce_quaternion_label(self):
        q_tracker = QuaternionTracker()
        coords = [
            DecimalNumber(0, color=color, include_sign=sign, edge_to_fix=RIGHT)
            for color, sign in zip(
                [YELLOW, GREEN, RED, BLUE],
                [False, True, True, True],
            )
        ]
        label = VGroup(
            coords[0], VectorizedPoint(),
            coords[1], TexMobject("i"),
            coords[2], TexMobject("j"),
            coords[3], TexMobject("k"),
        )
        label.arrange(RIGHT, buff=SMALL_BUFF)
        label.to_corner(UR)

        def update_label(label):
            self.remove_fixed_in_frame_mobjects(label)
            quat = q_tracker.get_value()
            for value, coord in zip(quat, label[::2]):
                coord.set_value(value)
            self.add_fixed_in_frame_mobjects(label)
            return label

        label.add_updater(update_label)
        self.pink_dot_label = label

        def get_pq_point():
            point = self.project_quaternion(q_tracker.get_value())
            if get_norm(point) > 100:
                return point * 100 / get_norm(point)
            return point

        pq_dot = self.get_dot()
        pq_dot.add_updater(lambda d: d.move_to(get_pq_point()))
        dot_radius = pq_dot.get_width() / 2

        def get_pq_line():
            point = get_pq_point()
            norm = get_norm(point)
            origin = self.axes.coords_to_point(0, 0, 0)
            if norm > dot_radius:
                point -= origin
                point *= (norm - dot_radius) / norm
                point += origin
            result = Line(origin, point)
            result.set_stroke(width=1)
            return result

        pq_line = get_pq_line()
        pq_line.add_updater(lambda cl: cl.become(get_pq_line()))

        self.add(q_tracker, label, pq_line, pq_dot)

        self.q_tracker = q_tracker
        self.q_label = label
        self.pq_line = pq_line
        self.pq_dot = pq_dot

        rect = SurroundingRectangle(label, color=WHITE)
        self.add_fixed_in_frame_mobjects(rect)
        self.play(ShowCreation(rect))
        self.play(FadeOut(rect))
        self.remove_fixed_orientation_mobjects(rect)

        for value in self.initial_quaternion_sample_values:
            self.set_quat(value)
            self.wait()

    def show_one(self):
        q_tracker = self.q_tracker

        one_label = TexMobject("1")
        one_label.rotate(TAU / 4, RIGHT)
        one_label.next_to(ORIGIN, IN + RIGHT, SMALL_BUFF)
        one_label.set_shade_in_3d(True)
        one_label.set_background_stroke(width=0)

        self.play(
            ApplyMethod(
                q_tracker.set_value, [1, 0, 0, 0],
                run_time=2
            ),
            FadeInFromDown(one_label)
        )
        self.wait(4)

    def show_unit_sphere(self):
        sphere = self.sphere = self.get_projected_sphere(
            quaternion=[1, 0, 0, 0], null_axis=0,
            solid=False,
            stroke_width=0.5
        )
        self.specially_color_sphere(sphere)
        labels = self.get_unit_labels()
        labels.remove(labels[3])

        real_part = self.q_label[0]
        brace = Brace(real_part, DOWN)
        words = TextMobject("Real part zero")
        words.next_to(brace, DOWN, SMALL_BUFF, LEFT)

        self.play(Write(sphere))
        self.play(LaggedStartMap(
            FadeInFrom, labels,
            lambda m: (m, IN)
        ))
        self.add_fixed_in_frame_mobjects(brace, words)
        self.set_quat(
            [0, 1, 0, 0],
            added_anims=[
                GrowFromCenter(brace),
                Write(words),
            ]
        )
        self.wait()
        self.set_quat([0, 1, -1, 1])
        self.wait(2)
        self.set_quat([0, -1, -1, 1])
        self.wait(2)
        self.set_quat([0, 0, 0, 1])
        self.wait(2)
        self.set_quat([0, 0, -1, 0])
        self.wait(2)
        self.set_quat([0, 1, 0, 0])
        self.wait(2)
        self.play(FadeOut(words))
        self.remove_fixed_in_frame_mobjects(words)

        self.real_part_brace = brace

    def show_quaternions_with_nonzero_real_part(self):
        # Positive real part
        self.set_quat(
            [1, 1, 2, 0],
            added_anims=[
                ApplyMethod(
                    self.sphere.copy().scale, 0,
                    remover=True
                )
            ]
        )
        self.wait(2)
        self.set_quat([4, 0, -1, -1])
        self.wait(2)
        # Negative real part
        self.set_quat(
            [-1, 1, 2, 0],
            added_anims=[
                ApplyFunction(
                    lambda s: s.scale(10).fade(1),
                    self.sphere.copy(),
                    remover=True
                )
            ]
        )
        self.wait(2)
        self.set_quat([-2, 0, -1, 1])
        self.wait(2)
        self.set_quat([-1, 1, 0, 0])
        self.move_camera(theta=-160 * DEGREES, run_time=3)
        self.set_quat([-1, 0.001, 0, 0])
        self.wait(2)

    def emphasize_only_units(self):
        q_label = self.q_label
        brace = self.real_part_brace

        brace.target = Brace(q_label, DOWN, buff=SMALL_BUFF)
        words = TextMobject(
            "Only those where \\\\",
            "$w^2 + x^2 + y^2 + z^2 = 1$"
        )
        words.next_to(brace.target, DOWN, SMALL_BUFF)

        self.add_fixed_in_frame_mobjects(words)
        self.play(
            MoveToTarget(brace),
            Write(words)
        )
        self.set_quat([1, 1, 1, 1])
        self.wait(2)
        self.set_quat([1, 1, -1, 1])
        self.wait(2)
        self.set_quat([-1, 1, -1, 1])
        self.wait(8)
        self.play(FadeOut(brace), FadeOut(words))
        self.remove_fixed_in_frame_mobjects(brace, words)

    # TODO
    def show_reference_spheres(self):
        sphere = self.sphere
        self.move_camera(
            phi=60 * DEGREES,
            theta=-150 * DEGREES,
            added_anims=[
                self.q_tracker.set_value, [1, 0, 0, 0]
            ]
        )
        sphere_ijk = self.get_projected_sphere(null_axis=0)
        sphere_1jk = self.get_projected_sphere(null_axis=1)
        sphere_1ik = self.get_projected_sphere(null_axis=2)
        sphere_1ij = self.get_projected_sphere(null_axis=3)
        circle = StereoProjectedCircleFromHypersphere(axes=[0, 1])

        circle_words = TextMobject(
            "Circle through\\\\", "$1, i, -1, -i$"
        )
        sphere_1ij_words = TextMobject(
            "Sphere through\\\\", "$1, i, j, -1, -i, -j$"
        )
        sphere_1jk_words = TextMobject(
            "Sphere through\\\\", "$1, j, k, -1, -j, -k$"
        )
        sphere_1ik_words = TextMobject(
            "Sphere through\\\\", "$1, i, k, -1, -i, -k$"
        )
        for words in [circle_words, sphere_1ij_words, sphere_1jk_words, sphere_1ik_words]:
            words.to_corner(UL)
            self.add_fixed_in_frame_mobjects(words)

        self.play(
            ShowCreation(circle),
            Write(circle_words),
        )
        self.set_quat([0, 1, 0, 0])
        self.set_quat([1, 0, 0, 0])
        self.remove(sphere)
        sphere_ijk.match_style(sphere)
        self.add(sphere_ijk)

        # Show xy plane
        self.play(
            FadeOutAndShift(circle_words, DOWN),
            FadeInFromDown(sphere_1ij_words),
            FadeOut(circle),
            sphere_ijk.set_stroke, {"width": 0.0}
        )
        self.play(Write(sphere_1ij))
        self.wait(10)
        return

        # Show yz plane
        self.play(
            FadeOutAndShift(sphere_1ij_words, DOWN),
            FadeInFromDown(sphere_1jk_words),
            sphere_1ij.set_fill, BLUE_E, 0.25,
            sphere_1ij.set_stroke, {"width": 0.0},
            Write(sphere_1jk)
        )
        self.wait(5)

        # Show xz plane
        self.play(
            FadeOutAndShift(sphere_1jk_words, DOWN),
            FadeInFromDown(sphere_1ik_words),
            sphere_1jk.set_fill, GREEN_E, 0.25,
            sphere_1jk.set_stroke, {"width": 0.0},
            Write(sphere_1ik)
        )
        self.wait(5)
        self.play(
            sphere_1ik.set_fill, RED_E, 0.25,
            sphere_1ik.set_stroke, {"width": 0.0},
            FadeOut(sphere_1ik_words)
        )

        # Start applying quaternion multiplication
        kwargs = {"solid": False, "stroke_width": 0}
        sphere_ijk.add_updater(
            lambda s: s.become(self.get_projected_sphere(0, **kwargs))
        )
        sphere_1jk.add_updater(
            lambda s: s.become(self.get_projected_sphere(1, **kwargs))
        )
        sphere_1ik.add_updater(
            lambda s: s.become(self.get_projected_sphere(2, **kwargs))
        )
        sphere_1ij.add_updater(
            lambda s: s.become(self.get_projected_sphere(3, **kwargs))
        )

        self.set_quat([0, 1, 1, 1])

    #
    def project_quaternion(self, quat):
        return self.axes.coords_to_point(
            *stereo_project_point(quat, axis=0, r=1)[1:]
        )

    def get_dot(self):
        if self.fancy_dot:
            sphere = self.get_sphere()
            sphere.set_width(0.2)
            sphere.set_stroke(width=0)
            sphere.set_fill(PINK)
            return sphere
        else:
            return VGroup(
                Dot(color=PINK),
                Dot(color=PINK).rotate(TAU / 4, RIGHT),
            )

    def get_unit_labels(self):
        c2p = self.axes.coords_to_point
        tex_coords_vects = [
            ("i", [1, 0, 0], IN + RIGHT),
            ("-i", [-1, 0, 0], IN + LEFT),
            ("j", [0, 1, 0], UP + OUT + RIGHT),
            ("-j", [0, -1, 0], RIGHT + DOWN),
            ("k", [0, 0, 1], OUT + RIGHT),
            ("-k", [0, 0, -1], IN + RIGHT),
        ]
        labels = VGroup()
        for tex, coords, vect in tex_coords_vects:
            label = TexMobject(tex)
            label.scale(self.unit_labels_scale_factor)
            label.rotate(90 * DEGREES, RIGHT)
            label.next_to(c2p(*coords), vect, SMALL_BUFF)
            labels.add(label)
        labels.set_shade_in_3d(True)
        labels.set_background_stroke(width=0)
        return labels

    def set_quat(self, value, run_time=3, added_anims=None):
        if added_anims is None:
            added_anims = []
        self.play(
            self.q_tracker.set_value, value,
            *added_anims,
            run_time=run_time
        )

    def get_projected_sphere(self, null_axis, quaternion=None, solid=True, **kwargs):
        if quaternion is None:
            quaternion = self.get_multiplier()
        axes_to_color = {
            0: interpolate_color(YELLOW, BLACK, 0.5),
            1: GREEN_E,
            2: RED_D,
            3: BLUE_E,
        }
        color = axes_to_color[null_axis]
        config = dict(self.sphere_config)
        config.update({
            "stroke_color": WHITE,
            "stroke_width": 0.5,
            "stroke_opacity": 0.5,
            "max_r": 24,
        })
        if solid:
            config.update({
                "checkerboard_colors": [
                    color, interpolate_color(color, BLACK, 0.5)
                ],
                "fill_opacity": 1,
            })
        else:
            config.update({
                "checkerboard_colors": [],
                "fill_color": color,
                "fill_opacity": 0.25,
            })
        config.update(kwargs)
        sphere = StereoProjectedSphereFromHypersphere(
            quaternion=quaternion,
            null_axis=null_axis,
            **config
        )
        sphere.set_shade_in_3d(True)
        return sphere

    def get_projected_circle(self, quaternion=None, **kwargs):
        if quaternion is None:
            quaternion = self.get_multiplier()
        return StereoProjectedCircleFromHypersphere(quaternion, **kwargs)

    def get_multiplier(self):
        return self.q_tracker.get_value()

    def specially_color_sphere(self, sphere):
        sphere.set_color_by_gradient(BLUE, GREEN, PINK)
        return sphere
        # for submob in sphere:
        #     u, v = submob.u1, submob.v1
        #     x = np.cos(v) * np.sin(u)
        #     y = np.sin(v) * np.sin(u)
        #     z = np.cos(u)
        #     # rgb = sum([
        #     #     (x**2) * hex_to_rgb(GREEN),
        #     #     (y**2) * hex_to_rgb(RED),
        #     #     (z**2) * hex_to_rgb(BLUE),
        #     # ])
        #     # clip_in_place(rgb, 0, 1)
        #     # color = rgb_to_hex(rgb)
        #     color = interpolate_color(BLUE, RED, ((z**3) + 1) / 2)
        #     submob.set_fill(color)
        # return sphere


class MissingLabels(Scene):
    def construct(self):
        labels = VGroup(
            TexMobject("i").move_to(UR),
            TexMobject("1").move_to(0.3 * DOWN),
            TexMobject("-i").move_to(DOWN + 1.2 * LEFT),
            TexMobject("-j").move_to(1.7 * RIGHT + 0.8 * DOWN),
        )
        labels.set_background_stroke(width=0)
        self.add(labels)


class RuleOfQuaternionMultiplicationOverlay(Scene):
    def construct(self):
        q_mob, times_mob, p_mob = q_times_p = TexMobject(
            "q", "\\cdot", "p"
        )
        q_times_p.scale(2)
        q_mob.set_color(MAROON_B)
        p_mob.set_color(YELLOW)
        q_arrow = Vector(DOWN, color=WHITE)
        q_arrow.next_to(q_mob, UP)
        p_arrow = Vector(UP, color=WHITE)
        p_arrow.next_to(p_mob, DOWN)

        q_words = TextMobject("Think of as\\\\ an action")
        q_words.next_to(q_arrow, UP)
        p_words = TextMobject("Think of as\\\\ a point")
        p_words.next_to(p_arrow, DOWN)

        i_mob = TexMobject("i")[0]
        i_mob.scale(2)
        i_mob.move_to(q_mob, RIGHT)
        i_mob.set_color(GREEN)

        self.add(q_times_p)
        self.play(
            FadeInFrom(q_words, UP),
            GrowArrow(q_arrow),
        )
        self.play(
            FadeInFrom(p_words, DOWN),
            GrowArrow(p_arrow),
        )
        self.wait()
        self.play(*map(FadeOut, [
            q_words, q_arrow,
            p_words, p_arrow,
        ]))
        self.play(
            FadeInFromDown(i_mob),
            FadeOutAndShift(q_mob, UP)
        )
        product = VGroup(i_mob, times_mob, p_mob)
        self.play(product.to_edge, UP)

        # Show i products
        underline = Line(LEFT, RIGHT)
        underline.set_width(product.get_width() + MED_SMALL_BUFF)
        underline.next_to(product, DOWN)

        kwargs = {
            "tex_to_color_map": {
                "i": GREEN,
                "j": RED,
                "k": BLUE
            }
        }
        i_products = VGroup(
            TexMobject("i", "\\cdot", "1", "=", "i", **kwargs),
            TexMobject("i", "\\cdot", "i", "=", "-1", **kwargs),
            TexMobject("i", "\\cdot", "j", "=", "k", **kwargs),
            TexMobject("i", "\\cdot", "k", "=", "-j", **kwargs),
        )
        i_products.scale(2)
        i_products.arrange(
            DOWN, buff=MED_LARGE_BUFF,
            aligned_edge=LEFT,
        )
        i_products.next_to(underline, DOWN, LARGE_BUFF)
        i_products.align_to(i_mob, LEFT)

        self.play(ShowCreation(underline))
        self.wait()
        for i_product in i_products:
            self.play(TransformFromCopy(
                product, i_product[:3]
            ))
            self.wait()
            self.play(TransformFromCopy(
                i_product[:3], i_product[3:],
            ))
            self.wait()

        rect = SurroundingRectangle(
            VGroup(product, i_products),
            buff=0.4
        )
        rect.set_stroke(WHITE, width=5)
        self.play(ShowCreation(rect))
        self.play(FadeOut(rect))


class RuleOfQuaternionMultiplication(HypersphereStereographicProjection):
    CONFIG = {
        "fancy_dot": True,
        "initial_quaternion_sample_values": [],
    }

    def construct(self):
        self.setup_all_trackers()
        self.show_multiplication_by_i_on_circle_1i()
        self.show_multiplication_by_i_on_circle_jk()
        self.show_multiplication_by_i_on_ijk_sphere()

    def setup_all_trackers(self):
        self.setup_multiplier_tracker()
        self.force_skipping()
        self.setup_axes()
        self.introduce_quaternion_label()
        self.add_unit_labels()
        self.revert_to_original_skipping_status()

    def setup_multiplier_tracker(self):
        self.multiplier_tracker = QuaternionTracker([1, 0, 0, 0])
        self.multiplier_tracker.add_updater(
            lambda m: m.set_value(normalize(
                m.get_value(),
                fall_back=[1, 0, 0, 0]
            ))
        )
        self.add(self.multiplier_tracker)

    def add_unit_labels(self):
        labels = self.unit_labels = self.get_unit_labels()
        one_label = TexMobject("1")
        one_label.scale(self.unit_labels_scale_factor)
        one_label.set_shade_in_3d(True)
        one_label.rotate(90 * DEGREES, RIGHT)
        one_label.next_to(ORIGIN, IN + RIGHT, SMALL_BUFF)
        labels.add(one_label)
        self.add(labels)

    def show_multiplication_by_i_on_circle_1i(self):
        m_tracker = self.multiplier_tracker

        def get_circle_1i():
            return self.get_projected_circle(
                basis_vectors=[
                    [1, 0, 0, 0],
                    [1, 1, 0, 0],
                ],
                colors=[GREEN, YELLOW],
                quaternion=m_tracker.get_value(),
            )
        circle = get_circle_1i()
        arrows = self.get_i_circle_arrows()

        def set_to_q_value(mt):
            mt.set_value(self.q_tracker.get_value())

        self.play(ShowCreation(circle, run_time=2))
        self.play(LaggedStartMap(ShowCreation, arrows, lag_ratio=0.25))
        self.wait()
        circle.add_updater(lambda c: c.become(get_circle_1i()))
        m_tracker.add_updater(set_to_q_value)
        self.add(m_tracker)
        self.set_quat([0, 1, 0, 0])
        self.wait()
        self.set_quat([-1, 0.001, 0, 0])
        self.wait()
        self.q_tracker.set_value([-1, -0.001, 0, 0])
        self.set_quat([0, -1, 0, 0])
        self.wait()
        self.set_quat([1, 0, 0, 0])
        self.wait(3)
        self.play(FadeOut(arrows))

        m_tracker.remove_updater(set_to_q_value)
        self.circle_1i = circle

    def show_multiplication_by_i_on_circle_jk(self):
        def get_circle_jk():
            return self.get_projected_circle(
                basis_vectors=[
                    [0, 0, 1, 0],
                    [0, 0, 0, 1],
                ],
                colors=[RED, BLUE_E]
            )
        circle = get_circle_jk()
        arrows = self.get_jk_circle_arrows()
        m_tracker = self.multiplier_tracker
        q_tracker = self.q_tracker

        def set_q_to_mj(qt):
            qt.set_value(q_mult(
                m_tracker.get_value(), [0, 0, 1, 0]
            ))

        self.move_camera(theta=-50 * DEGREES)
        self.play(ShowCreation(circle, run_time=2))
        circle.add_updater(lambda c: c.become(get_circle_jk()))
        self.wait(10)
        self.stop_ambient_camera_rotation()
        self.begin_ambient_camera_rotation(rate=-0.01)
        self.play(*map(ShowCreation, arrows))
        self.wait()
        self.set_quat([0, 0, 1, 0], run_time=1)
        q_tracker.add_updater(set_q_to_mj, index=0)
        self.add(self.circle_1i)
        self.play(
            m_tracker.set_value, [0, 1, 0, 0],
            run_time=3
        )
        self.wait()
        self.play(
            m_tracker.set_value, [-1, 0.001, 0, 0],
            run_time=3
        )
        self.wait()
        m_tracker.set_value([-1, 0.001, 0, 0])
        self.play(
            m_tracker.set_value, [0, -1, 0, 0],
            run_time=3
        )
        self.wait()
        self.play(
            m_tracker.set_value, [1, 0, 0, 0],
            run_time=3
        )
        self.wait()
        q_tracker.remove_updater(set_q_to_mj)
        self.play(
            FadeOut(arrows),
            q_tracker.set_value, [1, 0, 0, 0],
        )
        self.wait(10)

        self.circle_jk = circle

    def show_multiplication_by_i_on_ijk_sphere(self):
        m_tracker = self.multiplier_tracker
        q_tracker = self.q_tracker
        m_tracker.add_updater(lambda m: m.set_value(q_tracker.get_value()))

        def get_sphere():
            result = self.get_projected_sphere(null_axis=0, solid=False)
            self.specially_color_sphere(result)
            return result

        sphere = get_sphere()

        self.play(Write(sphere))
        sphere.add_updater(lambda s: s.become(get_sphere()))

        self.set_quat([0, 1, 0, 0])
        self.wait()
        self.set_quat([-1, 0.001, 0, 0])
        self.wait()
        self.q_tracker.set_value([-1, -0.001, 0, 0])
        self.set_quat([0, -1, 0, 0])
        self.wait()
        self.set_quat([1, 0, 0, 0])
        self.wait(3)

    #
    def get_multiplier(self):
        return self.multiplier_tracker.get_value()

    def get_i_circle_arrows(self):
        c2p = self.axes.coords_to_point
        i_arrow = Arrow(
            ORIGIN, 2 * RIGHT, path_arc=-120 * DEGREES,
            buff=SMALL_BUFF,
        )
        neg_one_arrow = Arrow(
            ORIGIN, 5.5 * RIGHT + UP,
            path_arc=-30 * DEGREES,
            buff=SMALL_BUFF,
        )
        neg_i_arrow = Arrow(
            4.5 * LEFT + 1.5 * UP, ORIGIN,
            path_arc=-30 * DEGREES,
            buff=SMALL_BUFF,
        )
        one_arrow = i_arrow.copy()
        result = VGroup(i_arrow, neg_one_arrow, neg_i_arrow, one_arrow)
        for arrow in result:
            arrow.set_color(LIGHT_GREY)
            arrow.set_stroke(width=3)
            arrow.rotate(90 * DEGREES, RIGHT)
        i_arrow.next_to(c2p(0, 0, 0), OUT + RIGHT, SMALL_BUFF)
        neg_one_arrow.next_to(c2p(1, 0, 0), OUT + RIGHT, SMALL_BUFF)
        neg_i_arrow.next_to(c2p(-1, 0, 0), OUT + LEFT, SMALL_BUFF)
        one_arrow.next_to(c2p(0, 0, 0), OUT + LEFT, SMALL_BUFF)
        return result

    def get_jk_circle_arrows(self):
        arrow = Arrow(
            1.5 * RIGHT, 1.5 * UP,
            path_arc=90 * DEGREES,
            buff=SMALL_BUFF,
            use_rectangular_stem=False
        )
        arrow.set_color(LIGHT_GREY)
        arrow.set_stroke(width=3)
        arrows = VGroup(*[
            arrow.copy().rotate(angle, about_point=ORIGIN)
            for angle in np.arange(0, TAU, TAU / 4)
        ])
        arrows.rotate(90 * DEGREES, RIGHT)
        arrows.rotate(90 * DEGREES, OUT)
        return arrows


class ShowDistributionOfI(TeacherStudentsScene):
    def construct(self):
        tex_to_color_map = {
            "q": PINK,
            "w": YELLOW,
            "x": GREEN,
            "y": RED,
            "z": BLUE,
        }
        top_product = TexMobject(
            "q", "\\cdot", "\\left(",
            "w", "1", "+", "x", "i", "+", "y", "j", "+", "z", "k",
            "\\right)"
        )
        top_product.to_edge(UP)
        self.add(top_product)
        bottom_product = TexMobject(
            "w", "q", "\\cdot", "1",
            "+", "x", "q", "\\cdot", "i",
            "+", "y", "q", "\\cdot", "j",
            "+", "z", "q", "\\cdot", "k",
        )
        bottom_product.next_to(top_product, DOWN, MED_LARGE_BUFF)

        for product in [top_product, bottom_product]:
            for tex, color in tex_to_color_map.items():
                product.set_color_by_tex(tex, color, substring=False)

        self.student_says(
            "What does it do \\\\ to other quaternions?",
            target_mode="raise_left_hand"
        )
        self.change_student_modes(
            "pondering", "raise_left_hand", "erm",
            look_at_arg=top_product,
        )
        self.wait(2)
        self.play(
            self.teacher.change, "raise_right_hand",
            RemovePiCreatureBubble(self.students[1], target_mode="pondering"),
            *[
                TransformFromCopy(
                    top_product.get_parts_by_tex(tex, substring=False),
                    bottom_product.get_parts_by_tex(tex, substring=False),
                    run_time=2
                )
                for tex in ["1", "w", "x", "i", "y", "j", "z", "k", "+"]
            ]
        )
        self.play(*[
            TransformFromCopy(
                top_product.get_parts_by_tex(tex, substring=False),
                bottom_product.get_parts_by_tex(tex, substring=False),
                run_time=2
            )
            for tex in ["q", "\\cdot"]
        ])
        self.change_all_student_modes("thinking")
        self.wait(3)


class ComplexPlane135(Scene):
    def construct(self):
        plane = ComplexPlane(unit_size=2)
        plane.add_coordinates()
        for mob in plane.coordinate_labels:
            mob.scale(2, about_edge=UR)

        angle = 3 * TAU / 8
        circle = Circle(radius=2, color=YELLOW)
        arc = Arc(angle, radius=0.5)
        angle_label = Integer(0, unit="^\\circ")
        angle_label.next_to(arc.point_from_proportion(0.5), UR, SMALL_BUFF)
        line = Line(ORIGIN, 2 * RIGHT)

        point = circle.point_from_proportion(angle / TAU)
        dot = Dot(point, color=PINK)
        arrow = Vector(DR)
        arrow.next_to(dot, UL, SMALL_BUFF)
        arrow.match_color(dot)
        label = TexMobject("-\\frac{\\sqrt{2}}{2} + \\frac{\\sqrt{2}}{2} i")
        label.next_to(arrow.get_start(), UP, SMALL_BUFF)
        label.set_background_stroke(width=0)

        self.add(plane, circle, line, dot, label, arrow)
        self.play(
            Rotate(line, angle, about_point=ORIGIN),
            ShowCreation(arc),
            ChangeDecimalToValue(angle_label, 135),
            run_time=3
        )
        self.wait()


class ShowMultiplicationBy135Example(RuleOfQuaternionMultiplication):
    CONFIG = {
        "fancy_dot": True,
    }

    def construct(self):
        self.setup_all_trackers()
        self.add_circles()
        self.add_ijk_sphere()
        self.show_multiplication()

    def add_circles(self):
        self.circle_1i = self.add_auto_updating_circle(
            basis_vectors=[
                [1, 0, 0, 0],
                [0, 1, 0, 0],
            ],
            colors=[YELLOW, GREEN_E]
        )
        self.circle_jk = self.add_auto_updating_circle(
            basis_vectors=[
                [0, 0, 1, 0],
                [0, 0, 0, 1],
            ],
            colors=[RED, BLUE_E]

        )

    def add_auto_updating_circle(self, **circle_config):
        circle = self.get_projected_circle(**circle_config)
        circle.add_updater(
            lambda c: c.become(self.get_projected_circle(**circle_config))
        )
        self.add(circle)
        return circle

    def add_ijk_sphere(self):
        def get_sphere():
            result = self.get_projected_sphere(
                null_axis=0,
                solid=False,
                stroke_width=0.5,
                stroke_opacity=0.2,
                fill_opacity=0.2,
            )
            self.specially_color_sphere(result)
            return result
        sphere = get_sphere()
        sphere.add_updater(lambda s: s.become(get_sphere()))
        self.add(sphere)
        self.sphere = sphere

    def show_multiplication(self):
        m_tracker = self.multiplier_tracker

        quat = normalize(np.array([-1, 1, 0, 0]))
        point = self.project_quaternion(quat)
        arrow = Vector(DR)
        arrow.next_to(point, UL, MED_SMALL_BUFF)
        arrow.set_color(PINK)
        label = TexMobject(
            "-{\\sqrt{2} \\over 2}", "+",
            "{\\sqrt{2} \\over 2}", "i",
        )
        label.next_to(arrow.get_start(), UP)
        label.set_background_stroke(width=0)

        def get_one_point():
            return self.circle_1i[0].points[0]

        def get_j_point():
            return self.circle_jk[0].points[0]

        one_point = VectorizedPoint()
        one_point.add_updater(lambda v: v.set_location(get_one_point()))
        self.add(one_point)

        hand = Hand()
        hand.rotate(45 * DEGREES, RIGHT)
        hand.add_updater(
            lambda h: h.move_to(get_one_point(), LEFT)
        )

        j_line = Line(ORIGIN, get_j_point())
        moving_j_line = j_line.deepcopy()
        moving_j_line.add_updater(
            lambda m: m.put_start_and_end_on(ORIGIN, get_j_point())
        )

        self.add(j_line, moving_j_line)
        self.set_camera_orientation(
            phi=60 * DEGREES, theta=-70 * DEGREES
        )
        self.play(
            FadeInFromLarge(label, 3),
            GrowArrow(arrow)
        )
        self.set_quat(quat)
        self.wait(5)
        self.play(FadeInFromLarge(hand))
        self.add(m_tracker)
        for q in [quat, [1, 0, 0, 0], quat]:
            self.play(
                m_tracker.set_value, q,
                UpdateFromFunc(
                    m_tracker,
                    lambda m: m.set_value(normalize(m.get_value()))
                ),
                run_time=5
            )
            self.wait()


class JMultiplicationChart(Scene):
    def construct(self):
        # Largely copy-pasted....what are you gonna do about it?
        product = TexMobject("j", "\\cdot", "p")
        product[0].set_color(RED)
        product.scale(2)
        product.to_edge(UP)

        underline = Line(LEFT, RIGHT)
        underline.set_width(product.get_width() + MED_SMALL_BUFF)
        underline.next_to(product, DOWN)

        kwargs = {
            "tex_to_color_map": {
                "i": GREEN,
                "j": RED,
                "k": BLUE
            }
        }
        j_products = VGroup(
            TexMobject("j", "\\cdot", "1", "=", "j", **kwargs),
            TexMobject("j", "\\cdot", "j", "=", "-1", **kwargs),
            TexMobject("j", "\\cdot", "i", "=", "-k", **kwargs),
            TexMobject("j", "\\cdot", "k", "=", "i", **kwargs),
        )
        j_products.scale(2)
        j_products.arrange(
            DOWN, buff=MED_LARGE_BUFF,
            aligned_edge=LEFT,
        )
        j_products.next_to(underline, DOWN, LARGE_BUFF)
        j_products.align_to(product, LEFT)

        self.play(FadeInFromDown(product))
        self.play(ShowCreation(underline))
        self.wait()
        for j_product in j_products:
            self.play(TransformFromCopy(
                product, j_product[:3]
            ))
            self.wait()
            self.play(TransformFromCopy(
                j_product[:3], j_product[3:],
            ))
            self.wait()

        rect = SurroundingRectangle(
            VGroup(product, j_products),
            buff=MED_SMALL_BUFF
        )
        rect.set_stroke(WHITE, width=5)
        self.play(ShowCreation(rect))
        self.play(FadeOut(rect))


class ShowJMultiplication(ShowMultiplicationBy135Example):
    CONFIG = {
        "fancy_dot": True,
        "run_time_per_rotation": 4,
    }

    def construct(self):
        self.setup_all_trackers()
        self.add_circles()
        self.add_ijk_sphere()
        self.show_multiplication()

    def add_circles(self):
        self.circle_1j = self.add_auto_updating_circle(
            basis_vectors=[
                [1, 0, 0, 0],
                [0, 0, 1, 0],
            ],
            colors=[YELLOW, RED]
        )
        self.circle_ik = self.add_auto_updating_circle(
            basis_vectors=[
                [0, 1, 0, 0],
                [0, 0, 0, 1],
            ],
            colors=[GREEN, BLUE_E]
        )

    def show_multiplication(self):
        self.set_camera_orientation(theta=-80 * DEGREES)

        q_tracker = self.q_tracker
        m_tracker = self.multiplier_tracker

        def normalize_tracker(t):
            t.set_value(normalize(t.get_value()))

        updates = [
            UpdateFromFunc(tracker, normalize_tracker)
            for tracker in (q_tracker, m_tracker)
        ]

        run_time = self.run_time_per_rotation
        self.play(
            m_tracker.set_value, [0, 0, 1, 0],
            q_tracker.set_value, [0, 0, 1, 0],
            *updates,
            run_time=run_time,
        )
        self.wait(2)
        self.play(
            m_tracker.set_value, [-1, 0, 1e-3, 0],
            q_tracker.set_value, [-1, 0, 1e-3, 0],
            *updates,
            run_time=run_time,
        )
        self.wait(2)

        # Show ik circle
        circle = self.circle_ik.deepcopy()
        circle.clear_updaters()
        self.play(FadeInFromLarge(circle, remover=True))
        m_tracker.set_value([-1, 0, 0, 0])
        q_tracker.set_value([0, 1, 0, 0])
        self.wait()
        self.play(
            m_tracker.set_value, [0, 0, -1, 0],
            q_tracker.set_value, [0, 0, 0, -1],
            *updates,
            run_time=run_time,
        )
        self.wait(2)
        self.play(
            m_tracker.set_value, [1, 0, -1e-3, 0],
            q_tracker.set_value, [0, -1, 0, 0],
            *updates,
            run_time=run_time,
        )
        self.wait(2)


class ShowArbitraryMultiplication(ShowMultiplicationBy135Example):
    CONFIG = {
        "fancy_dot": True,
        "run_time_per_rotation": 4,
        "special_quaternion": [-0.5, 0.5, 0.5, 0.5],
    }

    def construct(self):
        self.setup_all_trackers()
        self.add_circles()
        self.add_ijk_sphere()
        self.show_multiplication()

    def add_circles(self):
        self.circle1 = self.add_auto_updating_circle(
            basis_vectors=[
                [1, 0, 0, 0],
                [0, 1, 1, 1],
            ],
            colors=[YELLOW_E, YELLOW]
        )
        bv1 = normalize([0, -1, -1, 2])
        bv2 = [0] + list(normalize(np.cross([1, 1, 1], bv1[1:])))
        self.circle2 = self.add_auto_updating_circle(
            basis_vectors=[bv1, bv2],
            colors=[WHITE, GREY]
        )

    def show_multiplication(self):
        q_tracker = self.q_tracker
        m_tracker = self.multiplier_tracker
        run_time = self.run_time_per_rotation

        def normalize_tracker(t):
            t.set_value(normalize(t.get_value()))

        # for tracker in q_tracker, m_tracker:
        #     self.add(Mobject.add_updater(tracker, normalize_tracker))
        updates = [
            UpdateFromFunc(tracker, normalize_tracker)
            for tracker in (q_tracker, m_tracker)
        ]

        special_q = self.special_quaternion
        pq_point = self.project_quaternion(special_q)
        label = TextMobject("Some unit quaternion")
        label.set_color(PINK)
        label.rotate(90 * DEGREES, RIGHT)
        label.next_to(pq_point, IN + RIGHT, SMALL_BUFF)

        circle1, circle2 = self.circle1, self.circle2
        for circle in [circle1, circle2]:
            circle.tucked_away_updaters = circle.updaters
            circle.clear_updaters()
            self.remove(circle)

        hand = Hand()
        hand.rotate(90 * DEGREES, RIGHT)
        hand.move_to(ORIGIN, LEFT)
        hand.set_shade_in_3d(True)
        one_dot = self.get_dot()
        one_dot.set_color(YELLOW_E)
        one_dot.move_to(ORIGIN)
        one_dot.add_updater(
            lambda m: m.move_to(circle1[0].points[0])
        )
        self.add(one_dot)

        self.stop_ambient_camera_rotation()
        self.begin_ambient_camera_rotation(rate=0.02)
        self.set_quat(special_q)
        self.play(FadeInFrom(label, IN))
        self.wait(3)
        for circle in [circle1, circle2]:
            self.play(ShowCreation(circle, run_time=3))
            circle.updaters = circle.tucked_away_updaters
            self.wait(2)
        self.play(
            FadeInFrom(hand, 2 * IN + 2 * RIGHT),
            run_time=2
        )
        hand.add_updater(
            lambda h: h.move_to(circle1[0].points[0], LEFT)
        )

        for quat in [special_q, [1, 0, 0, 0], special_q]:
            self.play(
                m_tracker.set_value, special_q,
                *updates,
                run_time=run_time,
            )
            self.wait()


class MentionCommutativity(TeacherStudentsScene):
    def construct(self):
        kwargs = {
            "tex_to_color_map": {
                "q": MAROON_B,
                "p": YELLOW,
                "i": GREEN,
                "j": RED,
                "k": BLUE,
            }
        }
        general_eq = TexMobject("q \\cdot p \\ne p \\cdot q", **kwargs)
        general_eq.get_part_by_tex("\\ne").submobjects.reverse()
        ij_eq = TexMobject("i \\cdot j = k", **kwargs)
        ji_eq = TexMobject("j \\cdot i = -k", **kwargs)

        for mob in [general_eq, ij_eq, ji_eq]:
            mob.move_to(self.hold_up_spot, DOWN)

        words = TextMobject("Multiplication doesn't \\\\ commute")
        words.next_to(general_eq, UP, MED_LARGE_BUFF)
        words.shift_onto_screen()

        joke = TextMobject("Quaternions work from home")
        joke.scale(0.75)
        joke.to_corner(UL, MED_SMALL_BUFF)

        self.play(
            FadeInFromDown(general_eq),
            self.teacher.change, "raise_right_hand",
            self.get_student_changes("erm", "confused", "sassy")
        )
        self.play(FadeInFrom(words, RIGHT))
        self.wait(2)
        self.play(
            ReplacementTransform(words, joke),
            general_eq.shift, UP,
            FadeInFromDown(ij_eq),
            self.get_student_changes(*["pondering"] * 3)
        )
        self.look_at(self.screen)
        self.wait(3)
        self.play(
            FadeInFrom(ji_eq),
            LaggedStartMap(
                ApplyMethod, VGroup(ij_eq, general_eq),
                lambda m: (m.shift, UP),
                lag_ratio=0.8,
            )
        )
        self.look_at(self.screen)
        self.wait(5)


class RubuiksCubeOperations(SpecialThreeDScene):
    def construct(self):
        self.set_camera_orientation(**self.get_default_camera_position())
        self.begin_ambient_camera_rotation()
        cube = RubiksCube()
        cube.shift(2.5 * RIGHT)
        cube2 = cube.copy()

        self.add(cube)
        self.play(
            Rotate(cube.get_face(RIGHT), 90 * DEGREES, RIGHT),
            run_time=2
        )
        self.play(
            Rotate(cube.get_face(DOWN), 90 * DEGREES, UP),
            run_time=2
        )
        self.wait()
        self.play(
            cube.shift, 5 * LEFT,
            FadeIn(cube2)
        )
        self.play(
            Rotate(cube2.get_face(DOWN), 90 * DEGREES, UP),
            run_time=2
        )
        self.play(
            Rotate(cube2.get_face(RIGHT), 90 * DEGREES, RIGHT),
            run_time=2
        )
        self.wait(6)


class RotationsOfCube(SpecialThreeDScene):
    def construct(self):
        self.set_camera_orientation(**self.get_default_camera_position())
        self.begin_ambient_camera_rotation(0.0001)
        cube = RubiksCube()
        cube2 = cube.copy()
        axes = self.get_axes()
        axes.scale(0.75)

        label1 = TextMobject(
            "z-axis\\\\",
            "then x-axis"
        )
        label2 = TextMobject(
            "x-axis\\\\",
            "then z-axis"
        )
        for label in [label1, label2]:
            for part in label:
                part.add_background_rectangle()
            label.rotate(90 * DEGREES, RIGHT)
            label.move_to(3 * OUT + 0.5 * IN)

        self.add(axes, cube)
        self.play(
            Rotate(cube, 90 * DEGREES, OUT, run_time=2),
            FadeInFrom(label1[0], IN),
        )
        self.play(
            Rotate(cube, 90 * DEGREES, RIGHT, run_time=2),
            FadeInFrom(label1[1], IN),
        )
        self.wait()
        self.play(
            cube.shift, 5 * RIGHT,
            label1.shift, 5 * RIGHT,
            Write(cube2, run_time=1)
        )
        self.play(
            Rotate(cube2, 90 * DEGREES, RIGHT, run_time=2),
            FadeInFrom(label2[0], IN),
        )
        self.play(
            Rotate(cube2, 90 * DEGREES, OUT, run_time=2),
            FadeInFrom(label2[1], IN),
        )
        self.wait(5)


class OneFinalPoint(TeacherStudentsScene):
    def construct(self):
        self.teacher_says("One final point!")
        self.change_student_modes("happy", "tease", "thinking")
        self.wait(3)


class MultiplicationFromTheRight(Scene):
    def construct(self):
        i, dot, j = product = TexMobject("i", "\\cdot", "j")
        product.set_height(1.5)
        product.to_edge(UP, buff=LARGE_BUFF)
        i.set_color(GREEN)
        j.set_color(RED)
        i_rect = SurroundingRectangle(i)
        j_rect = SurroundingRectangle(j)
        i_rect.match_height(j_rect, about_edge=UP, stretch=True)
        VGroup(i_rect, j_rect).set_color(WHITE)
        action_words = TextMobject("Think of as \\\\ an action")
        point_words = TextMobject("Think of as \\\\ a point")
        action_words.next_to(i_rect, LEFT)
        point_words.next_to(j_rect, RIGHT)

        arrow = Arrow(
            i.get_top(),
            j.get_top(),
            path_arc=-PI,
        )
        arrow.set_stroke(width=2)

        self.add(product)
        self.play(ShowCreation(arrow))
        self.play(
            FadeIn(i_rect),
            Write(action_words)
        )
        self.wait()
        self.play(
            FadeIn(j_rect),
            Write(point_words)
        )
        self.wait(2)
        self.play(arrow.flip)
        self.play(Swap(point_words, action_words))


class MultiplicationByJFromRight(ShowJMultiplication):
    def show_multiplication(self):
        self.set_camera_orientation(theta=-80 * DEGREES)

        q_tracker = self.q_tracker
        m_tracker = self.multiplier_tracker

        def normalize_tracker(t):
            t.set_value(normalize(t.get_value()))

        updates = [
            UpdateFromFunc(tracker, normalize_tracker)
            for tracker in (q_tracker, m_tracker)
        ]

        run_time = self.run_time_per_rotation

        m_values = [[1, 0, 0, 0]]
        q_values = [[0, 1, 0, 0]]
        for values in m_values, q_values:
            for x in range(4):
                values.append(
                    q_mult(values[-1], [0, 0, 1, 0])
                )

        for m_val, q_val in zip(m_values, q_values):
            self.play(
                m_tracker.set_value, m_val,
                q_tracker.set_value, q_val,
                *updates,
                run_time=run_time,
            )
            self.wait(2)

    def get_projected_sphere(self, *args, **kwargs):
        kwargs["multiply_from_right"] = True
        return ShowJMultiplication.get_projected_sphere(
            self, *args, **kwargs
        )

    def get_projected_circle(self, *args, **kwargs):
        kwargs["multiply_from_right"] = True
        return ShowJMultiplication.get_projected_circle(
            self, *args, **kwargs
        )


class HowQuaternionsRotate3dPoints(Scene):
    def construct(self):
        title = TextMobject(
            "Coming up:\\\\",
            "How quaternions act on 3d points"
        )
        title.to_edge(UP)

        expression = TexMobject(
            "q", "\\cdot", "p", "\\cdot", "q^{-1}"
        )
        expression.scale(2)
        expression.set_color_by_tex("q", PINK)
        expression.set_color_by_tex("p", YELLOW)

        right_arrow = Arrow(
            expression[0].get_top(),
            expression[2].get_top(),
            path_arc=-PI,
            color=WHITE,
        )
        right_arrow.set_stroke(width=4)
        left_arrow = right_arrow.copy()
        left_arrow.flip(about_point=expression[2].get_top())
        left_arrow.shift(SMALL_BUFF * RIGHT)

        self.add(title)
        self.play(Write(expression))
        self.play(ShowCreation(right_arrow))
        self.play(ShowCreation(left_arrow))
        self.wait()


class HoldUpQuanta(TeacherStudentsScene):
    def construct(self):
        logo = ImageMobject("Quanta logo")
        logo.set_width(6)
        logo.next_to(self.teacher, UR)
        logo.to_edge(RIGHT, buff=2)

        words = TextMobject("Associated quaternion post")
        words.to_edge(UP, buff=LARGE_BUFF)
        arrow = Arrow(logo.get_top(), words.get_bottom())

        self.play(
            FadeInFromDown(logo),
            self.teacher.change, "raise_right_hand"
        )
        self.change_all_student_modes("hooray")
        self.play(
            GrowArrow(arrow),
            GrowFromPoint(words, arrow.get_start())
        )
        self.wait(3)


class ShareWithFriends(PiCreatureScene):
    def construct(self):
        pi1, pi2 = self.pi_creatures

        self.pi_creature_says(
            pi1, "Come learn about \\\\ quaternions!",
            bubble_kwargs={
                "direction": LEFT,
                "width": 4,
                "height": 3,
            },
            target_mode="hooray",
            look_at_arg=pi2.eyes,
            added_anims=[
                ApplyMethod(
                    pi2.change, "confused",
                    run_time=1.5,
                    rate_func=squish_rate_func(smooth, 0.3, 1)
                )
            ]
        )
        bubble = ThoughtBubble(
            direction=RIGHT,
            width=4,
            height=4,
        )
        bubble.pin_to(pi2)
        bubble.write("What's that, some\\\\kind of particle?")
        bubble.resize_to_content()
        VGroup(bubble, bubble.content).shift_onto_screen(buff=SMALL_BUFF)
        self.play(
            pi2.look_at, pi1.eyes,
            pi1.look_at, pi2.eyes,
            ShowCreation(bubble),
            Write(bubble.content),
        )
        self.wait(1)
        self.play(
            RemovePiCreatureBubble(pi1, target_mode="raise_right_hand")
        )
        self.wait()

        time_words = TextMobject("Oh man...\\\\30 minutes")
        time_words.move_to(bubble.content)
        self.play(
            Animation(VectorizedPoint().next_to(pi1, UL, LARGE_BUFF)),
            pi2.change, "sad",
            FadeOutAndShift(bubble.content, DOWN),
            FadeInFromDown(time_words, DOWN),
        )
        self.wait(7)

    def create_pi_creatures(self):
        pi1 = PiCreature(color=BLUE)
        pi1.to_edge(DOWN)
        pi1.flip()
        pi1.shift(2.5 * RIGHT)
        pi2 = PiCreature(color=RED)
        pi2.to_edge(DOWN)
        pi2.shift(2 * LEFT)
        return [pi1, pi2]


class QuaternionEndscreen(PatreonEndScreen):
    CONFIG = {
        "specific_patrons": [
            "Juan Benet",
            "Matt Russell",
            "soekul",
            "Desmos",
            "Burt Humburg",
            "Dinesh Dharme",
            "Scott Walter",
            "Brice Gower",
            "Peter Mcinerney",
            "brian tiger chow",
            "Joseph Kelly",
            "Roy Larson",
            "Andrew Sachs",
            "Hoàng Tùng Lâm",
            "Devin Scott",
            "Akash Kumar",
            "Arthur Zey",
            "David Kedmey",
            "Ali Yahya",
            "Mayank M. Mehrotra",
            "Lukas Biewald",
            "Yana Chernobilsky",
            "Kaustuv DeBiswas",
            "Yu Jun",
            "dave nicponski",
            "Jordan Scales",
            "Markus Persson",
            "Lukáš Nový",
            "Fela",
            "Randy C. Will",
            "Britt Selvitelle",
            "Jonathan Wilson",
            "Ryan Atallah",
            "Joseph John Cox",
            "Luc Ritchie",
            "Ryan Williams",
            "Michael Hardel",
            "Federico Lebron",
            "L0j1k",
            "Ayan Doss",
            "Dylan Houlihan",
            "Steven Soloway",
            "Art Ianuzzi",
            "Nate Heckmann",
            "Michael Faust",
            "Richard Comish",
            "Nero Li",
            "Valeriy Skobelev",
            "Adrian Robinson",
            "Solara570",
            "Peter Ehrnstrom",
            "Kai Siang   Ang",
            "Alexis Olson",
            "Ludwig Schubert",
            "Omar Zrien",
            "Sindre Reino Trosterud",
            "Jeff Straathof",
            "Matt Langford",
            "Matt Roveto",
            "Magister Mugit",
            "Stevie Metke",
            "Cooper Jones",
            "James Hughes",
            "John V Wertheim",
            "Song Gao",
            "Richard Burgmann",
            "John Griffith",
            "Chris Connett",
            "Steven Tomlinson",
            "Jameel Syed",
            "Bong Choung",
            "Zhilong Yang",
            "Giovanni Filippi",
            "Eric Younge",
            "Prasant Jagannath",
            "Cody Brocious",
            "James H. Park",
            "Norton Wang",
            "Kevin Le",
            "Oliver Steele",
            "Yaw Etse",
            "Dave B",
            "Delton Ding",
            "Thomas Tarler",
            "1stViewMaths",
            "Jacob Magnuson",
            "Clark Gaebel",
            "Mathias Jansson",
            "David Clark",
            "Michael Gardner",
            "Mads Elvheim",
            "Awoo",
            "Dr  David G. Stork",
            "Ted Suzman",
            "Linh Tran",
            "Andrew Busey",
            "John Haley",
            "Ankalagon",
            "Eric Lavault",
            "Boris Veselinovich",
            "Julian Pulgarin",
            "Jeff Linse",
            "Robert Teed",
            "Jason Hise",
            "Bernd Sing",
            "James Thornton",
            "Mustafa Mahdi",
            "Mathew Bramson",
            "Jerry Ling",
            "Rish Kundalia",
            "Achille Brighton",
            "Ripta Pasay",
        ],
    }


class ThumbnailP1(RuleOfQuaternionMultiplication):
    CONFIG = {
        "three_d_axes_config": {
            "num_axis_pieces": 20,
        },
        "unit_labels_scale_factor": 1.5,
        "quaternion": [1, 0, 0, 0],
    }

    def construct(self):
        self.setup_all_trackers()
        self.remove(self.pink_dot_label)
        q_tracker = self.q_tracker
        m_tracker = self.multiplier_tracker

        # quat = normalize([-0.5, 0.5, -0.5, 0.5])
        quat = normalize(self.quaternion)
        m_tracker.set_value(quat)
        q_tracker.set_value(quat)
        proj_sphere = self.get_projected_sphere(0, solid=False)
        # self.specially_color_sphere(proj_sphere)
        proj_sphere.set_color_by_gradient(
            BLUE, YELLOW
        )
        proj_sphere.set_stroke(WHITE)
        proj_sphere.set_fill(opacity=0.4)
        for i, face in enumerate(proj_sphere):
            alpha = i / len(proj_sphere)
            opacity = 0.7 * (1 - there_and_back(alpha))
            face.set_fill(opacity=opacity)

        # unit_sphere = self.get_projected_sphere(0, quaternion=[1, 0, 0, 0], solid=False)
        # self.specially_color_sphere(unit_sphere)
        # unit_sphere.set_stroke(width=0)
        # proj_sphere.set_fill_by_checkerboard(BLUE_E, BLUE, opacity=0.8)
        for face in proj_sphere:
            face.points = face.points[::-1]
            max_r = np.max(np.apply_along_axis(get_norm, 1, face.points))
            if max_r > 30:
                face.fade(1)

        for label in self.unit_labels:
            label.set_shade_in_3d(False)
            label.set_background_stroke(color=BLACK, width=2)

        self.add(proj_sphere)
        # self.add(unit_sphere)

        for mobject in self.mobjects:
            try:
                mobject.shift(IN)
            except ValueError:
                pass

        self.set_camera_orientation(
            phi=70 * DEGREES,
            theta=-110 * DEGREES,
        )


class ThumbnailP2(ThumbnailP1):
    CONFIG = {
        "quaternion": [0, 1, 0, 0],
    }


class ThumbnailOverlay(Scene):
    def construct(self):
        title = TextMobject("Quaternions \\\\", "visualized")
        title.set_width(7)
        # title[1].scale(0.7, about_edge=UP)
        title.to_edge(UP, buff=MED_SMALL_BUFF)
        v_line = Line(DOWN, UP)
        v_line.set_height(FRAME_HEIGHT)

        title.set_background_stroke(color=BLACK, width=1)

        for part in (title[0][4:6], title[1][4:5]):
            rect = BackgroundRectangle(part)
            rect.set_fill(opacity=1)
            rect.stretch(0.9, 0)
            rect.stretch(1.1, 1)
            title.add_to_back(rect)
        # title.add_to_back(BackgroundRectangle(title[0]))

        arrow = Arrow(LEFT, RIGHT)
        arrow.scale(1.5)
        arrow.tip.scale(2)
        arrow.set_stroke(width=10)
        arrow.set_color(YELLOW)

        self.add(v_line)
        self.add(arrow)
        self.add(title)
