# (c) 2013-2018 Sebastian Humenda
# This code is licenced under the terms of the LGPL-3+, see the file COPYING for
# more details.
"""This module takes care of the actual image creation process.
Each formula is saved as an image, either as PNG or SVG. SVG is advised, since
it is a properly scalable format.
"""
import enum
import os
import re
import shutil
import subprocess
import sys
def remove_all(*files):
"""Guarded remove of files (rm -f); no exception is thrown if a file
couldn't be removed."""
for file in files:
try:
os.remove(file)
except OSError:
pass
def proc_call(cmd, cwd=None, install_recommends=True):
"""Execute cmd (list of arguments) as a subprocess. Returned is a tuple with
stdout and stderr, decoded if not None. If the return value is not equal 0, a
subprocess error is raised. Timeouts will happen after 20 seconds."""
with subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
bufsize=1, universal_newlines=False, cwd=cwd) as proc:
data = []
try:
data = [d.decode(sys.getdefaultencoding(), errors="surrogateescape")
for d in proc.communicate(timeout=20) if d]
if proc.wait():
raise subprocess.SubprocessError("Error while executing %s\n%s\n" %
(' '.join(cmd), '\n'.join(data)))
except subprocess.TimeoutExpired as e:
proc.kill()
note = 'Subprocess expired with time out: ' + str(cmd) + '\n'
poll = proc.poll()
if poll:
note += str(poll) + '\n'
if data:
raise subprocess.SubprocessError(str(data + '\n' + note))
else:
raise subprocess.SubprocessError('execution timed out after ' +
str(e.args[1]) + ' s: ' + ' '.join(e.args[0]))
except KeyboardInterrupt as e:
sys.stderr.write("\nInterrupted; ")
import traceback
traceback.print_exc(file=sys.stderr)
except FileNotFoundError:
# program missing, try to help
text = "Command `%s` not found." % cmd[0]
if install_recommends and shutil.which('dpkg'):
text += ' Install it using `sudo apt install ' + install_recommends
else:
text += ' Install a TeX distribution of your choice, e.g. MikTeX or TeXlive.'
raise subprocess.SubprocessError(text) from None
if isinstance(data, list):
return '\n'.join(data)
return data
#pylint: disable=too-few-public-methods
class Format(enum.Enum):
"""Chose the image output format."""
Png = 'png'
Svg = 'svg'
class Tex2img:
"""Convert a TeX document string into a png file.
This class interacts with the LaTeX and dvipng sub processes. Upon error
the methods throw a SubprocessError with all necessary information to fix
the issue.
The background of the PNG files will be transparent by default. If you set a
background colour within the LaTeX document, you need to turn off
transparency in this converter manually."""
def __init__(self, fmt, encoding="UTF-8"):
if not isinstance(fmt, Format):
raise ValueError("Enumeration of type Format expected."+str(fmt))
self.__format = fmt
self.__encoding = encoding
self.__parsed_data = None
self.__size = [115, None]
self.__background = 'transparent'
self.__keep_latex_source = False
def set_dpi(self, dpi):
"""Set output resolution for formula images. This has no effect ifthe
output format is SVG. It will automatically overwrite a font size, if
set."""
if not isinstance(dpi, (int, float)):
raise TypeError("Dpi must be an integer or floating point number")
self.__size[0] = int(dpi)
def set_fontsize(self, size):
"""Set font size for formulas. This will be automatically translated
into a DPI resolution for PNG images and taken literally for SVG
graphics."""
if not isinstance(size, (int, float)):
raise TypeError("Dpi must be an integer or floating point number")
self.__size[1] = float(size)
def set_transparency(self, flag):
"""Set whether or not to use background colour information from the DVI
file. This is only relevant for PNG output and if a background colour
other than "transparent" is required, in this case this set'r should be
set to false. It is set to True, resulting in a transparent
background."""
self.__background = ('transparent' if flag else 'not transparent')
def set_keep_latex_source(self, flag):
"""Set whether LaTeX source document should be kept."""
if not isinstance(flag, bool):
raise TypeError("boolean object required, got %s." % repr(flag))
self.__keep_latex_source = flag
def create_dvi(self, tex_document, dvi_fn):
"""Call LaTeX to produce a dvi file with the given LaTeX document.
Temporary files will be removed, even in the case of a LaTeX error.
This method raises a SubprocessError with the helpful part of LaTeX's
error output."""
path = os.path.dirname(dvi_fn)
if path and not os.path.exists(path):
os.makedirs(path)
if not path:
path = os.getcwd()
new_extension = lambda x: os.path.splitext(dvi_fn)[0] + '.' + x
if self.__size[1]: # font size in pt
tex_document.set_fontsize(self.__size[1])
tex_fn = new_extension('tex')
aux_fn = new_extension('aux')
log_fn = new_extension('log')
cmd = None
encoding = self.__encoding
with open(tex_fn, mode='w', encoding=encoding) as tex:
tex.write(str(tex_document))
cmd = ['latex', '-halt-on-error', os.path.basename(tex_fn)]
try:
proc_call(cmd, cwd=path, install_recommends='texlive-recommended')
except subprocess.SubprocessError as e:
remove_all(dvi_fn)
msg = ''
if e.args:
data = self.parse_latex_log(e.args[0])
if data:
msg += data
else:
msg += str(e.args[0])
raise subprocess.SubprocessError(msg) # propagate subprocess error
finally:
if self.__keep_latex_source:
remove_all(aux_fn, log_fn)
else:
remove_all(tex_fn, aux_fn, log_fn)
def create_image(self, dvi_fn):
"""Create the image containing the formula, using either dvisvgm or
dvipng."""
dirname = os.path.dirname(dvi_fn)
if dirname and not os.path.exists(dirname):
os.makedirs(dirname)
output_fn = '%s.%s' % (os.path.splitext(dvi_fn)[0], self.__format.value)
if self.__format == Format.Png:
dpi = (fontsize2dpi(self.__size[1]) if self.__size[1]
else self.__size[0])
return create_png(dvi_fn, output_fn,dpi,
self.__background)
if not self.__size[1]:
self.__size[1] = 12 # 12 pt
return create_svg(dvi_fn, output_fn)
def convert(self, tex_document, base_name):
"""Convert the given TeX document into an image. The base name is used
to create the required intermediate files and the resulting file will be
made of the base_name and the format-specific file extension.
This function returns the positioning information used in the CSS style
attribute."""
if not isinstance(tex_document, LaTeXDocument):
raise TypeError(("expected object of type typesetting.LaTeXDocument,"
" got %s") % type(tex_document))
dvi = '%s.dvi' % base_name
try:
self.create_dvi(tex_document, dvi)
return self.create_image(dvi)
except OSError:
remove_all('%s.%s' % (base_name, self.__format.value))
raise
def parse_latex_log(self, logdata):
"""Parse the LaTeX error output and return the relevant part of it."""
if not logdata:
return None
line = None
for line in logdata.split('\n'):
if line.startswith('! '):
line = line[2:]
break
if line: # try to remove LaTeX line numbers
lineno = re.search(r'\s*on input line \d+', line)
if lineno:
line = line[:lineno.span()[0]] + line[lineno.span()[1]:]
return line
return None
def fontsize2dpi(size_pt):
"""This function calculates the DPI for the resulting image. Depending on
the font size, a different resolution needs to be used. According to the
dvipng manual page, the formula is:
<dpi> = <font_px> * 72.27 / 10 [px * TeXpt/in / TeXpt]"""
size_px = size_pt * 1.3333333 # and more 3s!
return size_px * 72.27 / 10
def create_png(dvi_fn, output_name, dpi, background):
"""Create a PNG file from a given dvi file. The side effect is the PNG file
being written to disk.
By default, the background of the resulting image is transparent, setting
any other value will make it use whatever was is set in the DVI file.
:param dvi_fn Dvi file name
:param output_name Output file name
:param dpi Output resolution
:param background Background colour (default: transparent)
:return dimensions for embedding into an HTML document
:raises ValueError raised whenever dvipng output coudln't be parsed"""
if not output_name:
raise ValueError("Empty output_name")
cmd = ['dvipng', '-q*', '-D', str(dpi)]
if background == 'transparent':
cmd += ['-bg', background]
cmd += ['--height*', '--depth*', '--width*', # print information for embedding
'-o', output_name, dvi_fn]
data = None
try:
data = proc_call(cmd, install_recommends='dvipng')
except subprocess.SubprocessError:
remove_all(output_name)
raise
finally:
remove_all(dvi_fn)
for line in data.split('\n'):
found = DVIPNG_REGEX.search(line)
if found:
return dict(zip(['depth', 'height', 'width'],
map(float, found.groups())))
raise ValueError("Could not parse dvi output: " + repr(data))
def create_svg(dvi_fn, output_name):
"""Create a SVG file from a given dvi file. The side effect is the SVG file
being written to disk.
:param dvi_fn Dvi file name
:param output_name Output file name
:param size font size in pt
:return dimensions for embedding into an HTML document
:raises ValueError raised whenever dvipng output coudln't be parsed"""
if not output_name:
raise ValueError("Empty output_name")
cmd = ['dvisvgm', '--exact', '--no-fonts', '-o', output_name,
'--bbox=preview', dvi_fn]
data = None
try:
data = proc_call(cmd, install_recommends='texlive-binaries')
except subprocess.SubprocessError:
remove_all(output_name)
raise
finally:
remove_all(dvi_fn)
pos = {}
for line in data.split('\n'):
if not pos:
found = DVISVGM_DEPTH_REGEX.search(line)
if found:
# convert from pt to px (assuming 96 dpi)
pos['depth'] = float(found.groups()[0]) * 1.3333333
else:
found = DVISVGM_SIZE_REGEX.search(line)
if found:
pos.update(dict(zip(['width', 'height'],
# convert from pt to px (assuming 96 dpi)
(float(v) * 1.3333333 for v in found.groups()))))
return pos
raise ValueError("Could not parse dvisvgm output: " + repr(data))
