l_tour: Tour in loon
In loon.tourr: Tour in 'Loon'

Description Usage Arguments Details Value See Also Examples

View source: R/l_tour.R

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(),
  ...
)

`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.

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

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

l_getProjection

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