""" If rcParams['backend_fallback'] is true, check to see if the

backend = rcParams['backend']

if not rcParams['backend_fallback'] or \

backend not in _interactive_bk:

return

is_agg_backend = rcParams['backend'].endswith('Agg')

if 'wx' in sys.modules and not backend in ('WX', 'WXAgg'):

import wx

if wx.App.IsMainLoopRunning():

rcParams['backend'] = 'wx' + 'Agg' * is_agg_backend

elif 'qt' in sys.modules and not backend == 'QtAgg':

import qt

if not qt.qApp.startingUp():

# The mainloop is running.

rcParams['backend'] = 'qtAgg'

elif 'PyQt4.QtCore' in sys.modules and not backend == 'Qt4Agg':

import PyQt4.QtGui

if not PyQt4.QtGui.qApp.startingUp():

# The mainloop is running.

rcParams['backend'] = 'qt4Agg'

elif 'gtk' in sys.modules and not backend in ('GTK', 'GTKAgg',

'GTKCairo'):

import gobject

if gobject.MainLoop().is_running():

rcParams['backend'] = 'gtk' + 'Agg' * is_agg_backend

elif 'Tkinter' in sys.modules and not backend == 'TkAgg':

#import Tkinter

"""

close('all')

global _backend_mod, new_figure_manager, draw_if_interactive, _show

matplotlib.use(newbackend, warn=False, force=True)

from matplotlib.backends import pylab_setup

"""

global _show

"""

"""

backend = rcParams['backend']

if backend in _interactive_bk:

figManager = _pylab_helpers.Gcf.get_active()

if figManager is not None:

canvas = figManager.canvas

canvas.draw()

show(block=False)

canvas.start_event_loop(interval)

return

# No on-screen figure is active, so sleep() is all we need.

import time

"""

"""

figsize = None, # defaults to rc figure.figsize

dpi = None, # defaults to rc figure.dpi

facecolor = None, # defaults to rc figure.facecolor

edgecolor = None, # defaults to rc figure.edgecolor

frameon = True,

FigureClass = Figure,

**kwargs

):

"""

if figsize is None : figsize = rcParams['figure.figsize']

if dpi is None : dpi = rcParams['figure.dpi']

if facecolor is None : facecolor = rcParams['figure.facecolor']

if edgecolor is None : edgecolor = rcParams['figure.edgecolor']

allnums = get_fignums()

next_num = max(allnums) + 1 if allnums else 1

figLabel = ''

if num is None:

num = next_num

elif is_string_like(num):

figLabel = num

allLabels = get_figlabels()

if figLabel not in allLabels:

if figLabel == 'all':

warnings.warn("close('all') closes all existing figures")

num = next_num

else:

inum = allLabels.index(figLabel)

num = allnums[inum]

else:

num = int(num) # crude validation of num argument

figManager = _pylab_helpers.Gcf.get_fig_manager(num)

if figManager is None:

if get_backend().lower() == 'ps': dpi = 72

figManager = new_figure_manager(num, figsize=figsize,

dpi=dpi,

facecolor=facecolor,

edgecolor=edgecolor,

frameon=frameon,

FigureClass=FigureClass,

**kwargs)

if figLabel:

figManager.set_window_title(figLabel)

figManager.canvas.figure.set_label(figLabel)

# make this figure current on button press event

def make_active(event):

_pylab_helpers.Gcf.set_active(figManager)

cid = figManager.canvas.mpl_connect('button_press_event', make_active)

figManager._cidgcf = cid

_pylab_helpers.Gcf.set_active(figManager)

figManager.canvas.figure.number = num

draw_if_interactive()

"Return a reference to the current figure."

figManager = _pylab_helpers.Gcf.get_active()

if figManager is not None:

return figManager.canvas.figure

else:

"Return a list of existing figure numbers."

fignums = _pylab_helpers.Gcf.figs.keys()

fignums.sort()

"Return a list of existing figure labels."

figManagers = _pylab_helpers.Gcf.get_all_fig_managers()

figManagers.sort(key=lambda m: m.num)

figManager = _pylab_helpers.Gcf.get_active()

if figManager is None:

gcf() # creates an active figure as a side effect

figManager = _pylab_helpers.Gcf.get_active()

"""

if len(args)==0:

figManager = _pylab_helpers.Gcf.get_active()

if figManager is None: return

else:

_pylab_helpers.Gcf.destroy(figManager.num)

elif len(args)==1:

arg = args[0]

if arg=='all':

_pylab_helpers.Gcf.destroy_all()

elif isinstance(arg, int):

_pylab_helpers.Gcf.destroy(arg)

elif is_string_like(arg):

allLabels = get_figlabels()

if arg in allLabels:

num = get_fignums()[allLabels.index(arg)]

_pylab_helpers.Gcf.destroy(num)

elif isinstance(arg, Figure):

_pylab_helpers.Gcf.destroy_fig(arg)

else:

raise TypeError('Unrecognized argument type %s to close'%type(arg))

else:

"""

gcf().clf()

"""

"""

"""

ret = gcf().text(*args, **kwargs)

draw_if_interactive()

# allow callers to override the hold state by passing hold=True|False

ret = gcf().figimage(*args, **kwargs)

draw_if_interactive()

#sci(ret) # JDH figimage should not set current image -- it is not mappable, etc

"""

l = gcf().legend(handles, labels, loc, **kwargs)

draw_if_interactive()

"""

fig = gcf()

ax = fig.gca()

fig.hold(b)

ax.hold(b)

# b=None toggles the hold state, so let's get get the current hold

# state; but should pyplot hold toggle the rc setting - me thinks

# not

b = ax.ishold()

"""

"""

h = ishold()

hold(True)

func(*args, **kwargs)

"""

nargs = len(args)

if len(args)==0: return subplot(111, **kwargs)

if nargs>1:

raise TypeError('Only one non keyword arg to axes allowed')

arg = args[0]

if isinstance(arg, Axes):

a = gcf().sca(arg)

else:

rect = arg

a = gcf().add_axes(rect, **kwargs)

draw_if_interactive()

"""

if not len(args):

ax = gca()

else:

ax = args[0]

ret = gcf().delaxes(ax)

draw_if_interactive()

"""

managers = _pylab_helpers.Gcf.get_all_fig_managers()

for m in managers:

if ax in m.canvas.figure.axes:

_pylab_helpers.Gcf.set_active(m)

m.canvas.figure.sca(ax)

return

"""

ax = gcf().gca(**kwargs)

"""

# if subplot called without arguments, create subplot(1,1,1)

if len(args)==0:

args=(1,1,1)

# This check was added because it is very easy to type

# subplot(1, 2, False) when subplots(1, 2, False) was intended

# (sharex=False, that is). In most cases, no error will

# ever occur, but mysterious behavior can result because what was

# intended to be the sharex argument is instead treated as a

# subplot index for subplot()

if len(args) >= 3 and isinstance(args[2], bool) :

warnings.warn("The subplot index argument to subplot() appears"

" to be a boolean. Did you intend to use subplots()?")

fig = gcf()

a = fig.add_subplot(*args, **kwargs)

bbox = a.bbox

byebye = []

for other in fig.axes:

if other==a: continue

if bbox.fully_overlaps(other.bbox):

byebye.append(other)

for ax in byebye: delaxes(ax)

draw_if_interactive()

subplot_kw=None, **fig_kw):

"""

# for backwards compatibility

if isinstance(sharex, bool):

if sharex:

sharex = "all"

else:

sharex = "none"

if isinstance(sharey, bool):

if sharey:

sharey = "all"

else:

sharey = "none"

share_values = ["all", "row", "col", "none"]

if sharex not in share_values:

# This check was added because it is very easy to type subplots(1, 2, 1)

# when subplot(1, 2, 1) was intended. In most cases, no error will

# ever occur, but mysterious behavior will result because what was

# intended to be the subplot index is instead treated as a bool for

# sharex.

if isinstance(sharex, int):

warnings.warn("sharex argument to subplots() was an integer."

" Did you intend to use subplot() (without 's')?")

raise ValueError("sharex [%s] must be one of %s" % \

(sharex, share_values))

if sharey not in share_values:

raise ValueError("sharey [%s] must be one of %s" % \

(sharey, share_values))

if subplot_kw is None:

subplot_kw = {}

fig = figure(**fig_kw)

# Create empty object array to hold all axes. It's easiest to make it 1-d

# so we can just append subplots upon creation, and then

nplots = nrows*ncols

axarr = np.empty(nplots, dtype=object)

# Create first subplot separately, so we can share it if requested

ax0 = fig.add_subplot(nrows, ncols, 1, **subplot_kw)

#if sharex:

# subplot_kw['sharex'] = ax0

#if sharey:

# subplot_kw['sharey'] = ax0

axarr[0] = ax0

r, c = np.mgrid[:nrows, :ncols]

r = r.flatten() * ncols

c = c.flatten()

lookup = {

"none": np.arange(nplots),

"all": np.zeros(nplots, dtype=int),

"row": r,

"col": c,

}

sxs = lookup[sharex]

sys = lookup[sharey]

# Note off-by-one counting because add_subplot uses the MATLAB 1-based

# convention.

for i in range(1, nplots):

if sxs[i] == i:

subplot_kw['sharex'] = None

else:

subplot_kw['sharex'] = axarr[sxs[i]]

if sys[i] == i:

subplot_kw['sharey'] = None

else:

subplot_kw['sharey'] = axarr[sys[i]]

axarr[i] = fig.add_subplot(nrows, ncols, i + 1, **subplot_kw)

# returned axis array will be always 2-d, even if nrows=ncols=1

axarr = axarr.reshape(nrows, ncols)

# turn off redundant tick labeling

if sharex in ["col", "all"] and nrows > 1:

#if sharex and nrows>1:

# turn off all but the bottom row

for ax in axarr[:-1, :].flat:

for label in ax.get_xticklabels():

label.set_visible(False)

ax.xaxis.offsetText.set_visible(False)

if sharey in ["row", "all"] and ncols > 1:

#if sharey and ncols>1:

# turn off all but the first column

for ax in axarr[:, 1:].flat:

for label in ax.get_yticklabels():

label.set_visible(False)

ax.yaxis.offsetText.set_visible(False)

if squeeze:

# Reshape the array to have the final desired dimension (nrow,ncol),

# though discarding unneeded dimensions that equal 1. If we only have