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.

[Pasquale19]

Hey I found this thread while having some trouble to rotate objects at constant speed. After I read your thread I still don't understand why I can't rotate objects at constant speed when I use rate_func=linear. Something like this:

 self.play(theta_track.animate.increment_value(PI/2), run_time=10,rate_func=linear)
 self.play(Rotate(s1, angle=PI/2),run_time=5,rate_func=linear)

My workaround was to use the time parameter of the scene self.time. However I want to control the rotation by a ValueTracker.
Can somebody explain me this?

[uwezi]

your second line certainly gives a rotation at constant angular speed. For the first line it's unclear how you actually implemented the corresponding rotation using a value tracker, but if your updater contains a rotate(angle=theta_track.get_value()....) then your object will be rotated by increasing amounts starting at 0 degrees for the first frame generated, but from the next-to-last frame to the last frame your object will be rotated a full 90 degrees just in one frame.
If you program your updater correctly then you need something inside your object which can track the current rotation angle obtained in the previous call to the updater and only rotate the missing angle piece.

class rotations(Scene):
    def construct(self):
        theta = ValueTracker(0)

        obj1 = Text("incorrect").shift(4*LEFT)

        obj2 = VGroup(
            Text("correct"),
            Line([-1,0,0],[1,0,0],stroke_width=0) # invisible line
        )

        obj3 = Text("alternative").shift(4*RIGHT)

        def obj1_upd(obj):
            obj.rotate(theta.get_value(), about_point=obj.get_center_of_mass())
        obj1.add_updater(obj1_upd)

        def obj2_upd(obj):
            current_theta = obj[1].get_angle()
            obj.rotate(theta.get_value()-current_theta, about_point=obj.get_center_of_mass())
        obj2.add_updater(obj2_upd)

        self.add(obj1,obj2,obj3)
        self.wait()
        self.play(
            theta.animate.set_value(PI),
            Rotate(obj3, about_point=obj3.get_center_of_mass()),
            rate_func=rate_functions.linear,
            run_time=10
        )
        self.wait()

rotations.mp4

[Pasquale19]

Thank you for your quick explanation. In my first attempt I used something like you with obj. Then I tried different other methods. However it seems like I made a little spelling error in rate_func=rate_functions.linear in my sample scene.
Now I understand and know how to rotate my object at constant speed. Thank you.