xyplot                package:flowViz                R Documentation

_M_e_t_h_o_d _i_m_p_l_e_m_e_n_t_i_n_g _L_a_t_t_i_c_e _E_C_D_F _p_l_o_t_s _f_o_r _f_l_o_w _d_a_t_a

_D_e_s_c_r_i_p_t_i_o_n:

     These functions create Trellis scatter plots (a.k.a. dot plots in
     the Flow Cytometry community) from flow cytometry data.

_U_s_a_g_e:

     ## methods for 'flowSet' objects

     ## S4 method for signature 'formula, flowSet':
     xyplot(x, data,
            xlab, ylab,
            as.table = TRUE,
            prepanel = prepanel.xyplot.flowset,
            panel = panel.xyplot.flowset,
            pch = ".", smooth = TRUE,
            filter = NULL,
            filterResults = NULL,
            displayFilter = TRUE,
            ...)

     ## methods for 'flowFrame' objects

     ## S4 method for signature 'flowFrame, missing':
     xyplot(x, data,
            xlab = time, ylab = "", time = "Time",
            layout,
            type = "l", smooth = FALSE,
            ...)

     ## S4 method for signature 'formula, flowFrame':
     xyplot(x, data,
            smooth = TRUE, 
            panel = if (smooth) panel.smoothScatter else panel.xyplot,
            ...)

     ## S4 method for signature 'flowFrame, missing':
     splom(x, data, 
           pscales = 0,
           smooth = TRUE, pch = ".",
           time = "Time", exclude.time = TRUE,
           panel = function(x, y, smooth, ...) {
               if (smooth) panel.smoothScatter(x, y, ...)
               else panel.xyplot(x, y, ...)
           },
           ...)


     panel.xyplot.flowset(x, frames, channel.x, channel.y,
                  channel.x.name, channel.y.name, 
                  filter = NULL, filterResults = NULL, displayFilter = TRUE,
                  pch, smooth, ...)

     prepanel.xyplot.flowset(x, frames, channel.x, channel.y, ...)

_A_r_g_u_m_e_n_t_s:

       x: a formula describing the structure of the plot and the
          variables to be used in the display.  In
          'prepanel.xyplot.flowset' and 'panel.xyplot.flowset', names
          of flow frames. 

    data: a 'flowSet' or 'flowFrame' object that serves as the source
          of data 

  smooth: logical.  If 'TRUE', 'panel.smoothScatter' is used to display
          a partially smoothed version of the data. Otherwise, points
          are plotted as in a standard scatter plot. 

xlab, ylab: Labels for data axes, with suitable defaults taken from the
          formula 

     pch: the plotting character used when 'smooth=FALSE'

    type: type of rendering; see 'panel.xyplot' for details. 

prepanel: the prepanel function.  See 'xyplot' 

   panel: the panel function.  See 'xyplot' 

  filter: A filter object.  Ignored when 'filterResults' is not 'NULL'. 

filterResults: A filterResult object, that is the result of applying a
          filter on each frame in 'data'.  If this is 'NULL' but
          'filter' is not, it will be created on the fly by applying
          'filter' to each frame.  

displayFilter: logical or list.  If 'TRUE', an attempt is made to
          display the geometric boundaries of 'filter' (if specified)
          in the plot.  The same holds if 'displayFilter' is a list,
          but in that case the components are interpreted as graphical
          parameters to be passed on to 'panel.polygon' 

    time: A character string giving the name of the column recording
          time. 

exclude.time: logical, specifying whether to exclude the time variable
          from a scatter plot matrix. 

as.table, pscales, layout: These arguments are passed unchanged to the
          corresponding methods in lattice, and are listed here only
          because they provide different defaults.  See documentation
          for the original methods for details. 

channel.x, channel.y: expressions defining the x and y variables in
          terms of columns in the data.  Can involve functions or
          multiple columns from the data. 

channel.x.name, channel.y.name: character strings giving corresponding
          names, used to match filter parameters if applicable. 

  frames: an environment containing frame-specific data

     ...: more arguments, usually passed on to the underlying lattice
          methods. 

_M_e_t_h_o_d_s:


     _x_y_p_l_o_t 'signature(x = "formula", data = "flowSet")': creates
          scatter plots (a.k.a. dot plots) of a pair of channels


     _x_y_p_l_o_t 'signature(x = "flowFrame", data = "missing")': produces
          diagnostic time series plots of all channels against time.


     _x_y_p_l_o_t 'signature(x = "formula", data = "flowFrame")': more
          general scatter plots from a 'flowFrame' object.  The formula
          can be fairly general.


     _s_p_l_o_m 'signature(x = "flowFrame", data = "missing")': draws a
          scatter plot matrix of all channels (excluding time, by
          default) of a 'flowFrame' object.


_S_e_e _A_l_s_o:

     Not all standard lattice arguments will have the intended effect,
     but many should.  For a fuller description of possible arguments
     and their effects, consult documentation on lattice.

_E_x_a_m_p_l_e_s:

     data(GvHD)

     ## simple bivariate scatter plot (a.k.a. dot plot)
     ## by default ('smooth=TRUE') panel.smoothScatter is used

     xyplot(`SSC-H` ~ `FSC-H` | Patient:Visit, data = GvHD, 
            layout = c(7, 5))

     xyplot(`SSC-H` ~ `FSC-H` | Patient:Visit,
            data = transform("SSC-H"=asinh,"FSC-H"=asinh) %on% GvHD,
            layout = c(7, 5))

     ## version without smooth

     xyplot(`SSC-H` ~ `FSC-H` | Visit + Patient, data = GvHD, 
            smooth = FALSE, strip = strip.custom(strip.names = TRUE))

     ## several examples with time on the X axis

     xyplot(`FSC-H` ~ Time | Visit, GvHD, 
            smooth = FALSE, type = "l", 
            subset = (Patient == 5))

     xyplot(`FSC-H` ~ Time | Patient:Visit, GvHD, 
            smooth = FALSE, type = "l",
            strip = FALSE, strip.left = TRUE,
            aspect = "xy")

     ## combine plots for two channels

     ssc.time <- 

         xyplot(`SSC-H` ~ Time | factor(Patient):factor(Visit), GvHD, 
                smooth = FALSE, type = "l",
                strip = FALSE,
                strip.left = strip.custom(horizontal = TRUE),
                par.strip.text = list(lines = 3),
                between = list(y = rep(c(0, 0.5), c(6, 1))),
                scales = list(x = list(axs = "i"), y = list(draw = FALSE)),
                layout = c(1, 35))

     fsc.time <- 

         xyplot(`FSC-H` ~ Time | factor(Patient):factor(Visit), GvHD, 
                smooth = FALSE, type = "l",
                strip = FALSE,
                strip.left = strip.custom(horizontal = TRUE),
                par.strip.text = list(lines = 3),
                between = list(y = rep(c(0, 0.5), c(6, 1))),
                scales = list(x = list(axs = "i"), y = list(draw = FALSE)),
                layout = c(1, 35))

     plot(fsc.time, split = c(1, 1, 2, 1))
     plot(ssc.time, split = c(2, 1, 2, 1), newpage = FALSE)

     ## saving plots as variables allows more manipulation

     plot(update(fsc.time[29:35], layout = c(1, 7)),
          split = c(1, 1, 1, 2))

     plot(update(ssc.time[29:35], layout = c(1, 7)),
          split = c(1, 2, 1, 2), newpage = FALSE)

     ## scatter plot matrix of individual flowFrames

     splom(GvHD[["s10a07"]], smooth = FALSE)

     splom(GvHD[["s10a07"]], smooth = FALSE,
           prepanel.limits = function(x) quantile(as.numeric(x), c(0.0, 0.99)))

     ## time plot of individual flowFrames

     xyplot(GvHD[["s5a07"]], time = "Time")

     xyplot(`FSC-H` + `SSC-H` + `FL1-H` ~ Time, GvHD[["s5a07"]],
            aspect = "xy", outer = TRUE,
            scales = list(y = "free"),
            type = "l", smooth = FALSE)

     xyplot(`FSC-H` ~ `SSC-H`, GvHD[["s5a01"]], nbin = 100)

     ## displaying filters

     n2gate <- norm2Filter("SSC-H", "FSC-H")

     xyplot(`SSC-H` ~ `FSC-H` | Patient:Visit, data = GvHD,
            filter = n2gate, ## displayFilter = TRUE,
            layout = c(7, 5))

     xyplot(`SSC-H` ~ `FSC-H` | Patient:Visit,
            data = transform("SSC-H"=asinh,"FSC-H"=asinh) %on% GvHD,
            smooth = FALSE,
            filter = n2gate, ## displayFilter = list(border = "black"),
            layout = c(7, 5))

     xyplot(`SSC-H` ~ `FSC-H` | Patient:Visit,
            data = transform("SSC-H"=asinh,"FSC-H"=asinh) %on% GvHD,
            subset = Patient == "6",
            filter = rectangleGate("FSC-H"=c(5.5, 7),"SSC-H"=c(4, 6.5)),
            displayFilter = list(lwd = 3))

     n2gate.results <- filter(GvHD, n2gate %on% transform("SSC-H"=asinh,"FSC-H"=asinh))

     xyplot(`SSC-H` ~ `FSC-H` | Visit, data = GvHD,
            subset = Patient == "6",
            filterResults = n2gate.results, smooth = FALSE)

     xyplot(`SSC-H` ~ `FSC-H` | Visit,
            data = GvHD,
            subset = Patient == "6",
            smooth = FALSE,
            filter = n2gate,
            filterResults = n2gate.results,
            displayFilter = list(lwd = 0.5))

     xyplot(`SSC-H` ~ `FSC-H` | Visit,
            data = transform("SSC-H"=asinh,"FSC-H"=asinh) %on% GvHD,
            subset = Patient == "6",
            smooth = FALSE,
            filter = rectangleGate("FSC-H"=c(5.5, 7),"SSC-H"=c(4, 6.5)),
            filterResults = n2gate.results,
            displayFilter = list(border = 'red'))

