| | |
- matplotlib.backend_bases.FigureCanvasBase
-
- FigureCanvasTemplate
- matplotlib.backend_bases.FigureManagerBase
-
- FigureManagerTemplate
- FigureManagerTemplate
- matplotlib.backend_bases.GraphicsContextBase
-
- GraphicsContextTemplate
- matplotlib.backend_bases.RendererBase
-
- RendererTemplate
class FigureCanvasTemplate(matplotlib.backend_bases.FigureCanvasBase) |
| |
The canvas the figure renders into. Calls the draw and print fig
methods, creates the renderers, etc...
Public attribute
figure - A Figure instance
Note GUI templates will want to connect events for button presses,
mouse movements and key presses to functions that call the base
class methods button_press_event, button_release_event,
motion_notify_event, key_press_event, and key_release_event. See,
eg backend_gtk.py, backend_wx.py and backend_tkagg.py
|
| |
Methods defined here:
- draw(self)
- Draw the figure using the renderer
- print_figure(self, filename, dpi=150, facecolor='w', edgecolor='w', orientation='portrait')
- 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.
orientation - only currently applies to PostScript printing.
A GUI backend should save and restore the original figure settings.
An image backend does not need to do this since after the print the
figure is done
Methods inherited from matplotlib.backend_bases.FigureCanvasBase:
- __init__(self, figure)
- 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 MouseEvent
- button_release_event(self, x, y, button, guiEvent=None)
- Backend derived classes should call this function on any mouse
button release. x,y are the canvas coords: 0,0 is lower, left.
button and key are as defined in MouseEvent
- 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_idle(self, *args, **kwargs)
- draw only if idle; defaults to draw but backends can overrride
- key_press_event(self, key, guiEvent=None)
- key_release_event(self, key, guiEvent=None)
- motion_notify_event(self, x, y, guiEvent=None)
- Backend derived classes should call this function on any mouse
button release. x,y are the canvas coords: 0,0 is lower, left.
button and key are as defined in MouseEvent
- mpl_connect(self, s, func)
- Connect event with string s to func. The signature of func is
def func(event)
where event is a MplEvent. The following events are recognized
'key_press_event'
'button_press_event'
'button_release_event'
'motion_notify_event'
For the three events above, if the mouse is over the axes,
the variable event.inaxes will be set to the axes it is over,
and additionally, the variables event.xdata and event.ydata
will be defined. This is the mouse location in data coords.
See backend_bases.MplEvent.
return value is a connection id that can be used with
mpl_disconnect
- mpl_disconnect(self, cid)
- Connect s to func. return an id that can be used with disconnect
Method should return None
- 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 = ('key_press_event', 'key_release_event', 'button_press_event', 'button_release_event', 'motion_notify_event')
|
class GraphicsContextTemplate(matplotlib.backend_bases.GraphicsContextBase) |
| |
The graphics context provides the color, line styles, etc... See the gtk
and postscript backends for examples of mapping the graphics context
attributes (cap styles, join styles, line widths, colors) to a particular
backend. In GTK this is done by wrapping a gtk.gdk.GC object and
forwarding the appropriate calls to it using a dictionary mapping styles
to gdk constants. In Postscript, all the work is done by the renderer,
mapping line styles to postscript calls.
If it's more appropriate to do the mapping at the renderer level (as in
the postscript backend), you don't need to override any of the GC methods.
If it's more appropriate to wrap an instance (as in the GTK backend) and
do the mapping here, you'll need to override several of the setter
methods.
The base GraphicsContext stores colors as a RGB tuple on the unit
interval, eg, (0.5, 0.0, 1.0). You may need to map this to colors
appropriate for your backend.
|
| |
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_capstyle(self)
- Return the capstyle as a string in ('butt', 'round', 'projecting')
- get_clip_rectangle(self)
- Return the clip rectangle as (left, bottom, width, height)
- 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 for more info
Default value is None
- get_joinstyle(self)
- Return the line join style as one of ('miter', 'round', 'bevel')
- 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_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 GraphicsContext converts colors to rgb internally. If you
know the color is rgb already, you can set isRGB to True to
avoid the performace hit of the conversion
- set_graylevel(self, frac)
- Set the foreground color to be a gray level with frac frac
- 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 RendererTemplate(matplotlib.backend_bases.RendererBase) |
| |
The renderer handles drawing/rendering operations.
This is a minimal do-nothing class that can be used to get started when
writing a new backend. Refer to backend_bases.RendererBase for
documentation of the classes methods.
|
| |
Methods defined here:
- draw_arc(self, gcEdge, rgbFace, x, y, width, height, angle1, angle2)
- draw_image(self, x, y, im, origin, bbox)
- draw_line(self, gc, x1, y1, x2, y2)
- draw_lines(self, gc, x, y)
- draw_point(self, gc, x, y)
- draw_polygon(self, gcEdge, rgbFace, points)
- draw_rectangle(self, gcEdge, rgbFace, x, y, width, height)
- draw_text(self, gc, x, y, s, prop, angle, ismath=False)
- flipy(self)
- get_canvas_width_height(self)
- get_text_width_height(self, s, prop, ismath)
- new_gc(self)
- points_to_pixels(self, points)
Methods inherited from matplotlib.backend_bases.RendererBase:
- blit(self)
- blit the cached copy of the canvas, to be used in conjunction
with blit in support of animation
- cache(self)
- save a copy of the canvas, to be used in conjunction with blit
in support of animation
- close_group(self, s)
- close a grouping element with label s
Is only currently used by backend_svg
- draw_line_collection(self, segments, transform, clipbox, colors, linewidths, linestyle, antialiaseds, offsets, transOffset)
- This is a function for optimized line drawing. If you need to draw
many line segments with similar properties, it is faster to avoid the
overhead of all the object creation etc. The lack of total
configurability is compensated for with efficiency. Hence we don't use
a GC and many of the line props it supports. See
matplotlib.collections for more details.
segments is a sequence of ( line0, line1, line2), where linen =
(x0, y0), (x1, y1), ... (xm, ym). Each line can be a
different length
transform is used to Transform the lines
clipbox is a xmin, ymin, width, height clip rect
colors is a tuple of RGBA tuples
linewidths is a tuple of linewidths
*** really should be called 'dashes' not 'linestyle', since
we call gc.set_dashes() not gc.set_linestyle() ***
linestyle is an (offset, onoffseq) tuple or None,None for solid
antialiseds is a tuple of ones or zeros indicating whether the
segment should be aa or not
offsets, if not None, is a list of x,y offsets to translate the lines
by after transform is used to transform the offset coords
This function could be overridden in the backend to possibly implement
faster drawing, but it is already much faster than using draw_lines()
by itself.
- draw_poly_collection(self, verts, transform, clipbox, facecolors, edgecolors, linewidths, antialiaseds, offsets, transOffset)
- Draw a polygon collection
verts are a sequence of polygon vectors, where each polygon
vector is a sequence of x,y tuples of vertices
facecolors and edgecolors are a sequence of RGBA tuples
linewidths are a sequence of linewidths
antialiaseds are a sequence of 0,1 integers whether to use aa
- draw_regpoly_collection(self, clipbox, offsets, transOffset, verts, sizes, facecolors, edgecolors, linewidths, antialiaseds)
- Draw a regular poly collection
offsets - is a sequence is x,y tuples
transOffset - maps this to display coords
verts - are the vertices of the regular polygon at the origin
sizes are the area of the circle that circumscribes the
polygon in points^2
facecolors and edgecolors are a sequence of RGBA tuples
linewidths are a sequence of linewidths
antialiaseds are a sequence of 0,1 integers whether to use aa
- get_text_extent(self, text)
- Get the text extent in window coords
- open_group(self, s)
- open a grouping element with label s
Is only currently used by backend_svg
- strip_math(self, s)
| |