I am running code written with PyQt4 which uses matplotlib's Qt4Agg backend for showing live plots in windows. At the same time, I would like to use matplotlib in background thread to produce (different) figures which are only saved to file, not shown on the screen.
I can use Qt4Agg in the background thread, but I am getting a bunch of
QPixmap: It is not safe to use pixmaps outside the GUI thread
warnings, and also crashes in some cases.
As far as I see, matplotlib currently supports using only one backend at any given time (which can be changed via switch_backend, but that closes all existing figures). Is there some way to work around this limitation, and to assign per-figure backend?
To my knowledge, only if you don't use the pyplot interface.
For instance, using the full OO interface for a simple plot:
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
fig = Figure()
canvas = FigureCanvas(fig)
ax = fig.add_subplot(1,1,1)
ax.plot([1,2,3])
canvas.print_figure('test.png')
HTH
Related
In Jupyter, if the last statement in a cell returns a matplotlib.Figure, the figure is displayed.
One can perform a similar trick with custom classes by providing a _repr_png_ function in that class. However, matplotlib Figures do not provide this function. This makes me wonder. How does Jupyter "know" what to do with a matplotlib figure?
How does Jupyter "know" what to do with a matplotlib figure?
In the inline backend, this is achieved by registering a function to show changed figures (flush_figures) with the post_execute event in IPython, see configure_inline_support.
I'm new to Jupyterlab and matplotlib so this may be a dumb question but here goes.
FYI: I'm using the standalone jupyterlab app on a mac.
When I make a simple interactive plot using the matplotlib widget magic, the kernel stays busy forever. I had found an earlier post on stack overflow about putting the magic in the 2nd cell (why this works?) and the plot works fine, I just want to know what's going on with the kernel.
The code, which works fine, is just:
import numpy as np
%matplotlib widget
import matplotlib.pyplot as plt
x = np.arange(10)
y = 2*x
plt.figure()
plt.scatter(x,y)
A screenshot to illustrate.
Kernel stuck running in top right of shot
UPDATE: To be clear, this is occurring on the Jupyterlab Standalone app. If I run this on jupyterlab launched via the anaconda navigator, it works fine. For whatever reason, it seems confined to the standalone app only.
As for the App, I installed it via the binary at GitHub. I'm running 3.3.2-2
Is there a way to have the plots created inside Jupyter Notebook using matplotlib to appear on a separate pop-up screen that would allow you to expand/shrink the image by hand? I've tried experimenting with (%matplotlib notebook) but that didn't really do the trick.
Just wondering if this is possible.
Just use an interactive backend. This works for me:
import matplotlib.pyplot as plt
%matplotlib tk
plt.plot([1, 2])
The notebook (nbagg) backend also allows for expand/shrink by hand. It has some rough edges though.
The tkinter backend is a bit buggy (windows 10, python 3).
I used %matplotlib qt for the matplotlib plot that we are all used to.
I'm using Jupyter notebook with %matplotlib notebook in one of the first lines.
When making multiple plots, I have to physically press the 'stop interaction' button on each figure before running another plot, or else the newest plot will be overlaid onto the previous figure.
I think the problem is that I'm not specifying that a new figure needs to be made for each plot? But I'm stumped as to how best to do that!
DO I REALLY HAVE TO SAY PLT.FIGURE EVERY SINGLE TIME? THIS SEEMS UNLIKELY TO ME...?
Thanks in advance!
This is a bug with the notebook backend, but luckily the person who reported it also reported a workaround
Within the Notebook you will need to add the plt.ioff after you import pyplot.
Here is a snip from the top of a notebook, that makes it work for me. I was getting plots over written like you.
%matplotlib notebook # this is to allow the plotting in the notebook
import numpy as np
from scipy.linalg import hadamard
import matplotlib.pyplot as plt
plt.ioff() # this stops the graphs from overwriting each other
It's easy with pyplot but apparently pyplot shouldn't be used when embedding. I haven't been able to find any non-pyplot embedding examples where labels are used.
Maybe you found this page, too. Maybe this example helps. I have not tested it, thus I cannot say if it works.
Staying with the example from the matplotlib example, the labels in the subplot self.axes can be set using self.axes.set_xlabel(x Label") or self.axes.set_ylabel("y Label").