FramedPlot
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.
Basic Attributes:
Many of these can be sent as keywords during construction of the FramedPlot
instance.
- 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.
Axis Attributes:
Each side of the frame is an independent axis object: p.x1
(bottom), p.y1
(left), p.x2
(top), and p.y2
(right).
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 p.x1.log
. The .label_offset
and .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
If .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
Similar to .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
If .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"
instead.
- 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 .label
attribute.
Plot
Plot
behaves the same as FramedPlot
, except no axes, axis labels, or titles are drawn.
Attributes: Identical to FramedPlot
except the title/label options.
FramedArray(nrows, ncols)
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
where a
is a FramedArray
object, 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 FramedPlot
ones)
- cell layout
.cellspacing = number
[i,j].visible = True | False
.row_fractions = number-list
.col_fractions = number-list
The [i,j].visible
attribute turns the i,j
panel on or off. The .row_fractions
and .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
where t
is the Table object
, 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.
Attributes:
- cell layout
.cellpadding = number
.cellspacing = number
.align_interiors = True | False
Setting .align_interiors
attempts to align the axes interiors so that the output looks more like a FramedArray
.
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 l
and b
are used where l
runs from -pi
to pi
and b
from -pi/2
to pi/2
. The equator is b=0
, and 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
where 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 (rot
).
If you want to use HammerAitoffPlot
to plot maps of the globe, then l
and b
are east longitude and north
latitude. Here's an example.
Attributes:
- ribs
.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 .show()
, .write_XXX()
, etc was called).
- title
.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"
.
- show
.show ()
Plot the object in an X window.
- write
.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
.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
stdout. If type
is omitted the last three letters of filename are used.