This object represents a framed plot, where the axes surround the plotting region, instead of intersecting it. You build a plot by adding components, using:
p = FramedPlot() p.add(component, ...) p += component p += component1, component2, component3
where p is a
FramedPlot object. Components are rendered in the order they're added.
Many of these can be sent as keywords during construction of the
- axis labels
.xlabel = None | string .ylabel = None | string
- axis scaling
.xlog = 0 | 1 .ylog = 0 | 1
If 1 use log scaling, otherwise linear.
- axis range
.xrange = None | (number, number) .yrange = None | (number, number)
These attributes should be sufficient for casual use, but often you'll want greater control over the frame.
Each side of the frame is an independent axis object:
p.x2 (top), and
The axis attributes below apply to each of these objects. So for example, to label the right side of the frame, you would say:
p.y2.label = "something"
You can set the following attributes.
- labels, ranges and scaling
.label = None | string .label_offset = number .label_style = dictionary .log = 0 | 1 .range = None | (number, number)
The label, log, and range attributes are the same as the ones above. For instance, when you set
p.xlog you're actually setting
.label_style attributes let you control the placement and style of the axis label.
- grid lines
.grid_style = dictionary .draw_grid = 0 | 1
Grid lines are parallel to and coincident with the ticks.
- tick properties
.tickdir = +1 | -1
This controls the direction the ticks and subticks are drawn in. If +1 they point toward the ticklabels and if -1 they point away from the ticklabels.
.ticks = None | integer | number-list .ticks_size = number .ticks_style = dictionary .draw_ticks = 0 | 1
.ticks is set to None they will be automagically generated. If set to an integer n, n equally spaced ticks will be drawn. You can provide your own values by setting
.ticks to a sequence.
.ticklabels = None | string-list .ticklabels_dir = +1 | -1 .ticklabels_offset = number .ticklabels_style = dictionary .draw_ticklabels = 0 | 1
Ticklabels are the labels marking the values of the ticks. You can provide your own labels by setting
.ticklabels to a list of strings.
- sub/minor tick properties
.subticks = None | integer | number-list .subticks_size = number .subticks_style = dictionary .draw_subticks = None | 0 | 1
.ticks, except when
.subticks is set to an integer it sets the number of subticks drawn between ticks, not the total number of subticks. If
.draw_subticks is set to None subticks will be drawn only if ticks are drawn.
- axis spines
.spine_style = dictionary .draw_spine = 0 | 1
The spine is the line perpendicular to the ticks.
.draw_axis = 0 | 1 .draw_nothing = 0 | 1
.draw_axis is 0 the spine, ticks, and subticks are not drawn; otherwise it has no effect. If
.draw_nothing is 1 nothing is drawn; otherwise it has no effect.
So let's say you wanted to color all the ticks red. You could write:
p.x1.ticks_style["color"] = "red" p.x2.ticks_style["color"] = "red" p.y1.ticks_style["color"] = "red" p.y2.ticks_style["color"] = "red"
but it's tedious, and hazardous for your hands.
FramedPlot provides a mechanism for manipulating groups of axes, through the use of the following pseudo-attributes:
.frame ==> .x1, .x2, .y1, .y2 .frame1 ==> .x1, .y1 .frame2 ==> .x2, .y2 .x ==> .x1, .x2 .y ==> .y1, .y2
which lets you write
p.frame.ticks_style["color"] = "red"
- Managed PlotKey
You can always add a PlotKey to any plot, but sometimes it is
convenient to let the
FramedPlot manage a PlotKey for you. You
can do this by sending a key on construction
key=PlotKey(0.1, 0.9, halign='left') plt=FramedPlot(key=key)
then any components added to the plot are also added to the
key if they have a
Plot behaves the same as
FramedPlot, except no axes, axis labels, or titles are drawn.
Attributes: Identical to
FramedPlot except the title/label options.
Use this container if you want to plot an array of similar plots. To add a component to a specific cell, use
a[i,j].add(component, ...) a[i,j] += component a[i,j] += component1, component2, component3
a is a
i is the row number, and
j is the column number. You can also add a component to all the cells at once using:
a.add(component, ...) a += component a += component1, component2, component3
Attributes: (in addition to the basic
- cell layout
.cellspacing = number [i,j].visible = True | False .row_fractions = number-list .col_fractions = number-list
[i,j].visible attribute turns the
i,j panel on or off. The
.col_fractions set the fractional height or width of the total plot each row or column spans.
- cell limits
.uniform_limits = 0 | 1
If set to 1 every cell will have the same limits. Otherwise they are only forced to be the same across rows and down columns.
Table (nrows, ncols)
This container allows you to arrange other containers in a grid. To add a container to a specific cell, use
t[i,j] = container
t is the
i is the row number, and
j is the column number. Rows and columns are numbered starting from 0, with
t[0,0] being the upper left corner cell.
- cell layout
.cellpadding = number .cellspacing = number .align_interiors = True | False
.align_interiors attempts to align the axes interiors so that the output looks more like a
HammerAitoffPlot(l0=0, b0=0, rot=0)
This plot implements Hammer-Aitoff coordinates, which are an equal-area projection of the sphere into the plane,
commonly used in astrophysics. The spherical coordinates
b are used where
l runs from
pi/2. The equator is
b=+/-pi/2 are the north/south poles. You build a plot by adding components, using:
p = HammerAitoffPlot(l0=0, b0=0, rot=0) p.add(component, ...) p += component p += component1, component2, component3
p is a
HammerAitoffPlot object. Components are rendered in the order they're added. You can specify the coordinates of the plot center using
(l0, b0) and a rotation about that point (
If you want to use
HammerAitoffPlot to plot maps of the globe, then
b are east longitude and north
latitude. Here's an example.
.ribs_l = integer .ribs_b = integer .ribs_style = dictionary
Common Container Methods
These methods and attributes are common to all containers.
- aspect ratio
.aspect_ratio = None | number
Force the aspect ratio (height divided by width) to be a particular value. If None the container fills the available space.
- page margin
.page_margin = number
Extra padding applied when rendering the head container (ie, the container from which
.write_XXX(), etc was called).
.title = None | string
Draw a plot-centered supertitle.
- title offset
.title_offset = number
The distance between the title and the container's contents.
- title style
.title_style = dictionary
Want a red title? Try
p.title_style["color"] = "red".
Plot the object in an X window.
.write(filename [, type=, ..])
Write the plot to do disk. The type will be inferred from the extension, or can be forced using type=. Extra keywords can be sent depending on the type.
.write("myplot.eps" [, **kw])
Save plot as an Encapsulated PostScript (EPS) file. Force eps with.
type="eps" Additional keywords for eps creation can be sent.
.write("myplot.pdf", [, **kw])
Save plot as a PDF file. Additional keywords for eps creation can be sent.
.write("myplot.png" [, dpi=100, **kw])
Save plot as a PNG file. Additional keywords for eps creation can be sent (the image is converted from eps)
.write("myplot.jpg" [, dpi=100, **kw])
Save plot as a jpeg file.
Additional keywords for eps creation can be sent (the image is converted from eps)
.write_img ( [type,] width, height, filename )
Write non anti-aliased image. This method is much faster than the standard
write() method with ant-aliasing, but the curves will have a jagged look.
Valid types are "png", "svg", and "gif". Note that the GIF images produced do
not use (patented) LZW compression. If filename is "-" output is sent to
type is omitted the last three letters of filename are used.