Merge pull request #4679 from dbarbeau/jpg-inline

JPG compression for inline pylab

docs/source/whatsnew/pr/inline-jpg.rst

@@ -0,0 +1,3 b''
+* The InlineBackend.figure_format flag now supports JPEG output if PIL/Pillow is available.
+* The new ``InlineBackend.quality`` flag is a Integer in the range [10, 100] which controls 
+  the quality of figures where higher values give nicer images (currently JPEG only).

IPython/core/pylabtools.py

@@ -94,8 +94,10 b' def figsize(sizex, sizey):'
     matplotlib.rcParams['figure.figsize'] = [sizex, sizey]
 
 
-def print_figure(fig, fmt='png'):
-    """Convert a figure to svg or png for inline display."""
+def print_figure(fig, fmt='png', quality=90):
+    """Convert a figure to svg, png or jpg for inline display.
+    Quality is only relevant for jpg.
+    """
     from matplotlib import rcParams
     # When there's an empty figure, we shouldn't return anything, otherwise we
     # get big blank areas in the qt console.
@@ -110,7 +112,7 b" def print_figure(fig, fmt='png'):"
         dpi = dpi * 2
         fmt = 'png'
     fig.canvas.print_figure(bytes_io, format=fmt, bbox_inches='tight',
-                            facecolor=fc, edgecolor=ec, dpi=dpi)
+                            facecolor=fc, edgecolor=ec, dpi=dpi, quality=quality)
     data = bytes_io.getvalue()
     return data
     
@@ -163,8 +165,8 b' def mpl_runner(safe_execfile):'
     return mpl_execfile
 
 
-def select_figure_format(shell, fmt):
-    """Select figure format for inline backend, can be 'png', 'retina', or 'svg'.
+def select_figure_format(shell, fmt, quality=90):
+    """Select figure format for inline backend, can be 'png', 'retina', 'jpg', or 'svg'.
 
     Using this method ensures only one figure format is active at a time.
     """
@@ -173,18 +175,20 b' def select_figure_format(shell, fmt):'
 
     svg_formatter = shell.display_formatter.formatters['image/svg+xml']
     png_formatter = shell.display_formatter.formatters['image/png']
+    jpg_formatter = shell.display_formatter.formatters['image/jpeg']
+
+    [ f.type_printers.pop(Figure, None) for f in {svg_formatter, png_formatter, jpg_formatter} ]
 
     if fmt == 'png':
-        svg_formatter.pop(Figure, None)
         png_formatter.for_type(Figure, lambda fig: print_figure(fig, 'png'))
     elif fmt in ('png2x', 'retina'):
-        svg_formatter.pop(Figure, None)
         png_formatter.for_type(Figure, retina_figure)
+    elif fmt in ('jpg', 'jpeg'):
+        jpg_formatter.for_type(Figure, lambda fig: print_figure(fig, 'jpg', quality))
     elif fmt == 'svg':
-        png_formatter.pop(Figure, None)
         svg_formatter.for_type(Figure, lambda fig: print_figure(fig, 'svg'))
     else:
-        raise ValueError("supported formats are: 'png', 'retina', 'svg', not %r" % fmt)
+        raise ValueError("supported formats are: 'png', 'retina', 'svg', 'jpg', not %r" % fmt)
 
     # set the format to be used in the backend()
     backend_inline._figure_format = fmt
@@ -338,5 +342,5 b' def configure_inline_support(shell, backend):'
             del shell._saved_rcParams
 
     # Setup the default figure format
-    select_figure_format(shell, cfg.figure_format)
+    select_figure_format(shell, cfg.figure_format, cfg.quality)
 

IPython/core/tests/test_pylabtools.py

@@ -26,6 +26,8 b' import numpy as np'
 from IPython.core.interactiveshell import InteractiveShell
 from .. import pylabtools as pt
 
+from IPython.testing import decorators as dec
+
 #-----------------------------------------------------------------------------
 # Globals and constants
 #-----------------------------------------------------------------------------
@@ -53,6 +55,16 b' def test_figure_to_svg():'
     svg = pt.print_figure(fig, 'svg')[:100].lower()
     nt.assert_in(b'doctype svg', svg)
 
[e-mail]_without("PIL.Image")
+def test_figure_to_jpg():
+    # simple check for at least jpg-looking output
+    fig = plt.figure()
+    ax = fig.add_subplot(1,1,1)
+    ax.plot([1,2,3])
+    plt.draw()
+    jpg = pt.print_figure(fig, 'jpg')[:100].lower()
+    assert jpg.startswith(b'\xff\xd8')
+
 
 def test_import_pylab():
     ip = get_ipython()

IPython/kernel/zmq/pylab/config.py

@@ -14,13 +14,23 b' This module does not import anything from matplotlib.'
 #-----------------------------------------------------------------------------
 
 from IPython.config.configurable import SingletonConfigurable
-from IPython.utils.traitlets import Dict, Instance, CaselessStrEnum, Bool
+from IPython.utils.traitlets import Dict, Instance, CaselessStrEnum, Bool, Int, TraitError
 from IPython.utils.warn import warn
 
 #-----------------------------------------------------------------------------
 # Configurable for inline backend options
 #-----------------------------------------------------------------------------
 
+def pil_available():
+    """Test if PIL/Pillow is available"""
+    out = False
+    try:
+        from PIL import Image
+        out = True
+    except:
+        pass
+    return out
+
 # inherit from InlineBackendConfig for deprecation purposes
 class InlineBackendConfig(SingletonConfigurable):
     pass
@@ -53,15 +63,28 b' class InlineBackend(InlineBackendConfig):'
         inline backend."""
     )
 
-    figure_format = CaselessStrEnum(['svg', 'png', 'retina'], default_value='png', config=True,
-        help="The image format for figures with the inline backend.")
+
+    figure_format = CaselessStrEnum(['svg', 'png', 'retina', 'jpg'],
+                                    default_value='png', config=True,
+                                    help="""The image format for figures with the inline
+                                    backend. JPEG requires the PIL/Pillow library.""")
 
     def _figure_format_changed(self, name, old, new):
         from IPython.core.pylabtools import select_figure_format
+        if new in {"jpg", "jpeg"}:
+            if not pil_available():
+                raise TraitError("Requires PIL/Pillow for JPG figures")
         if self.shell is None:
             return
         else:
             select_figure_format(self.shell, new)
+
+    quality = Int(default_value=90, config=True,
+                  help="Quality of compression [10-100], currently for lossy JPEG only.")
+
+    def _quality_changed(self, name, old, new):
+        if new < 10 or new > 100:
+            raise TraitError("figure JPEG quality must be in [10-100] range.")
     
     close_figures = Bool(True, config=True,
         help="""Close all figures at the end of each cell.