# cloud

##### 3d Scatter Plot

Draws 3d scatter plots and surfaces.

- Keywords
- hplot

##### Usage

```
cloud(formula, data,
aspect = c(1, 1),
scales = list(distance = rep(1, 3), arrows = TRUE),
zlab,
zlim,
zoom = 0.8,
...)
wireframe(formula, data,
at = pretty(z, cuts),
col.regions,
alpha.regions,
drape = FALSE,
shade = FALSE,
pretty = FALSE,
colorkey = any(drape),
cuts = 70,
zoom,
scales,
...,
col.regions)
```

##### Arguments

- formula
- a formula of the form
`z ~ x * y | g1 * g2 * ...`

, where`z`

is a numeric response, and`x, y`

are numeric values.`g1, g2, ...`

, if present, are conditioning variables used for conditioning, and mus - data
- data frame in which variables are evaluated. Ignored is
`formula`

is not really a formula object. - aspect
- vector of length 2, giving the relative aspects of the y-size/x-size and z-size/x-size of the enclosing cube.
- scales
- a list describing the scales. As with other high level functions
(see
`xyplot`

for details), this list can contain parameters in name=value form. It can also contain components with the special n - zlab
- label describing the z variable. Similar to
`xlab`

and`ylab`

in other high level functions - zlim
- limits for the z-axis. Similar to
`xlim`

and`ylim`

in other high level functions - zoom
- factor by which to scale the picture. Useful to get the variable names into the plot. This is actually only used in the default prepanel function.
- drape
- logical, whether the wireframe is to be draped in color. If
`TRUE`

, the height of a facet is used to determine its color in a manner similar to the coloring scheme used in`levelplot`

- shade
- logical, whether the wireframe is to be rendered as being
illuminated from a light source. See
`panel.3dwire`

for details - at, col.regions, alpha.regions
- these arguments are analogous to those in
`levelplot`

. if`drape=TRUE`

,`at`

gives the vector of cutpoints where the colors change, and`col.regions`

the vector - cuts
- if
`at`

is unspecified, the approximate number of cutpoints if`drape=TRUE`

- 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
`levelplot`

for details. - ...
- other arguments, passed to the panel function. In particular, the
arguments
`distance`

,`perspective`

,`screen`

and`R.mat`

are very important in determining the 3-D display. These arguments are desc

##### Details

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 non-default values
of `aspect`

). The viewing direction is given by a sequence of
rotations specified by the `screen`

argument, starting from the
positive Z-axis. 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 3-D Scatter Plot, while `wireframe`

draws a
3-D 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
3-D 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`

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.

##### Value

- 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.

##### synopsis

cloud(formula, data = parent.frame(), allow.multiple = is.null(groups) || outer, outer = FALSE, auto.key = FALSE, aspect = c(1,1), panel = "panel.cloud", prepanel = NULL, scales = list(), strip = TRUE, groups = NULL, xlab, xlim = if (is.factor(x)) levels(x) else range(x, na.rm = TRUE), ylab, ylim = if (is.factor(y)) levels(y) else range(y, na.rm = TRUE), zlab, zlim = if (is.factor(z)) levels(z) else range(z, na.rm = TRUE), at, drape = FALSE, pretty = FALSE, drop.unused.levels = lattice.getOption("drop.unused.levels"), ..., default.scales = list(distance = c(1, 1, 1), arrows = TRUE, axs = axs.default), colorkey = any(drape), col.regions, alpha.regions, cuts = 70, subset = TRUE, axs.default = "r") wireframe(formula, data = parent.frame(), panel = "panel.wireframe", prepanel = NULL, strip = TRUE, groups = NULL, cuts = 70, pretty = FALSE, drape = FALSE, ..., colorkey = any(drape), subset = TRUE)

##### See Also

##### Examples

```
## 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$g + 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)
par.set <-
list(axis.line = list(col = "transparent"), clip = list(panel = FALSE))
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),
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),
split = c(2,1,2,1))
```

*Documentation reproduced from package lattice, version 0.10-10, License: GPL version 2 or later*