How to make a movie from a complex demonstration?

Question

I have a complex Manipulate-based demonstration containing a few sliders and a Setterbar.

I would like to make a movie out of it, avi, or whatever else. The movie will then be used for a journal publication as a Supporting material, so the quality should be good enough.

When the movie plays, the Setterbar should set its first value, then the sliders should move one after another, and then together. Further, the setter bar should set its second value and the slider manipulations should be repeated with this new Setterbar value. And so it should go for all Setterbar values. There will be something like 3-4 of them.

Is it possible at all?

To be more precise, I prepared a simplified demonstration with such controls:

    Manipulate[Plot[{Sin[a*x] + b*Cos[3 a*x], k*x}, {x, 0, \[Pi]}],
 {a, 1, 2}, {b, 0, 1}, {k, {0, 0.5, 1}}]

Answer 1

You can define a function that creates Manipulates with a "fake" SetterBar and a specific AutorunSequencing

m[k_, seq_] := Manipulate[
 Plot[{Sin[a*x] + b*Cos[3 a*x], k*x}, {x, 0, Pi}, ImageSize -> 400], 
 {a, 1, 2}, {b, 0, 1}, Grid@{{"k", SetterBar[k, {0, .5, 1}]}}, 
 AutorunSequencing -> seq, ContentSize -> {420, 270}]

then create the frames for the movie with

frames = Join @@ (ArrayPad[
    ImportString[ExportString[#, "AVI"], "ImageList"], {0, 3}, "Fixed"] & /@ 
  Flatten[Table[{m[k, {{1, 1}, {2, 1}}], m[k, {All, 2.85}]}, {k, 0, 1, 0.5}]]);

and export them as using

Export["D:\\animationTest.gif", frames]

or

Export["D:\\animationTest.avi", frames]

Without a specified ContentSize exporting to "AVI" fails, as the size of the frames varies.

Answer 2

I wrote something to do something a little like what you wanted. Here I've adapted it so you can get a run through for each setting of the SetterBar. Some description of the functions.

autolist[control_pattern] := list of manipulate settings for the animation

specs is a pattern for culling variable specifications out of a Manipulate

rulefunction[variable_spec] yields a rule for injecting a setting into a Manipulate

steps[man, sequence, frames] creates an animation of the Manipulate code man by animating the controls in sequence by interpolating over a number of frames, which can be a list the number of frames for each control (in order of the controls). The argument sequence has the form

{{i11, i12,...}, {i22,...},...}

For each setting of the controls in the first list, the controls in the second list run through there settings and so forth (like the iterators of Table).

specs = HoldPattern[Manipulate[body_, stuff___]] :> 
   Cases[Hold[stuff], sp_List :> Hold[sp], {1}];

rulefunction[spec : {{var_, i_, label___}, __} | {var_, __}] :=
  HoldPattern[{_?(MemberQ[{#}, HoldPattern[var], 2] &), rest___}] :> {{var, #,
       label}, rest} &;

(*Manipulator*)
autolist[Hold[
    spec : {var_, min_?NumericQ, max_?NumericQ, opts : OptionsPattern[]}], 
   nFrames_: 20] := Module[{init},
   init = If[Head[var] === List, var[[2]], min];
   Map[
    rulefunction@spec,
    Interpolation[
      Transpose[{Range[0, 1, 
           1/(Length[#] - 1)], #}] &@(DeleteDuplicates[{init, max, min}]~
         Append~init),
      InterpolationOrder -> 1]@Rescale@N@Range@nFrames
    ]
   ];
(*SetterBar/PopupMenu*)
striplabels[data : {__Rule}] := First /@ data;
striplabels[data_] := data
autolist[Hold[spec : {var_, data_List, opts : OptionsPattern[]}], 
   nFrames_: 20] :=
  Map[
   rulefunction@spec,
   striplabels[
       data][[Clip[
        Round[Rescale[#, {0, 1}, {0.5, Length@data + 0.5}]], {1, 
         Length@data}]]] &@Rescale@N@Range@Ceiling[nFrames, Length@data] 
   ];
(*skip anything else - add more cases to handle other controls*)
autolist[__] := {};

Clear[steps];
steps[man_, seq : {__List}, frames_: 20] := 
  With[{specifications = (man /. specs)[[First[seq]]]},
   Table[steps[Replace[man, setting, 1], Rest[seq], frames], {setting, 
     Flatten[MapThread[
       autolist, {specifications, 
        If[Head[frames] === List, frames[[First[seq]]], 
         ConstantArray[frames, Length@specifications]]}]]}]
   ];
steps[man_, {}, ___] := man;

Export["1Example.gif", #] &@
 With[{man = 
    Manipulate[
     Plot[{Sin[a*x] + b*Cos[3 a*x], k*x}, {x, 0, \[Pi]}], {a, 1, 2}, {b, 0, 
      1}, {k, {0, 0.5, 1}}],
   frames = {20, 20, 3}},
  Module[{seq},
   seq = {{3}, {1, 2}};
   Flatten[
    steps[man, seq, frames],
    Length[seq] - 1]
   ]
  ]

Answer 3

This is just an idea how to prepare frames to export, don't have time for more now:

f = Interpolation[
  {
   {0, {1, 0, 0}},
   {1, {2, 0, 0}},
   {2, {2, 1, 0}},
   {2.02, {1, 0, .5}},
   {3, {1, 0, .5}},
   {4, {2, 0, .5}},
   {5, {2, 1, .5}},
   {5.02, {1, 0, 1}},
   {6, {1, 0, 1}},
   {7, {2, 0, 1}},
   {8, {2, 1, 1}}
   },
  InterpolationOrder -> 1];

ClearAll[expr, a, b, k];

expr := Plot[{Sin[a*x] + b*Cos[3 a*x], k*x}, {x, 0, \[Pi]}, 
   PlotRange -> {{0, Pi}, {-2, 2}}];

frames = Block[{a = #, b = #2, k = #3}, expr] & @@@  Array[f, 80, {0, 8}];

ListAnimate @ frames      (*Export["gif.gif", frames]*)

Answer 4

The export to movie is easy. (just write p=Manipulate[..] then export p to movie.

Controlling the sequences as you want, I think have to be programmed in. Autorunsquences does not give one full control of all the scenario needed.

Here is the Manipulate you have. It runs in 2 modes. Automode, runs pre-programmed scenario. Click again, turn this off, so you can use the Manipulate as before (manually).

Manipulate[
 tick;
 Module[{p},
  p = Plot[{Sin[a*x] + b*Cos[3 a*x], k*x}, {x, 0, Pi},PlotRange ->{Automatic, {-3, 3}}];
  If[autoMode,
   Which[1 <= a <= 1.9, a += 0.1; tick = Not[tick],
    0 <= b <= .9, b += 0.1; tick = Not[tick],
    state == "ka", state = "kb"; a = 1; b = 0; k = 0.5; tick = Not[tick],
    state == "kb", state = "done"; k = 1; a = 1; b = 0; tick = Not[tick],
    True, autoMode = False
    ]
   ];
  p],
 Grid[{
   {"a", Manipulator[Dynamic[a, {a = #; tick = Not[tick]} &], {1, 2, .1}, 
      ImageSize -> Tiny], Dynamic[a]},
   {"b", Manipulator[Dynamic[b, {b = #; tick = Not[tick]} &], {0, 1, .1}, 
      ImageSize -> Tiny], Dynamic[b]},
   {"k", SetterBar[Dynamic[k, {k = #, tick = Not[tick]} &], {0, .5, 1}]},
   {Button["run auto mode", autoMode = Not[autoMode];
     If[autoMode, state = "ka"; a = 1; b = 0; k = 0; tick = Not[tick]]]}
   }],
 {{a, 1}, None},
 {{b, 0}, None},
 {{k, 0}, None},
 {{tick, False}, None},
 {{autoMode, False}, None},
 {{state, "ka"}, None},
 TrackedSymbols :> {tick}
 ]