Question

I am a total matplotlib noob, at the moment making small changes to example programs and seeing what happens, and attempting to comprehend the extensive but not well ordered documentation.

I’m trying to add a graph display to an existing tk gui based python program. I am quite happy for the graph to float in a new window, I don’t need it embedded in the tk (yet, next week perhaps).

The existing program has a tk.Button that the user presses, which calls a function which retrieves some data and updates max/min/average in some labels.

I want to enhance the functionality so that as well as updating the labels, it also pops up a graph of the data. If the graph is already there, the next button press should replace the old trace with a new one and re auto scale the axes. If the user closes the graph window, the next button press should pop up a new one.

A fresh graph every press was easy, adding the if not self.fig test gets me down to one. It added persistent traces until I added plt.clf(). However if the user closes the graph window, the code below doesn’t recreate it. I think I need something like if graph visible, or if graph exists, rather than testing on self.fig. Or maybe I’ve missed the obvious way to do it, and there’s a much better way? Help much appreciated.

import Tkinter as tk
import os, sys
import numpy as np
import numpy.random as npr
import matplotlib.pyplot as plt

class Plotter():
    def __init__(self):
        self.fig=None
        self.ax=None    

    def do_stuff(self):
        # make plausible data
        a=np.arange(0,3,0.1)
        b=npr.random(1)
        c=np.power(a,b)            

        if not self.fig:
            self.fig = plt.figure()
        else:
            plt.clf()

        self.ax = self.fig.add_subplot(111)
        self.ax.plot(a,c,'k--')
        self.ax.set_yticklabels([])
        self.ax.set_xticklabels([])

        plt.show()


p=Plotter()
root=tk.Tk()

rt = tk.Button(root, text='Capture', command=p.do_stuff)
rt.grid(row=0, column=0)

qt = tk.Button(root, text='quit', command=sys.exit)
qt.grid(row=1, column=0)

root.mainloop()

Answer 1

Edited with new solution: Another solution is to use pyplot.fignum_exists to check if your figure is still around. So you could do:

if self.fig is None or not pyplot.fignum_exists(self.fig.number):
    self.fig = pyplot.figure()
# self.fig will now be active, either via an old still-open figure or a newly-created one

Old solution for posterity:

The thing is that if closing the figure won’t affect your self.fig, although it will render that Figure object useless. One option is to use pyplot.gcf() instead of pyplot.figure(), which stands for “get current figure”. This will return an existing figure if one is open, or it will make a new one if there is no active figure. So in your do_stuff method you can use pyplot.gcf() and it will return your old figure object or a new one, and you don’t need to worry about which. So just do:

def do_stuff(self):
    # make plausible data
    fig = pyplot.gcf()
    fig.clf()
    self.ax = fig.add_subplot(111)
    # etc.

This obviously has limitations. In particular, if any other part of your program also creates or uses matplotlib figures, then using gcf might cause weird results since the “current” figure might be some other figure that some other function created. For what you’re doing right now this seems like a workable solution, though.