drawnow

Update figures and process callbacks

Syntax

drawnow

drawnow limitrate

drawnow nocallbacks

drawnow limitrate nocallbacks

drawnow update

drawnow expose

Description

drawnow updates figures and processes any pending callbacks. Use this command if you modify graphics objects and want to see the updates on the screen immediately.

drawnow limitrate limits the number of updates to 20 frames per second. If it has been fewer than 50 milliseconds since the last update, or if the graphics renderer is busy with the previous change, then drawnow discards the new updates. Use this command if you are updating graphics objects in a loop and do not need to see every update on the screen. Skipping updates can create faster animations. Pending callbacks are processed, so you can interact with figures during animations.

drawnow nocallbacks defers callbacks, such as the ButtonDownFcn callback, until the next full drawnow command. Use this option if you want to prevent callbacks from interrupting your code. Deferring callbacks temporarily disables figure interactions, such as mouse clicks or resizing the figure. Deferring callbacks does not affect animation speed.

drawnow limitrate nocallbacks limits the number of updates to 20 frames per second and skips updates if the renderer is busy. This syntax also prevents callbacks from interrupting your code, which temporarily disables figure interactions.

drawnow update skips updates if the renderer is busy and defers callbacks. This syntax is not recommended. Use the limitrate option instead.

drawnow expose updates figures, but defers callbacks. This syntax is not recommended. Use the nocallbacks option instead.

Examples

Create Animation of Streaming Data

Create an animation of a line growing as it accumulates 2,000 data points. Use drawnow to display the changes on the screen after each iteration through the loop.

h = animatedline;
axis([0 4*pi -1 1])
x = linspace(0,4*pi,2000);

for k = 1:length(x)
    y = sin(x(k));
    addpoints(h,x(k),y);
    drawnow
end

Skip Updates for Faster Animation

Create an animation of a line growing as it accumulates 10,000 points. Since there are 10,000 points, drawing each update on the screen is slow. Create a faster, smooth animation by limiting the number of updates using drawnow limitrate. Then, display the final updates on the screen by calling drawnow after the loop ends.

h = animatedline;
axis([0 4*pi -1 1])
x = linspace(0,4*pi,10000);

for k = 1:length(x)
    y = sin(x(k));
    addpoints(h,x(k),y);
    drawnow limitrate
end
drawnow

Precompute Data, Then Create Animation

Compute all the data before the animation loop.

h = animatedline;
axis([0 4*pi -1 1])
x = linspace(0,4*pi,10000);
y = sin(x);

for k = 1:length(x)
    addpoints(h,x(k),y(k));
    drawnow limitrate
end
drawnow

If you have long computations, precomputing the data can improve performance. Precomputing minimizes the computation time by letting the computation run without interruptions. Additionally, it helps ensure a smooth animation by focusing on only graphics code in the animation loop.

More About

Actions Equivalent to drawnow

These actions are equivalent to calling a full drawnow command:

• Returning to the MATLAB^® prompt.

• Using the getframe, pause, and waitfor functions.

• Using functions that wait for user input, such as waitforbuttonpress, input, keyboard, or ginput.

Tips

• The nocallbacks option always adds interrupting callbacks to the queue. If you want to discard interrupting callbacks, then use the Interruptible and BusyAction properties instead.