Lattice               package:lattice               R Documentation

_L_a_t_t_i_c_e _G_r_a_p_h_i_c_s

_D_e_s_c_r_i_p_t_i_o_n:

     Implementation of Trellis Graphics in R

_D_e_t_a_i_l_s:

     Trellis Graphics is a framework for data visualization developed
     at the Bell Labs by Rick Becker, Bill Cleveland et al, extending
     ideas presented in Bill Cleveland's 1993 book _Visualizing Data_.

     Lattice is best thought of as an implementation of Trellis
     Graphics for R. Its interface is based on the implementation in
     S-PLUS, but there are several differences.  To the extent
     possible, care has been taken to ensure that existing Trellis code
     written for S-PLUS works unchanged (or with minimal change) in
     Lattice. If you are having problems porting S-PLUS code, read the
     entry for 'panel' in the documentation for 'xyplot'. Most high
     level Trellis functions in S-PLUS are implemented, with the
     exception of 'piechart'.

     Lattice is built upon the Grid Graphics engine for R being
     developed by Paul Murrell and requires the 'grid' add-on package.

     Type 'help(package = lattice)' to see a list of (public) Lattice
     graphics functions for which further documentation is available. 
     The 'See Also' section below has list of specific areas of
     possible interest and pointers to the help pages with respective
     details.  Apart from the documentation accompanying this package,
     several documents outlining the use of Trellis graphics is
     available from Bell Lab's website that might provide a holistic
     introduction to the Trellis paradigm.  The example section shows
     how to bring up a brief history of changes to the lattice package,
     which provides a summary of new features.

_N_o_t_e:

     High level Lattice functions (like 'xyplot') are different from
     conventional R graphics functions because they don't actually draw
     anything. Instead, they return an object of class '"trellis"'
     which has to be then 'print'ed or 'plot'ted to create the actual
     plot.  This is normally done automatically, but not when the high
     level functions are called inside another function (most often
     'source') or other contexts where automatic printing is suppressed
     (e.g. 'for' or 'while' loops).  In such situations, an explicit
     call to 'print' or 'plot' is required.

     Lattice plots are highly customizable via user-modifiable
     settings. However, these are completely unrelated to base graphics
     settings; in particular, changing 'par()' settings usually have no
     effect on lattice plots.

_A_u_t_h_o_r(_s):

     Deepayan Sarkar Deepayan.Sarkar@R-project.org

_R_e_f_e_r_e_n_c_e_s:

     Bell Lab's Trellis Page: <URL:
     http://cm.bell-labs.com/cm/ms/departments/sia/project/trellis/>

     Cleveland, W.S. (1993) _Visualizing Data_.

     Becker, R.A., Cleveland, W.S. and Shyu, M. "The Visual Design and
     Control of Trellis Display", _Journal of Computational and
     Graphical Statistics_

_S_e_e _A_l_s_o:

     The Lattice user interface primarily consists of several 'high
     level' generic functions (listed below), each designed to create a
     particular type of statistical display by default.  While each
     function does different things, they share several common
     features, reflected in several common arguments that affect the
     resulting displays in similar ways.  These arguments are
     extensively (sometimes only) documented in the help page for
     'xyplot'.  This includes a discussion of _conditioning_ and
     control of the Trellis layout.

     Lattice employs an extensive system of user-controllable
     parameters to determine the look and feel of the displays it
     produces.  To learn how to use and customise the Graphical
     parameters used by the Lattice functions, see 'trellis.par.set'. 
     For other settings, see 'lattice.options'.  The default graphical
     settings are different for different graphical devices.  To learn
     how to initialise new devices with the desired settings or change
     the settings of the current device, see 'trellis.device'.

     To learn about sophisticated (non-default) printing capabilities,
     see 'print.trellis'.  See 'update.trellis' to learn about
     manipulating a '"trellis"' object.  Tools to augment lattice plots
     after they are drawn (including 'locator'-like functionality) is
     described in the 'interaction' help page.

     The following is a list of 'high level' functions in the Lattice
     package with a brief description of what they do.  In all cases,
     the actual display is produced by the so-called 'panel' function,
     which has a suitable default, but can be substituted by an user
     defined function to create custom displays.  The user will most
     often be interested in the default panel functions, which have a
     separate help page, linked to from the help pages of the
     corresponding high level function.  Although documented
     separately, arguments to these panel functions can be supplied
     directly to the high level functions, which will forward the
     arguments as appropriate.

     *Univariate:*  

     'barchart' bar plots

     'bwplot' box and whisker plots

     'densityplot' kernel density plots  

     'dotplot' dot plots

     'histogram' histograms

     'qqmath' quantile plots against mathematical distributions

     'stripplot' 1-dimensional scatterplot

     *Bivariate:*

     'qq' q-q plot for comparing two distributions

     'xyplot' scatter plot (and possibly a lot more)

     *Trivariate:*

     'levelplot' level plots (similar to image plots in R)

     'contourplot' contour plots

     'cloud' 3-D scatter plots

     'wireframe' 3-D surfaces (similar to persp plots in R)

     *Hypervariate:*

     'splom' scatterplot matrix

     'parallel' parallel coordinate plots

     *Miscellaneous:*

     'rfs' residual and fitted value plot (also see 'oneway')

     'tmd' Tukey Mean-Difference plot

     Additionally, there are several panel functions that do little by
     themselves, but can be useful components of custom panel
     functions. These are documented in 'panel.functions'.  Lattice
     also has a collection of convenience functions that correspond to
     the base graphics primitives 'lines', 'points', etc.  They are
     implemented using Grid graphics, but try to be as close to the
     base versions as possible in terms of their argument list.  These
     functions have imaginative names like 'llines' or 'panel.lines'
     and are often useful when writing (or porting from S-PLUS code)
     nontrivial panel functions.

_E_x_a_m_p_l_e_s:

     ## Not run: 
     ## brief history of changes
     file.show(system.file("Changes", package = "lattice"))
     ## End(Not run)

