panel.cloud

0th

Percentile

Default Panel Function for cloud

These are default panel functions controlling cloud and wireframe displays.

Keywords
dplot
Usage
panel.cloud(x, y, subscripts, z,
            groups = NULL,
            perspective = TRUE,
            distance = if (perspective) 0.2 else 0, 
            xlim, ylim, zlim,
            panel.3d.cloud = "panel.3dscatter",
            panel.3d.wireframe = "panel.3dwire",
            screen = list(z = 40, x = -60),
            R.mat = diag(4), aspect = c(1, 1),
            par.box = NULL,
            xlab, ylab, zlab,
            xlab.default, ylab.default, zlab.default,
            scales.3d,
            proportion = 0.6,
            wireframe = FALSE,
            scpos,
            ...,
            at)
panel.wireframe(...)
panel.3dscatter(x, y, z, rot.mat, distance,
                groups, type = 'p',
                xlim.scaled, ylim.scaled, zlim.scaled,
                zero.scaled,
                col, col.point, col.line,
                lty, lwd, cex, pch,
                cross, ..., subscripts)
panel.3dwire(x, y, z, rot.mat = diag(4), distance,
             shade = FALSE,
             shade.colors.palette = trellis.par.get("shade.colors")$palette,
             light.source = c(0, 0, 1000),
             xlim.scaled,
             ylim.scaled,
             zlim.scaled,
             col = if (shade) "transparent" else "black",
             lty = 1, lwd = 1,
             alpha,
             col.groups = superpose.fill$col,
             polynum = 100,
             ...,
             drape = FALSE,
             at,
             col.regions = regions$col,
             alpha.regions = regions$alpha)
Arguments
x, y, z
numeric (or possibly factors) vectors representing the data to be displayed. The interpretation depends on the context. For panel.cloud these are essentially the same as the data passed to the high level plot (except if form
subscripts
index specifying which points to draw. The same x, y, z values (representing the whole data) are passed to panel.cloud for each panel. subscripts specifies the subset of rows to be used for the particular
groups
specification of a grouping variable, passed down from the high level functions.
perspective
logical, whether to plot a perspective view. Setting this to FALSE is equivalent to setting distance to 0
distance
numeric, between 0 and 1, controls amount of perspective. The distance of the viewing point from the origin (in the transformed coordinate system) is 1 / distance. This is described in a little more detail in the documentation for
screen
A list determining the sequence of rotations to be applied to the data before being plotted. The initial position starts with the viewing point along the positive z-axis, and the x and y axes in the usual position. Each component of the list s
R.mat
initial rotation matrix in homogeneous coordinates, to be applied to the data before screen rotates the view further.
par.box
graphical parameters for box, namely, col, lty and lwd. By default obtained from the parameter box.3d
xlim, ylim, zlim
limits for the respective axes. As with other lattice functions, these could each be a numeric 2-vector or a character vector indicating levels of a factor.
panel.3d.cloud, panel.3d.wireframe
functions that draw the data-driven part of the plot (as opposed to the bounding box and scales) in cloud and wireframe. This function is called after the `back' of the bounding box is drawn, but before the `front' is
aspect
aspect as in cloud
xlab, ylab, zlab
Labels, have to be lists. Typically the user will not manipulate these, but instead control this via arguments to cloud directly.
xlab.default
for internal use
ylab.default
for internal use
zlab.default
for internal use
scales.3d
list defining the scales
proportion
numeric scalar, gives the length of arrows as a proportion of the sides
scpos
A list with three components x, y and z (each a scalar integer), describing which of the 12 sides of the cube the scales should be drawn. The defaults should be OK. Valid values are x: 1, 3, 9, 11; y: 8, 5, 7, 6 and z: 4, 2, 10, 12. (See comme
wireframe
logical, indicating whether this is a wireframe plot
drape
logical, whether the facets will be colored by height, in a manner similar to levelplot. This is ignored if shade=TRUE.
at, col.regions, alpha.regions
deals with specification of colors when drape = TRUE in wireframe. at can be a numeric vector, col.regions a vector of colors, and alpha.regions
rot.mat
4x4 transformation matrix in homogeneous coordinates. This gives the rotation matrix combining the screen and R.mat arguments to panel.cloud
type
character vector, specifying type of cloud plot. Can include one or more of ``p'', ``l'', ``h'' or ``b''. ``p'' and ``l'' mean `points' and `lines' respectively, and ``b'' means `both'. ``h'' stands for `histogram', and causes a line to be dra
xlim.scaled, ylim.scaled, zlim.scaled
axis limits (after being scaled to the bounding box)
zero.scaled
z-axis location (after being scaled to the bounding box) of the X-Y plane in the original data scale, to which lines will be dropped (if within range) from each point when type = 'h'
cross
logical, defaults to TRUE if pch='+'. panel.3dscatter can represent each point by a 3d `cross' of sorts (it's much easier to understand looking at an example than from a description). This is different fr
shade
logical, indicating whether the surface is to be colored using an illumination model with a single light source
shade.colors.palette
a function (or the name of one) that is supposed to calculate the color of a facet when shading is being used. Three pieces of information is available to the function: first, the cosine of the angle between the incident light ray and the norm
light.source
a 3-vector representing (in cartesian coordinates) the light source. This is relative to the viewing point being (0, 0, 1/distance) (along the positive z-axis), keeping in mind that all observations are bounded within the [-0.5, 0.5] cube
polynum
quadrilateral faces are drawn in batches of polynum at a time. Drawing too few at a time increases the total number of calls to the underlying grid.polygon function, which affects speed. Trying to draw too many at onc
col.groups
colors for different groups
col, col.point, col.line, lty, lwd, cex, pch, alpha
graphical parameters
...
other parameters, passed down when appropriate
Details

These functions together are responsible for the content drawn inside each panel in cloud and wireframe. panel.wireframe is a wrapper to panel.cloud, which does the actual work.

panel.cloud is responsible for drawing the content that does not depend on the data, namely, the bounding box, the arrows/scales, etc. At some point, depending on whether wireframe is TRUE, it calls either panel.3d.wireframe or panel.3d.cloud, which draws the data-driven part of the plot.

The arguments accepted by these two functions are different, since they have essentially different purposes. For cloud, the data is unstructured, and x, y, z are all passed to the panel.3d.cloud function. For wireframe, on the other hand, x and y are increasing vectors with unique values, defining a rectangular grid. z must be a matrix with length(x) * length(y) rows, and as many columns as the number of groups.

panel.3dscatter is the default panel.3d.cloud function. It has a type argument similar to panel.xyplot, and supports grouped displays. It tries to honour depth ordering, i.e., points and lines closer to the camera are drawn later, overplotting more distant ones. (Of course there is no absolute ordering for line segments, so an ad hoc ordering is used. There is no hidden point removal.)

panel.3dwire is the default panel.3d.wireframe function. It calculates polygons corresponding to the facets one by one, but waits till it has collected information about polynum facets, and draws them all at once. This avoids the overhead of drawing grid.polygon repeatedly, speeding up the rendering considerably. If shade = TRUE, these attempt to color the surface as being illuminated from a light source at light.source. palette.shade is a simple function that provides the deafult shading colors

Multiple surfaces are drawn if groups is non-null in the call to wireframe, however, the algorithm is not sophisticated enough to render intersecting surfaces correctly.

See Also

cloud

Aliases
  • panel.cloud
  • panel.wireframe
  • panel.3dscatter
  • panel.3dwire
Documentation reproduced from package lattice, version 0.10-10, License: GPL version 2 or later

Community examples

Looks like there are no examples yet.