Best practice to rotate Mobjects -> Idea DeltaValueTracker

[kolibril13]

I found currently 5 ways rotate Mobjects in manim, but they are all not very satisfying when one wants to use normal ValueTrackers. Here is the example:

class DoAndDont(ZoomedScene):
    def construct(self, **kwargs):
        s1= Square().set_color(YELLOW)
        s2= Square().set_color(PURPLE)
        s3= Square().set_color(ORANGE)
        s4= Square().set_color(GREEN)
        s5= Square().set_color(BLUE)
        s6= Square().set_color(PINK)

        self.add(s1,s2,s3,s4,s5,s6)
        Group(*self.mobjects).arrange(buff=0.7).scale(0.8)
        np.random.seed(23)
        
        # ValueTracker Approach 3.
        theta_track= ValueTracker(0)
        s3.previous_angle=0
        def pref(x):
            x.previous_angle=theta_track.get_value()
        s3.add_updater(lambda x: x.rotate(theta_track.get_value()-s3.previous_angle))
        s3.add_updater(pref)

        # DeltaValueTracker Approach 4. -> not yet implemented
        #theta_track= DeltaValueTracker(0)
        #s1.add_updater(lambda x: x.rotate(theta_track.get_delta_value()))
        #self.play(theta_track.animate.set_value(90*DEGREES))

        
        # ValueTracker Approach 5. bad practice!
        s5.add_updater(lambda x: x.rotate(theta_track.get_value()))
        
        #dt Approach 6. rotation Let the line rotate 90° per second
        s6.add_updater(lambda mobject, dt: mobject.rotate(dt*PI/2))

        
        self.play(
            AnimationGroup(
            Rotate(s1, angle=PI/2),  # 1. Rotate approach.
            s2.animate.rotate(PI/2), # 2. Animate approach.
            theta_track.animate.increment_value(PI/2) # 3,4,5: ValueTracker approach
            ), run_time=1
        )

1e062afd924abf52d646d92f29347aa7161ec086.mp4

Therefore I had the idea of an DeltaValueTracker, which could look like this:

class DeltaValueTracker(ValueTracker):
    """
    Operates just like ValueTracker, except it has the option to store the previous value as well,
    so it can e.g. be used for rotations.
    """
    def __init__(self,value=0, **kwargs):
        ValueTracker.__init__(self,value,**kwargs)
        self.prev_value =value
        
    # question: how to update: self.prev_value ??
    
    def get_previous_value(self):
        return self.prev_value
    
    def get_delta_value(self):
        return self.get_value()-self.get_previous_value()

    def increment_value(self, d_value):
        self.set_value(self.get_value() + d_value)
    
    def set_value(self, value):
        self.points[0, 0] = value
        return self

class DetltaNewValTry(Scene):
    def construct(self):
        theta_track= DeltaValueTracker(1)
        s = Square().set_color(YELLOW)
        s.add_updater(lambda x: x.rotate(theta_track.get_delta_value())) #not yet working
        self.add(s)
        self.play(theta_track.animate.increment_value(TAU/2))
        self.wait()

Any help on this idea is greatly appreciated.

[PhotonSpheres]

I really like the idea. I guess the get_delta_value could be directly implemented in ValueTracker without the need for DeltaValueTracker? Also, assuming a straight_path, get_delta_value would always give back the same number, namely something like "(end_value - start_value)/alpha", no? So one would need to calculate that number.

[kolibril13]

I chose an extra class for this, because saving the previous value is one extra calculation and could slow down Valuetracker a bit. But when then this is not the case, yes, then we can also directly implement this feature in ValueTracker.

To your second point, in case that rate_func=linear you are right, then the delta is constant, however, when we have e.g. rate_func=smooth, then the delta is not constant anymore.