3

I have an animation coded like this:

plt[t_] := ParametricPlot[{Cos[s] + t, Sin[s] + t (t + 2 Cos[s])}, {s, 0, 2 Pi}]; 
spp = StreamPlot[{1, 2 x}, {x, -1.2, 2.0}, {y, -1.2, 2.0}, StreamStyle -> {"Line"}]; 
Animate[Show[plt[u], spp, PlotRange -> All], {u, 0, 0.5}]

Which works fine and runs smoothly. However, if I want a more fancy StreamPlot, dropping the "Line" directive so I now have

plt[t_] := ParametricPlot[{Cos[s] + t, Sin[s] + t (t + 2 Cos[s])}, {s, 0, 2 Pi}]; 
spp = StreamPlot[{1, 2 x}, {x, -1.2, 2.0}, {y, -1.2, 2.0}]; 
Animate[Show[plt[u], spp, PlotRange -> All], {u, 0, 0.5}]

The animation slows down significantly and becomes really choppy. I'm fairly sure this is because the StreamPlot spp takes a lot more work to compute now. However, spp is fixed and does not change during the animation, and one would hope that Mathematica can take advantage of that fact.

I tried a few things I could think of, but I'd rather not embarrass myself even more by showing those; suffice it to say that none of them worked. The advanced documentation on Manipulate talks about using Dynamic inside the body of Manipulate to prevent Mathematica from updating parts that do not need to be updated, but I couldn't get that to work.

Is there a way to tell Mathematica to plot spp, and then animate plt[t]"on top of it", without reevaluating either?

Extended Comment:

Following J.M.'s suggestion, I just tried

plt[t_] := ParametricPlot[{Cos[s] + t, Sin[s] + t (t + 2 Cos[s])}, {s, 0, 2 Pi}]; 
    spp = Graphics[StreamPlot[{1, 2 x}, {x, -1.2, 2.0}, {y, -1.2, 2.0}][[1]]]; 
    Animate[Show[plt[u], spp, PlotRange -> All], {u, 0, 0.5}]

but the animation is just as choppy. However, if I do

Timing[Show[spp]]

I get 0.. I take that to mean that showing the streamplot should not slow things down that much, but perhaps I am missing something.

Pirx
  • 4,139
  • 12
  • 37
  • It may be more effective to pre-calculate a list of the objects to animate, then use ListAnimate on the list. For instance, ListAnimate@ Table[Show[plt1, plt2[u], spp, PlotRange -> All], {u, 0, 0.5, 0.005}] is pretty smooth. Alternatively, you could try and play with the step size in independent variable within Animate together with DisplayAllSteps -> True, and perhaps with AnimationRate. – MarcoB Oct 02 '16 at 00:41
  • Thanks, but I know about the workaround of using ListAnimate. The issue with that is that it may take a long time to initialize the animation, and/or it makes the size of the notebook (and later the CDF) balloon enormously. The advanced documentation on Manipulate talks about using Dynamic inside the body of Manipulate to prevent Mathematica from updating parts that do not need to be updated, but I couldn't get that to work. I'm certain that it's possible to speed things up, I just seem to be unable to figure this out. – Pirx Oct 02 '16 at 00:57
  • The main issue here is that Animate insists on redoing the streamplot for every frame, even though that plot never changes. If I could find a way to keep Mathematica from updating this plot, things would be perfect. – Pirx Oct 02 '16 at 00:59
  • What version and OS are you on? Version 11 on Xubuntu Trusty gives a relatively smooth animation. If need be, you could extract just the first part of spp (it is a Graphics[] object after all) and put that instead in the animation. – J. M.'s missing motivation Oct 02 '16 at 13:45
  • This is version 11.0.1 on Win7 x64. You mean like Animate[Show[plt[u], Graphics[spp[[1]]], PlotRange -> All], {u, 0, 0.5}]? That's just as slow as the first. P.S.: Are you saying you're not seeing a big difference between the two versions I have given? – Pirx Oct 02 '16 at 13:50
  • Nothing noticeable. I'll try it on a Windows machine when I get the chance. – J. M.'s missing motivation Oct 02 '16 at 18:03
  • I just tried it on a faster machine, and the choppiness is much less noticeable, but still there. I think if you have a really fast machine, the issue will be less apparent, or even disappear. – Pirx Oct 02 '16 at 18:18
  • Have you seen this? – Michael E2 Oct 02 '16 at 21:51
  • No, I hadn't seen this. This is a great example for some extensions of things I'm currently working on. Thanks again! – Pirx Oct 02 '16 at 21:56
  • As for timing the rendering of spp, you can't do that with Timing or AbsoluteTiming, which just measure the Kernel time. Here is what I do: In one input cell, put foo = SessionTime[]; AbsoluteTiming[Show[spp]]. In another cell just below it, put SessionTime[] - foo. Select both cells an execute simultaneously. The FE sends the first cell to the Kernel; gets the output and displays it; then sends the second cell etc. – Michael E2 Oct 03 '16 at 02:50

1 Answers1

2

I believe it is simply that rendering many arrows is slower than rendering fewer lines. Wrapping the ParametricPlot[] in Dynamic to isolate the dynamic updates will mean that only part of the graphics will be updated in the FE's workings. Note Show[Dynamic@Graphics[..]] does not work; you have to have the structure Show[Graphics[Dynamic@stuff]] (or have Dynamic buried further within stuff). Below I use ParametricPlot[] to dynamically construct the stuff to be plotted.

plt[t_] := ParametricPlot[{Cos[s] + t, Sin[s] + t (t + 2 Cos[s])}, {s, 0, 2 Pi}];
spp = StreamPlot[{1, 2 x}, {x, -1.2, 2.0}, {y, -1.2, 2.0}];
Animate[Show[Graphics[Dynamic@First@plt[u], Options[plt[0]]], spp, 
  PlotRange -> All],
 {u, 0, 0.5}]

The options Options[plt[0]] could be pre-computed and injected, but since in the above it is never recomputed, it doesn't matter.

Michael E2
  • 235,386
  • 17
  • 334
  • 747
  • Great, that does the trick! My problem really was to figure out how to apply the Dynamic. Thanks! – Pirx Oct 02 '16 at 21:52
  • @Pirx You're welcome. Yeah, I think this problem & trick deserves to be better known. – Michael E2 Oct 02 '16 at 21:54
  • 1
    @Pirx Here's an alternative solution, with a slightly different styling inherited from StreamPlot instead of from ParametricPlot: Animate[StreamPlot[{1, 2 x}, {x, -1.2, 2.0}, {y, -1.2, 2.0}, Epilog -> Dynamic@First@plt[u]], {u, 0, 0.5}] – Michael E2 Oct 02 '16 at 21:59
  • Yes. I'm still at a stage where I'm asking myself whether I was just being dense and should have read the docs more attentively, or whether it's really something that's not easy to discover. For once, that's not even a knock of Wolfram; the functionality is so enormous that I understand it's just hard to document everything properly. But, specifically, how would I have figured out exactly how to use Dynamic here, from the built-in documentation? – Pirx Oct 02 '16 at 21:59
  • 3
    @Pirx I figured out it a long time ago (in V6) by paying attention to what worked and what didn't and thinking about it -- and by a lot of trial and error, and rereading the advanced docs. The generic tip I got from the developers was that the Dynamic[] has to get passed to the Front End. In Show[Dynamic@Plot[],..], it fails in the Kernel, before it reaches the FE. Therefore you have to think of something else. Of course, "passed to the FE" is not the whole story, but for a simple rule, I get pretty good mileage out of it. – Michael E2 Oct 02 '16 at 22:07