Tour in loon

An interactive tour in loon

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.

Value

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

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 TRUE, a l_tour (or a l_tour_compound) object is returned. It is a list essentially with the first object loon (tcl) widget and the second object matrix of projection vectors. The benefit is that the matrix of projection vectors can be accessed via function `[` (or l_cget). However, the drawback is that, since it is not a valid loon (tcl) widget (call l_isLoonWidget would return **FALSE**)

  • If FALSE: a valid loon (tcl) widget (call l_isLoonWidget would return "TRUE") or a l_compound object will be returned so that the matrix of projection vectors cannot be accessed directly from it. However, function l_getProjection could return an estimated one.

• 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))

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))
}