matplotlib-users Mailing List for matplotlib

What I'm trying to accomplish is something like:
http://bm2.genes.nig.ac.jp/RGM2/R_current/library/plotrix/man/images/big_pyramid.plot_001.png
For that I was trying to use subplots where both draw in horizontal
orientation but one will be flipped or mirrored.
I couldn't find any parameter to do so. There is left for horizontal
plots but no right. The same goes for bottom, but no top.
Is there any way to achieve this?
Thanks,
Renato

Hi, thanks for having a look at this.
Problem is that a scatter plot doesn't seem to have the option to actually
update the data, or at least I couldn't find it.
Is there maybe a way?
On Thu, Jan 7, 2010 at 2:58 AM, Laurent Dufrechou <
lau...@gm...> wrote:
> Hi alexander,
>
>
>
> I tryed yesterday to play a little with your script.
>
> I suspect that in fact each time you draw a figure, it is added to a pool
> of figure to be rendered.
>
> Thus it goes slower and slower.
>
>
>
> What I do in my scritpt is either update the datas or if the drawing is a
> completely new one (like a polar ionstaed of log previously) I delete the
> figure.
>
>
>
> To update data use:
>
>
>
> 1/self._plot, = axe.plot(x, y, 'b', animated=self._animated)
>
>
>
> Later:
>
> Loop:
>
> 2/self._plot.set_ydata(self._value)
>
>
>
>
>
> If you need to delete your figure (that is not your case, but who knows for
> the future):
>
> axe = fig.add_axes(self.getPosition())
>
> ...
>
> self._fig.delaxes(self._axe)
>
>
>
> To go even faster(x10) you have the blitting method, but set_ydata should
> be sufficent.
>
>
>
> Laurent
>
>
>
> *De :* Alexander Hupfer [mailto:so...@gm...]
> *Envoyé :* jeudi 7 janvier 2010 03:36
> *C**c :* mat...@li...
> *Objet :* Re: [Matplotlib-users] Colorbar embedding in qt4
>
>
>
> I isolated the problem a bit more. For some reason drawing gets slower and
> slower with each plot drawn.
>
> from os import sys
> from time import time
> from PyQt4 import QtGui, QtCore
>
> import matplotlib
>
> matplotlib.use('QT4Agg')
>
> from matplotlib.backends.backend_qt4agg import FigureCanvasQTAgg as
> FigureCanvas
> from matplotlib.figure import Figure
>
>
> class MyMplCanvas(FigureCanvas):
> """Ultimately, this is a QWidget (as well as a FigureCanvasAgg,
> etc.)."""
> def __init__(self, parent=None, width=5, height=4, dpi=100):
> fig = Figure(figsize=(width, height), dpi=dpi)
> self.axes = fig.add_subplot(111)
> # We want the axes cleared every time plot() is called
> self.axes.hold(False)
>
> self.compute_initial_figure()
>
> #
> FigureCanvas.__init__(self, fig)
> self.setParent(parent)
>
> FigureCanvas.setSizePolicy(self,
> QtGui.QSizePolicy.Expanding,
> QtGui.QSizePolicy.Expanding)
> FigureCanvas.updateGeometry(self)
>
> def compute_initial_figure(self):
> pass
>
> class MyDynamicMplCanvas(MyMplCanvas):
> """A canvas that updates itself every second with a new plot."""
> def __init__(self, *args, **kwargs):
> MyMplCanvas.__init__(self, *args, **kwargs)
> timer = QtCore.QTimer(self)
> QtCore.QObject.connect(timer, QtCore.SIGNAL("timeout()"),
> self.update_figure)
> timer.start(0)
> self.firstrun = True
> self.colorbar = None
> self.time = time()
> self.p = None
> def compute_initial_figure(self):
> pass
>
> def update_figure(self):
> self.p = self.axes.scatter([1,2,3],[4,5,6], c = range(3),
> animated=True)
> self.axes.set_xlabel('psi')
> self.axes.set_ylabel('delta')
> if self.firstrun == True:
> self.colorbar = self.axes.figure.colorbar(self.p)
> self.firstrun = False
> self.colorbar.set_clim(vmin=0,vmax=2)
> self.colorbar.draw_all()
> self.colorbar.set_label('time [abtr. ]')
> self.draw()
> newtime = time()
> print newtime - self.time
> self.time = newtime
>
> class ApplicationWindow(QtGui.QMainWindow):
> def __init__(self):
> QtGui.QMainWindow.__init__(self)
> self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
>
> self.main_widget = QtGui.QWidget(self)
>
> l = QtGui.QVBoxLayout(self.main_widget)
>
> dc = MyDynamicMplCanvas(self.main_widget, width=5, height=4,
> dpi=100)
>
> l.addWidget(dc)
>
> self.main_widget.setFocus()
> self.setCentralWidget(self.main_widget)
>
>
> qApp = QtGui.QApplication(sys.argv)
>
> aw = ApplicationWindow()
> aw.setWindowTitle("%s" % "Slow!")
> aw.setGeometry(100,100,800,600)
> aw.show()
> sys.exit(qApp.exec_())
>
> On Mon, Jan 4, 2010 at 3:36 PM, Alexander Hupfer <so...@gm...> wrote:
>
> Ok, here is the code as a whole. I think it's still short enough to
> ilustrate the problem. Just start it with the datafile "elips" as an
> argument
>
> http://dl.dropbox.com/u/226980/elipsometry.tar.gz
>
> The timer shows how long each render cycle takes. The time seems to grow
> with number of cycles rendered even when no more points are added (the
> points are calculated with a continous rate in a background thread and are
> about 300 total).
>
>
>
> On Sun, Jan 3, 2010 at 8:16 PM, John Hunter <jd...@gm...> wrote:
>
> On Sun, Jan 3, 2010 at 7:02 PM, Alexander Hupfer <so...@gm...> wrote:
> > Thanks I got it fixed.
> > This leads to the follow up question:
> > What is the right way to keep an application responsive while the graph
> is
> > drawn?
> > Drawing a scatter plot with 300 points seems to take a while. I guess I
> need
> > to launch the drawing in another thread but don't know exactly how to do
> > this and only find examples of doing calculations in the background and
> not
> > actual widget interaction.
>
> You posted some real code and a traceback, which helped move the ball
> forward. What we really need to see to help you though is a complete,
> free-standing example, that we can run on our machines, which exposes
> the problem.
>
> JDH
>
>
>
>
>

Has anyone managed to plot a candlestick chart with a
scikits.timeseries? Is there an easy way to wrap the
matplotlib.finance.candlestick call?
James

Hi
I finally managed to write a simplified version of my python script
which crashes when trying to save the figure as a postscript file. (this
is related to a previous post). See below. The script is provided, as
well as the full error message.
Sorry for the long script, but basically I am plotting 3x7 arrays via
pcolormesh. The script looks pretty dum because it was adapted from a
more complicated one where the bins/pixels are not exactly squared and
are rotated. In the version below I have tried to remove the unncessary
complication. And I get a failure from ghostscript when I try to save it
as eps. It works when I save it as a png.
Can anyone tell me what's wrong there? Again I am using:
### On an OpenSuse 11.2, 64b
xpdf distiller (but I tried others).
matplotlib 0.99.1.1
backend WXAgg version 2.8.10.1
Python 2.6.2 (r262:71600, Oct 24 2009, 03:15:21)
IPython 0.10 -- An enhanced Interactive Python.
THANKS
Eric
====================================================================
######################################################################
# Script to run which crashes when saving the figure as an eps file
######################################################################
#!/usr/bin/python
import numpy as num
import pylab as pl
def pos(i,j, w, h) :
 return [0.05+ j*(w+0.02), 0.99 - (i+1)*(h+0.023)+0.025, w, h]
## Opening the figure
## Figure
pl.figure(1, figsize=(5*1.2, 7*1.5))
fig = pl.gcf()
pl.clf()
## Size of figure
figH = fig.get_figheight()
figW = fig.get_figwidth()
w = 0.99 / 3. -0.03
h = 0.99 / 7 - 0.022
## List of data to plot (I take 7 times the same stuff)
listgal = ["1","2","3","4","5","6",",7"]
## Initialisation of start, end and step
ngal = len(listgal)
start = [-30.,-30.]
end = [30.,30.]
npix = [80,80]
x = num.linspace(start[0],end[0], npix[0])
y = num.linspace(start[1],end[1], npix[1])
step = [x[1]-x[0], y[1]-y[0]]
X,Y = num.meshgrid(x,y)
## Initialisation of data
data = num.random.random((npix[0], npix[1]))
pl.ioff()
for k in range(ngal) :
 gal = listgal[k]
 ## Coordinates
 ## Grid for rotation
 Xp,Yp = X - step[0]/2., Y - step[1]/2.
 X1,Y1 = X+step[0]/2.,Y+step[1]/2.
 X2,Y2 = X-step[0]/2.,Y+step[1]/2.
 X3,Y3 = X-step[0]/2.,Y-step[1]/2.
 X4,Y4 = X+step[0]/2.,Y-step[1]/2.
 minXc = num.min(num.concatenate((X1,X2,X3,X4)))
 maxXc = num.max(num.concatenate((X1,X2,X3,X4)))
 minYc = num.min(num.concatenate((Y1,Y2,Y3,Y4)))
 maxYc = num.max(num.concatenate((Y1,Y2,Y3,Y4)))
 dX = maxXc - minXc
 dY = maxYc - minYc
 ## Deriving the right aspect ratio etc
 aspectIma = dX / dY
 aspectFig = figW / figH
 aspectWin = w / h
 if (aspectIma < aspectWin*aspectFig) :
 maxXc = maxXc * aspectFig * aspectWin / aspectIma
 minXc = minXc * aspectFig * aspectWin / aspectIma
 else :
 maxYc = maxYc * aspectIma / (aspectFig * aspectWin)
 minYc = minYc * aspectIma / (aspectFig * aspectWin)
 extentR = minXc, maxXc, minYc, maxYc
 cmap = pl.cm.jet
 minI, maxI = 0., 1.
 cmap.set_bad('w',1.0)
 j = 0
 ax1 = fig.add_axes(pos(k,j, w, h))
 map1 = ax1.pcolormesh(Xp,Yp,data,shading='flat',vmin=minI,vmax=maxI,
cmap=cmap)
 pl.plot([0.],[0.],'k+', markersize=10, lw=3)
 xticklabels = pl.getp(pl.gca(), 'xticklabels')
 pl.setp(xticklabels, fontsize=8)
 yticklabels = pl.getp(pl.gca(), 'yticklabels')
 pl.setp(yticklabels, fontsize=8)
 pl.axis(extentR)
 j += 1
 ax2 = fig.add_axes(pos(k,j, w, h))
 map2 = ax2.pcolormesh(Xp,Yp,data,shading='flat',vmin=minI,vmax=maxI,
cmap=cmap)
 pl.plot([0.],[0.],'k+', markersize=10, lw=3)
 pl.axis(extentR)
 ax2.set_yticks([])
 xticklabels = pl.getp(pl.gca(), 'xticklabels')
 pl.setp(xticklabels, fontsize=8)
 pl.text(0.02,0.96, "%4.0f/%4.0f"%(minI,maxI),
verticalalignment='top',rotation='vertical',transform = ax2.transAxes,
fontsize=8)
 j += 1
 ax3 = fig.add_axes(pos(k,j, w, h))
 map2 = ax3.pcolormesh(Xp,Yp,data,shading='flat',vmin=0.,vmax=1.,
cmap=cmap)
 pl.plot([0.],[0.],'k+', markersize=10, lw=3)
 pl.axis(extentR)
 ax3.set_yticks([])
 xticklabels = pl.getp(pl.gca(), 'xticklabels')
 pl.setp(xticklabels, fontsize=8)
 pl.text(0.02,0.96, "%4.0f/%4.0f"%(minI,maxI),
verticalalignment='top',rotation='vertical',transform = ax3.transAxes,
fontsize=8)
 j += 1
 pl.text(0.92,0.5, gal,
rotation='vertical',verticalalignment='center',transform = ax3.transAxes)
 k += 1
pl.ion()
pl.show()
#######################################################################
## ERROR MESSAGE WHEN DOING:
## savefig("tmp.eps")
########################################################################
savefig("toto.eps")
Error: /limitcheck in --def--
Operand stack:
 pa_c2c --nostringval--
Execution stack:
 %interp_exit .runexec2 --nostringval-- --nostringval--
--nostringval-- 2 %stopped_push --nostringval-- --nostringval--
 --nostringval-- false 1 %stopped_push 1878 1 3
%oparray_pop 1877 1 3 %oparray_pop 1861 1 3 %oparray_pop
 1755 1 3 %oparray_pop --nostringval-- %errorexec_pop
.runexec2 --nostringval-- --nostringval-- --nostringval-- 2
%stopped_push --nostringval--
Dictionary stack:
 --dict:1171/3371(ro)(G)-- --dict:1/20(G)-- --dict:74/200(L)--
--dict:5/6(ro)(L)-- --dict:179/300(L)-- --dict:44/200(L)--
--dict:65534/65534(L)--
Current allocation mode is local
Last OS error: 2
Current file position is 14229051
GPL Ghostscript 8.64: Unrecoverable error, exit code 1
---------------------------------------------------------------------------
RuntimeError Traceback (most recent call
last)
/science/ATLAS3D/python/Analysis/Try.py in <module>()
----> 1
 2
 3
 4
 5
/usr/lib64/python2.6/site-packages/matplotlib/pyplot.pyc in
savefig(*args, **kwargs)
 354 def savefig(*args, **kwargs):
 355 fig = gcf()
--> 356 return fig.savefig(*args, **kwargs)
 357 if Figure.savefig.__doc__ is not None:
 358 savefig.__doc__ = dedent(Figure.savefig.__doc__)
/usr/lib64/python2.6/site-packages/matplotlib/figure.pyc in
savefig(self, *args, **kwargs)
 1030 patch.set_alpha(0.0)
 1031
-> 1032 self.canvas.print_figure(*args, **kwargs)
 1033
 1034 if transparent:
/usr/lib64/python2.6/site-packages/matplotlib/backends/backend_wxagg.pyc
in print_figure(self, filename, *args, **kwargs)
 98 def print_figure(self, filename, *args, **kwargs):
 99 # Use pure Agg renderer to draw
--> 100 FigureCanvasAgg.print_figure(self, filename, *args,
**kwargs)
 101 # Restore the current view; this is needed because the
 102 # artist contains methods rely on particular attributes
/usr/lib64/python2.6/site-packages/matplotlib/backend_bases.pyc in
print_figure(self, filename, dpi, facecolor, edgecolor, orientation,
format, **kwargs)
 1474 orientation=orientation,
 1475 bbox_inches_restore=_bbox_inches_restore,
-> 1476 **kwargs)
 1477 finally:
 1478 if bbox_inches and restore_bbox:
/usr/lib64/python2.6/site-packages/matplotlib/backend_bases.pyc in
print_eps(self, *args, **kwargs)
 1327 from backends.backend_ps import FigureCanvasPS # lazy
import
 1328 ps = self.switch_backends(FigureCanvasPS)
-> 1329 return ps.print_eps(*args, **kwargs)
 1330
 1331 def print_pdf(self, *args, **kwargs):
/usr/lib64/python2.6/site-packages/matplotlib/backends/backend_ps.pyc in
print_eps(self, outfile, *args, **kwargs)
 853
 854 def print_eps(self, outfile, *args, **kwargs):
--> 855 return self._print_ps(outfile, 'eps', *args, **kwargs)
 856
 857
/usr/lib64/python2.6/site-packages/matplotlib/backends/backend_ps.pyc in
_print_ps(self, outfile, format, *args, **kwargs)
 882 self._print_figure_tex(outfile, format, imagedpi,
facecolor, edgecolor,
 883 orientation, isLandscape,
papertype,
--> 884 **kwargs)
 885 else:
 886 self._print_figure(outfile, format, imagedpi,
facecolor, edgecolor,
/usr/lib64/python2.6/site-packages/matplotlib/backends/backend_ps.pyc in
_print_figure_tex(self, outfile, format, dpi, facecolor, edgecolor,
orientation, isLandscape, papertype, **kwargs)
 1188 gs_distill(tmpfile, isEPSF, ptype=papertype,
bbox=bbox)
 1189 elif rcParams['ps.usedistiller'] == 'xpdf':
-> 1190 xpdf_distill(tmpfile, isEPSF, ptype=papertype,
bbox=bbox)
 1191 elif rcParams['text.usetex']:
 1192 if False: pass # for debugging
/usr/lib64/python2.6/site-packages/matplotlib/backends/backend_ps.pyc in
xpdf_distill(tmpfile, eps, ptype, bbox)
 1345 fh = file(outfile)
 1346 if exit_status: raise RuntimeError('ps2pdf was not able to
process your \
-> 1347 image.\n\Here is the report generated by ghostscript:\n\n' +
fh.read())
 1348 else: verbose.report(fh.read(), 'debug')
 1349 fh.close()
RuntimeError: ps2pdf was not able to process your image.
\Here is the report generated by ghostscript:

Hi,
I'm plotting two y-axis with the twinx() command. But when I'm
creating my legend there is only one entry in the legend-box instead
of two.
Here is my code:
grafik1 = plt.figure()
ax1 = grafik1.add_subplot(111)
ax1.plot(TIME, BTM, color='red', label='Biomass')
ax1.set_ylabel('Biomass')
ax2 = ax1.twinx()
ax2.plot(TIME, FLUOR, label='Productivity')
ax2.set_ylabel('Produktivity')
ax2.set_xlabel('Time')
grafik1_legend = legend(loc=10)

Hi,
I've been playing around with the parasite_axes toolkit. It's very nice 
but I discovered from the example that I always get an extra set of x 
and y axis labels. See attached png. I've got around this by simply 
turning the first axis off. Is this a bug in the code or the example? 
Also there appears to be an additional set of axis label commands in the 
example.
 From demo_parasite_axes2.py
----------------------------------------------------------------------
from mpl_toolkits.axes_grid.parasite_axes import SubplotHost
import matplotlib.pyplot as plt
if 1:
 fig = plt.figure(1)
 plt.axis('off') # Extra line to remove unwanted axis labels
 host = SubplotHost(fig, 111)
 host.set_ylabel("Density")
 host.set_xlabel("Distance")
 par1 = host.twinx()
 par2 = host.twinx()
 par1.set_ylabel("Temperature")
 par2.axis["right"].set_visible(False)
 offset = 60, 0
 new_axisline = par2.get_grid_helper().new_fixed_axis
 par2.axis["right2"] = new_axisline(loc="right",
 axes=par2,
 offset=offset)
 par2.axis["right2"].label.set_visible(True)
 par2.axis["right2"].set_label("Velocity")
 fig.add_axes(host)
 plt.subplots_adjust(right=0.75)
 host.set_xlim(0, 2)
 host.set_ylim(0, 2)
 host.set_xlabel("Distance") # Why reset these three labels..
 host.set_ylabel("Density")
 par1.set_ylabel("Temperature")
 p1, = host.plot([0, 1, 2], [0, 1, 2], label="Density")
 p2, = par1.plot([0, 1, 2], [0, 3, 2], label="Temperature")
 p3, = par2.plot([0, 1, 2], [50, 30, 15], label="Velocity")
 par1.set_ylim(0, 4)
 par2.set_ylim(1, 65)
 host.legend()
 host.axis["left"].label.set_color(p1.get_color())
 par1.axis["right"].label.set_color(p2.get_color())
 par2.axis["right2"].label.set_color(p3.get_color())
 plt.draw()
 plt.show()

Hi alexander,
 
I tryed yesterday to play a little with your script.
I suspect that in fact each time you draw a figure, it is added to a pool of
figure to be rendered.
Thus it goes slower and slower.
 
What I do in my scritpt is either update the datas or if the drawing is a
completely new one (like a polar ionstaed of log previously) I delete the
figure.
 
To update data use:
 
1/self._plot, = axe.plot(x, y, 'b', animated=self._animated)
 
Later:
Loop:
2/self._plot.set_ydata(self._value)
 
 
If you need to delete your figure (that is not your case, but who knows for
the future):
axe = fig.add_axes(self.getPosition())
… 
self._fig.delaxes(self._axe)
 
To go even faster(x10) you have the blitting method, but set_ydata should be
sufficent.
 
Laurent
 
De : Alexander Hupfer [mailto:so...@gm...] 
Envoyé : jeudi 7 janvier 2010 03:36
Cc : mat...@li...
Objet : Re: [Matplotlib-users] Colorbar embedding in qt4
 
I isolated the problem a bit more. For some reason drawing gets slower and
slower with each plot drawn.
from os import sys
from time import time
from PyQt4 import QtGui, QtCore
import matplotlib
matplotlib.use('QT4Agg')
from matplotlib.backends.backend_qt4agg import FigureCanvasQTAgg as
FigureCanvas
from matplotlib.figure import Figure
class MyMplCanvas(FigureCanvas):
 """Ultimately, this is a QWidget (as well as a FigureCanvasAgg,
etc.)."""
 def __init__(self, parent=None, width=5, height=4, dpi=100):
 fig = Figure(figsize=(width, height), dpi=dpi)
 self.axes = fig.add_subplot(111)
 # We want the axes cleared every time plot() is called
 self.axes.hold(False)
 self.compute_initial_figure()
 #
 FigureCanvas.__init__(self, fig)
 self.setParent(parent)
 FigureCanvas.setSizePolicy(self,
 QtGui.QSizePolicy.Expanding,
 QtGui.QSizePolicy.Expanding)
 FigureCanvas.updateGeometry(self)
 def compute_initial_figure(self):
 pass
class MyDynamicMplCanvas(MyMplCanvas):
 """A canvas that updates itself every second with a new plot."""
 def __init__(self, *args, **kwargs):
 MyMplCanvas.__init__(self, *args, **kwargs)
 timer = QtCore.QTimer(self)
 QtCore.QObject.connect(timer, QtCore.SIGNAL("timeout()"),
self.update_figure)
 timer.start(0)
 self.firstrun = True
 self.colorbar = None
 self.time = time()
 self.p = None
 def compute_initial_figure(self):
 pass
 def update_figure(self):
 self.p = self.axes.scatter([1,2,3],[4,5,6], c = range(3),
animated=True)
 self.axes.set_xlabel('psi')
 self.axes.set_ylabel('delta')
 if self.firstrun == True:
 self.colorbar = self.axes.figure.colorbar(self.p)
 self.firstrun = False
 self.colorbar.set_clim(vmin=0,vmax=2) 
 self.colorbar.draw_all()
 self.colorbar.set_label('time [abtr. ]')
 self.draw()
 newtime = time()
 print newtime - self.time
 self.time = newtime
class ApplicationWindow(QtGui.QMainWindow):
 def __init__(self):
 QtGui.QMainWindow.__init__(self)
 self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
 self.main_widget = QtGui.QWidget(self)
 l = QtGui.QVBoxLayout(self.main_widget)
 dc = MyDynamicMplCanvas(self.main_widget, width=5, height=4,
dpi=100)
 l.addWidget(dc)
 self.main_widget.setFocus()
 self.setCentralWidget(self.main_widget)
qApp = QtGui.QApplication(sys.argv)
aw = ApplicationWindow()
aw.setWindowTitle("%s" % "Slow!")
aw.setGeometry(100,100,800,600)
aw.show()
sys.exit(qApp.exec_())
On Mon, Jan 4, 2010 at 3:36 PM, Alexander Hupfer <so...@gm...> wrote:
Ok, here is the code as a whole. I think it's still short enough to
ilustrate the problem. Just start it with the datafile "elips" as an
argument
http://dl.dropbox.com/u/226980/elipsometry.tar.gz
The timer shows how long each render cycle takes. The time seems to grow
with number of cycles rendered even when no more points are added (the
points are calculated with a continous rate in a background thread and are
about 300 total).
 
On Sun, Jan 3, 2010 at 8:16 PM, John Hunter <jd...@gm...> wrote:
On Sun, Jan 3, 2010 at 7:02 PM, Alexander Hupfer <so...@gm...> wrote:
> Thanks I got it fixed.
> This leads to the follow up question:
> What is the right way to keep an application responsive while the graph is
> drawn?
> Drawing a scatter plot with 300 points seems to take a while. I guess I
need
> to launch the drawing in another thread but don't know exactly how to do
> this and only find examples of doing calculations in the background and
not
> actual widget interaction.
You posted some real code and a traceback, which helped move the ball
forward. What we really need to see to help you though is a complete,
free-standing example, that we can run on our machines, which exposes
the problem.
JDH
 
 

I isolated the problem a bit more. For some reason drawing gets slower and
slower with each plot drawn.
from os import sys
from time import time
from PyQt4 import QtGui, QtCore
import matplotlib
matplotlib.use('QT4Agg')
from matplotlib.backends.backend_qt4agg import FigureCanvasQTAgg as
FigureCanvas
from matplotlib.figure import Figure
class MyMplCanvas(FigureCanvas):
 """Ultimately, this is a QWidget (as well as a FigureCanvasAgg,
etc.)."""
 def __init__(self, parent=None, width=5, height=4, dpi=100):
 fig = Figure(figsize=(width, height), dpi=dpi)
 self.axes = fig.add_subplot(111)
 # We want the axes cleared every time plot() is called
 self.axes.hold(False)
 self.compute_initial_figure()
 #
 FigureCanvas.__init__(self, fig)
 self.setParent(parent)
 FigureCanvas.setSizePolicy(self,
 QtGui.QSizePolicy.Expanding,
 QtGui.QSizePolicy.Expanding)
 FigureCanvas.updateGeometry(self)
 def compute_initial_figure(self):
 pass
class MyDynamicMplCanvas(MyMplCanvas):
 """A canvas that updates itself every second with a new plot."""
 def __init__(self, *args, **kwargs):
 MyMplCanvas.__init__(self, *args, **kwargs)
 timer = QtCore.QTimer(self)
 QtCore.QObject.connect(timer, QtCore.SIGNAL("timeout()"),
self.update_figure)
 timer.start(0)
 self.firstrun = True
 self.colorbar = None
 self.time = time()
 self.p = None
 def compute_initial_figure(self):
 pass
 def update_figure(self):
 self.p = self.axes.scatter([1,2,3],[4,5,6], c = range(3),
animated=True)
 self.axes.set_xlabel('psi')
 self.axes.set_ylabel('delta')
 if self.firstrun == True:
 self.colorbar = self.axes.figure.colorbar(self.p)
 self.firstrun = False
 self.colorbar.set_clim(vmin=0,vmax=2)
 self.colorbar.draw_all()
 self.colorbar.set_label('time [abtr. ]')
 self.draw()
 newtime = time()
 print newtime - self.time
 self.time = newtime
class ApplicationWindow(QtGui.QMainWindow):
 def __init__(self):
 QtGui.QMainWindow.__init__(self)
 self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
 self.main_widget = QtGui.QWidget(self)
 l = QtGui.QVBoxLayout(self.main_widget)
 dc = MyDynamicMplCanvas(self.main_widget, width=5, height=4,
dpi=100)
 l.addWidget(dc)
 self.main_widget.setFocus()
 self.setCentralWidget(self.main_widget)
qApp = QtGui.QApplication(sys.argv)
aw = ApplicationWindow()
aw.setWindowTitle("%s" % "Slow!")
aw.setGeometry(100,100,800,600)
aw.show()
sys.exit(qApp.exec_())
On Mon, Jan 4, 2010 at 3:36 PM, Alexander Hupfer <so...@gm...> wrote:
> Ok, here is the code as a whole. I think it's still short enough to
> ilustrate the problem. Just start it with the datafile "elips" as an
> argument
>
> http://dl.dropbox.com/u/226980/elipsometry.tar.gz
>
> The timer shows how long each render cycle takes. The time seems to grow
> with number of cycles rendered even when no more points are added (the
> points are calculated with a continous rate in a background thread and are
> about 300 total).
>
>
> On Sun, Jan 3, 2010 at 8:16 PM, John Hunter <jd...@gm...> wrote:
>
>> On Sun, Jan 3, 2010 at 7:02 PM, Alexander Hupfer <so...@gm...>
>> wrote:
>> > Thanks I got it fixed.
>> > This leads to the follow up question:
>> > What is the right way to keep an application responsive while the graph
>> is
>> > drawn?
>> > Drawing a scatter plot with 300 points seems to take a while. I guess I
>> need
>> > to launch the drawing in another thread but don't know exactly how to do
>> > this and only find examples of doing calculations in the background and
>> not
>> > actual widget interaction.
>>
>> You posted some real code and a traceback, which helped move the ball
>> forward. What we really need to see to help you though is a complete,
>> free-standing example, that we can run on our machines, which exposes
>> the problem.
>>
>> JDH
>>
>
>