"""

A PostScript backend, which can produce both PostScript .ps and .eps.

"""

import datetime

from enum import Enum

import glob

from io import StringIO, TextIOWrapper

import logging

import math

import os

import pathlib

import re

import shutil

from tempfile import TemporaryDirectory

import time

import numpy as np

import matplotlib as mpl

from matplotlib import _api, cbook, _path

from matplotlib import _text_layout

from matplotlib.afm import AFM

from matplotlib.backend_bases import (

_Backend, _check_savefig_extra_args, FigureCanvasBase, FigureManagerBase,

GraphicsContextBase, RendererBase, _no_output_draw)

from matplotlib.cbook import is_writable_file_like, file_requires_unicode

from matplotlib.font_manager import get_font

from matplotlib.ft2font import LOAD_NO_HINTING, LOAD_NO_SCALE

from matplotlib._ttconv import convert_ttf_to_ps

from matplotlib.mathtext import MathTextParser

from matplotlib._mathtext_data import uni2type1

from matplotlib.path import Path

from matplotlib.texmanager import TexManager

from matplotlib.transforms import Affine2D

from matplotlib.backends.backend_mixed import MixedModeRenderer

from . import _backend_pdf_ps

_log = logging.getLogger(__name__)

backend_version = 'Level II'

debugPS = 0

class PsBackendHelper:

def __init__(self):

self._cached = {}

ps_backend_helper = PsBackendHelper()

papersize = {'letter': (8.5, 11),

'legal': (8.5, 14),

'ledger': (11, 17),

'a0': (33.11, 46.81),

'a1': (23.39, 33.11),

'a2': (16.54, 23.39),

'a3': (11.69, 16.54),

'a4': (8.27, 11.69),

'a5': (5.83, 8.27),

'a6': (4.13, 5.83),

'a7': (2.91, 4.13),

'a8': (2.07, 2.91),

'a9': (1.457, 2.05),

'a10': (1.02, 1.457),

'b0': (40.55, 57.32),

'b1': (28.66, 40.55),

'b2': (20.27, 28.66),

'b3': (14.33, 20.27),

'b4': (10.11, 14.33),

'b5': (7.16, 10.11),

'b6': (5.04, 7.16),

'b7': (3.58, 5.04),

'b8': (2.51, 3.58),

'b9': (1.76, 2.51),

'b10': (1.26, 1.76)}

def _get_papertype(w, h):

for key, (pw, ph) in sorted(papersize.items(), reverse=True):

if key.startswith('l'):

continue

if w < pw and h < ph:

return key

return 'a0'

def _num_to_str(val):

if isinstance(val, str):

return val

ival = int(val)

if val == ival:

return str(ival)

s = "%1.3f" % val

s = s.rstrip("0")

s = s.rstrip(".")

return s

def _nums_to_str(*args):

return ' '.join(map(_num_to_str, args))

def quote_ps_string(s):

"""

Quote dangerous characters of S for use in a PostScript string constant.

"""

s = s.replace(b"\\", b"\\\\")

s = s.replace(b"(", b"\\(")

s = s.replace(b")", b"\\)")

s = s.replace(b"'", b"\\251")

s = s.replace(b"`", b"\\301")

s = re.sub(br"[^ -~\n]", lambda x: br"\%03o" % ord(x.group()), s)

return s.decode('ascii')

def _move_path_to_path_or_stream(src, dst):

"""

Move the contents of file at *src* to path-or-filelike *dst*.

If *dst* is a path, the metadata of *src* are *not* copied.

"""

if is_writable_file_like(dst):

fh = (open(src, 'r', encoding='latin-1')

if file_requires_unicode(dst)

else open(src, 'rb'))

with fh:

shutil.copyfileobj(fh, dst)

else:

shutil.move(src, dst, copy_function=shutil.copyfile)

def _font_to_ps_type3(font_path, glyph_ids):

"""

Subset *glyph_ids* from the font at *font_path* into a Type 3 font.

Parameters

----------

font_path : path-like

Path to the font to be subsetted.

glyph_ids : list of int

The glyph indices to include in the subsetted font.

Returns

-------

str

The string representation of a Type 3 font, which can be included

verbatim into a PostScript file.

"""

font = get_font(font_path, hinting_factor=1)

preamble = """\

%!PS-Adobe-3.0 Resource-Font

%%Creator: Converted from TrueType to Type 3 by Matplotlib.

10 dict begin

/FontName /{font_name} def

/PaintType 0 def

/FontMatrix [{inv_units_per_em} 0 0 {inv_units_per_em} 0 0] def

/FontBBox [{bbox}] def

/FontType 3 def

/Encoding [{encoding}] def

/CharStrings {num_glyphs} dict dup begin

/.notdef 0 def

""".format(font_name=font.postscript_name,

inv_units_per_em=1 / font.units_per_EM,

bbox=" ".join(map(str, font.bbox)),

encoding=" ".join("/{}".format(font.get_glyph_name(glyph_id))

for glyph_id in glyph_ids),

num_glyphs=len(glyph_ids) + 1)

postamble = """

end readonly def

/BuildGlyph {

exch begin

CharStrings exch

2 copy known not {pop /.notdef} if

true 3 1 roll get exec

end

} _d

/BuildChar {

1 index /Encoding get exch get

1 index /BuildGlyph get exec

} _d

FontName currentdict end definefont pop

"""

entries = []

for glyph_id in glyph_ids:

g = font.load_glyph(glyph_id, LOAD_NO_SCALE)

v, c = font.get_path()

entries.append(

"/%(name)s{%(bbox)s sc\n" % {

"name": font.get_glyph_name(glyph_id),

"bbox": " ".join(map(str, [g.horiAdvance, 0, *g.bbox])),

}

+ _path.convert_to_string(

# Convert back to TrueType's internal units (1/64's).

# (Other dimensions are already in these units.)

Path(v * 64, c), None, None, False, None, 0,

# No code for quad Beziers triggers auto-conversion to cubics.

# Drop intermediate closepolys (relying on the outline

# decomposer always explicitly moving to the closing point

# first).

[b"m", b"l", b"", b"c", b""], True).decode("ascii")

+ "ce} _d"

)

return preamble + "\n".join(entries) + postamble

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 = _api.deprecated("3.4")(property(

lambda self: MathTextParser("PS")))

used_characters = _api.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 _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_cmd(self, gc):

clip = []

rect = gc.get_clip_rectangle()

if rect is not None:

clip.append("%s clipbox\n" % _nums_to_str(*rect.size, *rect.p0))

path, trf = gc.get_clip_path()

if path is not None:

key = (path, id(trf))

custom_clip_cmd = self._clip_paths.get(key)

if custom_clip_cmd is None:

custom_clip_cmd = "c%x" % len(self._clip_paths)

self._pswriter.write(f"""\

/{custom_clip_cmd} {{

{self._convert_path(path, trf, simplify=False)}

clip

newpath

}} bind def

""")

self._clip_paths[key] = custom_clip_cmd

clip.append(f"{custom_clip_cmd}\n")

return "".join(clip)

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

self._pswriter.write(f"""\

gsave

{self._get_clip_cmd(gc)}

{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 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

{self._get_clip_cmd(gc)}

{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')

write(self._get_clip_cmd(gc))

# 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")

def _is_transparent(rgb_or_rgba):

if rgb_or_rgba is None:

return True # Consistent with rgbFace semantics.

elif len(rgb_or_rgba) == 4:

if rgb_or_rgba[3] == 0:

return True

if rgb_or_rgba[3] != 1:

_log.warning(

"The PostScript backend does not support transparency; "

"partially transparent artists will be rendered opaque.")

return False

else: # len() == 3.

return False

@_api.deprecated("3.4", alternative="GraphicsContextBase")

class GraphicsContextPS(GraphicsContextBase):

def get_capstyle(self):

return {'butt': 0, 'round': 1, 'projecting': 2}[super().get_capstyle()]

def get_joinstyle(self):

return {'miter': 0, 'round': 1, 'bevel': 2}[super().get_joinstyle()]

class _Orientation(Enum):

portrait, landscape = range(2)

def swap_if_landscape(self, shape):

return shape[::-1] if self.name == "landscape" else shape

class FigureCanvasPS(FigureCanvasBase):

fixed_dpi = 72

filetypes = {'ps': 'Postscript',

'eps': 'Encapsulated Postscript'}

def get_default_filetype(self):

return 'ps'

def print_ps(self, outfile, *args, **kwargs):

return self._print_ps(outfile, 'ps', *args, **kwargs)

def print_eps(self, outfile, *args, **kwargs):

return self._print_ps(outfile, 'eps', *args, **kwargs)

@_api.delete_parameter("3.4", "dpi")

def _print_ps(

self, outfile, format, *args,

dpi=None, metadata=None, papertype=None, orientation='portrait',

**kwargs):

if dpi is None: # always use this branch after deprecation elapses.

dpi = self.figure.get_dpi()

self.figure.set_dpi(72) # Override the dpi kwarg

dsc_comments = {}

if isinstance(outfile, (str, os.PathLike)):

filename = pathlib.Path(outfile).name

dsc_comments["Title"] = \

filename.encode("ascii", "replace").decode("ascii")

dsc_comments["Creator"] = (metadata or {}).get(

"Creator",

f"Matplotlib v{mpl.__version__}, https://matplotlib.org/")

# See https://reproducible-builds.org/specs/source-date-epoch/

source_date_epoch = os.getenv("SOURCE_DATE_EPOCH")

dsc_comments["CreationDate"] = (

datetime.datetime.utcfromtimestamp(

int(source_date_epoch)).strftime("%a %b %d %H:%M:%S %Y")

if source_date_epoch

else time.ctime())

dsc_comments = "\n".join(

f"%%{k}: {v}" for k, v in dsc_comments.items())

if papertype is None:

papertype = mpl.rcParams['ps.papersize']

papertype = papertype.lower()

_api.check_in_list(['auto', *papersize], papertype=papertype)

orientation = _api.check_getitem(

_Orientation, orientation=orientation.lower())

printer = (self._print_figure_tex

if mpl.rcParams['text.usetex'] else

self._print_figure)

printer(outfile, format, dpi=dpi, dsc_comments=dsc_comments,

orientation=orientation, papertype=papertype, **kwargs)

@_check_savefig_extra_args

def _print_figure(

self, outfile, format, *,

dpi, dsc_comments, orientation, papertype,

bbox_inches_restore=None):

"""

Render the figure to a filesystem path or a file-like object.

Parameters are as for `.print_figure`, except that *dsc_comments* is a

all string containing Document Structuring Convention comments,

generated from the *metadata* parameter to `.print_figure`.

"""

is_eps = format == 'eps'

if isinstance(outfile, (str, os.PathLike)):

outfile = os.fspath(outfile)

passed_in_file_object = False

elif is_writable_file_like(outfile):

passed_in_file_object = True

else:

raise ValueError("outfile must be a path or a file-like object")

# find the appropriate papertype

width, height = self.figure.get_size_inches()

if papertype == 'auto':

papertype = _get_papertype(

*orientation.swap_if_landscape((width, height)))

paper_width, paper_height = orientation.swap_if_landscape(

papersize[papertype])

if mpl.rcParams['ps.usedistiller']:

# distillers improperly clip eps files if pagesize is too small

if width > paper_width or height > paper_height:

papertype = _get_papertype(

*orientation.swap_if_landscape((width, height)))

paper_width, paper_height = orientation.swap_if_landscape(

papersize[papertype])

# center the figure on the paper

xo = 72 * 0.5 * (paper_width - width)

yo = 72 * 0.5 * (paper_height - height)

llx = xo

lly = yo

urx = llx + self.figure.bbox.width

ury = lly + self.figure.bbox.height

rotation = 0

if orientation is _Orientation.landscape:

llx, lly, urx, ury = lly, llx, ury, urx

xo, yo = 72 * paper_height - yo, xo

rotation = 90

bbox = (llx, lly, urx, ury)

self._pswriter = StringIO()

# mixed mode rendering

ps_renderer = RendererPS(width, height, self._pswriter, imagedpi=dpi)

renderer = MixedModeRenderer(

self.figure, width, height, dpi, ps_renderer,

bbox_inches_restore=bbox_inches_restore)

self.figure.draw(renderer)

def print_figure_impl(fh):

# write the PostScript headers

if is_eps:

print("%!PS-Adobe-3.0 EPSF-3.0", file=fh)

else:

print(f"%!PS-Adobe-3.0\n"

f"%%DocumentPaperSizes: {papertype}\n"

f"%%Pages: 1\n",

end="", file=fh)

print(f"{dsc_comments}\n"

f"%%Orientation: {orientation.name}\n"

f"{get_bbox_header(bbox)[0]}\n"

f"%%EndComments\n",

end="", file=fh)

Ndict = len(psDefs)

print("%%BeginProlog", file=fh)

if not mpl.rcParams['ps.useafm']:

Ndict += len(ps_renderer._character_tracker.used)

print("/mpldict %d dict def" % Ndict, file=fh)

print("mpldict begin", file=fh)

print("\n".join(psDefs), file=fh)

if not mpl.rcParams['ps.useafm']:

for font_path, chars \

in ps_renderer._character_tracker.used.items():

if not chars:

continue

font = get_font(font_path)

glyph_ids = [font.get_char_index(c) for c in chars]

fonttype = mpl.rcParams['ps.fonttype']

# Can't use more than 255 chars from a single Type 3 font.

if len(glyph_ids) > 255:

fonttype = 42

fh.flush()

if fonttype == 3:

fh.write(_font_to_ps_type3(font_path, glyph_ids))

else:

try:

convert_ttf_to_ps(os.fsencode(font_path),

fh, fonttype, glyph_ids)

except RuntimeError:

_log.warning(

"The PostScript backend does not currently "

"support the selected font.")

raise

print("end", file=fh)

print("%%EndProlog", file=fh)

if not is_eps:

print("%%Page: 1 1", file=fh)

print("mpldict begin", file=fh)

print("%s translate" % _nums_to_str(xo, yo), file=fh)

if rotation:

print("%d rotate" % rotation, file=fh)

print("%s clipbox" % _nums_to_str(width*72, height*72, 0, 0),

file=fh)

# write the figure

print(self._pswriter.getvalue(), file=fh)

# write the trailer

print("end", file=fh)

print("showpage", file=fh)

if not is_eps: