Mathematica: Asynchronous incremental generation of dynamical graphics - wolfram-mathematica

Question

What is the simplest way to asynchronously apply consecutive improvements to a Graphics object in a dynamic setting (and abort the evaluation of the unneeded results if input changes while they are being computed)?
As a simple example, consider this:
speed[r_] := Graphics#{Red, Circle[{0, 0}, r]}
qualityA[r_] := (Pause[1]; Graphics#{Red, Disk[{0, 0}, r]})
qualityB[r_] := (Pause[1]; Graphics#{Black, Circle[{0, 0}, r]})
Manipulate[Show[
ControlActive[speed[r], {qualityA[r], qualityB[r]}],
PlotRange -> {{-1, 1}, {-1, 1}}
], {{r, .5}, 0, 1}]
How can I evaluate qualityA and qualityB consecutively, and append their output to the display when it is ready?
Bonus points for Abort'ing the evaluation of unneeded results, and for allowing a part of the result to be calculated multiple times, so that after releasing the control I would see e.g. {qualityA[r]} then {qualityA[r],qualityB[r]}, and finally {qualityA2[r],qualityB[r]}.

Answer 1

My colleague Lou, an expert on Dynamic, suggested this neat answer:
Manipulate[
ControlActive[
Graphics[{LightRed, Circle[{0, 0}, r]},
PlotRange -> {{-1, 1}, {-1, 1}}],
DynamicModule[{exprs = {Red, Circle[{0, 0}, r]}, rr = r},
Graphics[Dynamic[exprs], PlotRange -> {{-1, 1}, {-1, 1}}],
Initialization :> (Pause[1];
AppendTo[exprs, {Red, Disk[{0, 0}, rr]}]; Pause[1];
AppendTo[exprs, {Black, Circle[{0, 0}, rr]}]),
SynchronousInitialization -> False]], {{r, 0.5}, 0, 1}]
How it works:
When not ControlActive, the result of the dynamic expression is a DynamicModule. The code for refining the graphics is contained in the Initialization option of this DynamicModule. The SynchronousInitialization -> False makes this initialization run asynchronously.
Renaming rr = r in the DynamicModule serves two purposes. First, it makes the result always depend on the Manipulate variable r. Second, you can check rr != r to decide whether the user has moved the slider during initialization, and abort early, saving computation time:
Manipulate[
ControlActive[
Graphics[{LightRed, Circle[{0, 0}, r]},
PlotRange -> {{-1, 1}, {-1, 1}}],
DynamicModule[{exprs = {Red, Circle[{0, 0}, r]}, rr = r},
Graphics[Dynamic[exprs], PlotRange -> {{-1, 1}, {-1, 1}}],
Initialization :> (If[rr =!= r, Abort[]]; Pause[1];
AppendTo[exprs, {Red, Disk[{0, 0}, rr]}]; If[rr =!= r, Abort[]];
Pause[1]; AppendTo[exprs, {Black, Circle[{0, 0}, rr]}]),
SynchronousInitialization -> False]], {{r, 0.5}, 0, 1}]
I hope this helps.

Answer 2

Really good question.
I may be overlooking a simpler way. There often is one when it comes to Dynamic... But here is my suggestion:
DynamicModule[{quality = 0, exprs = {}},
Manipulate[
Show[
ControlActive[
exprs = {}; quality = 0; Graphics#{Red, Circle[{0, 0}, r]},
Switch[quality,
0, Pause[1]; quality = 1;
AppendTo[exprs, Graphics#{Red, Disk[{0, 0}, r]}],
1, Pause[1]; quality = 2;
AppendTo[exprs, Graphics#{Black, Circle[{0, 0}, r]}],
_, r];
exprs
],
PlotRange -> {{-1, 1}, {-1, 1}}],
{{r, .5}, 0, 1}
]
]
First we define some variables controlling increasingly high quality graphics: quality (ranging to 0 to the maximum quality, 2 in this case), and exprs (a list of expressions to Show, just as in your example).
Now note what happens in the two cases of ControlActive:
When ControlActive, the result is the same as yours, except we take the opportunity to reset quality and exprs relating to the "high quality" graphics.
When not ControlActive, the Dynamic expression evaluates to
code; exprs
This expression has the following key properties.
It returns the list exprs every time.
Each time code is evaluated, it improves the graphics by appending something to exprs.
Each time code is evaluated, at least one of the variables lexically contained in code; exprs (such as quality) is changed. This means Dynamic will go ahead and evaluate our dynamic expression again, and again, and again, until ...
Eventually code evaluates without any of the variables lexically contained in code; exprs changing. This means Dynamic will stop re-evaluating.
The final evaluation lexically contains r. (Via the otherwise useless default case in the Switch, _, r.) This is important to make the slider still trigger updates.
Give it a try and let me know if that works for you.
Edit: What $Version of Mathematica are you using? I see some version dependence in the behavior of my code above.
Edit 2: I asked an expert on Dynamic and he found a better way, which I will describe in a separate answer.