add InlineBackendConfig

The inline backend now has preliminary config support for rc and figure format.

IPython/lib/pylabtools.py

@@ -1,309 +1,323 b''
 # -*- coding: utf-8 -*-
 """Pylab (matplotlib) support utilities.
 
 Authors
 -------
 
 * Fernando Perez.
 * Brian Granger
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2009  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from cStringIO import StringIO
 
 from IPython.utils.decorators import flag_calls
 
 # If user specifies a GUI, that dictates the backend, otherwise we read the
 # user's mpl default from the mpl rc structure
 backends = {'tk': 'TkAgg',
             'gtk': 'GTKAgg',
             'wx': 'WXAgg',
             'qt': 'Qt4Agg', # qt3 not supported
             'qt4': 'Qt4Agg',
             'osx': 'MacOSX',
             'inline' : 'module://IPython.zmq.pylab.backend_inline'}
 
 # We also need a reverse backends2guis mapping that will properly choose which
 # GUI support to activate based on the desired matplotlib backend.  For the
 # most part it's just a reverse of the above dict, but we also need to add a
 # few others that map to the same GUI manually:
 backend2gui = dict(zip(backends.values(), backends.keys()))
 # In the reverse mapping, there are a few extra valid matplotlib backends that
 # map to the same GUI support
 backend2gui['GTK'] = backend2gui['GTKCairo'] = 'gtk'
 backend2gui['WX'] = 'wx'
 backend2gui['CocoaAgg'] = 'osx'
 
 #-----------------------------------------------------------------------------
 # Matplotlib utilities
 #-----------------------------------------------------------------------------
 
 
 def getfigs(*fig_nums):
     """Get a list of matplotlib figures by figure numbers.
 
     If no arguments are given, all available figures are returned.  If the
     argument list contains references to invalid figures, a warning is printed
     but the function continues pasting further figures.
 
     Parameters
     ----------
     figs : tuple
         A tuple of ints giving the figure numbers of the figures to return.
     """
     from matplotlib._pylab_helpers import Gcf
     if not fig_nums:
         fig_managers = Gcf.get_all_fig_managers()
         return [fm.canvas.figure for fm in fig_managers]
     else:
         figs = []
         for num in fig_nums:
             f = Gcf.figs.get(num)
             if f is None:
                 print('Warning: figure %s not available.' % num)
             else:
                 figs.append(f.canvas.figure)
         return figs
 
 
 def figsize(sizex, sizey):
     """Set the default figure size to be [sizex, sizey].
 
     This is just an easy to remember, convenience wrapper that sets::
 
       matplotlib.rcParams['figure.figsize'] = [sizex, sizey]
     """
     import matplotlib
     matplotlib.rcParams['figure.figsize'] = [sizex, sizey]
 
 
-def figure_to_svg(fig):
-    """Convert a figure to svg for inline display."""
+def print_figure(fig, fmt='png'):
+    """Convert a figure to svg or png for inline display."""
     # When there's an empty figure, we shouldn't return anything, otherwise we
     # get big blank areas in the qt console.
     if not fig.axes:
         return
 
     fc = fig.get_facecolor()
     ec = fig.get_edgecolor()
     fig.set_facecolor('white')
     fig.set_edgecolor('white')
     try:
         string_io = StringIO()
-        fig.canvas.print_figure(string_io, format='svg')
-        svg = string_io.getvalue()
+        # use 72 dpi to match QTConsole's dpi
+        fig.canvas.print_figure(string_io, format=fmt, dpi=72)
+        data = string_io.getvalue()
     finally:
         fig.set_facecolor(fc)
         fig.set_edgecolor(ec)
-    return svg
+    if fmt == 'png':
+        data = data.encode('base64')
+    return data
 
 
 # We need a little factory function here to create the closure where
 # safe_execfile can live.
 def mpl_runner(safe_execfile):
     """Factory to return a matplotlib-enabled runner for %run.
 
     Parameters
     ----------
     safe_execfile : function
       This must be a function with the same interface as the
       :meth:`safe_execfile` method of IPython.
 
     Returns
     -------
     A function suitable for use as the ``runner`` argument of the %run magic
     function.
     """
     
     def mpl_execfile(fname,*where,**kw):
         """matplotlib-aware wrapper around safe_execfile.
 
         Its interface is identical to that of the :func:`execfile` builtin.
 
         This is ultimately a call to execfile(), but wrapped in safeties to
         properly handle interactive rendering."""
 
         import matplotlib
         import matplotlib.pylab as pylab
 
         #print '*** Matplotlib runner ***' # dbg
         # turn off rendering until end of script
         is_interactive = matplotlib.rcParams['interactive']
         matplotlib.interactive(False)
         safe_execfile(fname,*where,**kw)
         matplotlib.interactive(is_interactive)
         # make rendering call now, if the user tried to do it
         if pylab.draw_if_interactive.called:
             pylab.draw()
             pylab.draw_if_interactive.called = False
 
     return mpl_execfile
 
 
+def select_figure_format(shell, fmt):
+    """Select figure format for inline backend, either 'png' or 'svg'.
+
+    Using this method ensures only one figure format is active at a time.
+    """
+    from matplotlib.figure import Figure
+    from IPython.zmq.pylab import backend_inline
+
+    svg_formatter = shell.display_formatter.formatters['image/svg+xml']
+    png_formatter = shell.display_formatter.formatters['image/png']
+
+    if fmt=='png':
+        svg_formatter.type_printers.pop(Figure, None)
+        png_formatter.for_type(Figure, lambda fig: print_figure(fig, 'png'))
+    elif fmt=='svg':
+        png_formatter.type_printers.pop(Figure, None)
+        svg_formatter.for_type(Figure, lambda fig: print_figure(fig, 'svg'))
+    else:
+        raise ValueError("supported formats are: 'png', 'svg', not %r"%fmt)
+
+    # set the format to be used in the backend()
+    backend_inline._figure_format = fmt
+
 #-----------------------------------------------------------------------------
 # Code for initializing matplotlib and importing pylab
 #-----------------------------------------------------------------------------
 
 
 def find_gui_and_backend(gui=None):
     """Given a gui string return the gui and mpl backend.
 
     Parameters
     ----------
     gui : str
         Can be one of ('tk','gtk','wx','qt','qt4','inline').
 
     Returns
     -------
     A tuple of (gui, backend) where backend is one of ('TkAgg','GTKAgg',
     'WXAgg','Qt4Agg','module://IPython.zmq.pylab.backend_inline').
     """
 
     import matplotlib
 
     if gui:
         # select backend based on requested gui
         backend = backends[gui]
     else:
         backend = matplotlib.rcParams['backend']
         # In this case, we need to find what the appropriate gui selection call
         # should be for IPython, so we can activate inputhook accordingly
         gui = backend2gui.get(backend, None)
     return gui, backend
 
 
 def activate_matplotlib(backend):
     """Activate the given backend and set interactive to True."""
 
     import matplotlib
     if backend.startswith('module://'):
         # Work around bug in matplotlib: matplotlib.use converts the
         # backend_id to lowercase even if a module name is specified!
         matplotlib.rcParams['backend'] = backend
     else:
         matplotlib.use(backend)
     matplotlib.interactive(True)
 
     # This must be imported last in the matplotlib series, after
     # backend/interactivity choices have been made
     import matplotlib.pylab as pylab
 
     # XXX For now leave this commented out, but depending on discussions with
     # mpl-dev, we may be able to allow interactive switching...
     #import matplotlib.pyplot
     #matplotlib.pyplot.switch_backend(backend)
 
     pylab.show._needmain = False
     # We need to detect at runtime whether show() is called by the user.
     # For this, we wrap it into a decorator which adds a 'called' flag.
     pylab.draw_if_interactive = flag_calls(pylab.draw_if_interactive)
 
-
 def import_pylab(user_ns, backend, import_all=True, shell=None):
     """Import the standard pylab symbols into user_ns."""
 
     # Import numpy as np/pyplot as plt are conventions we're trying to
     # somewhat standardize on.  Making them available to users by default
     # will greatly help this.
     s = ("import numpy\n"
           "import matplotlib\n"
           "from matplotlib import pylab, mlab, pyplot\n"
           "np = numpy\n"
           "plt = pyplot\n"
           )
     exec s in user_ns
 
     if shell is not None:
         exec s in shell.user_ns_hidden
         # If using our svg payload backend, register the post-execution
         # function that will pick up the results for display.  This can only be
         # done with access to the real shell object.
+        #
+        from IPython.zmq.pylab.backend_inline import InlineBackendConfig
+
+        cfg = InlineBackendConfig.instance(config=shell.config)
+        cfg.shell = shell
+
         if backend == backends['inline']:
-            from IPython.zmq.pylab.backend_inline import flush_svg
+            from IPython.zmq.pylab.backend_inline import flush_figures
             from matplotlib import pyplot
-            shell.register_post_execute(flush_svg)
-            # The typical default figure size is too large for inline use,
-            # so we shrink the figure size to 6x4, and tweak fonts to
-            # make that fit.  This is configurable via Global.pylab_inline_rc,
-            # or rather it will be once the zmq kernel is hooked up to
-            # the config system.
-            
-            default_rc = {
-                'figure.figsize': (6.0,4.0),
-                # 12pt labels get cutoff on 6x4 logplots, so use 10pt.
-                'font.size': 10,
-                # 10pt still needs a little more room on the xlabel:
-                'figure.subplot.bottom' : .125
-            }
-            rc = getattr(shell.config.Global, 'pylab_inline_rc', default_rc)
-            pyplot.rcParams.update(rc)
-            shell.config.Global.pylab_inline_rc = rc
+            shell.register_post_execute(flush_figures)
+            # load inline_rc
+            pyplot.rcParams.update(cfg.rc)
             
             # Add 'figsize' to pyplot and to the user's namespace
             user_ns['figsize'] = pyplot.figsize = figsize
             shell.user_ns_hidden['figsize'] = figsize
         
+        # Setup the default figure format
+        fmt = cfg.figure_format
+        select_figure_format(shell, fmt)
+
         # The old pastefig function has been replaced by display
-        # Always add this svg formatter so display works.
-        from IPython.core.display import display, display_svg
-        svg_formatter = shell.display_formatter.formatters['image/svg+xml']
-        svg_formatter.for_type_by_name(
-            'matplotlib.figure','Figure',figure_to_svg
-        )
+        from IPython.core.display import display
         # Add display and display_png to the user's namespace
         user_ns['display'] = display
         shell.user_ns_hidden['display'] = display
-        user_ns['display_svg'] = display_svg
-        shell.user_ns_hidden['display_svg'] = display_svg
         user_ns['getfigs'] = getfigs
         shell.user_ns_hidden['getfigs'] = getfigs
 
     if import_all:
         s = ("from matplotlib.pylab import *\n"
              "from numpy import *\n")
         exec s in user_ns
         if shell is not None:
             exec s in shell.user_ns_hidden
 
 
 def pylab_activate(user_ns, gui=None, import_all=True):
     """Activate pylab mode in the user's namespace.
 
     Loads and initializes numpy, matplotlib and friends for interactive use.
 
     Parameters
     ----------
     user_ns : dict
       Namespace where the imports will occur.
 
     gui : optional, string
       A valid gui name following the conventions of the %gui magic.
 
     import_all : optional, boolean
       If true, an 'import *' is done from numpy and pylab.
 
     Returns
     -------
     The actual gui used (if not given as input, it was obtained from matplotlib
     itself, and will be needed next to configure IPython's gui integration.
     """
     gui, backend = find_gui_and_backend(gui)
     activate_matplotlib(backend)
     import_pylab(user_ns, backend)
 
     print """
 Welcome to pylab, a matplotlib-based Python environment [backend: %s].
 For more information, type 'help(pylab)'.""" % backend
     
     return gui
 

IPython/zmq/pylab/backend_inline.py

@@ -1,81 +1,117 b''
 """Produce SVG versions of active plots for display by the rich Qt frontend.
 """
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 from __future__ import print_function
 
 # Standard library imports
 import sys
 
 # Third-party imports
 import matplotlib
-from matplotlib.backends.backend_svg import new_figure_manager
+from matplotlib.backends.backend_agg import new_figure_manager
 from matplotlib._pylab_helpers import Gcf
 
 # Local imports.
+from IPython.config.configurable import SingletonConfigurable
 from IPython.core.displaypub import publish_display_data
-from IPython.lib.pylabtools import figure_to_svg
+from IPython.lib.pylabtools import print_figure, select_figure_format
+from IPython.utils.traitlets import Dict, Instance, CaselessStrEnum
+#-----------------------------------------------------------------------------
+# Configurable for inline backend options
+#-----------------------------------------------------------------------------
+
+class InlineBackendConfig(SingletonConfigurable):
+    """An object to store configuration of the inline backend."""
+
+    # The typical default figure size is too large for inline use,
+    # so we shrink the figure size to 6x4, and tweak fonts to
+    # make that fit.  This is configurable via Global.pylab_inline_rc,
+    # or rather it will be once the zmq kernel is hooked up to
+    # the config system.
+    rc = Dict({'figure.figsize': (6.0,4.0),
+        # 12pt labels get cutoff on 6x4 logplots, so use 10pt.
+        'font.size': 10,
+        # 10pt still needs a little more room on the xlabel:
+        'figure.subplot.bottom' : .125
+        }, config=True,
+        help="""Subset of matplotlib rcParams that should be different for the
+        inline backend."""
+    )
+    figure_format = CaselessStrEnum(['svg', 'png'], default_value='png', config=True,
+        help="The image format for figures with the inline backend.")
+
+    def _format_changed(self, name, old, new):
+        if self.shell is None:
+            return
+        else:
+            select_figure_format(self.shell, new)
+
+    shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
+
 
 #-----------------------------------------------------------------------------
 # Functions
 #-----------------------------------------------------------------------------
 
 def show(close=True):
     """Show all figures as SVG payloads sent to the IPython clients.
 
     Parameters
     ----------
     close : bool, optional
       If true, a ``plt.close('all')`` call is automatically issued after
       sending all the SVG figures. If this is set, the figures will entirely
       removed from the internal list of figures.
     """
     for figure_manager in Gcf.get_all_fig_managers():
-        send_svg_figure(figure_manager.canvas.figure)
+        send_figure(figure_manager.canvas.figure)
     if close:
         matplotlib.pyplot.close('all')
 
 
 # This flag will be reset by draw_if_interactive when called
 show._draw_called = False
 
 
 def draw_if_interactive():
     """
     Is called after every pylab drawing command
     """
     # We simply flag we were called and otherwise do nothing.  At the end of
     # the code execution, a separate call to show_close() will act upon this.
     show._draw_called = True
 
 
-def flush_svg():
-    """Call show, close all open figures, sending all SVG images.
+def flush_figures():
+    """Call show, close all open figures, sending all figure images.
 
     This is meant to be called automatically and will call show() if, during
     prior code execution, there had been any calls to draw_if_interactive.
     """
     if show._draw_called:
         show()
         show._draw_called = False
 
 
-def send_svg_figure(fig):
-    """Draw the current figure and send it as an SVG payload.
+def send_figure(fig):
+    """Draw the current figure and send it as a PNG payload.
     """
     # For an empty figure, don't even bother calling figure_to_svg, to avoid
     # big blank spaces in the qt console
     if not fig.axes:
         return
-
-    svg = figure_to_svg(fig)
+    fmt = InlineBackendConfig.instance().figure_format
+    data = print_figure(fig, fmt)
+    mimetypes = { 'png' : 'image/png', 'svg' : 'image/svg+xml' }
+    mime = mimetypes[fmt]
     # flush text streams before sending figures, helps a little with output
     # synchronization in the console (though it's a bandaid, not a real sln)
     sys.stdout.flush(); sys.stderr.flush()
     publish_display_data(
-        'IPython.zmq.pylab.backend_inline.send_svg_figure',
+        'IPython.zmq.pylab.backend_inline.send_figure',
         'Matplotlib Plot',
-        {'image/svg+xml' : svg}
+        {mime : data}
     )