@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 
 * freetype2 w/ ft2font
 * using ttf_manager to get font
 
TODO:
 
  * allow save to file handle
 
  * allow load from png
 
  * integrate screen dpi w/ ppi and text
  
INSTALLING 
 
  REQUIREMENTs
 
    python2.2+
    Numeric 22+
    agg2 (see below)
    freetype 2
    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
 
     
   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')

 
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_image(self, x, y, im)
Draw the Image instance into the current axes; x, y is the
upper left hand corner of the image
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, t)
Draw the math text using matplotlib.mathtext
draw_point(self, gc, x, y)
Draw a single point at x,y
draw_text(self, gc, x, y, t)
Render the text
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 = {}
mathfonts = {}
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
flipy(self)
return true if y small numbers are top for renderer
new_gc(self)
Return an instance of a GraphicsContextBase

 
Functions
       
FT2Font(...)
FT2Font(ttffile)
 
Create a new FT2Font object; the following global font attributes
are defined
num_faces        # number of faces in file
face_flags       # the face flags as python int
style_flags      # the style flags as python int
num_glyphs       # the number of glyphs in the face
family_name      # the face family name
style_name       # the face syle name
num_fixed_sizes  # the number of embedded bitmap strikes in the current face
 
# the following are only available if face.scalable
bbox                 # the face global bounding box (xmin, ymin, xmax, ymax)
units_per_EM         # number of font units covered by the EM
ascender             # the ascender in 26.6 units
descender            # the descender in 26.6 units
height               # the height in 26.6 units; used to compute a default
                       line spacing (i.e., the baseline-to-baseline distance)  
max_advance_width    # maximum horizontal cursor advance for all glyphs
max_advance_height   # same for vertical layout
underline_position   # vertical position of the underline bar
underline_thickness  # vertical thickness of the underline
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@