Ha, ok finally ive solved the issue.
In fact each time you call blit method you must force a repaint.
This what v4 does.
Ive also removed self.repaint() in my script and modified backend_qt4agg:
def blit(self, bbox=None):
"""
Blit the region in bbox
"""
self.replot = bbox
l, b, w, h = bbox.bounds
t = b + h
#self.update(l, self.renderer.height-t, w, h) ß before
self.repaint(l, self.renderer.height-t, w, h)
And it work like a charm.
I got 72 FPS that it way better than the old 7 FPS I go without blitting.
Im not sure it is the ideal solution.
Any thought?
Laurent
De : Auré Gourrier [mailto:aurelien.gourr...@yahoo.fr]
Envoyé : mercredi 21 octobre 2009 13:55
À : matplotlib-users@lists.sourceforge.net
Cc : Laurent Dufr?chou
Objet : Re : Re: Little issue with blitting
Hi Laurent,
I think I might have found a way to solve your problem: instead of creating
your axes using pylab.suplot, you should create the axes using the class
way. I modified your code below and it works fine without loosing speed in
the frame rate. Only thing is, I have no clue as to what is really the
underlying problem... my best guess is that there is a conflict between
pylab and the general class. I very rearely use pylab directly unless the
problem is really simple, because I saw several posts mentioning possible
conflicts.
Hope this helps you.
Cheers,
Aurélien
-----
import sys
import pylab as p
import matplotlib as mpl
import numpy as npy
import time
fig = p.figure(figsize=(8.,4.))
#ax = p.subplot(212)
ax = fig.add_axes((.05,.55,.9,.4))
#ax2 = p.subplot(211)
ax2 = fig.add_axes((.05,.05,.9,.4))
canvas = ax.figure.canvas
# create the initial line
x = npy.arange(0,2*npy.pi,0.01)
#line, = p.plot(x, npy.sin(x), animated=True, lw=2)
line, = ax.plot(x, npy.sin(x), animated=True, lw=2)
line2, = ax2.plot(x, npy.cos(x), animated=True, lw=2)
def run(*args):
background = canvas.copy_from_bbox(ax.bbox)
background2 = canvas.copy_from_bbox(ax2.bbox)
# for profiling
tstart = time.time()
while 1:
# restore the clean slate background
canvas.restore_region(background)
canvas.restore_region(background2)
# update the data
line.set_ydata(npy.sin(x+run.cnt/10.0))
line2.set_ydata(npy.cos(x+run.cnt/10.0))
# just draw the animated artist
ax.draw_artist(line)
ax2.draw_artist(line2)
# just redraw the axes rectangle
canvas.blit(ax.bbox)
canvas.blit(ax2.bbox)
#canvas.blit(ax.get_figure().bbox)
if run.cnt==100:
# print the timing info and quit
print 'FPS:' , 100/(time.time()-tstart)
#return
sys.exit()
run.cnt += 1
run.cnt = 0
#no need for the following since it is done directly when creating the axes
#p.subplots_adjust(left=0.3, bottom=0.3) # check for flipy bugs
#p.grid() # to ensure proper background restore
ax.grid() # to ensure proper background restore
ax2.grid() # to ensure proper background restore
manager = p.get_current_fig_manager()
manager.window.after(100, run)
p.show()
------------------------------
Message: 2
Date: Thu, 15 Oct 2009 18:40:22 +0200
From: Laurent Dufr?chou <laurent.dufrec...@gmail.com>
Subject: Re: [Matplotlib-users] [Solved] Little issue with blitting
technique
To: 'Aur? Gourrier' <aurelien.gourr...@yahoo.fr>,
<matplotlib-users@lists.sourceforge.net>
Message-ID: <4ad7507f.0a1ad00a.018e.ffff8...@mx.google.com>
Content-Type: text/plain; charset="iso-8859-1"
Hi Aur?,
Taking this example (FPS is computed at the end of the loop each 100
frames):
(this is the same example as you but not using FileUtils10)
################################################
import sys
import pylab as p
import numpy as npy
import time
ax2 = p.subplot(212)
ax = p.subplot(211)
canvas = ax.figure.canvas
# create the initial line
x = npy.arange(0,2*npy.pi,0.01)
line, = p.plot(x, npy.sin(x), animated=True, lw=2)
def run(*args):
background = canvas.copy_from_bbox(ax.bbox)
# for profiling
tstart = time.time()
while 1:
# restore the clean slate background
canvas.restore_region(background)
# update the data
line.set_ydata(npy.sin(x+run.cnt/10.0))
# just draw the animated artist
ax.draw_artist(line)
# just redraw the axes rectangle
canvas.blit(ax.bbox)
if run.cnt==100:
# print the timing info and quit
print 'FPS:' , 100/(time.time()-tstart)
return
run.cnt += 1
run.cnt = 0
p.subplots_adjust(left=0.3, bottom=0.3) # check for flipy bugs
p.grid() # to ensure proper background restore
manager = p.get_current_fig_manager()
manager.window.after(100, run)
p.show()
################################################
This example will work on my machine @99FPS.
Now replace:
ax2 = p.subplot(212)
ax = p.subplot(211)
with:
ax = p.subplot(212)
ax2 = p.subplot(211)
The image is buggy because the blitting is no more working, still I get
86FPS. So let say no change.
Now replace ?ax.bbox? with ?ax.get_figure().bbox?:
The bug disappear and I get a small 20 FPS?
Tested under windows vista , matplotlib 0.99.1, python 2.5.4.
Laurent
Ps: I think ax.getFigure().bbox is getting the whole picture so this is why
it is slower.
De : Aur? Gourrier [mailto:aurelien.gourr...@yahoo.fr]
Envoy? : jeudi 15 octobre 2009 10:32
? : matplotlib-users@lists.sourceforge.net
Objet : Re: [Matplotlib-users] [Solved] Little issue with blitting technique
>On Tue, Oct 13, 2009 at 5:06 PM, Laurent Dufr?chou
><laurent.dufrec...@gmail.com> wrote:
>> Hey, coparing on how GTK2 example is done I've seen a difference between
the two!
>>
>> In QT4Agg example and WX example the code use:
>>
>> canvas.copy_from_bbox(ax.bbox)
>> replacing all occurrence of ax.bbox with ax.get_figure().bbox solved all
the issue I add.
>>
>
>I'm not sure why using ax.bbox does not work, and it SHOULD work.
>Note that animation_blit_gtk.py DOES use ax.bbox.
>
>> Perhaps we should correct the examples.
>> I can send you the good working example if you want.
>
>If using ax.bbox does not work, than it is a bug (either mpl or the
example).
>Unfortunately, this seems to happen only on windows.
>So, please file a bug report (again).
>
>Regards,
>
>-JJ
>
Hy guys,
Just saw your posts. I don't understand the business with the
ax.get_figure().bbox.
I'm also using windows, and a modified version of the animation_blit_tk.py
using imshow work fine for me.
I just checked whether the get_figure() changes anything and I get exactly
the same result in terms of performance.
I attach the code below if it can be of any use.
Cheers,
Aur?
# For detailed comments on animation and the techniqes used here, see
# the wiki entry http://www.scipy.org/Cookbook/Matplotlib/Animations
import matplotlib
matplotlib.use('TkAgg')
import sys
import pylab as p
import matplotlib.numerix as nx
import time
from FileUtils10 import fileHandling
# for profiling
tstart = time.time()
tprevious = time.time()
fnamelist = ['....']
ax = p.subplot(111)
canvas = ax.figure.canvas
print 't1 ',time.time()-tprevious
tprevious = time.time()
# create the initial line
dataarr = fileHandling(fnamelist[0]).read()
#print dataarr.dtype
#dataarr = dataarr.astype('uint8')
print 't2 ',time.time()-tprevious
tprevious = time.time()
image = p.imshow(dataarr, animated=True)
print 't3 ',time.time()-tprevious
tprevious = time.time()
def run(*args):
tprevious = time.time()
background = canvas.copy_from_bbox(ax.bbox)
print 't4 ',time.time()-tprevious
tprevious = time.time()
while 1:
#print fnamelist[run.cnt]
# restore the clean slate background
canvas.restore_region(background)
print 't5 ',time.time()-tprevious
tprevious = time.time()
# update the data
dataarr = fileHandling(fnamelist[run.cnt]).readMCCD()
dataarr *= run.cnt
print 't6 ',time.time()-tprevious
tprevious = time.time()
image.set_data(dataarr)
print 't7 ',time.time()-tprevious
tprevious = time.time()
# just draw the animated artist
ax.draw_artist(image)
print 't8 ',time.time()-tprevious
tprevious = time.time()
# just redraw the axes rectangle
canvas.blit(ax.bbox)
print 't9 ',time.time()-tprevious
tprevious = time.time()
if fnamelist[run.cnt] == fnamelist[-1]:
# print the timing info and quit
print 'total time:' , time.time()-tstart
print 'FPS:' , 1000./(time.time()-tstart)
p.close('all')
sys.exit()
run.cnt += 1
run.cnt = 0
p.subplots_adjust(left=0.3, bottom=0.3) # check for flipy bugs
p.grid() # to ensure proper background restore
manager = p.get_current_fig_manager()
manager.window.after(100, run)
p.show()
-------------- next part --------------
An HTML attachment was scrubbed...
------------------------------
----------------------------------------------------------------------------
--
Come build with us! The BlackBerry(R) Developer Conference in SF, CA
is the only developer event you need to attend this year. Jumpstart your
developing skills, take BlackBerry mobile applications to market and stay
ahead of the curve. Join us from November 9 - 12, 2009. Register now!
http://p.sf.net/sfu/devconference
------------------------------
_______________________________________________
Matplotlib-users mailing list
Matplotlib-users@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/matplotlib-users
End of Matplotlib-users Digest, Vol 41, Issue 51
************************************************
# For detailed comments on animation and the techniqes used here, see
# the wiki entry http://www.scipy.org/Cookbook/Matplotlib/Animations
import os
import sys
#import matplotlib
#matplotlib.use('Qt4Agg')
from matplotlib.figure import Figure
from matplotlib.backends.backend_qt4agg import FigureCanvasQTAgg as FigureCanvas
import matplotlib.transforms as mtransforms
import matplotlib.cm as cm
from PyQt4 import QtCore, QtGui
ITERS = 100
import numpy as np
import time
class BlitQT(FigureCanvas):
def __init__(self):
FigureCanvas.__init__(self, Figure())
fig = self.figure
self.ax = fig.add_axes([0.1,0.7,0.8,0.2])
self.ax.grid()
self.draw()
NUMBER_OF_DATA = 1024
self.x = np.arange(NUMBER_OF_DATA)
self.ax2 = fig.add_axes([0.1,0.4,0.8,0.2])
self.ax2.grid()
self.draw()
self.old_size = self.ax.bbox.width, self.ax.bbox.height
self.cnt = 0
# create the initial lines
self.line, = self.ax.plot(self.x, self.x, 'r', animated=True, lw=.5)
self.line2, = self.ax2.plot(self.x, self.getY(), animated=True, lw=.5)
self.bbox = mtransforms.Bbox.from_bounds(32,24,608-32,407)
self.bbox = mtransforms.Bbox.from_bounds(64,192,576-64,432-193)
print self.ax.bbox.corners()
print self.ax2.bbox.corners()
self.background = self.copy_from_bbox(self.ax.bbox)
self.background2 = self.copy_from_bbox(self.ax2.bbox)
self.tstart = time.time()
self.startTimer(0)
def getY(self):
return np.random.random_sample(1024)
def timerEvent(self, evt):
#if (self.cnt % 3) == 0:
current_size = self.ax.bbox.width, self.ax.bbox.height
if self.old_size != current_size:
self.old_size = current_size
self.ax.clear()
self.ax.grid()
self.ax2.clear()
self.ax2.grid()
self.draw()
self.background = self.copy_from_bbox(self.ax.bbox)
self.background2 = self.copy_from_bbox(self.ax2.bbox)
# update the data
self.line.set_ydata(self.x+(self.cnt%100))
self.line2.set_ydata(self.getY())
# restore the clean slate background
self.restore_region(self.background)
self.restore_region(self.background2)
# just draw the animated artist
self.ax.draw_artist(self.line)
self.ax2.draw_artist(self.line2)
# and blit the different zones
self.blit(self.ax.bbox)
self.repaint()
self.blit(self.ax2.bbox)
self.repaint()
if self.cnt == 0:
self.draw()
if not (self.cnt%ITERS):
# print the timing info and quit
print 'FPS:' , ITERS/(time.time()-self.tstart)
self.tstart = time.time()
self.cnt += 1
app = QtGui.QApplication(sys.argv)
widget = BlitQT()
widget.show()
app.exec_()
------------------------------------------------------------------------------
Come build with us! The BlackBerry(R) Developer Conference in SF, CA
is the only developer event you need to attend this year. Jumpstart your
developing skills, take BlackBerry mobile applications to market and stay
ahead of the curve. Join us from November 9 - 12, 2009. Register now!
http://p.sf.net/sfu/devconference
_______________________________________________
Matplotlib-users mailing list
Matplotlib-users@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/matplotlib-users
