Merge pull request #1861 from tkf/dvipng

Use dvipng to format sympy.Matrix, enabling display of matrices in the Qt console with the sympy printing extension.

Two changes are introduced:

    new dvipng backend is added to latex_to_png
    PNG formatter for sympy.Matrix uses the dvipng backend

IPython/extensions/sympyprinting.py

@@ -1,133 +1,151 b''
 """
 A print function that pretty prints sympy Basic objects.
 
 :moduleauthor: Brian Granger
 
 Usage
 =====
 
 Once the extension is loaded, Sympy Basic objects are automatically
 pretty-printed.
 
 """
 #-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2011  The IPython Development Team
+#  Copyright (C) 2008  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 IPython.lib.latextools import latex_to_png
 from IPython.testing import decorators as dec
 # use @dec.skipif_not_sympy to skip tests requiring sympy
 
 try:
     from sympy import pretty, latex
 except ImportError:
     pass
 
 #-----------------------------------------------------------------------------
 # Definitions of special display functions for use with IPython
 #-----------------------------------------------------------------------------
 
 def print_basic_unicode(o, p, cycle):
     """A function to pretty print sympy Basic objects."""
     if cycle:
         return p.text('Basic(...)')
     out = pretty(o, use_unicode=True)
     if '\n' in out:
         p.text(u'\n')
     p.text(out)
 
 
 def print_png(o):
-    """A function to display sympy expression using LaTex -> PNG."""
+    """
+    A function to display sympy expression using inline style LaTeX in PNG.
+    """
     s = latex(o, mode='inline')
     # mathtext does not understand certain latex flags, so we try to replace
     # them with suitable subs.
     s = s.replace('\\operatorname','')
     s = s.replace('\\overline', '\\bar')
     png = latex_to_png(s)
     return png
 
+
+def print_display_png(o):
+    """
+    A function to display sympy expression using display style LaTeX in PNG.
+    """
+    s = latex(o, mode='plain')
+    s = s.strip('$')
+    # As matplotlib does not support display style, dvipng backend is
+    # used here.
+    png = latex_to_png('$$%s$$' % s, backend='dvipng')
+    return png
+
+
 def can_print_latex(o):
     """
     Return True if type o can be printed with LaTeX.
 
     If o is a container type, this is True if and only if every element of o
     can be printed with LaTeX.
     """
     import sympy
     if isinstance(o, (list, tuple, set, frozenset)):
         return all(can_print_latex(i) for i in o)
     elif isinstance(o, dict):
         return all((isinstance(i, basestring) or can_print_latex(i)) and can_print_latex(o[i]) for i in o)
     elif isinstance(o,(sympy.Basic, sympy.matrices.Matrix, int, long, float)):
         return True
     return False
 
 def print_latex(o):
     """A function to generate the latex representation of sympy
     expressions."""
     if can_print_latex(o):
         s = latex(o, mode='plain')
         s = s.replace('\\dag','\\dagger')
         s = s.strip('$')
         return '$$%s$$' % s
     # Fallback to the string printer
     return None
 
 _loaded = False
 
 def load_ipython_extension(ip):
     """Load the extension in IPython."""
     import sympy
     global _loaded
     if not _loaded:
         plaintext_formatter = ip.display_formatter.formatters['text/plain']
 
         for cls in (object, str):
             plaintext_formatter.for_type(cls, print_basic_unicode)
 
         printable_containers = [list, tuple]
 
         # set and frozen set were broken with SymPy's latex() function, but
         # was fixed in the 0.7.1-git development version. See
         # http://code.google.com/p/sympy/issues/detail?id=3062.
         if sympy.__version__ > '0.7.1':
             printable_containers += [set, frozenset]
         else:
             plaintext_formatter.for_type(cls, print_basic_unicode)
 
         plaintext_formatter.for_type_by_name(
             'sympy.core.basic', 'Basic', print_basic_unicode
         )
         plaintext_formatter.for_type_by_name(
             'sympy.matrices.matrices', 'Matrix', print_basic_unicode
         )
 
         png_formatter = ip.display_formatter.formatters['image/png']
 
         png_formatter.for_type_by_name(
             'sympy.core.basic', 'Basic', print_png
         )
+        png_formatter.for_type_by_name(
+            'sympy.matrices.matrices', 'Matrix', print_display_png
+        )
         for cls in [dict, int, long, float] + printable_containers:
             png_formatter.for_type(cls, print_png)
 
         latex_formatter = ip.display_formatter.formatters['text/latex']
         latex_formatter.for_type_by_name(
             'sympy.core.basic', 'Basic', print_latex
         )
         latex_formatter.for_type_by_name(
             'sympy.matrices.matrices', 'Matrix', print_latex
         )
 
         for cls in printable_containers:
             # Use LaTeX only if every element is printable by latex
             latex_formatter.for_type(cls, print_latex)
 
         _loaded = True

IPython/lib/latextools.py

@@ -1,110 +1,181 b''
 # -*- coding: utf-8 -*-
 """Tools for handling LaTeX.
 
 Authors:
 
 * Brian Granger
 """
 #-----------------------------------------------------------------------------
-# Copyright (C) 2010-2011, IPython Development Team.
+# Copyright (C) 2010 IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from StringIO import StringIO
 from base64 import encodestring
+import os
+import tempfile
+import shutil
+import subprocess
+
+from IPython.utils.process import find_cmd, FindCmdError
 
 #-----------------------------------------------------------------------------
 # Tools
 #-----------------------------------------------------------------------------
 
 
-def latex_to_png(s, encode=False):
-    """Render a LaTeX string to PNG using matplotlib.mathtext.
+def latex_to_png(s, encode=False, backend='mpl'):
+    """Render a LaTeX string to PNG.
 
     Parameters
     ----------
     s : str
         The raw string containing valid inline LaTeX.
     encode : bool, optional
         Should the PNG data bebase64 encoded to make it JSON'able.
+    backend : {mpl, dvipng}
+        Backend for producing PNG data.
+
+    None is returned when the backend cannot be used.
+
     """
-    from matplotlib import mathtext
+    if backend == 'mpl':
+        f = latex_to_png_mpl
+    elif backend == 'dvipng':
+        f = latex_to_png_dvipng
+    else:
+        raise ValueError('No such backend {0}'.format(backend))
+    bin_data = f(s)
+    if encode and bin_data:
+        bin_data = encodestring(bin_data)
+    return bin_data
+
+
+def latex_to_png_mpl(s):
+    try:
+        from matplotlib import mathtext
+    except ImportError:
+        return None
     
     mt = mathtext.MathTextParser('bitmap')
     f = StringIO()
     mt.to_png(f, s, fontsize=12)
-    bin_data = f.getvalue()
-    if encode:
-        bin_data = encodestring(bin_data)
+    return f.getvalue()
+
+
+def latex_to_png_dvipng(s):
+    try:
+        find_cmd('latex')
+        find_cmd('dvipng')
+    except FindCmdError:
+        return None
+    try:
+        workdir = tempfile.mkdtemp()
+        tmpfile = os.path.join(workdir, "tmp.tex")
+        dvifile = os.path.join(workdir, "tmp.dvi")
+        outfile = os.path.join(workdir, "tmp.png")
+
+        with open(tmpfile, "w") as f:
+            f.write(_latex_header)
+            f.write(s)
+            f.write(_latex_footer)
+
+        subprocess.check_call(
+            ["latex", "-halt-on-errror", tmpfile], cwd=workdir,
+            stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+        subprocess.check_call(
+            ["dvipng", "-T", "tight", "-x", "1500", "-z", "9",
+             "-bg", "transparent", "-o", outfile, dvifile], cwd=workdir,
+            stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+        with open(outfile) as f:
+            bin_data = f.read()
+    finally:
+        shutil.rmtree(workdir)
     return bin_data
 
 
+_latex_header = r'''
+\documentclass{article}
+\usepackage{amsmath}
+\usepackage{amsthm}
+\usepackage{amssymb}
+\usepackage{bm}
+\pagestyle{empty}
+\begin{document}
+'''
+
+_latex_footer = r'\end{document}'
+
+
 _data_uri_template_png = """<img src="data:image/png;base64,%s" alt=%s />"""
 
 def latex_to_html(s, alt='image'):
     """Render LaTeX to HTML with embedded PNG data using data URIs.
 
     Parameters
     ----------
     s : str
         The raw string containing valid inline LateX.
     alt : str
         The alt text to use for the HTML.
     """
     base64_data = latex_to_png(s, encode=True)
-    return _data_uri_template_png  % (base64_data, alt)
+    if base64_data:
+        return _data_uri_template_png  % (base64_data, alt)
 
 
 # From matplotlib, thanks to mdboom. Once this is in matplotlib releases, we
 # will remove.
 def math_to_image(s, filename_or_obj, prop=None, dpi=None, format=None):
     """
     Given a math expression, renders it in a closely-clipped bounding
     box to an image file.
 
     *s*
        A math expression.  The math portion should be enclosed in
        dollar signs.
 
     *filename_or_obj*
        A filepath or writable file-like object to write the image data
        to.
 
     *prop*
        If provided, a FontProperties() object describing the size and
        style of the text.
 
     *dpi*
        Override the output dpi, otherwise use the default associated
        with the output format.
 
     *format*
        The output format, eg. 'svg', 'pdf', 'ps' or 'png'.  If not
        provided, will be deduced from the filename.
     """
     from matplotlib import figure
     # backend_agg supports all of the core output formats
     from matplotlib.backends import backend_agg
     from matplotlib.font_manager import FontProperties
     from matplotlib.mathtext import MathTextParser
 
     if prop is None:
         prop = FontProperties()
 
     parser = MathTextParser('path')
     width, height, depth, _, _ = parser.parse(s, dpi=72, prop=prop)
 
     fig = figure.Figure(figsize=(width / 72.0, height / 72.0))
     fig.text(0, depth/height, s, fontproperties=prop)
     backend_agg.FigureCanvasAgg(fig)
     fig.savefig(filename_or_obj, dpi=dpi, format=format)
 
     return depth