l_tour {loon.tourr}

Tour in loon

Description

An interactive tour in loon

Usage

l_tour(
  data,
  scaling = c("data", "variable", "observation", "sphere"),
  by = NULL,
  on,
  as.l_tour = TRUE,
  color = loon::l_getOption("color"),
  tour_path = tourr::grand_tour(),
  group = "color",
  start = NULL,
  slicing = FALSE,
  slicingDistance = NULL,
  numOfTours = 30L,
  interpolation = 40L,
  parent = NULL,
  envir = parent.frame(),
  ...
)

Arguments

data

a data frame with numerical data only

scaling

one of 'variable', 'data', 'observation', 'sphere', or 'none' to specify how the data is scaled. See Details

by

loon plot can be separated by some variables into multiple panels. This argument can take a formula, n dimensional state names (see l_nDimStateNames) an n-dimensional vector and data.frame or a list of same lengths n as input.

on

if the x or by is a formula, an optional data frame containing the variables in the x or by. If the variables are not found in data, they are taken from environment, typically the environment from which the function is called.

as.l_tour

return a l_tour object; see details

color

vector with line colors. Default is given by l_getOption("color").

tour_path

tour path generator, defaults to 2d grand tour

group

only used for layers. As we scroll the bar, the layers are re-calculated. This argument is used to specify which state is used to set groups (i.e. "color", "linewidth", etc).

start

projection to start at, if not specified, uses default associated with tour path

slicing

whether to show a sliced scatter plot

slicingDistance

the slicing distance that if the distance between points and the projected plane is less than this distance, points will be preserved; else points will be invisible. The default is NULL and a suggested value will be given. See details

numOfTours

the number of tours

interpolation

the steps between two serial projections. The larger the value is, the smoother the transitions would be.

parent

a valid Tk parent widget path. When the parent widget is specified (i.e. not NULL) then the plot widget needs to be placed using some geometry manager like tkpack or tkplace in order to be displayed. See the examples below.

envir

the environment to use.

...

named arguments to modify the serialaxes states or layouts, see details.

Details

• tour_path is a tour generator; available tours are grand_tour, dependence_tour, frozen_tour, guided_tour, planned_tour, and etc

• Argument as.l_tour

  • If set to TRUE, the function returns an l_tour (or an l_tour_compound) object. Essentially, this object is a list with the first element being a loon (Tcl) widget and the second element a matrix of projection vectors. The advantage of this setup is that the matrix of projection vectors can be easily accessed using the `[` function (or the l_cget function). However, a limitation is that it does not constitute a valid loon (Tcl) widget-calling l_isLoonWidget would return FALSE. Consequently, many of loon's functionalities remain inaccessible.

  • If set to FALSE, the function returns either a loon (Tcl) widget (where calling l_isLoonWidget would return TRUE) or an l_compound object. In this case, the matrix of projection vectors is not directly accessible from it. However, the l_getProjection function can be used to retrieve an estimated matrix of projection vectors.

• The scaling state defines how the data is scaled. The axes display 0 at one end and 1 at the other. For the following explanation assume that the data is in a n x p dimensional matrix. The scaling options are then

  variable	per column scaling
  observation	per row scaling
  data	whole matrix scaling
  sphere	transforming variables to principal components

• The default slidingDistance is suggested by Laa, U., Cook, D., & Valencia, G. (2020). First, find the maximum Euclidean distance of each observation (centralized), say maxD. Then, compute the "relative volume" that vRel = (maxD^(d - 2))/10, where d is the dimension of this data set. In the end, the suggested slidingDistance is given by vRel^(1/(d - 2))

Value

an l_tour or an l_tour_compound object that one can query the loon states and a matrix projection vectors

See Also

l_getProjection

Examples

if(interactive() && requireNamespace('tourr')) {
  # 2D projection
  fl <- tourr::flea[, 1:6]
  # different scaling will give very different projections
  # in this dataset, scaling 'variable' will give the best separation
  p <- l_tour(fl, scaling = 'variable',
              color = tourr::flea$species)
  l0 <- l_layer_hull(p, group = p["color"],
                     color = "red", linewidth = 4)
  l1 <- l_layer_density2d(p)
  # a `l_tour` object
  class(p)

  # query the matrix of projection vectors
  proj <- p['projection'] # or `l_getProjection(p)`
  # suppose the scaling is still 'observation'
  new_xy <- as.matrix(
    loon::l_getScaledData(data = fl,
                          scaling = 'observation')) %*%
    proj
  plot(new_xy, xlab = "V1", ylab = "V2",
       col = loon::hex12tohex6(p['color']))

  # A higher dimension projection
  # turn the `tour` to 4 dimensional space
  s <- l_tour(fl, color = tourr::flea$species,
              scaling = "observation",
              tour_path = tourr::grand_tour(4L))

  # set `as.l_tour` FALSE
  p <- l_tour(fl, scaling = 'observation',
              color = tourr::flea$species)
  class(p)
  ## ERROR
  ## p["projection"]

  # query the estimated matrix of projection vectors
  l_getProjection(p)

  ##### facet by region
  olive <- tourr::olive
  p <- with(olive, l_tour(olive[, -c(1, 2)],
                          by = region,
                          color = area))
}