Generic functions to draw 3d scatter plots and surfaces. The
"formula"
methods do most of the actual work.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61  cloud(x, data, ...)
wireframe(x, data, ...)
## S3 method for class 'formula'
cloud(x,
data,
allow.multiple = is.null(groups)  outer,
outer = FALSE,
auto.key = FALSE,
aspect = c(1,1),
panel.aspect = 1,
panel = lattice.getOption("panel.cloud"),
prepanel = NULL,
scales = list(),
strip = TRUE,
groups = NULL,
xlab,
ylab,
zlab,
xlim = if (is.factor(x)) levels(x) else range(x, finite = TRUE),
ylim = if (is.factor(y)) levels(y) else range(y, finite = TRUE),
zlim = if (is.factor(z)) levels(z) else range(z, finite = TRUE),
at,
drape = FALSE,
pretty = FALSE,
drop.unused.levels,
...,
lattice.options = NULL,
default.scales =
list(distance = c(1, 1, 1),
arrows = TRUE,
axs = axs.default),
default.prepanel = lattice.getOption("prepanel.default.cloud"),
colorkey,
col.regions,
alpha.regions,
cuts = 70,
subset = TRUE,
axs.default = "r")
## S3 method for class 'formula'
wireframe(x,
data,
panel = lattice.getOption("panel.wireframe"),
default.prepanel = lattice.getOption("prepanel.default.wireframe"),
...)
## S3 method for class 'matrix'
cloud(x, data = NULL, type = "h",
zlab = deparse(substitute(x)), aspect, ...,
xlim, ylim, row.values, column.values)
## S3 method for class 'table'
cloud(x, data = NULL, groups = FALSE,
zlab = deparse(substitute(x)),
type = "h", ...)
## S3 method for class 'matrix'
wireframe(x, data = NULL,
zlab = deparse(substitute(x)), aspect, ...,
xlim, ylim, row.values, column.values)

x 
The object on which method dispatch is carried out. For the For Missing values are allowed, either as Both 
data 
for the 
row.values, column.values 
Optional vectors of values that
define the grid when 
allow.multiple, outer, auto.key, prepanel, strip, groups, xlab,
xlim, ylab, ylim, drop.unused.levels, lattice.options,
default.scales, subset 
These arguments are documented in the help page for

type 
type of display in 
aspect, panel.aspect 
Unlike other high level functions, For the 
panel 
panel function used to create the display. See

default.prepanel 
Fallback prepanel function. See 
scales 
a list describing the scales. As with other high level functions
(see The most common use for this argument is to set Other components that work in the Note, however, that for these functions 
axs.default 
Unlike 2D display functions, 
zlab 
Specifies a label describing the z variable in ways similar to

zlim 
limits for the zaxis. Similar to 
drape 
logical, whether the wireframe is to be draped in color. If

at, col.regions, alpha.regions 
these arguments are analogous to those in

cuts 
if 
pretty 
whether automatic choice of cutpoints should be prettfied 
colorkey 
logical indicating whether a color key should be drawn
alongside, or a list describing such a key. See

... 
Any number of other arguments can be specified, and are passed to
the panel function. In particular, the arguments Additionally, an argument called 
These functions produce three dimensional plots in each panel (as long
as the default panel functions are used). The orientation is obtained
as follows: the data are scaled to fall within a bounding box that is
contained in the [0.5, 0.5] cube (even smaller for nondefault values
of aspect
). The viewing direction is given by a sequence of
rotations specified by the screen
argument, starting from the
positive Zaxis. The viewing point (camera) is located at a distance
of 1/distance
from the origin. If perspective=FALSE
,
distance
is set to 0 (i.e., the viewing point is at an infinite
distance).
cloud
draws a 3D Scatter Plot, while wireframe
draws a
3D surface (usually evaluated on a grid). Multiple surfaces can be
drawn by wireframe
using the groups
argument (although
this is of limited use because the display is incorrect when the
surfaces intersect). Specifying groups
with cloud
results in a panel.superpose
like effect (via
panel.3dscatter
).
wireframe
can optionally render the surface as being
illuminated by a light source (no shadows though). Details can be
found in the help page for panel.3dwire
. Note that
although arguments controlling these are actually arguments for the
panel function, they can be supplied to cloud
and
wireframe
directly.
For single panel plots, wireframe
can also plot parametrized
3D surfaces (i.e., functions of the form f(u,v) = (x(u,v), y(u,v),
z(u,v)), where values of (u,v) lie on a rectangle. The simplest
example of this sort of surface is a sphere parametrized by latitude
and longitude. This can be achieved by calling wireframe
with a
formula x
of the form z~x*y
, where x
, y
and z
are all matrices of the same dimension, representing the
values of x(u,v), y(u,v) and z(u,v) evaluated on a discrete
rectangular grid (the actual values of (u,v) are irrelevant).
When this feature is used, the heights used to calculate drape
colors or shading colors are no longer the z
values, but the
distances of (x,y,z)
from the origin.
Note that this feature does not work with groups
,
subscripts
, subset
, etc. Conditioning variables are also
not supported in this case.
The algorithm for identifying which edges of the bounding box are
‘behind’ the points doesn't work in some extreme
situations. Also, panel.cloud
tries to figure out the
optimal location of the arrows and axis labels automatically, but can
fail on occasion (especially when the view is from ‘below’ the
data). This can be manually controlled by the scpos
argument in
panel.cloud
.
These and all other high level Trellis functions have several other
arguments in common. These are extensively documented only in the
help page for xyplot
, which should be consulted to learn
more detailed usage.
An object of class "trellis"
. The
update
method can be used to
update components of the object and the
print
method (usually called by
default) will plot it on an appropriate plotting device.
There is a known problem with grouped wireframe
displays
when the (x, y) coordinates represented in the data do not represent
the full evaluation grid. The problem occurs whether the grouping is
specified through the groups
argument or through the formula
interface, and currently causes memory access violations. Depending
on the circumstances, this is manifested either as a meaningless plot
or a crash. To work around the problem, it should be enough to have
a row in the data frame for each grid point, with an NA
response (z
) in rows that were previously missing.
Deepayan Sarkar Deepayan.Sarkar@Rproject.org
Sarkar, Deepayan (2008) Lattice: Multivariate Data Visualization with R, Springer. http://lmdvr.rforge.rproject.org/
Lattice
for an overview of the package, as well as
xyplot
, levelplot
,
panel.cloud
.
For interaction, see panel.identify.cloud
.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43  ## volcano ## 87 x 61 matrix
wireframe(volcano, shade = TRUE,
aspect = c(61/87, 0.4),
light.source = c(10,0,10))
g < expand.grid(x = 1:10, y = 5:15, gr = 1:2)
g$z < log((g$x^g$gr + g$y^2) * g$gr)
wireframe(z ~ x * y, data = g, groups = gr,
scales = list(arrows = FALSE),
drape = TRUE, colorkey = TRUE,
screen = list(z = 30, x = 60))
cloud(Sepal.Length ~ Petal.Length * Petal.Width  Species, data = iris,
screen = list(x = 90, y = 70), distance = .4, zoom = .6)
## cloud.table
cloud(prop.table(Titanic, margin = 1:3),
type = c("p", "h"), strip = strip.custom(strip.names = TRUE),
scales = list(arrows = FALSE, distance = 2), panel.aspect = 0.7,
zlab = "Proportion")[, 1]
## transparent axes
par.set <
list(axis.line = list(col = "transparent"),
clip = list(panel = "off"))
print(cloud(Sepal.Length ~ Petal.Length * Petal.Width,
data = iris, cex = .8,
groups = Species,
main = "Stereo",
screen = list(z = 20, x = 70, y = 3),
par.settings = par.set,
scales = list(col = "black")),
split = c(1,1,2,1), more = TRUE)
print(cloud(Sepal.Length ~ Petal.Length * Petal.Width,
data = iris, cex = .8,
groups = Species,
main = "Stereo",
screen = list(z = 20, x = 70, y = 0),
par.settings = par.set,
scales = list(col = "black")),
split = c(2,1,2,1))

Questions? Problems? Suggestions? Tweet to @rdrrHQ or email at ian@mutexlabs.com.
All documentation is copyright its authors; we didn't write any of that.