| | |
- matplotlib.backend_bases.FigureCanvasBase
-
- FigureCanvasGD
- matplotlib.backend_bases.FigureManagerBase
-
- FigureManagerGD
- FigureManagerGD
- matplotlib.backend_bases.GraphicsContextBase
-
- GraphicsContextGD
- matplotlib.backend_bases.RendererBase
-
- RendererGD
class FigureCanvasGD(matplotlib.backend_bases.FigureCanvasBase) |
| | |
Methods defined here:
- draw(self)
- Draw to a gd image and return the image instance
- print_figure(self, filename, dpi=150, facecolor='w', edgecolor='w', orientation='portrait')
- Render the figure to hardcopy using self.renderer as the
renderer if neccessary
filename can be a string filename or writable file instance
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 GraphicsContextGD(matplotlib.backend_bases.GraphicsContextBase) |
| |
The graphics context provides the color, line styles, etc... See
the gtk and postscript backends for examples of mapping the
graphics context attributes (cap styles, join styles, line widths,
colors) to a particular backend.
|
| |
Methods defined here:
- __init__(self, im, renderer)
- Initialize with a gd image
- set_clip_rectangle(self, rectangle)
- set_linestyle(self, style)
- set_linewidth(self, lw)
Methods inherited from matplotlib.backend_bases.GraphicsContextBase:
- 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_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')
|
class RendererGD(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, im, dpi)
- Initialize the renderer with a gd image instance
- compute_text_offsets(self, t)
- Return the (x,y) offsets to adjust for the alignment
specifications
- draw_arc(self, gc, 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
- 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, gc, rgbFace, points)
- Draw a polygon. points is a len vertices tuple, each element
giving the x,y coords a vertex
- draw_rectangle(self, gc, rgbFace, x, y, width, height)
- Draw a rectangle at lower left x,y with width and height
If filled=True, fill the rectangle with the gc foreground
gc is a GraphicsContext instance
- draw_text(self, gc, x, y, t)
- Render the text using the RendererGD instance
- finish(self)
- flush_clip(self)
- get_gd_color(self, rgb)
- RGB is a unit RGB tuple, return a gd color
- get_text_extent(self, t)
- get_text_scale(self, t)
- Return the scale factor for fontsize taking screendpi and pixels per
inch into account
- new_gc(self)
- Return an instance of a GraphicsContextGD
- points_to_pixels(self, points)
- convert point measures to pixes using dpi and the pixels per
inch of the display
Methods inherited from matplotlib.backend_bases.RendererBase:
- draw_image(self, x, y, im)
- Draw the Image instance into the current axes
- flipy(self)
- return true if y small numbers are top for renderer
| |