matplotlib.github.com/3.4.1/_modules/matplotlib/texmanager.html at main · ACPMAD/matplotlib.github.com

History

537 lines (455 loc) · 72.2 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<head>

<title>matplotlib.texmanager — Matplotlib 3.4.1 documentation</title>

title="Search within Matplotlib 3.4.1 documentation"

href="../../_static/opensearch.xml"/>

</head><body>

<div id="unreleased-message"> You are reading an old version of the documentation (v3.4.1). For the latest version see <a href="/stable/">https://matplotlib.org/stable/</a> </div>

<!--

</div>

-->

<div style="float: left; position: absolute; width: 496px; bottom: 0; padding-bottom: 24px">Version 3.4.1</div>

<div id="forkongithub"><a href="https://github.com/matplotlib/matplotlib">Fork me on GitHub</a></div>

</div>

<ul>

<li><a href="../../users/installing.html">Installation</a></li>

<li><a href="../../contents.html">Documentation</a></li>

<li><a href="../../gallery/index.html">Examples</a></li>

<li><a href="../../tutorials/index.html">Tutorials</a></li>

<li><a href="../../devel/index.html">Contributing</a></li>

</form>

</li>

</ul>

</nav>

<h3>Navigation</h3>

<ul>

<a href="../../genindex.html" title="General Index"

accesskey="I">index</a></li>

<a href="../../py-modindex.html" title="Python Module Index"

>modules</a> |</li>

<li><a href="../../contents.html">contents</a> »</li>

<li class="nav-item nav-item-1"><a href="../index.html" >Module code</a> »</li>

<li class="nav-item nav-item-2"><a href="../matplotlib.html" accesskey="U">matplotlib</a> »</li>

<li class="nav-item nav-item-this"><a href="">matplotlib.texmanager</a></li>

</ul>

</div>

</div>

<h1>Source code for matplotlib.texmanager</h1><div class="highlight"><pre>

r"""

Support for embedded TeX expressions in Matplotlib via dvipng and dvips for the

raster and PostScript backends. The tex and dvipng/dvips information is cached

in ~/.matplotlib/tex.cache for reuse between sessions.

Requirements:

* LaTeX

* \*Agg backends: dvipng>=1.6

* PS backend: psfrag, dvips, and Ghostscript>=9.0

For raster output, you can get RGBA numpy arrays from TeX expressions

as follows::

texmanager = TexManager()

s = "\TeX\ is Number $\displaystyle\sum_{n=1}^\infty\frac{-e^{i\pi}}{2^n}$!"

Z = texmanager.get_rgba(s, fontsize=12, dpi=80, rgb=(1, 0, 0))

To enable TeX rendering of all text in your Matplotlib figure, set

:rc:`text.usetex` to True.

"""

import functools

import glob

import hashlib

import logging

import os

from pathlib import Path

import re

import subprocess

from tempfile import TemporaryDirectory

import numpy as np

import matplotlib as mpl

from matplotlib import _api, cbook, dviread, rcParams

_log = logging.getLogger(__name__)

<div class="viewcode-block" id="TexManager"><a class="viewcode-back" href="../../api/texmanager_api.html#matplotlib.texmanager.TexManager">[docs]</a>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 = _api.deprecated(

"3.3", alternative="matplotlib.get_cachedir()")(

property(lambda self: mpl.get_cachedir()))

rgba_arrayd = _api.deprecated("3.3")(property(lambda self: {}))

_fonts = {} # Only for deprecation period.

serif = _api.deprecated("3.3")(property(

lambda self: self._fonts.get("serif", ('cmr', ''))))

sans_serif = _api.deprecated("3.3")(property(

lambda self: self._fonts.get("sans-serif", ('cmss', ''))))

cursive = _api.deprecated("3.3")(property(

lambda self:

self._fonts.get("cursive", ('pzc', r'\usepackage{chancery}'))))

monospace = _api.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)

<div class="viewcode-block" id="TexManager.get_font_config"><a class="viewcode-back" href="../../api/texmanager_api.html#matplotlib.texmanager.TexManager.get_font_config">[docs]</a> 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)

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)</div>

<div class="viewcode-block" id="TexManager.get_basefile"><a class="viewcode-back" href="../../api/texmanager_api.html#matplotlib.texmanager.TexManager.get_basefile">[docs]</a> 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())</div>

<div class="viewcode-block" id="TexManager.get_font_preamble"><a class="viewcode-back" href="../../api/texmanager_api.html#matplotlib.texmanager.TexManager.get_font_preamble">[docs]</a> def get_font_preamble(self):

"""

Return a string containing font configuration for the tex preamble.

"""

return self._font_preamble</div>

<div class="viewcode-block" id="TexManager.get_custom_preamble"><a class="viewcode-back" href="../../api/texmanager_api.html#matplotlib.texmanager.TexManager.get_custom_preamble">[docs]</a> def get_custom_preamble(self):

"""Return a string containing user additions to the tex preamble."""

return rcParams['text.latex.preamble']</div>

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",

])

<div class="viewcode-block" id="TexManager.make_tex"><a class="viewcode-back" href="../../api/texmanager_api.html#matplotlib.texmanager.TexManager.make_tex">[docs]</a> 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</div>

_re_vbox = re.compile(

r"MatplotlibBox:$([\d.]+)pt\+([\d.]+)pt$x([\d.]+)pt")

<div class="viewcode-block" id="TexManager.make_tex_preview"><a class="viewcode-back" href="../../api/texmanager_api.html#matplotlib.texmanager.TexManager.make_tex_preview">[docs]</a> @_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.

"""

texfile = '%s.tex' % basefile

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}

encoding='utf-8')

return texfile</div>

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

<div class="viewcode-block" id="TexManager.make_dvi"><a class="viewcode-back" href="../../api/texmanager_api.html#matplotlib.texmanager.TexManager.make_dvi">[docs]</a> 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)

dvifile = '%s.dvi' % basefile

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</div>

<div class="viewcode-block" id="TexManager.make_dvi_preview"><a class="viewcode-back" href="../../api/texmanager_api.html#matplotlib.texmanager.TexManager.make_dvi_preview">[docs]</a> @_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.

"""

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(

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</div>

<div class="viewcode-block" id="TexManager.make_png"><a class="viewcode-back" href="../../api/texmanager_api.html#matplotlib.texmanager.TexManager.make_png">[docs]</a> def make_png(self, tex, fontsize, dpi):

"""

Generate a png file containing latex's rendering of tex string.

Return the file name.

"""

pngfile = '%s.png' % basefile

# see get_rgba for a discussion of the background

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</div>

<div class="viewcode-block" id="TexManager.get_grey"><a class="viewcode-back" href="../../api/texmanager_api.html#matplotlib.texmanager.TexManager.get_grey">[docs]</a> 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</div>

<div class="viewcode-block" id="TexManager.get_rgba"><a class="viewcode-back" href="../../api/texmanager_api.html#matplotlib.texmanager.TexManager.get_rgba">[docs]</a> 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</div>

<div class="viewcode-block" id="TexManager.get_text_width_height_descent"><a class="viewcode-back" href="../../api/texmanager_api.html#matplotlib.texmanager.TexManager.get_text_width_height_descent">[docs]</a> 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

# use preview.sty

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.

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</div></div>

</pre></div>

</div>

</div>

Last updated on Mar 31, 2021.

Created using

<a href="http://sphinx-doc.org/">Sphinx</a> 3.2.1.

Doc version v3.4.1-3-gc6d08c6a8b-dirty.

</div>

</footer>

(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){

(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),

m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)

})(window,document,'script','//www.google-analytics.com/analytics.js','ga');

ga('create', 'UA-55954603-1', 'auto');

ga('send', 'pageview');

</script>

</body>

</html>

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

FilesExpand file tree

texmanager.html

Latest commit

History

texmanager.html

File metadata and controls