| | |
- Cursors
- FigureCanvasBase
- FigureManagerBase
- GraphicsContextBase
- MplEvent
- NavigationToolbar2
- RendererBase
- Stack
class Cursors |
| |
# cursors
|
| |
Data and other attributes defined here:
- HAND = 0
- MOVE = 3
- POINTER = 1
- SELECT_REGION = 2
|
class FigureCanvasBase |
| |
The canvas the figure renders into.
Public attribute
figure - A Figure instance
|
| |
Methods defined here:
- __init__(self, figure)
- draw(self)
- Render the figure
- 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
'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
- print_figure(self, filename, dpi=300, facecolor='w', edgecolor='w')
- 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
- 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 defined here:
- events = ('button_press_event', 'button_release_event', 'motion_notify_event')
|
class FigureManagerBase |
| |
Helper class for matlab mode, wraps everything up into a neat bundle
Public attibutes
canvas - A FigureCanvas instance
num - The figure number
|
| |
Methods defined here:
- __init__(self, canvas, num)
- add_axes(self, rect, **kwargs)
- Add an axes to the current figure
- add_subplot(self, *args, **kwargs)
- Add a subplot to the current figure
- clf(self)
- clear the figure
- destroy(self)
- get_current_axis(self)
- Return the current axes
- set_current_axes(self, a)
- Set the current axes to be a
|
class GraphicsContextBase |
| | |
Methods defined here:
- __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 shuold 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
- set_foreground(self, fg, isRGB=None)
- 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
|
class MplEvent |
| |
A matplotlib event. Attach additional attributes as defined in
FigureCanvas.connect. The following attributes are defined and
shown with their default values
name # the event name
canvas # the FigureCanvas instance generating the event
x = None # x position - pixels from left of canvas
y = None # y position - pixels from bottom of canvas
button = None # button pressed None, 1, 2, 3
key = None # the key pressed: None, chr(range(255), shift, win, or control
inaxes = None # the Axes instance if mouse us over axes
xdata = None # x coord of mouse in data coords
ydata = None # y coord of mouse in data coords
|
| |
Methods defined here:
- __init__(self, name, canvas)
Data and other attributes defined here:
- button = None
- inaxes = None
- x = None
- xdata = None
- y = None
- ydata = None
|
class NavigationToolbar2 |
| |
Base class for the navigation cursor, version 2
backends must implement a canvas that handles connections for
'button_press_event' and 'button_release_event'. See
FigureCanvas.connect for more information
They must also define
* save_figure - save the current figure
* set_cursor - if you want the pointer icon to change
* _init_toolbar - create your toolbar widget
* draw_rubberband (optional) : draw the zoom to rect
"rubberband" rectangle
* press : (optional) whenever a mouse button is pressed, you'll be
notified with the event
* release : (optional) whenever a mouse button is released,
you'll be notified with the event
* dynamic_update (optional) dynamically update the window while
navigating
That's it, we'll do the rest!
|
| |
Methods defined here:
- __init__(self, canvas)
- back(self, *args)
- move back up the view lim stack
- drag_pan(self, event)
- the drag callback in pan/zoom mode
- draw(self)
- redraw the canvases, update the locators
- draw_rubberband(self, event, x0, y0, x1, y1)
- draw a rectangle rubberband to indicate zoom limits
- dynamic_update(self)
- forward(self, *args)
- move forward in the view lim stack
- home(self, *args)
- restore the original view
- mouse_move(self, event)
- pan(self, *args)
- Activate the pan/zoom tool. pan with left button, zoom with right
- press(self, event)
- this will be called whenver a mouse button is pressed
- press_pan(self, event)
- the press mouse button in pan/zoom mode callback
- press_zoom(self, event)
- the press mouse button in zoom to rect mode callback
- push_current(self)
- push the current view limits onto the stack
- release(self, event)
- this will be called whenever mouse button is released
- release_pan(self, event)
- the release mouse button callback in pan/zoom mode
- release_zoom(self, event)
- the release mouse button callback in zoom to rect mode
- save_figure(self, *args)
- save the current figure
- set_cursor(self, cursor)
- Set the current cursor to one of the backend_bases.Cursors
enums values
- update(self)
- reset the axes stack
- zoom(self, *args)
- activate zoom to rect mode
|
class RendererBase |
| | |
Methods defined here:
- close_group(self, s)
- close a grouping element with label s
- draw_arc(self, gcEdge, gcFace, 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 gcFace is not None, fill the rectangle with it. gcEdge
is a GraphicsContext instance
- 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(self, gc, x1, y1, x2, y2)
- Draw a single line from x1,y1 to x2,y2
- draw_line_collection(self, segments, transform, clipbox, colors, linewidths, 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
sements 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
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 transoff is used to transform the offset
coords
This function is intended to be overridden by the backend
level in extension code for backends that want fast line
collection drawing. Here is is implemented using native
backend calls and may be slow
- draw_lines(self, gc, x, y)
- x and y are equal length arrays, draw lines connecting each
point in x, y
- draw_point(self, gc, x, y)
- Draw a single point at 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. points is a len vertices tuple, each element
giving the x,y coords a vertex
If rgbFace is not None, fill the poly with it. gc
is a GraphicsContext instance
- draw_rectangle(self, gcEdge, gcFace, x, y, width, height)
- Draw a rectangle with lower left at x,y with width and height.
If gcFace is not None, fill the rectangle with it. gcEdge
is a GraphicsContext instance
- 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 and 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
- draw_text(self, gc, x, y, s, prop, angle, ismath=False)
- Draw string s at x,y (display coords) with font properties
instance prop at angle in degrees
- flipy(self)
- return true if y small numbers are top for renderer
- get_canvas_width_height(self)
- return the canvas width and height in display coords
- get_text_extent(self, text)
- Get the text extent in window coords
- get_text_width_height(self, s, fontsize, ismath=False)
- get the width and height in display coords of the string s
with fontsize in points
- new_gc(self)
- Return an instance of a GraphicsContextBase
- open_group(self, s)
- open a grouping element with label s
- points_to_pixels(self, points)
- convert points to display units; unless your backend doesn't
have dpi, eg, postscript, you need to overrride this function
|
class Stack |
| |
Implement a stack where elements can be pushed on and you can move
back and forth. But no pop. Should mimib home / back / forward
in a browser
|
| |
Methods defined here:
- __call__(self)
- return the current element, or None
- __init__(self)
- back(self)
- move the position back and return the current element
- clear(self)
- empty the stack
- empty(self)
- forward(self)
- move the position forward and return the current element
- home(self)
- push the first element onto the top of the stack
- push(self, o)
- push object onto stack at current position - all elements
occurring later than the current position are discarded
| |