matplotlib-users

[Matplotlib-users] dynamically add subplots to figure

[Tom V. <to...@so...>]

Is it possible to add subplots to a figure if I don't know in advance
how many subplots I need to add?

What I do now is I call add_subplot like add_subplot(i, 1, i) where i
is 1 initially, and just increases by 1 on each call. This almost
works. Except the first plot takes up the whole figure, the second
plot is placed on top of the bottom half of the first plot, etc. Is
there a way to "resize" the plots when a subplot is added? Or how
would I "re-plot" the previous subplots?

Thanks.

-Tom

Re: [Matplotlib-users] dynamically add subplots to figure

[John H. <jd...@gm...>]

On Tue, Jun 2, 2009 at 9:03 AM, Tom Vaughan <to...@so...> wrote:
> Is it possible to add subplots to a figure if I don't know in advance
> how many subplots I need to add?
>
> What I do now is I call add_subplot like add_subplot(i, 1, i) where i
> is 1 initially, and just increases by 1 on each call. This almost
> works. Except the first plot takes up the whole figure, the second
> plot is placed on top of the bottom half of the first plot, etc. Is
> there a way to "resize" the plots when a subplot is added? Or how
> would I "re-plot" the previous subplots?

See the Axes.change_geometry command

  http://matplotlib.sourceforge.net/api/axes_api.html#matplotlib.axes.SubplotBase.change_geometry

As in this example::

    import matplotlib.pyplot as plt

    # start with one
    fig = plt.figure()
    ax = fig.add_subplot(111)
    ax.plot([1,2,3])

    # now later you get a new subplot; change the geometry of the existing
    n = len(fig.axes)
    for i in range(n):
        fig.axes[i].change_geometry(n+1, 1, i+1)

    # add the new
    ax = fig.add_subplot(n+1, 1, n+1)
    ax.plot([4,5,6])




    plt.show()

JDH

>
> Thanks.
>
> -Tom
>
> ------------------------------------------------------------------------------
> OpenSolaris 2009.06 is a cutting edge operating system for enterprises
> looking to deploy the next generation of Solaris that includes the latest
> innovations from Sun and the OpenSource community. Download a copy and
> enjoy capabilities such as Networking, Storage and Virtualization.
> Go to: http://p.sf.net/sfu/opensolaris-get
> _______________________________________________
> Matplotlib-users mailing list
> Mat...@li...
> https://lists.sourceforge.net/lists/listinfo/matplotlib-users
>

Re: [Matplotlib-users] dynamically add subplots to figure

[Tom V. <to...@so...>]

On Tue, Jun 2, 2009 at 07:33, John Hunter<jd...@gm...> wrote:
> On Tue, Jun 2, 2009 at 9:03 AM, Tom Vaughan <to...@so...> wrote:
>> Is it possible to add subplots to a figure if I don't know in advance
>> how many subplots I need to add?
>>
>> What I do now is I call add_subplot like add_subplot(i, 1, i) where i
>> is 1 initially, and just increases by 1 on each call. This almost
>> works. Except the first plot takes up the whole figure, the second
>> plot is placed on top of the bottom half of the first plot, etc. Is
>> there a way to "resize" the plots when a subplot is added? Or how
>> would I "re-plot" the previous subplots?
>
> See the Axes.change_geometry command
>
>  http://matplotlib.sourceforge.net/api/axes_api.html#matplotlib.axes.SubplotBase.change_geometry
>
> As in this example::
>
>    import matplotlib.pyplot as plt
>
>    # start with one
>    fig = plt.figure()
>    ax = fig.add_subplot(111)
>    ax.plot([1,2,3])
>
>    # now later you get a new subplot; change the geometry of the existing
>    n = len(fig.axes)
>    for i in range(n):
>        fig.axes[i].change_geometry(n+1, 1, i+1)

Awesome. Thanks.

Strangely this doesn't quite work for me. Luckily I keep a list of my
subplots. So I do:

        def new_subplot(self):
                nsubplots = len(self.__subplots) + 1

                for i, subplot in enumerate(self.__subplots):
                        subplot.change_geometry(nsubplots, 1, i + 1)

                subplot = self.figure.add_subplot(nsubplots, 1, nsubplots)
                subplot.grid(True)

                self.__subplots.append(subplot)
                self.__subplot = subplot

Interestingly, if I were to 'print dir(self.figure.axes[i])' I can see
the change_geometry attribute, but when I attempt to call it, I am
told "AttributeError: 'AxesSubplot' object has no attribute
'change_geomtry'" This lead me to what I have above.

Thanks.

-Tom

Re: [Matplotlib-users] dynamically add subplots to figure

[John H. <jd...@gm...>]

On Tue, Jun 2, 2009 at 10:18 AM, Tom Vaughan <to...@so...> wrote:

> Interestingly, if I were to 'print dir(self.figure.axes[i])' I can see
> the change_geometry attribute, but when I attempt to call it, I am
> told "AttributeError: 'AxesSubplot' object has no attribute
> 'change_geomtry'" This lead me to what I have above.
>

Check your spelling: 'change_geomtry'

Re: [Matplotlib-users] dynamically add subplots to figure

[Tom V. <to...@so...>]

On Tue, Jun 2, 2009 at 08:40, John Hunter<jd...@gm...> wrote:
> On Tue, Jun 2, 2009 at 10:18 AM, Tom Vaughan <to...@so...> wrote:
>
>> Interestingly, if I were to 'print dir(self.figure.axes[i])' I can see
>> the change_geometry attribute, but when I attempt to call it, I am
>> told "AttributeError: 'AxesSubplot' object has no attribute
>> 'change_geomtry'" This lead me to what I have above.
>>
>
> Check your spelling: 'change_geomtry'

Whoops. Thanks.

-Tom

Re: [Matplotlib-users] dynamically add subplots to figure

[Tom V. <to...@so...>]

On Tue, Jun 2, 2009 at 07:33, John Hunter<jd...@gm...> wrote:
> On Tue, Jun 2, 2009 at 9:03 AM, Tom Vaughan <to...@so...> wrote:
>> Is it possible to add subplots to a figure if I don't know in advance
>> how many subplots I need to add?
>>
>> What I do now is I call add_subplot like add_subplot(i, 1, i) where i
>> is 1 initially, and just increases by 1 on each call. This almost
>> works. Except the first plot takes up the whole figure, the second
>> plot is placed on top of the bottom half of the first plot, etc. Is
>> there a way to "resize" the plots when a subplot is added? Or how
>> would I "re-plot" the previous subplots?
>
> See the Axes.change_geometry command
>
>  http://matplotlib.sourceforge.net/api/axes_api.html#matplotlib.axes.SubplotBase.change_geometry

To follow-up on this a bit, the second, third, etc subplots all seem
to get stuck with the first subplot's x-axis. Let's say the first plot
is -60 to 60, and the second plot is 2 - 4. The data in the second
plot is plotted on the correct scale (2 to 4), but I still see -60 to
60.

Actually, this isn't entirely correct. When I add a third subplot, the
second subplot becomes correct. So the -60 to 60 only sticks to the
most recently added subplot.

Any ideas?

Thanks.

-Tom

Re: [Matplotlib-users] dynamically add subplots to figure

[John H. <jd...@gm...>]

On Tue, Jun 2, 2009 at 1:51 PM, Tom Vaughan <to...@so...> wrote:
> On Tue, Jun 2, 2009 at 07:33, John Hunter<jd...@gm...> wrote:
>> On Tue, Jun 2, 2009 at 9:03 AM, Tom Vaughan <to...@so...> wrote:
>>> Is it possible to add subplots to a figure if I don't know in advance
>>> how many subplots I need to add?
>>>
>>> What I do now is I call add_subplot like add_subplot(i, 1, i) where i
>>> is 1 initially, and just increases by 1 on each call. This almost
>>> works. Except the first plot takes up the whole figure, the second
>>> plot is placed on top of the bottom half of the first plot, etc. Is
>>> there a way to "resize" the plots when a subplot is added? Or how
>>> would I "re-plot" the previous subplots?
>>
>> See the Axes.change_geometry command
>>
>>  http://matplotlib.sourceforge.net/api/axes_api.html#matplotlib.axes.SubplotBase.change_geometry
>
> To follow-up on this a bit, the second, third, etc subplots all seem
> to get stuck with the first subplot's x-axis. Let's say the first plot
> is -60 to 60, and the second plot is 2 - 4. The data in the second
> plot is plotted on the correct scale (2 to 4), but I still see -60 to
> 60.
>
> Actually, this isn't entirely correct. When I add a third subplot, the
> second subplot becomes correct. So the -60 to 60 only sticks to the
> most recently added subplot.
>
> Any ideas?

post some code

Re: [Matplotlib-users] dynamically add subplots to figure

[Tom V. <to...@so...>]

On Tue, Jun 2, 2009 at 11:59, John Hunter<jd...@gm...> wrote:
> On Tue, Jun 2, 2009 at 1:51 PM, Tom Vaughan <to...@so...> wrote:
>> On Tue, Jun 2, 2009 at 07:33, John Hunter<jd...@gm...> wrote:
>>> On Tue, Jun 2, 2009 at 9:03 AM, Tom Vaughan <to...@so...> wrote:
>>>> Is it possible to add subplots to a figure if I don't know in advance
>>>> how many subplots I need to add?
>>>>
>>>> What I do now is I call add_subplot like add_subplot(i, 1, i) where i
>>>> is 1 initially, and just increases by 1 on each call. This almost
>>>> works. Except the first plot takes up the whole figure, the second
>>>> plot is placed on top of the bottom half of the first plot, etc. Is
>>>> there a way to "resize" the plots when a subplot is added? Or how
>>>> would I "re-plot" the previous subplots?
>>>
>>> See the Axes.change_geometry command
>>>
>>>  http://matplotlib.sourceforge.net/api/axes_api.html#matplotlib.axes.SubplotBase.change_geometry
>>
>> To follow-up on this a bit, the second, third, etc subplots all seem
>> to get stuck with the first subplot's x-axis. Let's say the first plot
>> is -60 to 60, and the second plot is 2 - 4. The data in the second
>> plot is plotted on the correct scale (2 to 4), but I still see -60 to
>> 60.
>>
>> Actually, this isn't entirely correct. When I add a third subplot, the
>> second subplot becomes correct. So the -60 to 60 only sticks to the
>> most recently added subplot.
>>
>> Any ideas?
>
> post some code
>

I thought this might be required...

We have a variety of telemetry applications that all require some sort
of visual display of data. We've created a widget based upon
matplotlib that can be used stand-alone (reads JSON formatted data
files), or within PyGTK applications and can plot data sets in
"real-time". So the whole thing is excessively complex. I'd be happy
to package up the whole thing if anyone is interested. Currently it
requires the latest Ubuntu release with several additional development
libraries like GLib. What I've posted below is just the abstract plot
widget.

I think the relevant parts are:

                from matplotlib.figure import Figure
                self.figure = Figure()

                self.__subplots = []
                self.subplot_new()

                self.__axl = self.figure.gca()
                self.__axl.yaxis.set_label_position('left')
                self.__axl.yaxis.tick_left()

                self.__axr = self.__axl.twinx()
                self.__axr.yaxis.set_label_position('right')
                self.__axr.yaxis.tick_right()

and then:

        def subplot_new(self):
                nsubplots = len(self.__subplots) + 1

                subplot = self.figure.add_subplot(nsubplots, 1, nsubplots)
                subplot.grid(True)

                self.__subplots.append(subplot)
                self.__subplot = subplot

                for i, subplot in enumerate(self.__subplots):
                        subplot.change_geometry(nsubplots, 1, i + 1)

and then:

        def __plot__(self, x, y, style='-', color=0xFF0000,
xlabel=None, ylabel=None):
                IBackend.__plot__(self, x, y, style=style,
color=color, xlabel=xlabel, ylabel=ylabel)

                if xlabel != None:
                        self.__subplot.set_xlabel(xlabel)
                if ylabel != None:
                        self.__subplot.set_ylabel(ylabel)

                self.__subplot.plot(x, y, style, color='#%06X' % (color))
                self.__subplot.grid(True)

        def plotr(self, *args, **kwargs):
                self.figure.sca(self.__axr)
                if not kwargs.has_key('color'):
                        kwargs['color'] = 0x00FF00
                self.__plot__(*args, **kwargs)

        def plotl(self, *args, **kwargs):
                self.figure.sca(self.__axl)
                if not kwargs.has_key('color'):
                        kwargs['color'] = 0xFF0000
                self.__plot__(*args, **kwargs)

The whole thing:

from __future__ import with_statement

# standard python libraries
try:
        import json
except:
        import simplejson as json

import re
import os
import time

# matplotlib.sf.net
import matplotlib
import numpy

# www.gtk.org
import gtk

# our own libraries
from elrond.macros import clamp
from elrond.util import Object, Property

def parse(f):
        x = []
        y = []

        fd = open(f, 'r')
        lines = [l.strip() for l in fd.readlines()]
        fd.close()

        for i, line in enumerate(lines):
                data = filter(lambda x: x != '', re.split('[, ]', line.strip()))

                try:
                        y.append(float(data[1]))
                        x.append(float(data[0]))
                except IndexError:
                        y.append(float(data[0]))
                        x.append(i)

        return x, y

##
## Backends...
##

class IBackend(Object):
        """The IBackend class is the base implementation for any class
that can produce plots.
        e.g. ASCII art or fancy GUI backends like matplotlib.
        """

        def stripchart(self, filename):
                x_list, y_list = parse(filename)

                self.clear()

                self.props.ymin = 0
                self.props.ymax = 100

                step = 100

                x_first = x_list[0: clamp(step, u=len(x_list))]
                y_first = y_list[0: clamp(step, u=len(y_list))]

                self.props.xmin = 0
                self.props.xmax = len(x_first)

                for i in range(0, len(x_first)):
                        self.plotl(x_first[0:i + 1], y_first[0:i + 1])
                        self.draw()

                self.plotl(x_list, y_list)

                for i in range(0, len(x_list)):
                        self.props.xmin = i + 1
                        self.props.xmax = i + 1 + step

                        self.draw()

        def open(self, filename):
                self.clear()

                if self.subplotkludge:
                        self.subplot_new()

                self.subplotkludge = True

                with open(filename, 'r') as f:
                        storage = json.load(f)

                        print 'File: %s' % (filename)
                        print 'Timestamp: %s' % (storage['timestamp'])

                        for data in storage['data']:
                                self.plotl(data['x'], data['y'],
xlabel=data['xlabel'], ylabel=data['ylabel'],
                                           style=data['style'],
color=int(data['color'], 0))

                self.draw()

                if not self.props.overlay:
                        self.__storage['data'] = []

                self.__storage['data'].extend(storage['data'])

        def save(self, filename):
                self.__storage['timestamp'] = time.ctime(time.time())

                with open(filename, 'w') as f:
                        json.dump(self.__storage, f, indent=8)

        # TODO:
        def stats(self, x, y):
                print '  len =', len(y)
                print ' mean =', numpy.mean(y)
                print '  sum =', sum(y)
                print '  std =', numpy.std(y)

                ymin = numpy.min(y)
                print ' ymin =', ymin
                print ' xmin =', x[y.index(ymin)]

                ymax = numpy.max(y)
                print ' ymax =', ymax
                print ' xmax =', x[y.index(ymax)]

        def __plot__(self, x, y, style=None, color=0xFF0000,
xlabel=None, ylabel=None):
                self.stats(x, y)

                data = {
                        'xlabel': xlabel,
                        'x': x,
                        'ylabel': ylabel,
                        'y': y,
                        'style': style,
                        'color': '0x%06X' % (color)
                }

                if not self.props.overlay:
                        self.__storage['data'] = []

                self.__storage['data'].append(data)

        def plotr(self, *args, **kwargs):
                self.__plot__(*args, **kwargs)

        def plotl(self, *args, **kwargs):
                self.__plot__(*args, **kwargs)

        def ploth(self, *args, **kwargs):
                self.__plot__(*args, **kwargs)

        def plotv(self, *args, **kwargs):
                self.__plot__(*args, **kwargs)

        def draw(self, *args, **kwargs):
                pass

        def clear(self, *args, **kwargs):
                pass

        def show(self, *args, **kwargs):
                pass

        def hide(self, *args, **kwargs):
                pass

        def run(self, *args, **kwargs):
                pass

        def __init__(self):
                Object.__init__(self)

                self.__storage = {
                        'data': []
                }

class ConsoleBackend(IBackend):
        """This is the simplest of backends. This simply prints to the
console. This backend
        must be used within a ConsoleContainer.
        """

        def __plot__(self, x, y, style=None, color=0xFF0000,
xlabel=None, ylabel=None):
                IBackend.__plot__(self, x, y, style=style,
color=color, xlabel=xlabel, ylabel=ylabel)

                for i in range(0, len(x)):
                        print 'x,y[%d] = %.4f, %4f' % (i, x[i], y[i])

class IMatplotlibBackend(IBackend):
        """This backend uses matplotlib to prodce plots. An
ImageContainer or WindowContainer in-turn
        contains this backed to either render the plot to and image or to a GUI.
        """

        def __plot__(self, x, y, style='-', color=0xFF0000,
xlabel=None, ylabel=None):
                IBackend.__plot__(self, x, y, style=style,
color=color, xlabel=xlabel, ylabel=ylabel)

                if xlabel != None:
                        self.__subplot.set_xlabel(xlabel)
                if ylabel != None:
                        self.__subplot.set_ylabel(ylabel)

                self.__subplot.plot(x, y, style, color='#%06X' % (color))
                self.__subplot.grid(True)

        def plotr(self, *args, **kwargs):
                self.figure.sca(self.__axr)
                if not kwargs.has_key('color'):
                        kwargs['color'] = 0x00FF00
                self.__plot__(*args, **kwargs)

        def plotl(self, *args, **kwargs):
                self.figure.sca(self.__axl)
                if not kwargs.has_key('color'):
                        kwargs['color'] = 0xFF0000
                self.__plot__(*args, **kwargs)

        def ploth(self, y, style='--', color=0xFF0000):
                self.__subplot.axhline(y, ls=style, color='#%06X' % (color))
                self.__subplot.grid(True)

        def plotv(self, x, style='--', color=0xFF0000):
                self.__subplot.axvline(x, ls=style, color='#%06X' % (color))
                self.__subplot.grid(True)

        def draw(self):
                self.__subplot.axis('auto')

                limits = [self.props.xmin, self.props.xmax,
self.props.ymin, self.props.ymax]

                if filter(lambda x: x != 0, limits):
                        self.__subplot.axis(limits)

                self.canvas.draw()

        def clear(self):
                if self.props.overlay:
                        return

                self.__subplot.clear()
                self.__subplot.grid(True)

        def subplot_new(self):
                nsubplots = len(self.__subplots) + 1

                subplot = self.figure.add_subplot(nsubplots, 1, nsubplots)
                subplot.grid(True)

                self.__subplots.append(subplot)
                self.__subplot = subplot

                for i, subplot in enumerate(self.__subplots):
                        subplot.change_geometry(nsubplots, 1, i + 1)

        def __init__(self):
                IBackend.__init__(self)

                from matplotlib.figure import Figure
                self.figure = Figure()

                self.__subplots = []
                self.subplot_new()

                self.subplotkludge = False

                self.__axl = self.figure.gca()
                self.__axl.yaxis.set_label_position('left')
                self.__axl.yaxis.tick_left()

                self.__axr = self.__axl.twinx()
                self.__axr.yaxis.set_label_position('right')
                self.__axr.yaxis.tick_right()

class MatplotlibImageBackend(IMatplotlibBackend):

        def render(self, filename):
                self.figure.savefig(filename)

        def __init__(self):
                IMatplotlibBackend.__init__(self)

                from matplotlib.backends.backend_cairo \
                  import FigureCanvasCairo as FigureCanvas

                self.canvas = FigureCanvas(self.figure)

class MatplotlibWindowBackend(IMatplotlibBackend):

        @Property
        def widget():
                def fget(self):
                        self.__widget = gtk.VBox()

                        self.__widget.pack_start(self.canvas)
                        self.__widget.pack_start(self.toolbar, False, False)

                        return self.__widget

                def fset(self, widget):
                        self.__widget = widget

                return locals()

        def show(self):
                self.__widget.show()
                self.canvas.show()
                self.toolbar.show()

        def hide(self):
                self.toolbar.hide()
                self.canvas.hide()
                self.__widget.hide()

        def __init__(self):
                IMatplotlibBackend.__init__(self)

                from matplotlib.backends.backend_gtk \
                  import FigureCanvasGTK as FigureCanvas

                self.canvas = FigureCanvas(self.figure)

                from matplotlib.backends.backend_gtk \
                  import NavigationToolbar2GTK as NavigationToolbar

                self.toolbar = NavigationToolbar(self.canvas, None)

##
## Containers...
##

class IContainer(Object):
        """The IContainer class is the base implementation for any
class that contains IBackends.
        e.g. console wrappers, image only wrappers, or fancy GUI
toolkits like GTK+.
        """

        @Property
        def props():
                def fget(self):
                        return self.backend.props

                def fset(self, props):
                        self.backend.props = props

                return locals()

        def plotr(self, *args, **kwargs):
                self.backend.plotr(*args, **kwargs)

        def plotl(self, *args, **kwargs):
                self.backend.plotl(*args, **kwargs)

        def ploth(self, *args, **kwargs):
                self.backend.ploth(*args, **kwargs)

        def plotv(self, *args, **kwargs):
                self.backend.plotv(*args, **kwargs)

        def draw(self, *args, **kwargs):
                self.backend.draw(*args, **kwargs)

        def clear(self, *args, **kwargs):
                self.backend.clear(*args, **kwargs)

        def show(self, *args, **kwargs):
                self.backend.show(*args, **kwargs)

        def hide(self, *args, **kwargs):
                self.backend.hide(*args, **kwargs)

        def run(self, *args, **kwargs):
                self.backend.run(*args, **kwargs)

        def stripchart(self, filename):
                self.backend.stripchart(filename)

        def open(self, filename):
                self.backend.open(filename)

        def save(self, filename):
                self.backend.save(filename)

class ConsoleContainer(IContainer):

        def __init__(self):
                IContainer.__init__(self)

                self.backend = ConsoleBackend()

class ImageContainer(IContainer):

        def draw(self, *args, **kwargs):
                IContainer.draw(self, *args, **kwargs)

                self.backend.render('foobar.png')

        def __init__(self):
                IContainer.__init__(self)

                self.backend = MatplotlibImageBackend()

class WindowContainer(IContainer):

        @Property
        def props():
                def fget(self):
                        return self.backend.props

                def fset(self, props):
                        self.backend.props = props

                        widget =
self.__builder.get_object('preferences_xmin_entry')
                        widget.set_text(str(self.backend.props.xmin))

                        widget =
self.__builder.get_object('preferences_xmax_entry')
                        widget.set_text(str(self.backend.props.xmax))

                        widget =
self.__builder.get_object('preferences_ymin_entry')
                        widget.set_text(str(self.backend.props.ymin))

                        widget =
self.__builder.get_object('preferences_ymax_entry')
                        widget.set_text(str(self.backend.props.ymax))

                return locals()

        @Property
        def title():
                def fget(self):
                        return self.__title

                def fset(self, title):
                        self.__title = title

                        if not self.__title:
                                return

                        self.__container.set_title(self.__title)

                return locals()

        def clear(self, *args, **kwargs):
                IContainer.clear(self, *args, **kwargs)

        def show(self, *args, **kwargs):
                IContainer.show(self, *args, **kwargs)

                self.__container.show()

        def hide(self, *args, **kwargs):
                IContainer.hide(self, *args, **kwargs)

                self.__container.hide()

        def run(self):
                gtk.main()

        def on_open_ok_button_clicked(self, widget, data=None):
                self.__open.hide()

                filename = self.__open.get_filename()
                if not filename:
                        return
                self.__open.set_filename(filename)

                self.open(filename)

        def on_open_cancel_button_clicked(self, widget, data=None):
                self.__open.hide()

        def on_open_chooser_delete_event(self, widget, data=None):
                self.__open.hide()
                return True

        def on_plot_open_button_clicked(self, widget, data=None):
                self.__open = self.__builder.get_object('open_chooser')
                self.__open.show()

        def on_plot_save_button_clicked(self, widget, data=None):
                if not self.filename:
                        self.on_plot_saveas_button_clicked(self, None)

                if self.filename:
                        self.save(self.filename)

        def on_saveas_ok_button_clicked(self, widget, data=None):
                self.__saveas.hide()

                filename = self.__saveas.get_filename()
                if not filename:
                        return
                self.__saveas.set_filename(filename)

                self.filename = filename

                self.on_plot_save_button_clicked(self, None)

        def on_saveas_cancel_button_clicked(self, widget, data=None):
                self.__saveas.hide()

        def on_saveas_chooser_delete_event(self, widget, data=None):
                self.__saveas.hide()
                return True

        def on_plot_saveas_button_clicked(self, widget, data=None):
                self.__saveas = self.__builder.get_object('saveas_chooser')
                self.__saveas.show()

        def on_preferences_ok_button_clicked(self, widget, data=None):
                self.__preferences.hide()

                widget = self.__builder.get_object('preferences_xmin_entry')
                self.props.xmin = float(widget.get_text())

                widget = self.__builder.get_object('preferences_xmax_entry')
                self.props.xmax = float(widget.get_text())

                widget = self.__builder.get_object('preferences_ymin_entry')
                self.props.ymin = float(widget.get_text())

                widget = self.__builder.get_object('preferences_ymax_entry')
                self.props.ymax = float(widget.get_text())

                self.draw()

        def on_preferences_cancel_button_clicked(self, widget, data=None):
                self.__preferences.hide()

        def on_plot_preferences_button_clicked(self, widget, data=None):
                self.__preferences =
self.__builder.get_object('preferences_dialog')
                self.__preferences.show()

        def on_preferences_dialog_delete_event(self, widget, data=None):
                self.__preferences.hide()
                return True

        def on_plot_overlay_button_toggled(self, widget, data=None):
                self.props.overlay = widget.get_active()

        def on_plot_window_destroy(self, widget, data=None):
                gtk.main_quit()

        def __init__(self, container):
                IContainer.__init__(self)

                self.backend = MatplotlibWindowBackend()

                buildername = os.environ['GRIMA_ETC'] + os.sep + 'grima-plot.ui'
                self.__builder = gtk.Builder()
                self.__builder.add_from_file(buildername)
                self.__builder.connect_signals(self)

                if container:
                        self.__container = container
                        widget = self.__builder.get_object('plot_embeddable')
                        container = self.__builder.get_object('plot_container')
                        container.remove(widget)
                        self.__container.add(widget)
                else:
                        self.__container =
self.__builder.get_object('plot_window')

                        # TODO: this should not be needed, but somehow
the widget show'ing order
                        # is all screwed up and the window doesn't
display correctly without this
                        self.__container.set_default_size(700, 500)

                widget = self.__builder.get_object('plot_backend')
                widget.add(self.backend.widget)

                # TODO:
                self.filename = None

##
## This is the public API...
##

class Plot(Object):

        def __create_display(self):
                if not self.__enabled:
                        return

                if self.type == 'console':
                        self.__display = ConsoleContainer()
                if self.type == 'image':
                        self.__display = ImageContainer()
                if self.type == 'window':
                        self.__display = WindowContainer(self.container)

                try:
                        self.__display.props = self
                        self.__display.title = self.title
                except:
                        self.__enabled = False

        @Property
        def enabled():
                def fget(self):
                        return self.__enabled

                def fset(self, enabled):
                        self.__enabled = enabled
                        self.__create_display()

                return locals()

        @Property
        def type():
                def fget(self):
                        return self.__type

                def fset(self, type):
                        self.__type = type
                        self.__create_display()

                return locals()

        @Property
        def title():
                def fget(self):
                        return self.__title

                def fset(self, title):
                        self.__title = title

                return locals()

        def plotr(self, *args, **kwargs):
                if not self.enabled:
                        return

                self.__display.plotr(*args, **kwargs)

        def plotl(self, *args, **kwargs):
                if not self.enabled:
                        return

                self.__display.plotl(*args, **kwargs)

        def ploth(self, *args, **kwargs):
                if not self.enabled:
                        return

                self.__display.ploth(*args, **kwargs)

        def plotv(self, *args, **kwargs):
                if not self.enabled:
                        return

                self.__display.plotv(*args, **kwargs)

        def draw(self, *args, **kwargs):
                if not self.enabled:
                        return

                self.__display.draw(*args, **kwargs)

        def clear(self, *args, **kwargs):
                if not self.enabled:
                        return

                self.__display.clear(*args, **kwargs)

        def show(self, *args, **kwargs):
                if not self.enabled:
                        return

                self.__display.show(*args, **kwargs)

        def hide(self, *args, **kwargs):
                if not self.enabled:
                        return

                self.__display.hide(*args, **kwargs)

        def run(self, *args, **kwargs):
                if not self.enabled:
                        return

                self.__display.run(*args, **kwargs)

        def stripchart(self, *args, **kwargs):
                if not self.enabled:
                        return

                self.__display.stripchart(*args, **kwargs)

        def open(self, *args, **kwargs):
                if not self.enabled:
                        return

                self.__display.open(*args, **kwargs)

        def save(self, *args, **kwargs):
                if not self.enabled:
                        return

                self.__display.save(*args, **kwargs)

        def __init__(self):
                Object.__init__(self)

                self.enabled = False
                self.container = None
                self.type = 'console'
                self.title = None

                # TODO: use preferences
                self.xmin = 0
                self.xmax = 0
                self.ymin = 0
                self.ymax = 0
                self.overlay = False

# Local Variables:
# indent-tabs-mode: nil
# python-continuation-offset: 2
# python-indent: 8
# End:
# vim: ai et si sw=8 ts=8

Re: [Matplotlib-users] dynamically add subplots to figure

[Christopher B. <Chr...@no...>]

Tom Vaughan wrote:
>> post some code
>>
> 
> I thought this might be required...
> 
> So the whole thing is excessively complex.

It can be very instructive to write a little app that just tests the 
issue at hand -- it may help you figure out what's wrong, and if not, 
you will have a self-contained sample that you can post here for feedback.

> I think the relevant parts are:
> 
>                 from matplotlib.figure import Figure

>                 self.__axl = self.figure.gca()

I don't know what your issue is, but I thin you will be ell served to 
use the OO interface, rather than pylab to write a complex app like this 
-- pylab is designed for simple interactive use and quick scripts. In an 
app, you want full control.


-Chris


-- 
Christopher Barker, Ph.D.
Oceanographer

Emergency Response Division
NOAA/NOS/OR&R            (206) 526-6959   voice
7600 Sand Point Way NE   (206) 526-6329   fax
Seattle, WA  98115       (206) 526-6317   main reception

Chr...@no...

Re: [Matplotlib-users] dynamically add subplots to figure

[John H. <jd...@gm...>]

On Tue, Jun 2, 2009 at 4:34 PM, Christopher Barker
<Chr...@no...> wrote:

>> I think the relevant parts are:
>>
>>                 from matplotlib.figure import Figure
>
>>                 self.__axl = self.figure.gca()
>
> I don't know what your issue is, but I thin you will be ell served to
> use the OO interface, rather than pylab to write a complex app like this
> -- pylab is designed for simple interactive use and quick scripts. In an
> app, you want full control.

This is the API -- figure is a Figure instance, and gca is a figure
method.  pyplot.gca is a wrapper around this method.  The Figure
tracks the "current" axes, but the API doesn't really use this method
other than to provide it for pyplot.

But the larger point is still well taken -- you should probably be
using self.figure.add_subplot(111) here rather than gca.

JDH

Re: [Matplotlib-users] dynamically add subplots to figure

[Tom V. <to...@so...>]

On Tue, Jun 2, 2009 at 07:33, John Hunter<jd...@gm...> wrote:
> On Tue, Jun 2, 2009 at 9:03 AM, Tom Vaughan <to...@so...> wrote:
>> Is it possible to add subplots to a figure if I don't know in advance
>> how many subplots I need to add?
>>
>> What I do now is I call add_subplot like add_subplot(i, 1, i) where i
>> is 1 initially, and just increases by 1 on each call. This almost
>> works. Except the first plot takes up the whole figure, the second
>> plot is placed on top of the bottom half of the first plot, etc. Is
>> there a way to "resize" the plots when a subplot is added? Or how
>> would I "re-plot" the previous subplots?
>
> See the Axes.change_geometry command
>
>  http://matplotlib.sourceforge.net/api/axes_api.html#matplotlib.axes.SubplotBase.change_geometry

twinx() does not return an axes that contains the change_geometry
method. How then can I do the equivalent on this axes? Calling twinx()
again on the original axes after change_geometry() has been called
does not do the trick. Thanks.

-Tom

Re: [Matplotlib-users] dynamically add subplots to figure

[Jae-Joon L. <lee...@gm...>]

One work around is to call

  self.figure.subplots_adjust()

after geometry changed. After this call, the twinx-ed axes will have
the same axes position as the original one.

Another option is to use mpl_toolkits.axes_grid
(http://matplotlib.sourceforge.net/mpl_toolkits/axes_grid/users/overview.html#parasiteaxes).
But the previous solution seems to be much easier for you.
Regards,

-JJ


On Thu, Jul 16, 2009 at 1:16 PM, Tom Vaughan<to...@so...> wrote:
> On Tue, Jun 2, 2009 at 07:33, John Hunter<jd...@gm...> wrote:
>> On Tue, Jun 2, 2009 at 9:03 AM, Tom Vaughan <to...@so...> wrote:
>>> Is it possible to add subplots to a figure if I don't know in advance
>>> how many subplots I need to add?
>>>
>>> What I do now is I call add_subplot like add_subplot(i, 1, i) where i
>>> is 1 initially, and just increases by 1 on each call. This almost
>>> works. Except the first plot takes up the whole figure, the second
>>> plot is placed on top of the bottom half of the first plot, etc. Is
>>> there a way to "resize" the plots when a subplot is added? Or how
>>> would I "re-plot" the previous subplots?
>>
>> See the Axes.change_geometry command
>>
>>  http://matplotlib.sourceforge.net/api/axes_api.html#matplotlib.axes.SubplotBase.change_geometry
>
> twinx() does not return an axes that contains the change_geometry
> method. How then can I do the equivalent on this axes? Calling twinx()
> again on the original axes after change_geometry() has been called
> does not do the trick. Thanks.
>
> -Tom
>
> ------------------------------------------------------------------------------
> Enter the BlackBerry Developer Challenge
> This is your chance to win up to $100,000 in prizes! For a limited time,
> vendors submitting new applications to BlackBerry App World(TM) will have
> the opportunity to enter the BlackBerry Developer Challenge. See full prize
> details at: http://p.sf.net/sfu/Challenge
> _______________________________________________
> Matplotlib-users mailing list
> Mat...@li...
> https://lists.sourceforge.net/lists/listinfo/matplotlib-users
>

Re: [Matplotlib-users] dynamically add subplots to figure

[Tom V. <to...@so...>]

Great. That worked. Thanks!

-Tom


On Thu, Jul 16, 2009 at 11:23, Jae-Joon Lee<lee...@gm...> wrote:
> One work around is to call
>
>  self.figure.subplots_adjust()
>
> after geometry changed. After this call, the twinx-ed axes will have
> the same axes position as the original one.
>
> Another option is to use mpl_toolkits.axes_grid
> (http://matplotlib.sourceforge.net/mpl_toolkits/axes_grid/users/overview.html#parasiteaxes).
> But the previous solution seems to be much easier for you.
> Regards,
>
> -JJ
>
>
> On Thu, Jul 16, 2009 at 1:16 PM, Tom Vaughan<to...@so...> wrote:
>> On Tue, Jun 2, 2009 at 07:33, John Hunter<jd...@gm...> wrote:
>>> On Tue, Jun 2, 2009 at 9:03 AM, Tom Vaughan <to...@so...> wrote:
>>>> Is it possible to add subplots to a figure if I don't know in advance
>>>> how many subplots I need to add?
>>>>
>>>> What I do now is I call add_subplot like add_subplot(i, 1, i) where i
>>>> is 1 initially, and just increases by 1 on each call. This almost
>>>> works. Except the first plot takes up the whole figure, the second
>>>> plot is placed on top of the bottom half of the first plot, etc. Is
>>>> there a way to "resize" the plots when a subplot is added? Or how
>>>> would I "re-plot" the previous subplots?
>>>
>>> See the Axes.change_geometry command
>>>
>>>  http://matplotlib.sourceforge.net/api/axes_api.html#matplotlib.axes.SubplotBase.change_geometry
>>
>> twinx() does not return an axes that contains the change_geometry
>> method. How then can I do the equivalent on this axes? Calling twinx()
>> again on the original axes after change_geometry() has been called
>> does not do the trick. Thanks.
>>
>> -Tom
>>
>> ------------------------------------------------------------------------------
>> Enter the BlackBerry Developer Challenge
>> This is your chance to win up to $100,000 in prizes! For a limited time,
>> vendors submitting new applications to BlackBerry App World(TM) will have
>> the opportunity to enter the BlackBerry Developer Challenge. See full prize
>> details at: http://p.sf.net/sfu/Challenge
>> _______________________________________________
>> Matplotlib-users mailing list
>> Mat...@li...
>> https://lists.sourceforge.net/lists/listinfo/matplotlib-users
>>
>



-- 
Website: www.software6.net
E-mail/Google Talk: tom (at) software6 (dot) net
Mobile: +1 (310) 751-0187