| | |
- matplotlib.backend_bases.FigureCanvasBase
-
- FigureCanvasPS
- matplotlib.backend_bases.FigureManagerBase
-
- FigureManagerPS
- FigureManagerPS
- matplotlib.backend_bases.GraphicsContextBase
-
- GraphicsContextPS
- matplotlib.backend_bases.RendererBase
-
- RendererPS
class FigureCanvasPS(matplotlib.backend_bases.FigureCanvasBase) |
| | |
Methods defined here:
- draw(self)
- get_default_filetype(self)
- print_eps(self, outfile, *args, **kwargs)
- print_ps(self, outfile, *args, **kwargs)
Data and other attributes defined here:
- filetypes = {'eps': 'Encapsulated Postscript', 'ps': 'Postscript'}
Methods inherited from matplotlib.backend_bases.FigureCanvasBase:
- __init__(self, figure)
- blit(self, bbox=None)
- blit the canvas in bbox (default entire canvas)
- button_press_event(self, x, y, button, guiEvent=None)
- Backend derived classes should call this function on any mouse
button press. x,y are the canvas coords: 0,0 is lower, left.
button and key are as defined in :class:`MouseEvent`.
This method will be call all functions connected to the
'button_press_event' with a :class:`MouseEvent` instance.
- button_release_event(self, x, y, button, guiEvent=None)
- Backend derived classes should call this function on any mouse
button release.
*x*
the canvas coordinates where 0=left
*y*
the canvas coordinates where 0=bottom
*guiEvent*
the native UI event that generated the mpl event
This method will be call all functions connected to the
'button_release_event' with a :class:`MouseEvent` instance.
- draw_cursor(self, event)
- Draw a cursor in the event.axes if inaxes is not None. Use
native GUI drawing for efficiency if possible
- draw_event(self, renderer)
- This method will be call all functions connected to the
'draw_event' with a :class:`DrawEvent`
- draw_idle(self, *args, **kwargs)
- :meth:`draw` only if idle; defaults to draw but backends can overrride
- flush_events(self)
- Flush the GUI events for the figure. Implemented only for
backends with GUIs.
- get_supported_filetypes(self)
- get_supported_filetypes_grouped(self)
- get_width_height(self)
- return the figure width and height in points or pixels
(depending on the backend), truncated to integers
- idle_event(self, guiEvent=None)
- call when GUI is idle
- key_press_event(self, key, guiEvent=None)
- This method will be call all functions connected to the
'key_press_event' with a :class:`KeyEvent`
- key_release_event(self, key, guiEvent=None)
- This method will be call all functions connected to the
'key_release_event' with a :class:`KeyEvent`
- motion_notify_event(self, x, y, guiEvent=None)
- Backend derived classes should call this function on any
motion-notify-event.
*x*
the canvas coordinates where 0=left
*y*
the canvas coordinates where 0=bottom
*guiEvent*
the native UI event that generated the mpl event
This method will be call all functions connected to the
'motion_notify_event' with a :class:`MouseEvent` instance.
- mpl_connect(self, s, func)
- Connect event with string *s* to *func*. The signature of *func* is::
def func(event)
where event is a :class:`matplotlib.backend_bases.Event`. The
following events are recognized
- 'button_press_event'
- 'button_release_event'
- 'draw_event'
- 'key_press_event'
- 'key_release_event'
- 'motion_notify_event'
- 'pick_event'
- 'resize_event'
- 'scroll_event'
For the location events (button and key press/release), if the
mouse is over the axes, the variable ``event.inaxes`` will be
set to the :class:`~matplotlib.axes.Axes` the event occurs is
over, and additionally, the variables ``event.xdata`` and
``event.ydata`` will be defined. This is the mouse location
in data coords. See
:class:`~matplotlib.backend_bases.KeyEvent` and
:class:`~matplotlib.backend_bases.MouseEvent` for more info.
Return value is a connection id that can be used with
:meth:`~matplotlib.backend_bases.Event.mpl_disconnect`.
Example usage::
def on_press(event):
print 'you pressed', event.button, event.xdata, event.ydata
cid = canvas.mpl_connect('button_press_event', on_press)
- mpl_disconnect(self, cid)
- disconnect callback id cid
Example usage::
cid = canvas.mpl_connect('button_press_event', on_press)
#...later
canvas.mpl_disconnect(cid)
- onHilite(self, ev)
- Mouse event processor which highlights the artists
under the cursor. Connect this to the 'motion_notify_event'
using::
canvas.mpl_connect('motion_notify_event',canvas.onHilite)
- onRemove(self, ev)
- Mouse event processor which removes the top artist
under the cursor. Connect this to the 'mouse_press_event'
using::
canvas.mpl_connect('mouse_press_event',canvas.onRemove)
- pick(self, mouseevent)
- pick_event(self, mouseevent, artist, **kwargs)
- This method will be called by artists who are picked and will
fire off :class:`PickEvent` callbacks registered listeners
- print_bmp = print_raw(self, *args, **kwargs)
- print_emf(self, *args, **kwargs)
- print_figure(self, filename, dpi=None, facecolor='w', edgecolor='w', orientation='portrait', format=None, **kwargs)
- Render the figure to hardcopy. Set the figure patch face and edge
colors. This is useful because some of the GUIs have a gray figure
face color background and you'll probably want to override this on
hardcopy.
Arguments are:
*filename*
can also be a file object on image backends
*orientation*
only currently applies to PostScript printing.
*dpi*
the dots per inch to save the figure in; if None, use savefig.dpi
*facecolor*
the facecolor of the figure
*edgecolor*
the edgecolor of the figure
*orientation* '
landscape' | 'portrait' (not supported on all backends)
*format*
when set, forcibly set the file format to save to
- print_pdf(self, *args, **kwargs)
- print_png(self, *args, **kwargs)
- print_raw(self, *args, **kwargs)
- print_rgb = print_raw(self, *args, **kwargs)
- print_svg(self, *args, **kwargs)
- print_svgz(self, *args, **kwargs)
- resize(self, w, h)
- set the canvas size in pixels
- resize_event(self)
- This method will be call all functions connected to the
'resize_event' with a :class:`ResizeEvent`
- scroll_event(self, x, y, step, guiEvent=None)
- Backend derived classes should call this function on any
scroll wheel event. x,y are the canvas coords: 0,0 is lower,
left. button and key are as defined in MouseEvent.
This method will be call all functions connected to the
'scroll_event' with a :class:`MouseEvent` instance.
- set_window_title(self, title)
- Set the title text of the window containing the figure. Note that
this has no effect if there is no window (eg, a PS backend).
- start_event_loop(self, timeout)
- Start an event loop. This is used to start a blocking event
loop so that interactive functions, such as ginput and
waitforbuttonpress, can wait for events. This should not be
confused with the main GUI event loop, which is always running
and has nothing to do with this.
This is implemented only for backends with GUIs.
- start_event_loop_default(self, timeout=0)
- Start an event loop. This is used to start a blocking event
loop so that interactive functions, such as ginput and
waitforbuttonpress, can wait for events. This should not be
confused with the main GUI event loop, which is always running
and has nothing to do with this.
This function provides default event loop functionality based
on time.sleep that is meant to be used until event loop
functions for each of the GUI backends can be written. As
such, it throws a deprecated warning.
Call signature::
start_event_loop_default(self,timeout=0)
This call blocks until a callback function triggers
stop_event_loop() or *timeout* is reached. If *timeout* is
<=0, never timeout.
- stop_event_loop(self)
- Stop an event loop. This is used to stop a blocking event
loop so that interactive functions, such as ginput and
waitforbuttonpress, can wait for events.
This is implemented only for backends with GUIs.
- stop_event_loop_default(self)
- Stop an event loop. This is used to stop a blocking event
loop so that interactive functions, such as ginput and
waitforbuttonpress, can wait for events.
Call signature::
stop_event_loop_default(self)
- switch_backends(self, FigureCanvasClass)
- instantiate an instance of FigureCanvasClass
This is used for backend switching, eg, to instantiate a
FigureCanvasPS from a FigureCanvasGTK. Note, deep copying is
not done, so any changes to one of the instances (eg, setting
figure size or line props), will be reflected in the other
Data and other attributes inherited from matplotlib.backend_bases.FigureCanvasBase:
- events = ['resize_event', 'draw_event', 'key_press_event', 'key_release_event', 'button_press_event', 'button_release_event', 'scroll_event', 'motion_notify_event', 'pick_event', 'idle_event']
|
class GraphicsContextPS(matplotlib.backend_bases.GraphicsContextBase) |
| | |
Methods defined here:
- get_capstyle(self)
- get_joinstyle(self)
Methods inherited from matplotlib.backend_bases.GraphicsContextBase:
- __init__(self)
- copy_properties(self, gc)
- Copy properties from gc to self
- get_alpha(self)
- Return the alpha value used for blending - not supported on
all backends
- get_antialiased(self)
- Return true if the object should try to do antialiased rendering
- get_clip_path(self)
- Return the clip path in the form (path, transform), where path
is a :class:`~matplotlib.path.Path` instance, and transform is
an affine transform to apply to the path before clipping.
- get_clip_rectangle(self)
- Return the clip rectangle as a :class:`~matplotlib.transforms.Bbox` instance
- get_dashes(self)
- Return the dash information as an offset dashlist tuple The
dash list is a even size list that gives the ink on, ink off
in pixels. See p107 of to postscript `BLUEBOOK
<http://www-cdf.fnal.gov/offline/PostScript/BLUEBOOK.PDF>`_
for more info
Default value is None
- get_hatch(self)
- Gets the current hatch style
- get_linestyle(self, style)
- Return the linestyle: one of ('solid', 'dashed', 'dashdot',
'dotted').
- get_linewidth(self)
- Return the line width in points as a scalar
- get_rgb(self)
- returns a tuple of three floats from 0-1. color can be a
matlab format string, a html hex color string, or a rgb tuple
- set_alpha(self, alpha)
- Set the alpha value used for blending - not supported on
all backends
- set_antialiased(self, b)
- True if object should be drawn with antialiased rendering
- set_capstyle(self, cs)
- Set the capstyle as a string in ('butt', 'round', 'projecting')
- set_clip_path(self, path)
- Set the clip path and transformation. Path should be a
:class:`~matplotlib.transforms.TransformedPath` instance.
- set_clip_rectangle(self, rectangle)
- Set the clip rectangle with sequence (left, bottom, width, height)
- set_dashes(self, dash_offset, dash_list)
- Set the dash style for the gc.
*dash_offset*
is the offset (usually 0).
*dash_list*
specifies the on-off sequence as points. ``(None, None)`` specifies a solid line
- set_foreground(self, fg, isRGB=False)
- Set the foreground color. fg can be a matlab format string, a
html hex color string, an rgb unit tuple, or a float between 0
and 1. In the latter case, grayscale is used.
The :class:`GraphicsContextBase` converts colors to rgb
internally. If you know the color is rgb already, you can set
``isRGB=True`` to avoid the performace hit of the conversion
- set_graylevel(self, frac)
- Set the foreground color to be a gray level with *frac*
- set_hatch(self, hatch)
- Sets the hatch style for filling
- set_joinstyle(self, js)
- Set the join style to be one of ('miter', 'round', 'bevel')
- set_linestyle(self, style)
- Set the linestyle to be one of ('solid', 'dashed', 'dashdot',
'dotted').
- set_linewidth(self, w)
- Set the linewidth in points
Data and other attributes inherited from matplotlib.backend_bases.GraphicsContextBase:
- dashd = {'dashdot': (0, (3.0, 5.0, 1.0, 5.0)), 'dashed': (0, (6.0, 6.0)), 'dotted': (0, (1.0, 3.0)), 'solid': (None, None)}
|
class RendererPS(matplotlib.backend_bases.RendererBase) |
| |
The renderer handles all the drawing primitives using a graphics
context instance that controls the colors/styles.
|
| |
Methods defined here:
- __init__(self, width, height, pswriter, imagedpi=72)
- 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
- draw_image(self, x, y, im, bbox, clippath=None, clippath_trans=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
bbox is a matplotlib.transforms.BBox instance for clipping, or
None
- draw_markers(self, 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(self, gc, x, y, s, prop, angle)
- Draw the math text using matplotlib.mathtext
- draw_path(self, gc, path, transform, rgbFace=None)
- Draws a Path instance using the given affine transform.
- draw_path_collection(self, master_transform, cliprect, clippath, clippath_trans, paths, all_transforms, offsets, offsetTrans, facecolors, edgecolors, linewidths, linestyles, antialiaseds)
- draw_tex(self, gc, x, y, s, prop, angle, ismath='TeX!')
- draw a Text instance
- draw_text(self, gc, x, y, s, prop, angle, ismath)
- draw a Text instance
- draw_unicode(self, gc, x, y, s, prop, angle)
- draw a unicode string. ps doesn't have unicode support, so
we have to do this the hard way
- flipy(self)
- return true if small y numbers are top for renderer
- get_canvas_width_height(self)
- return the canvas width and height in display coords
- 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.
- get_text_width_height_descent(self, s, prop, ismath)
- get the width and height in display coords of the string s
with FontPropertry prop
- merge_used_characters(self, other)
- new_gc(self)
- set_color(self, r, g, b, store=1)
- set_font(self, fontname, fontsize, store=1)
- set_hatch(self, hatch)
- hatch can be one of:
/ - diagonal hatching
\ - back diagonal
| - vertical
- - horizontal
+ - crossed
X - crossed diagonal
letters can be combined, in which case all the specified
hatchings are done
if same letter repeats, it increases the density of hatching
in that direction
- set_linecap(self, linecap, store=1)
- set_linedash(self, offset, seq, store=1)
- set_linejoin(self, linejoin, store=1)
- set_linewidth(self, linewidth, store=1)
- track_characters(self, font, s)
- Keeps track of which characters are required from
each font.
Data and other attributes defined here:
- afmfontd = {}
- fontd = {}
Methods inherited from matplotlib.backend_bases.RendererBase:
- close_group(self, s)
- Close a grouping element with label *s*
Is only currently used by :mod:`~matplotlib.backends.backend_svg`
- draw_quad_mesh(self, master_transform, cliprect, clippath, clippath_trans, meshWidth, meshHeight, coordinates, offsets, offsetTrans, facecolors, antialiased, showedges)
- This provides a fallback implementation of
:meth:`draw_quad_mesh` that generates paths and then calls
:meth:`draw_path_collection`.
- get_texmanager(self)
- return the :class:`matplotlib.texmanager.TexManager` instance
- open_group(self, s)
- Open a grouping element with label *s*. Is only currently used by
:mod:`~matplotlib.backends.backend_svg`
- option_image_nocomposite(self)
- overwrite this method for renderers that do not necessarily
want to rescale and composite raster images. (like SVG)
- points_to_pixels(self, points)
- Convert points to display units
*points*
a float or a numpy array of float
return points converted to pixels
You need to override this function (unless your backend
doesn't have a dpi, eg, postscript or svg). Some imaging
systems assume some value for pixels per inch::
points to pixels = points * pixels_per_inch/72.0 * dpi/72.0
- start_rasterizing(self)
- stop_rasterizing(self)
- strip_math(self, s)
| |