Adding a Scene Cacher

[safinsingh]

For tedious and long animations, people often have to render it multiple times just to see a small change they made, wasting lots of time. I'm not exactly sure how we could accomplish this, but we could look into having a way to cache scenes that have already been animated. Since all partial scenes are already stored, it would be easy to stitch together scenes that have already been animated. Also, you could verify that the scene has already been animated by adding it to some sort of array containing the hashes (MD5) of the scene, and hashing each scene before animating it. This way, if a scene has already been animated, it will skip over re-animating it and instead include the partial movie file that it has already been animated in. This could save a lot of time for people who come to use manim more often, so it should, at least somewhat, be a priority in this user-experience-based version of manim.

[huguesdevimeux]

This is a very good idea.

That reminds the optimization with the non-moving objects self.update_frame(excluded_mobjects=moving_mobjects) (l. 921 of scene.py) Maybe we could do something like that.

[leotrs]

Very very good. I'd love to see a PR on this. @safinsingh would you be down to do that?

[safinsingh]

I can try to, but I'm not exactly sure how to get started

[kilacoda-old]

Maybe ffprobe can be used? Though I don't know what impact it'll have on speed.

[Aathish04]

I was thinking of a system where, similar to what tex_file_writing.py does, the partial_video_files are named with a completely unique name, maybe like safinsingh suggested, with the md5 hash of something completely unique to each video file.

Since each play() like call makes its own video, maybe the md5 hash of the pixel array at the middle of each self.play would be unique enough?

We can then check if the hash matches with the name of the video file, and if it doesn't, then ffmpeg can rewrite the video file.

But now there's the issue of how we can get to the middle of the self.play without writing whatever came before it to the video file...

[kilacoda-old]

https://dsp.stackexchange.com/a/15133
https://stackoverflow.com/questions/32317857/digital-signature-hash-of-mp4-video

I was thinking of doing something like that too but apparently hashing video files and their subsegments isn't all that easy.

[Aathish04]

We don't need to hash the video after it's been created.

We hash a single/multiple frame(s) from the video, and name the video with that, and compare the names the next time it's rendered.

Since we can get at the pixel arrays of the frames pretty easily, we could get the hashes of those.

Now that I think about it, we could get the whole contents of the self.play call as a list of pixel arrays of the frames, and name the temporary mp4 with that...

[huguesdevimeux]

@Aathish04 But what is the interest if we render the scene before comparing ?
I mean, it's useless since (if I did understand well) what we want to avoid is rendering.
If we build a mechanism like that it should work before the rendering and prevent manim to even have the already-rendered scenes in memory.

[Aathish04]

@Aathish04 But what is the interest if we render the scene before comparing ?
I mean, it's useless since (if I did understand well) what we want to avoid is rendering.
If we build a mechanism like that it should work before the rendering and prevent manim to even have the already-rendered scenes in memory.

You raise a good point.

My partially working approach to this was to leverage manim's inbuilt ability to skip writing frames to FFMPEG, so the scenes are rendered, but not written to video files (kind of like what the -n flag does, but now, letting FFMPEG write the whole scene using cached and non cached video clips. ) This itself speeds up the process quite a bit.

The problems with the above approach were that the modifications made to the scene needed to be extreme in order for my modifications to pick up on the changes and actually write the new clip to a video file. I had to completely remove objects in order for Manim to pick up the changes... which isn't ideal.

I'm not sure how we can avoid rendering completely, considering that we need something to compare the old partial movie file with...

[safinsingh]

Would it be possible to somehow parse and hash the play() statements of a scene and write that to a file? That way, before even rendering an animation, it will first see if that hash has already been rendered therefore completely skipping it. Additionally, if the file containing hashes seems to be a problem, we could name the file with the md5 hash of the play statement itself concatenated with the position of mobjects (to avoid replaying clips that have the same animation but different mobject positions)

[Aathish04]

That strategy may work for smaller scenes, but if you have multiple mobjects moving around, say, due to an updater, simulating a system (which both of us have done, I think, @safinsingh ;) ), the name would become impossibly long.

Also, there's a method in Scene.py named compile_play_args_to_animation_list, that is called by self.play() and which converts everything there to a giant list of just Animations that can then be played through.

We could hash the output of that list...

This would lead to another problem though... how do we deal with self.wait() and updating?

[huguesdevimeux]

@Aathish04 Could you clarify in what extent that is a problem ?

[Aathish04]

@Aathish04 Could you clarify in what extent that is a problem ?

Gladly.

Looking at the way self.wait() is implemented, it seems to directly write frames to FFMPEG'S frame buffer.

https://github.com/ManimCommunity/manim/blob/master/manim/scene/scene.py#L1076

https://github.com/ManimCommunity/manim/blob/master/manim/scene/scene.py#L1130

How do we circumvent this?

[huguesdevimeux]

Aahhh I see.

I have an idea :
This is a little bit tricky but, since the waiting-partial-movies depends on the scene that happened just before, maybe we could say that if the scene before was identical (cached) and wait with the same parameters is called, we use the wait-partial-movie cached.

Thoughts ? I hope it's clear