matplotlib-users Mailing List for matplotlib

>>>>> "Frank" == Smith, Frank <F....@te...> writes:

    Frank> Hello Matplotlib users, I only just discovered Matplotlib
    Frank> and I'm having great fun with it.  Wonderful package. Thank
    Frank> you to all contributors and maintainers.

    Frank> I have an application where the data that I want to plot is
    Frank> only released when it changes. So when this time tagged
    Frank> data is plotted it should be "flat" until the next data
    Frank> value that the application receives at which point the line
    Frank> should go instantaneously vertical to the new y-value, and
    Frank> then go horizontal until it changes again. Some graphics
    Frank> packages that I've used can handle this type of data
    Frank> automatically. I haven't found anything in the
    Frank> documentation or examples that shows this kind of feature
    Frank> in Matplotlib. Has anyone implemented a similar type of
    Frank> data handling application or is there something I've missed
    Frank> in Matplotlib? Any help or direction to this newbie would
    Frank> be very appreciated.

Here is an example that does something close to what you are trying to
do.  It takes advantage of the new animation drawing techniques
described at http://www.scipy.org/wikis/topical_software/Animations
and requires matplotlib CVS.  These techniques work with GTKAgg, WXAgg
and TkAgg.

To do this right, you will probably want to take advantage of your GUI
event handling framework, eg an idle handler or a timer.  The example
below uses the gtk idle handler, but this approach should work fine
with other toolkits.

There are some refinements.  Eg you could make the redrawing more
efficient potentially by narrowing the bbox you want to redraw in the
call to self.canvas.blit(self.ax.bbox).  You could also tweak this to
preserve the old line (eg the 0-10 second data) while you are
redrawing the new line (eg the 10-20 second data) in the way many
oscilloscopes do.  

But this should get you started.  If you refine it or generalize it,
please post the fruits of your labors.

import gobject, gtk
import matplotlib
matplotlib.use('GTKAgg')
import matplotlib.numerix as nx
from matplotlib.lines import Line2D


class Scope:
    def __init__(self, ax, maxt=10, dt=0.01):
        self.ax = ax
        self.canvas = ax.figure.canvas
        self.dt = dt
        self.maxt = maxt
        self.tdata = [0]
        self.ydata = [0]
        self.line = Line2D(self.tdata, self.ydata, animated=True)
        self.ax.add_line(self.line)
        self.background = None
        self.canvas.mpl_connect('draw_event', self.update_background)
        self.ax.set_ylim(-.1, 1.1)
        self.ax.set_xlim(0, self.maxt)

    def update_background(self, event):
        self.background = self.canvas.copy_from_bbox(self.ax.bbox)
    
    def emitter(self, p=0.01):
        'return a random value with probability p, else 0'
        v = nx.mlab.rand(1)
        if v>p: return 0.
        else: return nx.mlab.rand(1)

    def update(self, *args):
        if self.background is None: return True
        y = self.emitter()
        lastt = self.tdata[-1]
        if lastt>self.tdata[0]+self.maxt: # reset the arrays 
            self.tdata = [self.tdata[-1]]
            self.ydata = [self.ydata[-1]]
            self.ax.set_xlim(self.tdata[0], self.tdata[0]+self.maxt)
            self.ax.figure.canvas.draw()
            
        self.canvas.restore_region(self.background)
        
        t = self.tdata[-1] + self.dt        
        self.tdata.append(t)
        self.ydata.append(y)
        self.line.set_data(self.tdata, self.ydata)
        self.ax.draw_artist(self.line)
        self.canvas.blit(self.ax.bbox)
        return True


from pylab import figure, show

fig = figure()
ax = fig.add_subplot(111)
scope = Scope(ax)
gobject.idle_add(scope.update)

show()

Hello Matplotlib users,

I only just discovered Matplotlib and I'm having great fun with it.
Wonderful package. Thank you to all contributors and maintainers.

I have an application where the data that I want to plot is only
released when it changes. So when this time tagged data is plotted it
should be "flat" until the next data value that the application receives
at which point the line should go instantaneously vertical to the new
y-value, and then go horizontal until it changes again. Some graphics
packages that I've used can handle this type of data automatically. I
haven't found anything in the documentation or examples that shows this
kind of feature in Matplotlib. Has anyone implemented a similar type of
data handling application or is there something I've missed in
Matplotlib? Any help or direction to this newbie would be very
appreciated.

Thanks,
Frank

On Wed, 2005-08-31 at 08:15 +0200, Sascha GL wrote:
> > As far as I know (and could very well be wrong)
> > libpng requires a FILE*, which StringIO and cStringIO do not provide.
> 
> I think this is exactly the reason why printing to stdout fails.
> 
> Well, if anybody has any other idea I'd be very grateful.

I posted this to the list a few days ago:

Using the agg backend you can obtain an RGBA buffer or RGB string which
can then be loaded as a PIL Image for processing.  I've adapted a the
examples/agg_oo.py to demonstrate.

----
from matplotlib.backends.backend_agg \
    import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
import Image

fig = Figure()
canvas = FigureCanvas(fig)
ax = fig.add_subplot(111)
ax.plot([1,2,3])
ax.set_title('hi mom')
ax.grid(True)
ax.set_xlabel('time')
ax.set_ylabel('volts')
canvas.draw()
size = canvas.get_width_height()
usebuffer = True
if usebuffer:
    # Load the agg buffer directly as the source of the PIL image
    # - could be less stable as agg and PIL share memory.
    buf = canvas.buffer_rgba()
    im = Image.frombuffer('RGBA', size, buf, 'raw', 'RGBA', 0, 1)
else:
    # Save the agg buffer to a string and load this into the PIL image.
    buf = canvas.tostring_rgb()
    im = Image.fromstring('RGB', size, buf, 'raw', 'RGB', 0, 1)

im.show()
----

If you are using a recent CVS version of mpl you will need to change
buffer_rgba() to buffer_rgba(0,0).

Nick

> As far as I know (and could very well be wrong)
> libpng requires a FILE*, which StringIO and cStringIO do not provide.

I think this is exactly the reason why printing to stdout fails.

Well, if anybody has any other idea I'd be very grateful.

Sascha

-- 
5 GB Mailbox, 50 FreeSMS http://www.gmx.net/de/go/promail
+++ GMX - die erste Adresse für Mail, Message, More +++

>>>>> "Sascha" == Sascha  <sas...@gm...> writes:

    Sascha> I am writing a web server app that creates charts among
    Sascha> other things. I am trying to get rid of the temporary file
    Sascha> that I use to transmit the figures created with matplotlib
    Sascha> to the actual web server. Although print_figure says "If
    Sascha> filename is a fileobject, write png to file object (thus
    Sascha> you can, for example, write the png to stdout)" I can't
    Sascha> successfully write anything to stdout. Anyone knows an
    Sascha> example or can give me some hint what I can do to get rid
    Sascha> of the tempfile?

Short answer: no known way to do this currently, though we'd like to
figure it out.  As far as I know (and could very well be wrong)
libpng requires a FILE*, which StringIO and cStringIO do not provide.

JDH

Hi!
Indeed, I misunderstood documentation and installed only one package
from two (Numeric and numarray). After installation of Numeric and 
devels for tcl and tk installation went smoothly.
Thank you

Alex Schwarzenberg-Czerny

On 
Tue, 30 Aug 2005, Fernando Perez wrote:

> Aleksander Schwarzenberg-Czerny wrote:
> 
> > src/_transforms.cpp:8:34: Numeric/arrayobject.h: No such file or directory
> 
> > Do I miss some required package?
> 
> First, check whether you actually have numeric installed:
> 
> planck[python]> python -c 'import Numeric;print Numeric.__version__'
> 23.7
> 
> If that works, it means that you have installed the Numeric headers in some 
> non-standard location.  On my system, they live in:
> 
> planck[python]> locate arrayobject.h
> /usr/include/python2.3/Numeric/arrayobject.h
> 
> 
> I believe by default, distutils adds automatically /path/to/include/python to 
> the include file search path (via -I), but if you've installed Numeric in some 
> non-standard location, that automatic search may fail.  I don't see 
> immediately a way to tell distutils to add specific extra paths, but there may 
> be one.  The cheap fix is to copy the Numeric/*.h directory over to the 
> standard python location for headers in your system.
> 
> Cheers,
> 
> f
>