matplotlib-users Mailing List for matplotlib

Hi guys,
I have a problem with the "set_array" function. In a example from the
matplotlib homepage this works fine, but when I tries to adaot to my needs,
the image just stays the same. No Update, but also no error messages:
see On Timer function --> the plot is just created during the start but
never updated again. If I use imshow all the time, it works, but my
intention was not to use imshow allover, just update the image data.
Any ideas?
Cheers,
Sebi
Here is the code:
#!/usr/bin/env python
"""
"""
import sys, time, os, gc
import matplotlib
matplotlib.use('WXAgg')
from matplotlib import rcParams
import matplotlib.cm as cm
import numpy as np
import optparse
from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg
from matplotlib.backends.backend_wx import NavigationToolbar2Wx
from matplotlib.figure import Figure
from wx import *
TIMER_ID = NewId()
class PlotFigure(Frame):
 def __init__(self):
Frame.__init__(self, None, -1, "Test embedded wxFigure")
 self.fig = Figure((8,6), 100)
self.canvas = FigureCanvasWxAgg(self, -1, self.fig)
self.toolbar = NavigationToolbar2Wx(self.canvas)
self.toolbar.Realize()
 # On Windows, default frame size behaviour is incorrect
# you don't need this under Linux
tw, th = self.toolbar.GetSizeTuple()
fw, fh = self.canvas.GetSizeTuple()
self.toolbar.SetSize(Size(fw, th))
 # Create a figure manager to manage things
 # Now put all into a sizer
sizer = BoxSizer(VERTICAL)
# This way of adding to sizer allows resizing
sizer.Add(self.canvas, 1, LEFT|TOP|GROW)
# Best to allow the toolbar to resize!
sizer.Add(self.toolbar, 0, GROW)
self.SetSizer(sizer)
self.Fit()
EVT_TIMER(self, TIMER_ID, self.onTimer)
 def init_plot_data(self):
 # initialize data array and plot for the 1st time
self.data = np.zeros([96])
# create matrix which will contain the number of counted cells
well96 = np.zeros([8,12])
 # read in cell numbers
#Nr = 8 # number of rows
#Nc = 12 # number of columns
 #labelx = ['1','2','3','4','5','6','7','8','9','10','11','12']
#labely = ['A','B','C','D','E','F','G','H']
 ax1 = self.fig.add_axes([0.075,0.1,0.75,0.85])
self.cax = self.fig.add_axes([0.85,0.1,0.075,0.85])
 self.im = ax1.imshow(well96, cmap=cm.jet, interpolation='nearest')
self.fig.colorbar(self.im, cax=self.cax, orientation='vertical')
 #self.ax1.set_xticks(np.arange(0,12,1))
#self.ax1.set_xticklabels(labelx)
#self.ax1.set_yticks(np.arange(0,8,1))
#self.ax1.set_yticklabels(labely)
#self.ax1.set_title('Cell Count per Well')
 def GetToolBar(self):
# You will need to override GetToolBar if you are using an
# unmanaged toolbar in your frame
return self.toolbar
 def onTimer(self, evt):
 datain = np.loadtxt(options.filename, delimiter=';')
self.data[0:len(datain[:,1])] = datain[:,1]
welldata = self.data.reshape(8,12)
print welldata
self.im.set_array(welldata)
#self.im = self.ax1.imshow(welldata, cmap=cm.jet, interpolation='nearest')
self.fig.colorbar(self.im, cax=self.cax,orientation='vertical')
self.canvas.draw()
 def onEraseBackground(self, evt):
# this is supposed to prevent redraw flicker on some X servers...
pass
if __name__ == '__main__':
 # configure parsing option for command line usage
parser = optparse.OptionParser()
parser.add_option('-f', '--file',
action="store", dest="filename",
help="query string", default="spam")
 # read command line arguments
options, args = parser.parse_args()
print 'Filename:', options.filename
 app = PySimpleApp()
frame = PlotFigure()
frame.init_plot_data()
 # Initialise the timer - wxPython requires this to be connected to
# the receiving event handler
t = Timer(frame, TIMER_ID)
t.Start(1000)
 frame.Show()
app.MainLoop()

On Thursday, November 8, 2012, Alejandro Weinstein wrote:
> If you are in a Linux machine, you can use `inotify`: "Inotify (inode
> notify) is a Linux kernel subsystem that acts to extend filesystems to
> notice changes to the filesystem".
>
> It seems that there are a few option to use this from Python:
>
> http://pyinotify.sourceforge.net/
> http://code.activestate.com/recipes/576375-low-level-inotify-wrapper/
>
> Alejandro.
>
> On Thu, Nov 8, 2012 at 1:34 AM, Sebastian Rhode <seb...@gm...<javascript:;>>
> wrote:
> > Hi,
> >
> > I have a textfile where every second a line is written. Usually the look
> > like this:
> >
> > 1; 124; 455
> >
> > a second later
> >
> > 1; 124; 455
> > 2; 104; 600
> >
> > ...
> >
> > Finally such a file is quite easy to plot using matplotlib. But what
> would
> > be very useful for me is a script, that is watching the TXT file and
> updates
> > the plot when a new row "arrives". Any good ideas?
> >
> > Cheers,
> >
> > Sebi
> >
> >
> >
> ------------------------------------------------------------------------------
> > Everyone hates slow websites. So do we.
> > Make your web apps faster with AppDynamics
> > Download AppDynamics Lite for free today:
> > http://p.sf.net/sfu/appdyn_d2d_nov
> > _______________________________________________
> > Matplotlib-users mailing list
> > Mat...@li... <javascript:;>
> > https://lists.sourceforge.net/lists/listinfo/matplotlib-users
> >
>
>
> ------------------------------------------------------------------------------
> Everyone hates slow websites. So do we.
> Make your web apps faster with AppDynamics
> Download AppDynamics Lite for free today:
> http://p.sf.net/sfu/appdyn_d2d_nov
> _______________________________________________
> Matplotlib-users mailing list
> Mat...@li... <javascript:;>
> https://lists.sourceforge.net/lists/listinfo/matplotlib-users
>
In bash:
watch -n1 tail file.txt
-- 
Damon McDougall
http://www.damon-is-a-geek.com
B2.39
Mathematics Institute
University of Warwick
Coventry
West Midlands
CV4 7AL
United Kingdom

If you are in a Linux machine, you can use `inotify`: "Inotify (inode
notify) is a Linux kernel subsystem that acts to extend filesystems to
notice changes to the filesystem".
It seems that there are a few option to use this from Python:
http://pyinotify.sourceforge.net/
http://code.activestate.com/recipes/576375-low-level-inotify-wrapper/
Alejandro.
On Thu, Nov 8, 2012 at 1:34 AM, Sebastian Rhode <seb...@gm...> wrote:
> Hi,
>
> I have a textfile where every second a line is written. Usually the look
> like this:
>
> 1; 124; 455
>
> a second later
>
> 1; 124; 455
> 2; 104; 600
>
> ...
>
> Finally such a file is quite easy to plot using matplotlib. But what would
> be very useful for me is a script, that is watching the TXT file and updates
> the plot when a new row "arrives". Any good ideas?
>
> Cheers,
>
> Sebi
>
>
> ------------------------------------------------------------------------------
> Everyone hates slow websites. So do we.
> Make your web apps faster with AppDynamics
> Download AppDynamics Lite for free today:
> http://p.sf.net/sfu/appdyn_d2d_nov
> _______________________________________________
> Matplotlib-users mailing list
> Mat...@li...
> https://lists.sourceforge.net/lists/listinfo/matplotlib-users
>

Hi,
You could use the time module.
import time
while 1:
 time.sleep(5) # freezes for 5 s
 update plot
This should be less CPU consuming ...
lpmp
On Thu, Nov 8, 2012 at 9:41 AM, francesco oteri
<fra...@gm...>wrote:
> Hi,
> what about opening-closing the file every now and then, for example every
> 5seconds?
> you can do it using the function time(). It gives you the amount of time
> since I don't kno when,
> but you can count how many seconds are left using:
>
> a=time()
> while 1:
> b=time()
> left= b-a
> if left == 5sec:
> updating plot
>
> Actually is very cpu consuming, but it is the best I can propose :(
>
>
> Francesco
>
>
>
> 2012年11月8日 Sebastian Rhode <seb...@gm...>
>
>> Hi,
>>
>> I have a textfile where every second a line is written. Usually the look
>> like this:
>>
>> 1; 124; 455
>>
>> a second later
>>
>> 1; 124; 455
>> 2; 104; 600
>>
>> ...
>>
>> Finally such a file is quite easy to plot using matplotlib. But what
>> would be very useful for me is a script, that is watching the TXT file and
>> updates the plot when a new row "arrives". Any good ideas?
>>
>> Cheers,
>>
>> Sebi
>>
>>
>>
>> ------------------------------------------------------------------------------
>> Everyone hates slow websites. So do we.
>> Make your web apps faster with AppDynamics
>> Download AppDynamics Lite for free today:
>> http://p.sf.net/sfu/appdyn_d2d_nov
>> _______________________________________________
>> Matplotlib-users mailing list
>> Mat...@li...
>> https://lists.sourceforge.net/lists/listinfo/matplotlib-users
>>
>>
>
>
> --
> Cordiali saluti, Dr.Oteri Francesco
>
>
> ------------------------------------------------------------------------------
> Everyone hates slow websites. So do we.
> Make your web apps faster with AppDynamics
> Download AppDynamics Lite for free today:
> http://p.sf.net/sfu/appdyn_d2d_nov
> _______________________________________________
> Matplotlib-users mailing list
> Mat...@li...
> https://lists.sourceforge.net/lists/listinfo/matplotlib-users
>
>

Hi,
what about opening-closing the file every now and then, for example every
5seconds?
you can do it using the function time(). It gives you the amount of time
since I don't kno when,
but you can count how many seconds are left using:
a=time()
while 1:
 b=time()
 left= b-a
 if left == 5sec:
 updating plot
Actually is very cpu consuming, but it is the best I can propose :(
Francesco
2012年11月8日 Sebastian Rhode <seb...@gm...>
> Hi,
>
> I have a textfile where every second a line is written. Usually the look
> like this:
>
> 1; 124; 455
>
> a second later
>
> 1; 124; 455
> 2; 104; 600
>
> ...
>
> Finally such a file is quite easy to plot using matplotlib. But what would
> be very useful for me is a script, that is watching the TXT file and
> updates the plot when a new row "arrives". Any good ideas?
>
> Cheers,
>
> Sebi
>
>
>
> ------------------------------------------------------------------------------
> Everyone hates slow websites. So do we.
> Make your web apps faster with AppDynamics
> Download AppDynamics Lite for free today:
> http://p.sf.net/sfu/appdyn_d2d_nov
> _______________________________________________
> Matplotlib-users mailing list
> Mat...@li...
> https://lists.sourceforge.net/lists/listinfo/matplotlib-users
>
>
-- 
Cordiali saluti, Dr.Oteri Francesco

Hi,
I have a textfile where every second a line is written. Usually the look
like this:
1; 124; 455
a second later
1; 124; 455
2; 104; 600
...
Finally such a file is quite easy to plot using matplotlib. But what would
be very useful for me is a script, that is watching the TXT file and
updates the plot when a new row "arrives". Any good ideas?
Cheers,
Sebi