How do I redraw an image using Python's Matplotlib?

To redraw an image using Python's Matplotlib, you can dynamically update plots by clearing and redrawing content. This is useful for creating animations or real-time data visualization.

Basic Steps for Redrawing

The process involves these key steps:

• Set the figure size and adjust the padding between and around the subplots
• Create a new figure or activate an existing figure
• Get the current axis using gca() method
• Show the current figure
• Iterate and redraw the plot with new data
• Use plot() method to plot data points
• Redraw on the figure and pause for a while
• Close the figure window when done

Example: Animated Random Points

Here's how to create an animated plot that continuously adds random points:

import numpy as np
from matplotlib import pyplot as plt

plt.rcParams["figure.figsize"] = [7.50, 3.50]
plt.rcParams["figure.autolayout"] = True

fig = plt.figure()
ax = fig.gca()
fig.show()

for i in range(20):
    ax.plot(np.random.randint(1, 5), np.random.randint(1, 5), '*', ms=10)
    fig.canvas.draw()
    plt.pause(0.1)

plt.close(fig)

Method Using clear() for Complete Redraw

For complete redrawing where you replace all content each time:

import numpy as np
import matplotlib.pyplot as plt

# Generate sample data
x = np.linspace(0, 10, 100)

fig, ax = plt.subplots(figsize=(8, 4))

for phase in range(5):
    ax.clear()  # Clear previous content
    y = np.sin(x + phase * 0.5)
    ax.plot(x, y, 'b-', linewidth=2)
    ax.set_title(f'Sine Wave - Phase {phase + 1}')
    ax.set_xlabel('X values')
    ax.set_ylabel('Y values')
    ax.grid(True)
    
    plt.draw()
    plt.pause(0.8)  # Pause to see the animation

print("Animation complete!")

Animation complete!

Key Methods for Redrawing

Interactive Mode Example

Using interactive mode for real-time updates:

import matplotlib.pyplot as plt
import numpy as np

plt.ion()  # Turn on interactive mode

fig, ax = plt.subplots()
x = np.arange(0, 10, 0.1)

for amplitude in [1, 2, 3, 2, 1]:
    ax.clear()
    y = amplitude * np.sin(x)
    ax.plot(x, y, 'r-')
    ax.set_ylim(-3, 3)
    ax.set_title(f'Amplitude: {amplitude}')
    plt.draw()
    plt.pause(0.5)

plt.ioff()  # Turn off interactive mode
print("Interactive redraw complete!")

Interactive redraw complete!

Output

The redrawing creates an animated effect where the plot updates continuously, showing different phases of the sine wave or adding new random points over time.

Conclusion

Use fig.canvas.draw() with plt.pause() for adding elements progressively. Use ax.clear() for complete redraws. Interactive mode with plt.ion() provides smoother real-time updates.