Enormously slow performance of the rendering with updaters and two axes at the same time

[FrightenedFox]

Hey everyone,

In my opinion, my problem seems to be a topic for a new issue, but I'm not sure I've done everything correctly, so I would be very grateful for any suggestions/help.

Description:

The performance of the rendering drops drastically with axes and updaters. If any one of them is removed the problem disappears.

Expected rendering speed:

ExpectedRenderingPerformance.mp4

Current rendering speed:

CurrentRenderingPerformance.mp4

Code:

The code is pretty much long, but I don't have an idea how to explain this properly in a shorter way.

from manimlib import *


# Change the following flag to compare the performance of the animation
WITHOUT_UPDATER = False


def rotate_line(k_old, b_old, angle):
    """
    Changes the parameters of the line (y = kx + b)
    in such a way that the line rotates about the 
    point where it intersects with the X axis
    """
    # let x == 1 and b_old == 0 then y_old == k_old
    x_new = np.cos(angle) - k_old * np.sin(angle)
    y_new = np.sin(angle) + k_old * np.cos(angle)
    k_new = y_new / x_new
    b_new = b_old * (k_new / k_old)
    return k_new, b_new


class TwoAxesWithUpdaters(Scene):
    def construct(self):
        axes = Axes(
            x_range=(0, 16, 2),
            y_range=(0, 9, 2),
            height=5,
            width=13,
            num_sampled_graph_points_per_tick=50,
        )
        
        # NOTE: XX is the number of the scene in the (sXX) comments
        # (s00)
        self.play(Write(axes, lag_ratio=0.001, run_time=1))

        dot_coords = [(7, 3), (13, 7), (9, 6)]
        dots = []
        for ind, coords in enumerate(dot_coords):
            dots.append(Dot(color=RED))
            dots[ind].move_to(axes.c2p(*coords))

        # (s01) DESCRIPTION: 3 dots appear
        self.play(*[FadeIn(dot, scale=0.5) for dot in dots])
        axes.add(*dots)

        # Line d1-d2: f(x) := 2/3*x - 5/3
        # Line d2-d3: g(x) := 1/4*x + 15/4
        # Line d1-d3: h(x) := 3/2*x - 15/2

        line_d0d1 = Line(
            axes.c2p(20, 35 / 3),
            axes.c2p(5 / 2, 0),
            stroke_color=MAROON_A,
            stroke_width=3
        )
        line_d1d2 = Line(
            axes.c2p(20, 35 / 4),
            axes.c2p(0, 15 / 4),
            stroke_color=MAROON_A,
            stroke_width=3
        )

        if WITHOUT_UPDATER:
            # (s02) DESCRIPTION: Draw the lines
            self.play(
                FadeIn(line_d0d1),
                FadeIn(line_d1d2),
            )
            axes.add(line_d0d1, line_d1d2)

            # Just to match up the final number of scenes:
            for _ in range(4):
                self.wait(0.001)

        else:

            # (s02) DESCRIPTION: Draw the fitted line and remove pink lines
            k_track, b_track = ValueTracker(.6), ValueTracker(-.5)

            def get_line_graph():
                line = axes.get_graph(
                    lambda x: k_track.get_value() * x + b_track.get_value(),
                    x_range=[5 / 6, 14.5],
                    color=TEAL)
                return DashedVMobject(line,
                                      num_dashes=40,
                                      positive_space_ratio=.6)

            def get_new_params(angle):
                return rotate_line(k_track.get_value(),
                                   b_track.get_value(),
                                   angle=angle)

            line_arx = always_redraw(get_line_graph)
            self.play(FadeIn(line_arx))
            self.add(line_arx)

            # (s03) DESCRIPTION: Add residuals
            res0 = always_redraw(lambda: Line(
                axes.c2p(*dot_coords[0]),
                axes.c2p(
                    dot_coords[0][0],
                    dot_coords[0][0] * k_track.get_value() + b_track.get_value()
                ),
                stroke_color=RED,
                stroke_width=3
            ))
            res1 = always_redraw(lambda: Line(
                axes.c2p(*dot_coords[1]),
                axes.c2p(
                    dot_coords[1][0],
                    dot_coords[1][0] * k_track.get_value() + b_track.get_value()
                ),
                stroke_color=BLUE,
                stroke_width=3
            ))
            res2 = always_redraw(lambda: Line(
                axes.c2p(*dot_coords[2]),
                axes.c2p(
                    dot_coords[2][0],
                    dot_coords[2][0] * k_track.get_value() + b_track.get_value()
                ),
                stroke_color=PURPLE,
                stroke_width=3
            ))
            self.play(FadeIn(res0),
                      FadeIn(res1),
                      FadeIn(res2),
                      dots[1].set_color, BLUE,
                      dots[2].set_color, PURPLE)
            self.bring_to_front(*dots)

            # (s04) DESCRIPTION: move approximated line with residuals
            def rotate_line_arx(angle):
                k_new, b_new = get_new_params(angle)
                self.play(k_track.set_value, k_new,
                          b_track.set_value, b_new,
                          rate_func=smooth)

            for ang in [PI / 20, -PI / 10, PI / 20]:
                rotate_line_arx(ang)

        # (s07) DESCRIPTION: Add another axes
        axes2 = Axes(
            x_range=(0, 1, 0.1),
            y_range=(0, 1, 0.2),
            height=5,
            width=13
        ).set_width(9).to_corner(UL, SMALL_BUFF)
        self.play(
            axes.set_width, 9,
            axes.to_corner, DL, SMALL_BUFF
        )
        self.play(
            Write(axes2, lag_ratio=0.001, run_time=1),
        )

        # (s09) DESCRIPTION: draw y = x ** 2 on the second axes
        line_x_squared = axes2.get_graph(
            lambda x: x ** 2,
            x_range=[0, 1],
            color=YELLOW
        )
        self.play(Write(line_x_squared))

        # (s10) DESCRIPTION: transform y = x ** 2 to y = x
        line_x = axes2.get_graph(
            lambda x: x,
            x_range=[0, 1],
            color=ORANGE
        )
        self.play(ReplacementTransform(line_x_squared, line_x))
        self.wait()

So, the question is: have I done anything wrong or do I have to open a new issue?

Thank you.