| | |
- matplotlib.backend_bases.FigureCanvasBase
-
- FigureCanvasAgg
- matplotlib.backend_bases.RendererBase
-
- RendererAgg
class FigureCanvasAgg(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
|
| |
Methods defined here:
- buffer_rgba(self)
- copy_from_bbox(self, bbox)
- draw(self)
- Draw the figure using the renderer
- get_renderer(self)
- 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
If the extension matches PNG, write a PNG file
If the extension matches BMP or RAW, write an RGBA bitmap file
If filename is a fileobject, write png to file object (thus
you can, for example, write the png to stdout
- restore_region(self, region)
- tostring_argb(self)
- tostring_rgb(self)
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 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_event(self, renderer)
- draw_idle(self, *args, **kwargs)
- draw only if idle; defaults to draw but backends can overrride
- get_width_height(self)
- return the figure width and height in points or pixels
(depending on the backend), truncated to integers
- 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
motion-notify-event. 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
'draw_event'
'key_press_event'
'key_release_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 RendererAgg(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, dpi)
- buffer_rgba(self)
- clear(self)
- draw_arc(self, gcEdge, rgbFace, x, y, width, height, angle1, angle2)
- Draw an arc centered at x,y with width and height and angles
from 0.0 to 360.0
If rgbFace is not None, fill the rectangle with that color. gcEdge
is a GraphicsContext instance
Currently, I'm only supporting ellipses, ie angle args are
ignored
- draw_line(self, gc, x1, y1, x2, y2)
- x and y are equal length arrays, draw lines connecting each
point in x, y
- draw_mathtext(self, gc, x, y, s, prop, angle)
- Draw the math text using matplotlib.mathtext
- draw_point(self, gc, x, y)
- Draw a single point at x,y
- draw_tex(self, gc, x, y, s, prop, angle)
- draw_text(self, gc, x, y, s, prop, angle, ismath)
- Render the text
- get_canvas_width_height(self)
- return the canvas width and height in display coords
- get_text_width_height(self, s, prop, ismath, rgb=(0, 0, 0))
- get the width and height in display coords of the string s
with FontPropertry prop
# passing rgb is a little hack to make cacheing in the
# texmanager more efficient. It is not meant to be used
# outside the backend
- points_to_pixels(self, points)
- convert point measures to pixes using dpi and the pixels per
inch of the display
- tostring_argb(self)
- tostring_rgb(self)
Data and other attributes defined here:
- debug = 1
- texd = {}
Methods inherited from matplotlib.backend_bases.RendererBase:
- close_group(self, s)
- close a grouping element with label s
Is only currently used by backend_svg
- draw_image(self, x, y, im, origin, bbox)
- Draw the Image instance into the current axes; x is the
distance in pixels from the left hand side of the canvas. y is
the distance from the origin. That is, if origin is upper, y
is the distance from top. If origin is lower, y is the
distance from bottom
origin is 'upper' or 'lower'
bbox is a matplotlib.transforms.BBox instance for clipping, or
None
- 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_lines(self, gc, x, y, transform=None)
- x and y are equal length arrays, draw lines connecting each
point in x, y
- 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_polygon(self, gc, rgbFace, points)
- Draw a polygon using the GraphicsContext instance gc.
points is a len vertices tuple, each element
giving the x,y coords a vertex
If the color rgbFace is not None, fill the polygon with it
- draw_rectangle(self, gcEdge, rgbFace, x, y, width, height)
- Draw a non-filled rectangle using the GraphicsContext instance gcEdge,
with lower left at x,y with width and height.
If rgbFace is not None, fill the rectangle with it.
- 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
- flipy(self)
- return true if y small numbers are top for renderer
Is used for drawing text (text.py) and images (image.py) only
- get_text_extent(self, text)
- Get the text extent in window coords
- new_gc(self)
- Return an instance of a GraphicsContextBase
- open_group(self, s)
- open a grouping element with label s
Is only currently used by backend_svg
- strip_math(self, s)
| |