matplotlib.backends.backend_ps

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

matplotlib.backends.backend_ps.FigureCanvas

alias of matplotlib.backends.backend_ps.FigureCanvasPS

class matplotlib.backends.backend_ps.FigureCanvasPS(figure)

Bases: matplotlib.backend_bases.FigureCanvasBase

draw()

filetypes = {u'eps': u'Encapsulated Postscript', u'ps': u'Postscript'}

fixed_dpi = 72

get_default_filetype()

print_eps(outfile, *args, **kwargs)

print_ps(outfile, *args, **kwargs)

matplotlib.backends.backend_ps.FigureManager

alias of matplotlib.backends.backend_ps.FigureManagerPS

class matplotlib.backends.backend_ps.FigureManagerPS(canvas, num)

Bases: matplotlib.backend_bases.FigureManagerBase

class matplotlib.backends.backend_ps.GraphicsContextPS

Bases: matplotlib.backend_bases.GraphicsContextBase

get_capstyle()

get_joinstyle()

shouldstroke()

class matplotlib.backends.backend_ps.PsBackendHelper

Bases: object

gs_exe

executable name of ghostscript.

gs_version

version of ghostscript.

supports_ps2write

True if the installed ghostscript supports ps2write device.

class matplotlib.backends.backend_ps.RendererPS(width, height, pswriter, imagedpi=72)

Bases: matplotlib.backend_bases.RendererBase

The renderer handles all the drawing primitives using a graphics context instance that controls the colors/styles.

Although postscript itself is dpi independent, we need to imform the image code about a requested dpi to generate high res images and them scale them before embeddin them

afmfontd = {}

create_hatch(hatch)

draw_gouraud_triangle(gc, points, colors, trans)

draw_gouraud_triangles(gc, points, colors, trans)

draw_image(gc, x, y, im, transform=None)

Draw the Image instance into the current axes; x is the distance in pixels from the left hand side of the canvas and y is the distance from bottom

draw_markers(gc, marker_path, marker_trans, path, trans, rgbFace=None)

Draw the markers defined by path at each of the positions in x and y. path coordinates are points, x and y coords will be transformed by the transform

draw_mathtext(gc, x, y, s, prop, angle)

Draw the math text using matplotlib.mathtext

draw_path(gc, path, transform, rgbFace=None)

Draws a Path instance using the given affine transform.

draw_path_collection(gc, master_transform, paths, all_transforms, offsets, offsetTrans, facecolors, edgecolors, linewidths, linestyles, antialiaseds, urls, offset_position)

draw_tex(gc, x, y, s, prop, angle, ismath=u'TeX!', mtext=None)

draw a Text instance

draw_text(gc, x, y, s, prop, angle, ismath=False, mtext=None)

Draw a Text instance.

flipy()

return true if small y numbers are top for renderer

get_canvas_width_height()

return the canvas width and height in display coords

get_image_magnification()

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.

get_text_width_height_descent(s, prop, ismath)

get the width and height in display coords of the string s with FontPropertry prop

merge_used_characters(other)

new_gc()

option_image_nocomposite()

return whether to generate a composite image from multiple images on a set of axes

option_scale_image()

ps backend support arbitrary scaling of image.

set_color(r, g, b, store=1)

set_font(fontname, fontsize, store=1)

set_linecap(linecap, store=1)

set_linedash(offset, seq, store=1)

set_linejoin(linejoin, store=1)

set_linewidth(linewidth, store=1)

track_characters(font, s)

Keeps track of which characters are required from each font.

matplotlib.backends.backend_ps.convert_psfrags(tmpfile, psfrags, font_preamble, custom_preamble, paperWidth, paperHeight, orientation)

When we want to use the LaTeX backend with postscript, we write PSFrag tags to a temporary postscript file, each one marking a position for LaTeX to render some text. convert_psfrags generates a LaTeX document containing the commands to convert those tags to text. LaTeX/dvips produces the postscript file that includes the actual text.

matplotlib.backends.backend_ps.get_bbox(tmpfile, bbox)

Use ghostscript's bbox device to find the center of the bounding box. Return an appropriately sized bbox centered around that point. A bit of a hack.

matplotlib.backends.backend_ps.get_bbox_header(lbrt, rotated=False)

return a postscript header stringfor the given bbox lbrt=(l, b, r, t). Optionally, return rotate command.

matplotlib.backends.backend_ps.gs_distill(tmpfile, eps=False, ptype=u'letter', bbox=None, rotated=False)

Use ghostscript's pswrite or epswrite device to distill a file. This yields smaller files without illegal encapsulated postscript operators. The output is low-level, converting text to outlines.

matplotlib.backends.backend_ps.pstoeps(tmpfile, bbox=None, rotated=False)

Convert the postscript to encapsulated postscript. The bbox of the eps file will be replaced with the given bbox argument. If None, original bbox will be used.

matplotlib.backends.backend_ps.quote_ps_string(s)

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

matplotlib.backends.backend_ps.xpdf_distill(tmpfile, eps=False, ptype=u'letter', bbox=None, rotated=False)

Use ghostscript's ps2pdf and xpdf's/poppler's pdftops to distill a file. This yields smaller files without illegal encapsulated postscript operators. This distiller is preferred, generating high-level postscript output that treats text as text.