@header@
 
 
matplotlib.backends.backend_agg		index
/matplotlib/backends/backend_agg.py

An agg http://antigrain.com/ backend
 
Features that are implemented
 
 * capstyles and join styles
 * dashes
 * linewidth 
 * lines, rectangles, ellipses
 * clipping to a rectangle
 * output to RGBA and PNG
 * alpha blending
 * DPI scaling properly - everything scales properly (dashes, linewidths, etc)
 * draw polygon 
 * freetype1
 
TODO:
 
 * use ttf manager to get font - right now I just use Vera
 * freetype2
 
INSTALLING 
 
  REQUIREMENTs
 
    python2.2+
    Numeric 22+
    agg2 (see below)
    freetype 1
    libpng
    libz
    
  Install AGG2 (cut and paste below into xterm should work)
 
    wget http://www.antigrain.com/agg2.tar.gz
    tar xvfz agg2.tar.gz
    cd agg2
    make
 
    (Optional) if you want to make the examples:
    cd examples/X11
    make
 
  Installing backend_agg
 
   Grab the latest CVS:
 
     cvs -d:pserver:anonymous@cvs.sourceforge.net:/cvsroot/matplotlib login 
     cvs -z3 -d:pserver:anonymous@cvs.sourceforge.net:/cvsroot/matplotlib co matplotlib
     
   Edit setup.py: change aggsrc to point to the agg2 src tree and
   replace if 0: with if 1: in the backend_agg section
 
   Then just do the usual thing: python setup.py build
 
   Please let me know if you encounter build problems, and tell me
   platform, gcc version, etc...  Currently the paths in setupext.py
   assume as linux like filesystem (eg X11 include dir, location of
   libttf, etcc) so you may need to tweak these
 
  Using agg backend
 
    python somefile.py -dAgg   
 
  or
 
    import matplotlib
    matplotlib.use('Agg')
    
TODO:
 
  * implement ttf font manager
 
  * allow save to file handle
 
  * allow load from png
 
 
Errors: running python2.2 on bace.bsd
 
    from _backend_agg import RendererAgg as _RendererAgg, Font
ImportError: /usr/lib/python2.2/site-packages/matplotlib/backends/_backend_agg.so: undefined symbol: __gxx_personality_v0

 
Modules
       
os
sys

 
Classes
       
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:
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
 
If the extension matches PNG, write a PNG file
 
If the extension matches BMP or RAW, write an RGBA bitmap file
Methods inherited from matplotlib.backend_bases.FigureCanvasBase:
__init__(self, figure)
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 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)
compute_text_offsets(self, t, props)
Return the (x,y) offsets to adjust for the alignment
specifications
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_point(self, gc, x, y)
Draw a single point at x,y
draw_text(self, gc, x, y, t)
Render the text using the RendererPaint instance
get_agg_color(self, rgb)
returns an agg color object based on the given rgb tuple
get_text_extent(self, t)
Return the ink extent of the text as Bound2D instance
get_text_scale(self)
Return the scale factor for fontsize taking screendpi and pixels per
inch into account
points_to_pixels(self, points)
convert point measures to pixes using dpi and the pixels per
inch of the display
Data and other attributes defined here:
fontd = {}
offsetd = {}
Methods inherited from matplotlib.backend_bases.RendererBase:
draw_lines(self, gc, x, y)
x and y are equal length arrays, draw lines connecting each
point in x, y
draw_polygon(self, gcEdge, gcFace, points)
Draw a polygon.  points is a len vertices tuple, each element
giving the x,y coords a vertex
 
If gcFace is not None, fill the rectangle with it.  gcEdge
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
new_gc(self)
Return an instance of a GraphicsContextBase

 
Functions
       
Font(...)
Font(filename, size = 12, rotate = 0)
 
Load the named font and return the font object
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.
new_figure_manager(num, *args)
Create a new figure manager instance

 
Data
        False = False
Float = 'd'
PIXELS_PER_INCH = 96
True = True
division = _Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)
fontManager = <matplotlib.backends.ttf_font_manager.FontManager instance>
@footer@