def __init__(self,
offset=(2, -2),
shadow_rgbFace=None,
alpha=None,
patch_alpha=None,
rho=0.3,
offset_xy=None,
**kwargs):
"""
Parameters
----------
offset : pair of floats
The offset of the shadow in points.
shadow_rgbFace : :ref:`color <mpl-color-spec>`
The shadow color.
alpha : float
The alpha transparency of the created shadow patch.
Default is 0.3.
http://matplotlib.1069221.n5.nabble.com/path-effects-question-td27630.html
rho : float
A scale factor to apply to the rgbFace color if `shadow_rgbFace`
is not specified. Default is 0.3.
**kwargs
Extra keywords are stored and passed through to
:meth:`AbstractPathEffect._update_gc`.
"""
if offset_xy is not None:
cbook.deprecated(
'v1.4', 'The offset_xy keyword is deprecated. '
'Use the offset keyword instead.')
offset = offset_xy
super(SimplePatchShadow, self).__init__(offset)
if shadow_rgbFace is None:
self._shadow_rgbFace = shadow_rgbFace
else:
self._shadow_rgbFace = colorConverter.to_rgba(shadow_rgbFace)
if patch_alpha is not None:
cbook.deprecated(
'v1.4', 'The patch_alpha keyword is deprecated. '
'Use the alpha keyword instead. Transform your '
'patch_alpha by alpha = 1 - patch_alpha')
if alpha is not None:
raise ValueError("Both alpha and patch_alpha were set. "
"Just use alpha.")
alpha = 1 - patch_alpha
if alpha is None:
alpha = 0.3
self._alpha = alpha
self._rho = rho
#: The dictionary of keywords to update the graphics collection with.
self._gc = kwargs
#: The offset transform object. The offset isn't calculated yet
#: as we don't know how big the figure will be in pixels.
self._offset_tran = mtransforms.Affine2D()
def __init__(self, offset=(2,-2),
shadow_rgbFace=None, alpha=None, patch_alpha=None,
rho=0.3, offset_xy=None, **kwargs):
"""
Parameters
----------
offset : pair of floats
The offset of the shadow in points.
shadow_rgbFace : :ref:`color <mpl-color-spec>`
The shadow color.
alpha : float
The alpha transparency of the created shadow patch.
Default is 0.3.
http://matplotlib.1069221.n5.nabble.com/path-effects-question-td27630.html
rho : float
A scale factor to apply to the rgbFace color if `shadow_rgbFace`
is not specified. Default is 0.3.
**kwargs
Extra keywords are stored and passed through to
:meth:`AbstractPathEffect._update_gc`.
"""
if offset_xy is not None:
cbook.deprecated('v1.4', 'The offset_xy keyword is deprecated. '
'Use the offset keyword instead.')
offset = offset_xy
super(SimplePatchShadow, self).__init__(offset)
if shadow_rgbFace is None:
self._shadow_rgbFace = shadow_rgbFace
else:
self._shadow_rgbFace = colorConverter.to_rgba(shadow_rgbFace)
if patch_alpha is not None:
cbook.deprecated('v1.4', 'The patch_alpha keyword is deprecated. '
'Use the alpha keyword instead. Transform your '
'patch_alpha by alpha = 1 - patch_alpha')
if alpha is not None:
raise ValueError("Both alpha and patch_alpha were set. "
"Just use alpha.")
alpha = 1 - patch_alpha
if alpha is None:
alpha = 0.3
self._alpha = alpha
self._rho = rho
#: The dictionary of keywords to update the graphics collection with.
self._gc = kwargs
#: The offset transform object. The offset isn't calculated yet
#: as we don't know how big the figure will be in pixels.
self._offset_tran = mtransforms.Affine2D()
def get_proxy_renderer(self, renderer):
"""Return a PathEffectRenderer instance for this PathEffect."""
cbook.deprecated('v1.4', name='get_proxy_renderer',
alternative='PathEffectRenderer')
return PathEffectRenderer([self], renderer)
class PdfPages:
"""
A multi-page PDF file using the pgf backend
Examples
--------
>>> import matplotlib.pyplot as plt
>>> # Initialize:
>>> with PdfPages('foo.pdf') as pdf:
... # As many times as you like, create a figure fig and save it:
... fig = plt.figure()
... pdf.savefig(fig)
... # When no figure is specified the current figure is saved
... pdf.savefig()
"""
__slots__ = (
'_output_name',
'keep_empty',
'_n_figures',
'_file',
'_info_dict',
'_metadata',
)
metadata = cbook.deprecated('3.3')(property(lambda self: self._metadata))
def __init__(self, filename, *, keep_empty=True, metadata=None):
"""
Create a new PdfPages object.
Parameters
----------
filename : str or path-like
Plots using `PdfPages.savefig` will be written to a file at this
location. Any older file with the same name is overwritten.
keep_empty : bool, default: True
If set to False, then empty pdf files will be deleted automatically
when closed.
metadata : dict, optional
Information dictionary object (see PDF reference section 10.2.1
'Document Information Dictionary'), e.g.:
``{'Creator': 'My software', 'Author': 'Me', 'Title': 'Awesome'}``.
The standard keys are 'Title', 'Author', 'Subject', 'Keywords',
'Creator', 'Producer', 'CreationDate', 'ModDate', and
'Trapped'. Values have been predefined for 'Creator', 'Producer'
and 'CreationDate'. They can be removed by setting them to `None`.
"""
self._output_name = filename
self._n_figures = 0
self.keep_empty = keep_empty
self._metadata = (metadata or {}).copy()
if metadata:
for key in metadata:
canonical = {
'creationdate': 'CreationDate',
'moddate': 'ModDate',
}.get(key.lower(),
key.lower().title())
if canonical != key:
cbook.warn_deprecated(
'3.3',
message='Support for setting PDF metadata keys '
'case-insensitively is deprecated since %(since)s and '
'will be removed %(removal)s; '
f'set {canonical} instead of {key}.')
self._metadata[canonical] = self._metadata.pop(key)
self._info_dict = _create_pdf_info_dict('pgf', self._metadata)
self._file = BytesIO()
def _write_header(self, width_inches, height_inches):
hyperref_options = ','.join(
_metadata_to_str(k, v) for k, v in self._info_dict.items())
latex_preamble = get_preamble()
latex_fontspec = get_fontspec()
latex_header = r"""\PassOptionsToPackage{{
pdfinfo={{
{metadata}
}}
}}{{hyperref}}
\RequirePackage{{hyperref}}
\documentclass[12pt]{{minimal}}
\usepackage[
paperwidth={width}in,
paperheight={height}in,
margin=0in
]{{geometry}}
{preamble}
{fontspec}
\usepackage{{pgf}}
\setlength{{\parindent}}{{0pt}}
\begin{{document}}%%
""".format(
width=width_inches,
height=height_inches,
preamble=latex_preamble,
fontspec=latex_fontspec,
metadata=hyperref_options,
)
self._file.write(latex_header.encode('utf-8'))
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self.close()
def close(self):
"""
Finalize this object, running LaTeX in a temporary directory
and moving the final pdf file to *filename*.
"""
self._file.write(rb'\end{document}\n')
if self._n_figures > 0:
self._run_latex()
elif self.keep_empty:
open(self._output_name, 'wb').close()
self._file.close()
def _run_latex(self):
texcommand = mpl.rcParams["pgf.texsystem"]
with TemporaryDirectory() as tmpdir:
tex_source = pathlib.Path(tmpdir, "pdf_pages.tex")
tex_source.write_bytes(self._file.getvalue())
cbook._check_and_log_subprocess([
texcommand, "-interaction=nonstopmode", "-halt-on-error",
tex_source
],
_log,
cwd=tmpdir)
shutil.move(tex_source.with_suffix(".pdf"), self._output_name)
def savefig(self, figure=None, **kwargs):
"""
Save a `.Figure` to this file as a new page.
Any other keyword arguments are passed to `~.Figure.savefig`.
Parameters
----------
figure : `.Figure` or int, optional
Specifies what figure is saved to file. If not specified, the
active figure is saved. If a `.Figure` instance is provided, this
figure is saved. If an int is specified, the figure instance to
save is looked up by number.
"""
if not isinstance(figure, Figure):
if figure is None:
manager = Gcf.get_active()
else:
manager = Gcf.get_fig_manager(figure)
if manager is None:
raise ValueError("No figure {}".format(figure))
figure = manager.canvas.figure
try:
orig_canvas = figure.canvas
figure.canvas = FigureCanvasPgf(figure)
width, height = figure.get_size_inches()
if self._n_figures == 0:
self._write_header(width, height)
else:
# \pdfpagewidth and \pdfpageheight exist on pdftex, xetex, and
# luatex<0.85; they were renamed to \pagewidth and \pageheight
# on luatex>=0.85.
self._file.write(br'\newpage'
br'\ifdefined\pdfpagewidth\pdfpagewidth'
br'\else\pagewidth\fi=%ain'
br'\ifdefined\pdfpageheight\pdfpageheight'
br'\else\pageheight\fi=%ain'
b'%%\n' % (width, height))
figure.savefig(self._file, format="pgf", **kwargs)
self._n_figures += 1
finally:
figure.canvas = orig_canvas
def get_pagecount(self):
"""Return the current number of pages in the multipage pdf file."""
return self._n_figures
class FigureCanvasTk(FigureCanvasBase):
keyvald = {
65507: 'control',
65505: 'shift',
65513: 'alt',
65515: 'super',
65508: 'control',
65506: 'shift',
65514: 'alt',
65361: 'left',
65362: 'up',
65363: 'right',
65364: 'down',
65307: 'escape',
65470: 'f1',
65471: 'f2',
65472: 'f3',
65473: 'f4',
65474: 'f5',
65475: 'f6',
65476: 'f7',
65477: 'f8',
65478: 'f9',
65479: 'f10',
65480: 'f11',
65481: 'f12',
65300: 'scroll_lock',
65299: 'break',
65288: 'backspace',
65293: 'enter',
65379: 'insert',
65535: 'delete',
65360: 'home',
65367: 'end',
65365: 'pageup',
65366: 'pagedown',
65438: '0',
65436: '1',
65433: '2',
65435: '3',
65430: '4',
65437: '5',
65432: '6',
65429: '7',
65431: '8',
65434: '9',
65451: '+',
65453: '-',
65450: '*',
65455: '/',
65439: 'dec',
65421: 'enter',
}
_keycode_lookup = {
262145: 'control',
524320: 'alt',
524352: 'alt',
1048584: 'super',
1048592: 'super',
131074: 'shift',
131076: 'shift',
}
"""_keycode_lookup is used for badly mapped (i.e. no event.key_sym set)
keys on apple keyboards."""
def __init__(self, figure, master=None, resize_callback=None):
super(FigureCanvasTk, self).__init__(figure)
self._idle = True
self._idle_callback = None
t1, t2, w, h = self.figure.bbox.bounds
w, h = int(w), int(h)
self._tkcanvas = Tk.Canvas(master=master,
background="white",
width=w,
height=h,
borderwidth=0,
highlightthickness=0)
self._tkphoto = Tk.PhotoImage(master=self._tkcanvas, width=w, height=h)
self._tkcanvas.create_image(w // 2, h // 2, image=self._tkphoto)
self._resize_callback = resize_callback
self._tkcanvas.bind("<Configure>", self.resize)
self._tkcanvas.bind("<Key>", self.key_press)
self._tkcanvas.bind("<Motion>", self.motion_notify_event)
self._tkcanvas.bind("<KeyRelease>", self.key_release)
for name in "<Button-1>", "<Button-2>", "<Button-3>":
self._tkcanvas.bind(name, self.button_press_event)
for name in "<Double-Button-1>", "<Double-Button-2>", "<Double-Button-3>":
self._tkcanvas.bind(name, self.button_dblclick_event)
for name in "<ButtonRelease-1>", "<ButtonRelease-2>", "<ButtonRelease-3>":
self._tkcanvas.bind(name, self.button_release_event)
# Mouse wheel on Linux generates button 4/5 events
for name in "<Button-4>", "<Button-5>":
self._tkcanvas.bind(name, self.scroll_event)
# Mouse wheel for windows goes to the window with the focus.
# Since the canvas won't usually have the focus, bind the
# event to the window containing the canvas instead.
# See http://wiki.tcl.tk/3893 (mousewheel) for details
root = self._tkcanvas.winfo_toplevel()
root.bind("<MouseWheel>", self.scroll_event_windows, "+")
# Can't get destroy events by binding to _tkcanvas. Therefore, bind
# to the window and filter.
def filter_destroy(evt):
if evt.widget is self._tkcanvas:
self._master.update_idletasks()
self.close_event()
root.bind("<Destroy>", filter_destroy, "+")
self._master = master
self._tkcanvas.focus_set()
def resize(self, event):
width, height = event.width, event.height
if self._resize_callback is not None:
self._resize_callback(event)
# compute desired figure size in inches
dpival = self.figure.dpi
winch = width / dpival
hinch = height / dpival
self.figure.set_size_inches(winch, hinch, forward=False)
self._tkcanvas.delete(self._tkphoto)
self._tkphoto = Tk.PhotoImage(master=self._tkcanvas,
width=int(width),
height=int(height))
self._tkcanvas.create_image(int(width / 2),
int(height / 2),
image=self._tkphoto)
self.resize_event()
self.draw()
# a resizing will in general move the pointer position
# relative to the canvas, so process it as a motion notify
# event. An intended side effect of this call is to allow
# window raises (which trigger a resize) to get the cursor
# position to the mpl event framework so key presses which are
# over the axes will work w/o clicks or explicit motion
self._update_pointer_position(event)
def _update_pointer_position(self, guiEvent=None):
"""
Figure out if we are inside the canvas or not and update the
canvas enter/leave events
"""
# if the pointer if over the canvas, set the lastx and lasty
# attrs of the canvas so it can process event w/o mouse click
# or move
# the window's upper, left coords in screen coords
xw = self._tkcanvas.winfo_rootx()
yw = self._tkcanvas.winfo_rooty()
# the pointer's location in screen coords
xp, yp = self._tkcanvas.winfo_pointerxy()
# not figure out the canvas coordinates of the pointer
xc = xp - xw
yc = yp - yw
# flip top/bottom
yc = self.figure.bbox.height - yc
# JDH: this method was written originally to get the pointer
# location to the backend lastx and lasty attrs so that events
# like KeyEvent can be handled without mouse events. e.g., if
# the cursor is already above the axes, then key presses like
# 'g' should toggle the grid. In order for this to work in
# backend_bases, the canvas needs to know _lastx and _lasty.
# There are three ways to get this info the canvas:
#
# 1) set it explicitly
#
# 2) call enter/leave events explicitly. The downside of this
# in the impl below is that enter could be repeatedly
# triggered if the mouse is over the axes and one is
# resizing with the keyboard. This is not entirely bad,
# because the mouse position relative to the canvas is
# changing, but it may be surprising to get repeated entries
# without leaves
#
# 3) process it as a motion notify event. This also has pros
# and cons. The mouse is moving relative to the window, but
# this may surpise an event handler writer who is getting
# motion_notify_events even if the mouse has not moved
# here are the three scenarios
if 1:
# just manually set it
self._lastx, self._lasty = xc, yc
elif 0:
# alternate implementation: process it as a motion
FigureCanvasBase.motion_notify_event(self, xc, yc, guiEvent)
elif 0:
# alternate implementation -- process enter/leave events
# instead of motion/notify
if self.figure.bbox.contains(xc, yc):
self.enter_notify_event(guiEvent, xy=(xc, yc))
else:
self.leave_notify_event(guiEvent)
show = cbook.deprecated(
"2.2", name="FigureCanvasTk.show",
alternative="FigureCanvasTk.draw")(lambda self: self.draw())
def draw_idle(self):
'update drawing area only if idle'
if self._idle is False:
return
self._idle = False
def idle_draw(*args):
try:
self.draw()
finally:
self._idle = True
self._idle_callback = self._tkcanvas.after_idle(idle_draw)
def get_tk_widget(self):
"""returns the Tk widget used to implement FigureCanvasTkAgg.
Although the initial implementation uses a Tk canvas, this routine
is intended to hide that fact.
"""
return self._tkcanvas
def motion_notify_event(self, event):
x = event.x
# flipy so y=0 is bottom of canvas
y = self.figure.bbox.height - event.y
FigureCanvasBase.motion_notify_event(self, x, y, guiEvent=event)
def button_press_event(self, event, dblclick=False):
x = event.x
# flipy so y=0 is bottom of canvas
y = self.figure.bbox.height - event.y
num = getattr(event, 'num', None)
if sys.platform == 'darwin':
# 2 and 3 were reversed on the OSX platform I
# tested under tkagg
if num == 2: num = 3
elif num == 3: num = 2
FigureCanvasBase.button_press_event(self,
x,
y,
num,
dblclick=dblclick,
guiEvent=event)
def button_dblclick_event(self, event):
self.button_press_event(event, dblclick=True)
def button_release_event(self, event):
x = event.x
# flipy so y=0 is bottom of canvas
y = self.figure.bbox.height - event.y
num = getattr(event, 'num', None)
if sys.platform == 'darwin':
# 2 and 3 were reversed on the OSX platform I
# tested under tkagg
if num == 2: num = 3
elif num == 3: num = 2
FigureCanvasBase.button_release_event(self, x, y, num, guiEvent=event)
def scroll_event(self, event):
x = event.x
y = self.figure.bbox.height - event.y
num = getattr(event, 'num', None)
if num == 4: step = +1
elif num == 5: step = -1
else: step = 0
FigureCanvasBase.scroll_event(self, x, y, step, guiEvent=event)
def scroll_event_windows(self, event):
"""MouseWheel event processor"""
# need to find the window that contains the mouse
w = event.widget.winfo_containing(event.x_root, event.y_root)
if w == self._tkcanvas:
x = event.x_root - w.winfo_rootx()
y = event.y_root - w.winfo_rooty()
y = self.figure.bbox.height - y
step = event.delta / 120.
FigureCanvasBase.scroll_event(self, x, y, step, guiEvent=event)
def _get_key(self, event):
val = event.keysym_num
if val in self.keyvald:
key = self.keyvald[val]
elif val == 0 and sys.platform == 'darwin' and \
event.keycode in self._keycode_lookup:
key = self._keycode_lookup[event.keycode]
elif val < 256:
key = chr(val)
else:
key = None
# add modifier keys to the key string. Bit details originate from
# http://effbot.org/tkinterbook/tkinter-events-and-bindings.htm
# BIT_SHIFT = 0x001; BIT_CAPSLOCK = 0x002; BIT_CONTROL = 0x004;
# BIT_LEFT_ALT = 0x008; BIT_NUMLOCK = 0x010; BIT_RIGHT_ALT = 0x080;
# BIT_MB_1 = 0x100; BIT_MB_2 = 0x200; BIT_MB_3 = 0x400;
# In general, the modifier key is excluded from the modifier flag,
# however this is not the case on "darwin", so double check that
# we aren't adding repeat modifier flags to a modifier key.
if sys.platform == 'win32':
modifiers = [
(17, 'alt', 'alt'),
(2, 'ctrl', 'control'),
]
elif sys.platform == 'darwin':
modifiers = [
(3, 'super', 'super'),
(4, 'alt', 'alt'),
(2, 'ctrl', 'control'),
]
else:
modifiers = [
(6, 'super', 'super'),
(3, 'alt', 'alt'),
(2, 'ctrl', 'control'),
]
if key is not None:
# note, shift is not added to the keys as this is already accounted for
for bitmask, prefix, key_name in modifiers:
if event.state & (1 << bitmask) and key_name not in key:
key = '{0}+{1}'.format(prefix, key)
return key
def key_press(self, event):
key = self._get_key(event)
FigureCanvasBase.key_press_event(self, key, guiEvent=event)
def key_release(self, event):
key = self._get_key(event)
FigureCanvasBase.key_release_event(self, key, guiEvent=event)
def new_timer(self, *args, **kwargs):
"""
Creates a new backend-specific subclass of :class:`backend_bases.Timer`.
This is useful for getting periodic events through the backend's native
event loop. Implemented only for backends with GUIs.
Other Parameters
----------------
interval : scalar
Timer interval in milliseconds
callbacks : list
Sequence of (func, args, kwargs) where ``func(*args, **kwargs)``
will be executed by the timer every *interval*.
"""
return TimerTk(self._tkcanvas, *args, **kwargs)
def flush_events(self):
self._master.update()
class TexManager:
"""
Convert strings to dvi files using TeX, caching the results to a directory.
Repeated calls to this constructor always return the same instance.
"""
# Caches.
texcache = os.path.join(mpl.get_cachedir(), 'tex.cache')
grey_arrayd = {}
font_family = 'serif'
font_families = ('serif', 'sans-serif', 'cursive', 'monospace')
font_info = {
'new century schoolbook': ('pnc', r'\renewcommand{\rmdefault}{pnc}'),
'bookman': ('pbk', r'\renewcommand{\rmdefault}{pbk}'),
'times': ('ptm', r'\usepackage{mathptmx}'),
'palatino': ('ppl', r'\usepackage{mathpazo}'),
'zapf chancery': ('pzc', r'\usepackage{chancery}'),
'cursive': ('pzc', r'\usepackage{chancery}'),
'charter': ('pch', r'\usepackage{charter}'),
'serif': ('cmr', ''),
'sans-serif': ('cmss', ''),
'helvetica': ('phv', r'\usepackage{helvet}'),
'avant garde': ('pag', r'\usepackage{avant}'),
'courier': ('pcr', r'\usepackage{courier}'),
# Loading the type1ec package ensures that cm-super is installed, which
# is necessary for unicode computer modern. (It also allows the use of
# computer modern at arbitrary sizes, but that's just a side effect.)
'monospace': ('cmtt', r'\usepackage{type1ec}'),
'computer modern roman': ('cmr', r'\usepackage{type1ec}'),
'computer modern sans serif': ('cmss', r'\usepackage{type1ec}'),
'computer modern typewriter': ('cmtt', r'\usepackage{type1ec}')
}
cachedir = cbook.deprecated("3.3",
alternative="matplotlib.get_cachedir()")(
property(lambda self: mpl.get_cachedir()))
rgba_arrayd = cbook.deprecated("3.3")(property(lambda self: {}))
_fonts = {} # Only for deprecation period.
serif = cbook.deprecated("3.3")(
property(lambda self: self._fonts.get("serif", ('cmr', ''))))
sans_serif = cbook.deprecated("3.3")(
property(lambda self: self._fonts.get("sans-serif", ('cmss', ''))))
cursive = cbook.deprecated("3.3")(property(lambda self: self._fonts.get(
"cursive", ('pzc', r'\usepackage{chancery}'))))
monospace = cbook.deprecated("3.3")(
property(lambda self: self._fonts.get("monospace", ('cmtt', ''))))
@functools.lru_cache() # Always return the same instance.
def __new__(cls):
Path(cls.texcache).mkdir(parents=True, exist_ok=True)
return object.__new__(cls)
def get_font_config(self):
ff = rcParams['font.family']
if len(ff) == 1 and ff[0].lower() in self.font_families:
self.font_family = ff[0].lower()
else:
_log.info(
'font.family must be one of (%s) when text.usetex is '
'True. serif will be used by default.',
', '.join(self.font_families))
self.font_family = 'serif'
fontconfig = [self.font_family]
for font_family in self.font_families:
for font in rcParams['font.' + font_family]:
if font.lower() in self.font_info:
self._fonts[font_family] = self.font_info[font.lower()]
_log.debug('family: %s, font: %s, info: %s', font_family,
font, self.font_info[font.lower()])
break
else:
_log.debug('%s font is not compatible with usetex.', font)
else:
_log.info(
'No LaTeX-compatible font found for the %s font '
'family in rcParams. Using default.', font_family)
self._fonts[font_family] = self.font_info[font_family]
fontconfig.append(self._fonts[font_family][0])
# Add a hash of the latex preamble to fontconfig so that the
# correct png is selected for strings rendered with same font and dpi
# even if the latex preamble changes within the session
preamble_bytes = self.get_custom_preamble().encode('utf-8')
fontconfig.append(hashlib.md5(preamble_bytes).hexdigest())
# The following packages and commands need to be included in the latex
# file's preamble:
cmd = [
self._fonts['serif'][1], self._fonts['sans-serif'][1],
self._fonts['monospace'][1]
]
if self.font_family == 'cursive':
cmd.append(self._fonts['cursive'][1])
self._font_preamble = '\n'.join([r'\usepackage{type1cm}', *cmd])
return ''.join(fontconfig)
def get_basefile(self, tex, fontsize, dpi=None):
"""
Return a filename based on a hash of the string, fontsize, and dpi.
"""
s = ''.join([
tex,
self.get_font_config(),
'%f' % fontsize,
self.get_custom_preamble(),
str(dpi or '')
])
return os.path.join(self.texcache,
hashlib.md5(s.encode('utf-8')).hexdigest())
def get_font_preamble(self):
"""
Return a string containing font configuration for the tex preamble.
"""
return self._font_preamble
def get_custom_preamble(self):
"""Return a string containing user additions to the tex preamble."""
return rcParams['text.latex.preamble']
def _get_preamble(self):
return "\n".join([
r"\documentclass{article}",
# Pass-through \mathdefault, which is used in non-usetex mode to
# use the default text font but was historically suppressed in
# usetex mode.
r"\newcommand{\mathdefault}[1]{#1}",
self._font_preamble,
r"\usepackage[utf8]{inputenc}",
r"\DeclareUnicodeCharacter{2212}{\ensuremath{-}}",
# geometry is loaded before the custom preamble as convert_psfrags
# relies on a custom preamble to change the geometry.
r"\usepackage[papersize=72in, margin=1in]{geometry}",
self.get_custom_preamble(),
# textcomp is loaded last (if not already loaded by the custom
# preamble) in order not to clash with custom packages (e.g.
# newtxtext) which load it with different options.
r"\makeatletter"
r"\@ifpackageloaded{textcomp}{}{\usepackage{textcomp}}"
r"\makeatother",
])
def make_tex(self, tex, fontsize):
"""
Generate a tex file to render the tex string at a specific font size.
Return the file name.
"""
basefile = self.get_basefile(tex, fontsize)
texfile = '%s.tex' % basefile
fontcmd = {
'sans-serif': r'{\sffamily %s}',
'monospace': r'{\ttfamily %s}'
}.get(self.font_family, r'{\rmfamily %s}')
Path(texfile).write_text(r"""
%s
\pagestyle{empty}
\begin{document}
%% The empty hbox ensures that a page is printed even for empty inputs, except
%% when using psfrag which gets confused by it.
\fontsize{%f}{%f}%%
\ifdefined\psfrag\else\hbox{}\fi%%
%s
\end{document}
""" % (self._get_preamble(), fontsize, fontsize * 1.25, fontcmd % tex),
encoding='utf-8')
return texfile
_re_vbox = re.compile(
r"MatplotlibBox:\(([\d.]+)pt\+([\d.]+)pt\)x([\d.]+)pt")
@_api.deprecated("3.3")
def make_tex_preview(self, tex, fontsize):
"""
Generate a tex file to render the tex string at a specific font size.
It uses the preview.sty to determine the dimension (width, height,
descent) of the output.
Return the file name.
"""
basefile = self.get_basefile(tex, fontsize)
texfile = '%s.tex' % basefile
fontcmd = {
'sans-serif': r'{\sffamily %s}',
'monospace': r'{\ttfamily %s}'
}.get(self.font_family, r'{\rmfamily %s}')
# newbox, setbox, immediate, etc. are used to find the box
# extent of the rendered text.
Path(texfile).write_text(r"""
%s
\usepackage[active,showbox,tightpage]{preview}
%% we override the default showbox as it is treated as an error and makes
%% the exit status not zero
\def\showbox#1%%
{\immediate\write16{MatplotlibBox:(\the\ht#1+\the\dp#1)x\the\wd#1}}
\begin{document}
\begin{preview}
{\fontsize{%f}{%f}%s}
\end{preview}
\end{document}
""" % (self._get_preamble(), fontsize, fontsize * 1.25, fontcmd % tex),
encoding='utf-8')
return texfile
def _run_checked_subprocess(self, command, tex, *, cwd=None):
_log.debug(cbook._pformat_subprocess(command))
try:
report = subprocess.check_output(
command,
cwd=cwd if cwd is not None else self.texcache,
stderr=subprocess.STDOUT)
except FileNotFoundError as exc:
raise RuntimeError(
'Failed to process string with tex because {} could not be '
'found'.format(command[0])) from exc
except subprocess.CalledProcessError as exc:
raise RuntimeError(
'{prog} was not able to process the following string:\n'
'{tex!r}\n\n'
'Here is the full report generated by {prog}:\n'
'{exc}\n\n'.format(prog=command[0],
tex=tex.encode('unicode_escape'),
exc=exc.output.decode('utf-8'))) from exc
_log.debug(report)
return report
def make_dvi(self, tex, fontsize):
"""
Generate a dvi file containing latex's layout of tex string.
Return the file name.
"""
if dict.__getitem__(rcParams, 'text.latex.preview'):
return self.make_dvi_preview(tex, fontsize)
basefile = self.get_basefile(tex, fontsize)
dvifile = '%s.dvi' % basefile
if not os.path.exists(dvifile):
texfile = self.make_tex(tex, fontsize)
# Generate the dvi in a temporary directory to avoid race
# conditions e.g. if multiple processes try to process the same tex
# string at the same time. Having tmpdir be a subdirectory of the
# final output dir ensures that they are on the same filesystem,
# and thus replace() works atomically.
with TemporaryDirectory(dir=Path(dvifile).parent) as tmpdir:
self._run_checked_subprocess([
"latex", "-interaction=nonstopmode", "--halt-on-error",
texfile
],
tex,
cwd=tmpdir)
(Path(tmpdir) / Path(dvifile).name).replace(dvifile)
return dvifile
@_api.deprecated("3.3")
def make_dvi_preview(self, tex, fontsize):
"""
Generate a dvi file containing latex's layout of tex string.
It calls make_tex_preview() method and store the size information
(width, height, descent) in a separate file.
Return the file name.
"""
basefile = self.get_basefile(tex, fontsize)
dvifile = '%s.dvi' % basefile
baselinefile = '%s.baseline' % basefile
if not os.path.exists(dvifile) or not os.path.exists(baselinefile):
texfile = self.make_tex_preview(tex, fontsize)
report = self._run_checked_subprocess([
"latex", "-interaction=nonstopmode", "--halt-on-error", texfile
], tex)
# find the box extent information in the latex output
# file and store them in ".baseline" file
m = TexManager._re_vbox.search(report.decode("utf-8"))
with open(basefile + '.baseline', "w") as fh:
fh.write(" ".join(m.groups()))
for fname in glob.glob(basefile + '*'):
if not fname.endswith(('dvi', 'tex', 'baseline')):
try:
os.remove(fname)
except OSError:
pass
return dvifile
def make_png(self, tex, fontsize, dpi):
"""
Generate a png file containing latex's rendering of tex string.
Return the file name.
"""
basefile = self.get_basefile(tex, fontsize, dpi)
pngfile = '%s.png' % basefile
# see get_rgba for a discussion of the background
if not os.path.exists(pngfile):
dvifile = self.make_dvi(tex, fontsize)
cmd = [
"dvipng", "-bg", "Transparent", "-D",
str(dpi), "-T", "tight", "-o", pngfile, dvifile
]
# When testing, disable FreeType rendering for reproducibility; but
# dvipng 1.16 has a bug (fixed in f3ff241) that breaks --freetype0
# mode, so for it we keep FreeType enabled; the image will be
# slightly off.
if (getattr(mpl, "_called_from_pytest", False)
and mpl._get_executable_info("dvipng").version != "1.16"):
cmd.insert(1, "--freetype0")
self._run_checked_subprocess(cmd, tex)
return pngfile
def get_grey(self, tex, fontsize=None, dpi=None):
"""Return the alpha channel."""
if not fontsize:
fontsize = rcParams['font.size']
if not dpi:
dpi = rcParams['savefig.dpi']
key = tex, self.get_font_config(), fontsize, dpi
alpha = self.grey_arrayd.get(key)
if alpha is None:
pngfile = self.make_png(tex, fontsize, dpi)
rgba = mpl.image.imread(os.path.join(self.texcache, pngfile))
self.grey_arrayd[key] = alpha = rgba[:, :, -1]
return alpha
def get_rgba(self, tex, fontsize=None, dpi=None, rgb=(0, 0, 0)):
"""Return latex's rendering of the tex string as an rgba array."""
alpha = self.get_grey(tex, fontsize, dpi)
rgba = np.empty((*alpha.shape, 4))
rgba[..., :3] = mpl.colors.to_rgb(rgb)
rgba[..., -1] = alpha
return rgba
def get_text_width_height_descent(self, tex, fontsize, renderer=None):
"""Return width, height and descent of the text."""
if tex.strip() == '':
return 0, 0, 0
dpi_fraction = renderer.points_to_pixels(1.) if renderer else 1
if dict.__getitem__(rcParams, 'text.latex.preview'):
# use preview.sty
basefile = self.get_basefile(tex, fontsize)
baselinefile = '%s.baseline' % basefile
if not os.path.exists(baselinefile):
dvifile = self.make_dvi_preview(tex, fontsize)
with open(baselinefile) as fh:
l = fh.read().split()
height, depth, width = [float(l1) * dpi_fraction for l1 in l]
return width, height + depth, depth
else:
# use dviread.
dvifile = self.make_dvi(tex, fontsize)
with dviread.Dvi(dvifile, 72 * dpi_fraction) as dvi:
page, = dvi
# A total height (including the descent) needs to be returned.
return page.width, page.height + page.descent, page.descent
import sys
import textwrap
import traceback
from docutils.parsers.rst import directives, Directive
from docutils.parsers.rst.directives.images import Image
import jinja2 # Sphinx dependency.
import matplotlib
from matplotlib.backend_bases import FigureManagerBase
import matplotlib.pyplot as plt
from matplotlib import _pylab_helpers, cbook
matplotlib.use('agg')
align = cbook.deprecated(
'3.4', alternative='docutils.parsers.rst.directives.images.Image.align')(
Image.align)
__version__ = 2
# -----------------------------------------------------------------------------
# Registration hook
# -----------------------------------------------------------------------------
def _option_boolean(arg):
if not arg or not arg.strip():
# no argument given, assume used as a flag
return True
elif arg.strip().lower() in ('no', '0', 'false'):
_mathtext.ship(0, 0, box)
return (self.width, self.height + self.depth, self.depth, self.glyphs,
self.rects)
for _cls_name in [
"Fonts",
*[c.__name__ for c in _mathtext.Fonts.__subclasses__()],
"FontConstantsBase",
*[c.__name__ for c in _mathtext.FontConstantsBase.__subclasses__()],
"Node",
*[c.__name__ for c in _mathtext.Node.__subclasses__()],
"Ship",
"Parser",
]:
globals()[_cls_name] = cbook.deprecated("3.4")(type(
_cls_name, (getattr(_mathtext, _cls_name), ), {}))
class MathTextWarning(Warning):
pass
@cbook.deprecated("3.3")
class GlueSpec:
"""See `Glue`."""
def __init__(self,
width=0.,
stretch=0.,
stretch_order=0,
shrink=0.,
shrink_order=0):
class NavigationToolbar2GTK3(NavigationToolbar2, Gtk.Toolbar):
ctx = cbook.deprecated("3.3")(property(
lambda self: self.canvas.get_property("window").cairo_create()))
def __init__(self, canvas, window):
self.win = window
GObject.GObject.__init__(self)
self.set_style(Gtk.ToolbarStyle.ICONS)
self._gtk_ids = {}
for text, tooltip_text, image_file, callback in self.toolitems:
if text is None:
self.insert(Gtk.SeparatorToolItem(), -1)
continue
image = Gtk.Image.new_from_gicon(
Gio.Icon.new_for_string(
str(
cbook._get_data_path('images',
f'{image_file}-symbolic.svg'))),
Gtk.IconSize.LARGE_TOOLBAR)
self._gtk_ids[text] = tbutton = (Gtk.ToggleToolButton()
if callback in ['zoom', 'pan']
else Gtk.ToolButton())
tbutton.set_label(text)
tbutton.set_icon_widget(image)
self.insert(tbutton, -1)
# Save the handler id, so that we can block it as needed.
tbutton._signal_handler = tbutton.connect('clicked',
getattr(self, callback))
tbutton.set_tooltip_text(tooltip_text)
toolitem = Gtk.SeparatorToolItem()
self.insert(toolitem, -1)
toolitem.set_draw(False)
toolitem.set_expand(True)
# This filler item ensures the toolbar is always at least two text
# lines high. Otherwise the canvas gets redrawn as the mouse hovers
# over images because those use two-line messages which resize the
# toolbar.
toolitem = Gtk.ToolItem()
self.insert(toolitem, -1)
label = Gtk.Label()
label.set_markup(
'<small>\N{NO-BREAK SPACE}\n\N{NO-BREAK SPACE}</small>')
toolitem.add(label)
toolitem = Gtk.ToolItem()
self.insert(toolitem, -1)
self.message = Gtk.Label()
toolitem.add(self.message)
self.show_all()
NavigationToolbar2.__init__(self, canvas)
def set_message(self, s):
escaped = GLib.markup_escape_text(s)
self.message.set_markup(f'<small>{escaped}</small>')
def set_cursor(self, cursor):
window = self.canvas.get_property("window")
if window is not None:
window.set_cursor(cursord[cursor])
Gtk.main_iteration()
def draw_rubberband(self, event, x0, y0, x1, y1):
height = self.canvas.figure.bbox.height
y1 = height - y1
y0 = height - y0
rect = [int(val) for val in (x0, y0, x1 - x0, y1 - y0)]
self.canvas._draw_rubberband(rect)
def remove_rubberband(self):
self.canvas._draw_rubberband(None)
def _update_buttons_checked(self):
for name, active in [("Pan", "PAN"), ("Zoom", "ZOOM")]:
button = self._gtk_ids.get(name)
if button:
with button.handler_block(button._signal_handler):
button.set_active(self.mode.name == active)
def pan(self, *args):
super().pan(*args)
self._update_buttons_checked()
def zoom(self, *args):
super().zoom(*args)
self._update_buttons_checked()
def save_figure(self, *args):
dialog = Gtk.FileChooserDialog(
title="Save the figure",
parent=self.canvas.get_toplevel(),
action=Gtk.FileChooserAction.SAVE,
buttons=(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_SAVE,
Gtk.ResponseType.OK),
)
for name, fmts \
in self.canvas.get_supported_filetypes_grouped().items():
ff = Gtk.FileFilter()
ff.set_name(name)
for fmt in fmts:
ff.add_pattern("*." + fmt)
dialog.add_filter(ff)
if self.canvas.get_default_filetype() in fmts:
dialog.set_filter(ff)
@functools.partial(dialog.connect, "notify::filter")
def on_notify_filter(*args):
name = dialog.get_filter().get_name()
fmt = self.canvas.get_supported_filetypes_grouped()[name][0]
dialog.set_current_name(
str(Path(dialog.get_current_name()).with_suffix("." + fmt)))
dialog.set_current_folder(mpl.rcParams["savefig.directory"])
dialog.set_current_name(self.canvas.get_default_filename())
dialog.set_do_overwrite_confirmation(True)
response = dialog.run()
fname = dialog.get_filename()
ff = dialog.get_filter() # Doesn't autoadjust to filename :/
fmt = self.canvas.get_supported_filetypes_grouped()[ff.get_name()][0]
dialog.destroy()
if response != Gtk.ResponseType.OK:
return
# Save dir for next time, unless empty str (which means use cwd).
if mpl.rcParams['savefig.directory']:
mpl.rcParams['savefig.directory'] = os.path.dirname(fname)
try:
self.canvas.figure.savefig(fname, format=fmt)
except Exception as e:
error_msg_gtk(str(e), parent=self)
def set_history_buttons(self):
can_backward = self._nav_stack._pos > 0
can_forward = self._nav_stack._pos < len(self._nav_stack._elements) - 1
if 'Back' in self._gtk_ids:
self._gtk_ids['Back'].set_sensitive(can_backward)
if 'Forward' in self._gtk_ids:
self._gtk_ids['Forward'].set_sensitive(can_forward)
def get_proxy_renderer(self, renderer):
"""Return a PathEffectRenderer instance for this PathEffect."""
cbook.deprecated('v1.4', name='get_proxy_renderer',
alternative='PathEffectRenderer')
return PathEffectRenderer([self], renderer)
class RendererPS(_backend_pdf_ps.RendererPDFPSBase):
"""
The renderer handles all the drawing primitives using a graphics
context instance that controls the colors/styles.
"""
_afm_font_dir = cbook._get_data_path("fonts/afm")
_use_afm_rc_name = "ps.useafm"
mathtext_parser = cbook.deprecated("3.4")(
property(lambda self: MathTextParser("PS")))
used_characters = cbook.deprecated("3.3")(
property(lambda self: self._character_tracker.used_characters))
def __init__(self, width, height, pswriter, imagedpi=72):
# Although postscript itself is dpi independent, we need to inform the
# image code about a requested dpi to generate high resolution images
# and them scale them before embedding them.
super().__init__(width, height)
self._pswriter = pswriter
if mpl.rcParams['text.usetex']:
self.textcnt = 0
self.psfrag = []
self.imagedpi = imagedpi
# current renderer state (None=uninitialised)
self.color = None
self.linewidth = None
self.linejoin = None
self.linecap = None
self.linedash = None
self.fontname = None
self.fontsize = None
self._hatches = {}
self.image_magnification = imagedpi / 72
self._clip_paths = {}
self._path_collection_id = 0
self._character_tracker = _backend_pdf_ps.CharacterTracker()
@_api.deprecated("3.3")
def track_characters(self, *args, **kwargs):
"""Keep track of which characters are required from each font."""
self._character_tracker.track(*args, **kwargs)
@_api.deprecated("3.3")
def merge_used_characters(self, *args, **kwargs):
self._character_tracker.merge(*args, **kwargs)
def set_color(self, r, g, b, store=True):
if (r, g, b) != self.color:
if r == g and r == b:
self._pswriter.write("%1.3f setgray\n" % r)
else:
self._pswriter.write("%1.3f %1.3f %1.3f setrgbcolor\n" %
(r, g, b))
if store:
self.color = (r, g, b)
def set_linewidth(self, linewidth, store=True):
linewidth = float(linewidth)
if linewidth != self.linewidth:
self._pswriter.write("%1.3f setlinewidth\n" % linewidth)
if store:
self.linewidth = linewidth
@staticmethod
def _linejoin_cmd(linejoin):
# Support for directly passing integer values is for backcompat.
linejoin = {
'miter': 0,
'round': 1,
'bevel': 2,
0: 0,
1: 1,
2: 2
}[linejoin]
return f"{linejoin:d} setlinejoin\n"
def set_linejoin(self, linejoin, store=True):
if linejoin != self.linejoin:
self._pswriter.write(self._linejoin_cmd(linejoin))
if store:
self.linejoin = linejoin
@staticmethod
def _linecap_cmd(linecap):
# Support for directly passing integer values is for backcompat.
linecap = {
'butt': 0,
'round': 1,
'projecting': 2,
0: 0,
1: 1,
2: 2
}[linecap]
return f"{linecap:d} setlinecap\n"
def set_linecap(self, linecap, store=True):
if linecap != self.linecap:
self._pswriter.write(self._linecap_cmd(linecap))
if store:
self.linecap = linecap
def set_linedash(self, offset, seq, store=True):
if self.linedash is not None:
oldo, oldseq = self.linedash
if np.array_equal(seq, oldseq) and oldo == offset:
return
if seq is not None and len(seq):
s = "[%s] %d setdash\n" % (_nums_to_str(*seq), offset)
self._pswriter.write(s)
else:
self._pswriter.write("[] 0 setdash\n")
if store:
self.linedash = (offset, seq)
def set_font(self, fontname, fontsize, store=True):
if (fontname, fontsize) != (self.fontname, self.fontsize):
self._pswriter.write(f"/{fontname} {fontsize:1.3f} selectfont\n")
if store:
self.fontname = fontname
self.fontsize = fontsize
def create_hatch(self, hatch):
sidelen = 72
if hatch in self._hatches:
return self._hatches[hatch]
name = 'H%d' % len(self._hatches)
linewidth = mpl.rcParams['hatch.linewidth']
pageheight = self.height * 72
self._pswriter.write(f"""\
<< /PatternType 1
/PaintType 2
/TilingType 2
/BBox[0 0 {sidelen:d} {sidelen:d}]
/XStep {sidelen:d}
/YStep {sidelen:d}
/PaintProc {{
pop
{linewidth:f} setlinewidth
{self._convert_path(
Path.hatch(hatch), Affine2D().scale(sidelen), simplify=False)}
gsave
fill
grestore
stroke
}} bind
>>
matrix
0.0 {pageheight:f} translate
makepattern
/{name} exch def
""")
self._hatches[hatch] = name
return name
def get_image_magnification(self):
"""
Get the factor by which to magnify images passed to draw_image.
Allows a backend to have images at a different resolution to other
artists.
"""
return self.image_magnification
def draw_image(self, gc, x, y, im, transform=None):
# docstring inherited
h, w = im.shape[:2]
imagecmd = "false 3 colorimage"
data = im[::-1, :, :3] # Vertically flipped rgb values.
# data.tobytes().hex() has no spaces, so can be linewrapped by simply
# splitting data every nchars. It's equivalent to textwrap.fill only
# much faster.
nchars = 128
data = data.tobytes().hex()
hexlines = "\n".join([
data[n * nchars:(n + 1) * nchars]
for n in range(math.ceil(len(data) / nchars))
])
if transform is None:
matrix = "1 0 0 1 0 0"
xscale = w / self.image_magnification
yscale = h / self.image_magnification
else:
matrix = " ".join(map(str, transform.frozen().to_values()))
xscale = 1.0
yscale = 1.0
bbox = gc.get_clip_rectangle()
clippath, clippath_trans = gc.get_clip_path()
clip = []
if bbox is not None:
clip.append('%s clipbox' % _nums_to_str(*bbox.size, *bbox.p0))
if clippath is not None:
id = self._get_clip_path(clippath, clippath_trans)
clip.append('%s' % id)
clip = '\n'.join(clip)
self._pswriter.write(f"""\
gsave
{clip}
{x:f} {y:f} translate
[{matrix}] concat
{xscale:f} {yscale:f} scale
/DataString {w:d} string def
{w:d} {h:d} 8 [ {w:d} 0 0 -{h:d} 0 {h:d} ]
{{
currentfile DataString readhexstring pop
}} bind {imagecmd}
{hexlines}
grestore
""")
def _convert_path(self, path, transform, clip=False, simplify=None):
if clip:
clip = (0.0, 0.0, self.width * 72.0, self.height * 72.0)
else:
clip = None
return _path.convert_to_string(path, transform, clip, simplify, None,
6, [b'm', b'l', b'', b'c', b'cl'],
True).decode('ascii')
def _get_clip_path(self, clippath, clippath_transform):
key = (clippath, id(clippath_transform))
pid = self._clip_paths.get(key)
if pid is None:
pid = 'c%x' % len(self._clip_paths)
clippath_bytes = self._convert_path(clippath,
clippath_transform,
simplify=False)
self._pswriter.write(f"""\
/{pid} {{
{clippath_bytes}
clip
newpath
}} bind def
""")
self._clip_paths[key] = pid
return pid
def draw_path(self, gc, path, transform, rgbFace=None):
# docstring inherited
clip = rgbFace is None and gc.get_hatch_path() is None
simplify = path.should_simplify and clip
ps = self._convert_path(path, transform, clip=clip, simplify=simplify)
self._draw_ps(ps, gc, rgbFace)
def draw_markers(self,
gc,
marker_path,
marker_trans,
path,
trans,
rgbFace=None):
# docstring inherited
if debugPS:
self._pswriter.write('% draw_markers \n')
ps_color = (None if _is_transparent(rgbFace) else '%1.3f setgray' %
rgbFace[0] if rgbFace[0] == rgbFace[1] == rgbFace[2] else
'%1.3f %1.3f %1.3f setrgbcolor' % rgbFace[:3])
# construct the generic marker command:
# don't want the translate to be global
ps_cmd = ['/o {', 'gsave', 'newpath', 'translate']
lw = gc.get_linewidth()
alpha = (gc.get_alpha() if gc.get_forced_alpha()
or len(gc.get_rgb()) == 3 else gc.get_rgb()[3])
stroke = lw > 0 and alpha > 0
if stroke:
ps_cmd.append('%.1f setlinewidth' % lw)
ps_cmd.append(self._linejoin_cmd(gc.get_joinstyle()))
ps_cmd.append(self._linecap_cmd(gc.get_capstyle()))
ps_cmd.append(
self._convert_path(marker_path, marker_trans, simplify=False))
if rgbFace:
if stroke:
ps_cmd.append('gsave')
if ps_color:
ps_cmd.extend([ps_color, 'fill'])
if stroke:
ps_cmd.append('grestore')
if stroke:
ps_cmd.append('stroke')
ps_cmd.extend(['grestore', '} bind def'])
for vertices, code in path.iter_segments(trans,
clip=(0, 0, self.width * 72,
self.height * 72),
simplify=False):
if len(vertices):
x, y = vertices[-2:]
ps_cmd.append("%g %g o" % (x, y))
ps = '\n'.join(ps_cmd)
self._draw_ps(ps, gc, rgbFace, fill=False, stroke=False)
def draw_path_collection(self, gc, master_transform, paths, all_transforms,
offsets, offsetTrans, facecolors, edgecolors,
linewidths, linestyles, antialiaseds, urls,
offset_position):
# Is the optimization worth it? Rough calculation:
# cost of emitting a path in-line is
# (len_path + 2) * uses_per_path
# cost of definition+use is
# (len_path + 3) + 3 * uses_per_path
len_path = len(paths[0].vertices) if len(paths) > 0 else 0
uses_per_path = self._iter_collection_uses_per_path(
paths, all_transforms, offsets, facecolors, edgecolors)
should_do_optimization = \
len_path + 3 * uses_per_path + 3 < (len_path + 2) * uses_per_path
if not should_do_optimization:
return RendererBase.draw_path_collection(
self, gc, master_transform, paths, all_transforms, offsets,
offsetTrans, facecolors, edgecolors, linewidths, linestyles,
antialiaseds, urls, offset_position)
path_codes = []
for i, (path, transform) in enumerate(
self._iter_collection_raw_paths(master_transform, paths,
all_transforms)):
name = 'p%x_%x' % (self._path_collection_id, i)
path_bytes = self._convert_path(path, transform, simplify=False)
self._pswriter.write(f"""\
/{name} {{
newpath
translate
{path_bytes}
}} bind def
""")
path_codes.append(name)
for xo, yo, path_id, gc0, rgbFace in self._iter_collection(
gc, master_transform, all_transforms, path_codes, offsets,
offsetTrans, facecolors, edgecolors, linewidths, linestyles,
antialiaseds, urls, offset_position):
ps = "%g %g %s" % (xo, yo, path_id)
self._draw_ps(ps, gc0, rgbFace)
self._path_collection_id += 1
@_api.delete_parameter("3.3", "ismath")
def draw_tex(self, gc, x, y, s, prop, angle, ismath='TeX!', mtext=None):
# docstring inherited
if not hasattr(self, "psfrag"):
_log.warning(
"The PS backend determines usetex status solely based on "
"rcParams['text.usetex'] and does not support having "
"usetex=True only for some elements; this element will thus "
"be rendered as if usetex=False.")
self.draw_text(gc, x, y, s, prop, angle, False, mtext)
return
w, h, bl = self.get_text_width_height_descent(s, prop, ismath="TeX")
fontsize = prop.get_size_in_points()
thetext = 'psmarker%d' % self.textcnt
color = '%1.3f,%1.3f,%1.3f' % gc.get_rgb()[:3]
fontcmd = {
'sans-serif': r'{\sffamily %s}',
'monospace': r'{\ttfamily %s}'
}.get(mpl.rcParams['font.family'][0], r'{\rmfamily %s}')
s = fontcmd % s
tex = r'\color[rgb]{%s} %s' % (color, s)
corr = 0 # w/2*(fontsize-10)/10
if dict.__getitem__(mpl.rcParams, 'text.latex.preview'):
# use baseline alignment!
pos = _nums_to_str(x - corr, y)
self.psfrag.append(
r'\psfrag{%s}[Bl][Bl][1][%f]{\fontsize{%f}{%f}%s}' %
(thetext, angle, fontsize, fontsize * 1.25, tex))
else:
# Stick to the bottom alignment.
pos = _nums_to_str(x - corr, y - bl)
self.psfrag.append(
r'\psfrag{%s}[bl][bl][1][%f]{\fontsize{%f}{%f}%s}' %
(thetext, angle, fontsize, fontsize * 1.25, tex))
self._pswriter.write(f"""\
gsave
{pos} moveto
({thetext})
show
grestore
""")
self.textcnt += 1
def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
# docstring inherited
if debugPS:
self._pswriter.write("% text\n")
if _is_transparent(gc.get_rgb()):
return # Special handling for fully transparent.
if ismath == 'TeX':
return self.draw_tex(gc, x, y, s, prop, angle)
if ismath:
return self.draw_mathtext(gc, x, y, s, prop, angle)
if mpl.rcParams['ps.useafm']:
font = self._get_font_afm(prop)
scale = 0.001 * prop.get_size_in_points()
thisx = 0
last_name = None # kerns returns 0 for None.
xs_names = []
for c in s:
name = uni2type1.get(ord(c), f"uni{ord(c):04X}")
try:
width = font.get_width_from_char_name(name)
except KeyError:
name = 'question'
width = font.get_width_char('?')
kern = font.get_kern_dist_from_name(last_name, name)
last_name = name
thisx += kern * scale
xs_names.append((thisx, name))
thisx += width * scale
else:
font = self._get_font_ttf(prop)
font.set_text(s, 0, flags=LOAD_NO_HINTING)
self._character_tracker.track(font, s)
xs_names = [(item.x, font.get_glyph_name(item.glyph_idx))
for item in _text_layout.layout(s, font)]
self.set_color(*gc.get_rgb())
ps_name = (font.postscript_name.encode("ascii",
"replace").decode("ascii"))
self.set_font(ps_name, prop.get_size_in_points())
thetext = "\n".join(f"{x:f} 0 m /{name:s} glyphshow"
for x, name in xs_names)
self._pswriter.write(f"""\
gsave
{x:f} {y:f} translate
{angle:f} rotate
{thetext}
grestore
""")
def draw_mathtext(self, gc, x, y, s, prop, angle):
"""Draw the math text using matplotlib.mathtext."""
if debugPS:
self._pswriter.write("% mathtext\n")
width, height, descent, glyphs, rects = \
self._text2path.mathtext_parser.parse(
s, 72, prop,
_force_standard_ps_fonts=mpl.rcParams["ps.useafm"])
self.set_color(*gc.get_rgb())
self._pswriter.write(f"gsave\n"
f"{x:f} {y:f} translate\n"
f"{angle:f} rotate\n")
lastfont = None
for font, fontsize, num, ox, oy in glyphs:
self._character_tracker.track(font, chr(num))
if (font.postscript_name, fontsize) != lastfont:
lastfont = font.postscript_name, fontsize
self._pswriter.write(
f"/{font.postscript_name} {fontsize} selectfont\n")
symbol_name = (font.get_name_char(chr(num)) if isinstance(
font, AFM) else font.get_glyph_name(font.get_char_index(num)))
self._pswriter.write(f"{ox:f} {oy:f} moveto\n"
f"/{symbol_name} glyphshow\n")
for ox, oy, w, h in rects:
self._pswriter.write(f"{ox} {oy} {w} {h} rectfill\n")
self._pswriter.write("grestore\n")
def draw_gouraud_triangle(self, gc, points, colors, trans):
self.draw_gouraud_triangles(gc, points.reshape((1, 3, 2)),
colors.reshape((1, 3, 4)), trans)
def draw_gouraud_triangles(self, gc, points, colors, trans):
assert len(points) == len(colors)
assert points.ndim == 3
assert points.shape[1] == 3
assert points.shape[2] == 2
assert colors.ndim == 3
assert colors.shape[1] == 3
assert colors.shape[2] == 4
shape = points.shape
flat_points = points.reshape((shape[0] * shape[1], 2))
flat_points = trans.transform(flat_points)
flat_colors = colors.reshape((shape[0] * shape[1], 4))
points_min = np.min(flat_points, axis=0) - (1 << 12)
points_max = np.max(flat_points, axis=0) + (1 << 12)
factor = np.ceil((2**32 - 1) / (points_max - points_min))
xmin, ymin = points_min
xmax, ymax = points_max
streamarr = np.empty(shape[0] * shape[1],
dtype=[('flags', 'u1'), ('points', '2>u4'),
('colors', '3u1')])
streamarr['flags'] = 0
streamarr['points'] = (flat_points - points_min) * factor
streamarr['colors'] = flat_colors[:, :3] * 255.0
stream = quote_ps_string(streamarr.tobytes())
self._pswriter.write(f"""\
gsave
<< /ShadingType 4
/ColorSpace [/DeviceRGB]
/BitsPerCoordinate 32
/BitsPerComponent 8
/BitsPerFlag 8
/AntiAlias true
/Decode [ {xmin:f} {xmax:f} {ymin:f} {ymax:f} 0 1 0 1 0 1 ]
/DataSource ({stream})
>>
shfill
grestore
""")
def _draw_ps(self, ps, gc, rgbFace, fill=True, stroke=True, command=None):
"""
Emit the PostScript snippet 'ps' with all the attributes from 'gc'
applied. 'ps' must consist of PostScript commands to construct a path.
The fill and/or stroke kwargs can be set to False if the
'ps' string already includes filling and/or stroking, in
which case _draw_ps is just supplying properties and
clipping.
"""
# local variable eliminates all repeated attribute lookups
write = self._pswriter.write
if debugPS and command:
write("% " + command + "\n")
mightstroke = (gc.get_linewidth() > 0
and not _is_transparent(gc.get_rgb()))
if not mightstroke:
stroke = False
if _is_transparent(rgbFace):
fill = False
hatch = gc.get_hatch()
if mightstroke:
self.set_linewidth(gc.get_linewidth())
self.set_linejoin(gc.get_joinstyle())
self.set_linecap(gc.get_capstyle())
self.set_linedash(*gc.get_dashes())
self.set_color(*gc.get_rgb()[:3])
write('gsave\n')
cliprect = gc.get_clip_rectangle()
if cliprect:
write('%1.4g %1.4g %1.4g %1.4g clipbox\n' %
(*cliprect.size, *cliprect.p0))
clippath, clippath_trans = gc.get_clip_path()
if clippath:
id = self._get_clip_path(clippath, clippath_trans)
write('%s\n' % id)
# Jochen, is the strip necessary? - this could be a honking big string
write(ps.strip())
write("\n")
if fill:
if stroke or hatch:
write("gsave\n")
self.set_color(*rgbFace[:3], store=False)
write("fill\n")
if stroke or hatch:
write("grestore\n")
if hatch:
hatch_name = self.create_hatch(hatch)
write("gsave\n")
write("%f %f %f " % gc.get_hatch_color()[:3])
write("%s setpattern fill grestore\n" % hatch_name)
if stroke:
write("stroke\n")
write("grestore\n")
import sys
import textwrap
import traceback
from docutils.parsers.rst import directives, Directive
from docutils.parsers.rst.directives.images import Image
import jinja2 # Sphinx dependency.
import matplotlib
from matplotlib.backend_bases import FigureManagerBase
import matplotlib.pyplot as plt
from matplotlib import _pylab_helpers, cbook
matplotlib.use("agg")
align = cbook.deprecated(
"3.4", alternative="docutils.parsers.rst.directives.images.Image.align")(
Image.align)
__version__ = 2
# -----------------------------------------------------------------------------
# Registration hook
# -----------------------------------------------------------------------------
def _option_boolean(arg):
if not arg or not arg.strip():
# no argument given, assume used as a flag
return True
elif arg.strip().lower() in ('no', '0', 'false'):
return False
class NoNorm(Normalize):
"""
Dummy replacement for Normalize, for the case where we
want to use indices directly in a
:class:`~matplotlib.cm.ScalarMappable` .
"""
def __call__(self, value, clip=None):
return value
def inverse(self, value):
return value
# compatibility with earlier class names that violated convention:
normalize = cbook.deprecated("1.3", alternative="Normalize", name="normalize", obj_type="class alias")(Normalize)
no_norm = cbook.deprecated("1.3", alternative="NoNorm", name="no_norm", obj_type="class alias")(NoNorm)
def rgb_to_hsv(arr):
"""
convert rgb values in a numpy array to hsv values
input and output arrays should have shape (M,N,3)
"""
out = np.zeros(arr.shape, dtype=np.float)
arr_max = arr.max(-1)
ipos = arr_max > 0
delta = arr.ptp(-1)
s = np.zeros_like(delta)
s[ipos] = delta[ipos] / arr_max[ipos]
ipos = delta > 0