@header@
 
 
matplotlib.backend_bases
index
/matplotlib/backend_bases.py

Abstract base classes definine the primitives that renderers and
graphics contexts must implement to serve as a matplotlib backend

 
Modules
       
sys

 
Classes
       
FigureCanvasBase
FigureManagerBase
GraphicsContextBase
RendererBase

 
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
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

 
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, axisbg)
Add an axes to the current figure
add_subplot(self, *args, **kwargs)
Add a subplot to the current 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_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_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 RendererBase
     Methods defined here:
draw_arc(self, gcEdge, faceColor, 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 faceColor is not None, fill the rectangle with it.  gcEdge
is a GraphicsContext instance
draw_line(self, gc, x1, y1, x2, y2)
Draw a single line from x1,y1 to x2,y2
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_polygon(self, gcEdge, faceColor, points)
Draw a polygon.  points is a len vertices tuple, each element
giving the x,y coords a vertex
 
If faceColor is not None, fill the rectangle with it.  gcEdge
is a GraphicsContext instance
draw_rectangle(self, gcEdge, faceColor, x, y, width, height)
Draw a rectangle with lower left at x,y with width and height.
 
If faceColor is not None, fill the rectangle with it.  gcEdge
is a GraphicsContext instance
draw_text(self, text)
Draw a text instance
get_text_extent(self, text)
Get the text extent in window coords
new_gc(self)
Return an instance of a GraphicsContextBase

 
Functions
       
arg_to_rgb(arg)
returns a tuple of three floats from 0-1.  arg can be a
matlab format string, a html hex color string, an rgb tuple,
or a float between 0 and 1.  In the latter case, grayscale is
used
array(...)
array(sequence, typecode=None, copy=1, savespace=0) will return a new array formed from the given (potentially nested) sequence with type given by typecode.  If no typecode is given, then the type will be determined as the minimum type required to hold the objects in sequence.  If copy is zero and sequence is already an array, a reference will be returned.  If savespace is nonzero, the new array will maintain its precision in operations.
error_msg(msg, *args, **kwargs)
Alert an error condition with message
hex2color(s)
Convert hex string (like html uses, eg, #efefef) to a r,g,b tuple

 
Data
        False = False
True = True
colors = {'b': (0.0, 0.0, 1.0), 'c': (0.0, 0.75, 0.75), 'g': (0.0, 0.5, 0.0), 'k': (0.0, 0.0, 0.0), 'm': (0.75, 0, 0.75), 'r': (1.0, 0.0, 0.0), 'w': (1.0, 1.0, 1.0), 'y': (0.75, 0.75, 0)}
division = _Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)
@footer@