Programmatic access of the interactive plot

At times, as when creating this document, it will be handy to have programmatic access to the loon plot. This can be done by assigning the loon plot to a variable, say lp, in any one of several different ways:

When it was first printed it, the interactive plot would have returned a string. For example, it was

#> [1] ".l0.ggplot.plot"

which is of the form ".lXX.ggplot.plot" where XX is a non-negative integer.

This is the tcltk “path” to the loon plot and uniquely identifies the loon structure. The data structure is now accessed through l_getFromPath(pathname) as below.

lp <- l_getFromPath(".lXX.ggplot.plot")  # replace XX by whatever number appeared

Of course, this requires you to have noticed and recovered the string pathname for that plot when it first appeared. Fortunately, that is not necessary. In the title bar of the window containing the loon plot, the string following "path: " can also be used. In the present case, this will be of the form ".lXX.ggplot" (as before but without the additional ".plot" suffix). The call

lp <- l_getFromPath(".lXX.ggplot")  # replace XX by whatever number appeared

will return the interactive plot as before.

Finally, if you have the foresight to know that you would like to have programmatic access to the interactive plot from the start, you could assign it to a variable when it was first created.
There are two ways to do this.

One is

lp <- print(lgp)

The other uses a powerful function called loon.ggplot() (more on this below):

lp <- loon.ggplot(lgp)

Note: that unlike l_getFromPath(), either of the above calls will produce a new interactive plot from lgp and assign it to lp.

The loon-ggplot duality

Using l_ggplot() in place of ggplot() extends the graphics grammar of ggplot2 to produce interactive loon plots.

• use l_ggplot() in place of ggplot()

  • plotting an l_ggplot produces a static ggplot display

  • printing an l_ggplot produces an interactive loon display.

• the l_ggplot is not the interactive loon plot; it is an enhanced ggplot and can be augmented just as any other ggplot.

• Changes to the ggplot have no effect on the interactive plot

  For example,

  plot(lgp + geom_smooth())

  behaves like any other ggplot with no effect on the interactive plot.

• Changes to the interactive loon plot have no effect on the static l_ggplot

  Make whatever changes you like interactively to the loon plot lp, or programmatically as below:

  # Change glyph aesthetics of ALL points
  lp["color"] <- "lightgrey"
  lp["glyph"] <- "ctriangle"  # closed triangle
  lp["size"]  <- 10           # proportional to area in loon
  
  # Dynamically change the scaling (magnify or zoom in and out)
  for (mag in rep(c(0.8, 1, 1.2), times = 5)){
     lp["zoomX"] <- mag
     lp["zoomY"] <- mag
     Sys.sleep(0.1) # slow down to see effect
   }
  # Settle on
  lp["zoomX"] <- 1.2
  lp["zoomY"] <- 1.2
  #
  # Or, similarly, change the location/origin of the plot
  xlocs <- seq(min(lp["x"]),
               median(lp["x"]),
               length.out = 10)
  
  ylocs <- seq(min(lp["y"]),
               median(lp["y"]),
               length.out = 10)
  # Dynamically change the origin
  for (i in 1:length(xlocs)){
    lp["panX"] <- xlocs[i]
    lp["panY"] <- ylocs[i]
    Sys.sleep(0.1) # slow down to see effect
  }
  # and back
  xlocs <- rev(xlocs)
  ylocs <- rev(ylocs)
  # dynamically
  for (i in 1:length(xlocs)){
    lp["panX"] <- xlocs[i]
    lp["panY"] <- ylocs[i]
    Sys.sleep(0.1) # slow down to see effect
  }
  # Perhaps settle on
  lp["panX"] <- 7
  lp["panY"] <- 0

  And now observe the effect on each of the plots:

  # First the l_ggplot 
  plot(lgp)  

  

  No change. It is unaffected by any change to the interactive plot.

  # Now the l_plot 
  plot(lp)   

  

  Reflects the changes made on the interactive plot.

The function loon.ggplot()

Earlier, loon.ggplot() was recommended as a means to produce an interactive plot from an l_ggplot and to assign it to a variable, as in

lp <- loon.ggplot(lgp)

This makes it seem essentially equivalent to print(lgp), but it is not.

Instead, loon.ggplot() is a powerful two way bridge between ggplots and loon plots.

When called on

• an l_ggplot (an extended ggplot) loon.ggplot(lgp) produces an interactive loon plot.

• an interactive loon plot, it produces a static ggplot

  loon.ggplot(lp)

  

  This is a ggplot with parameters to make it look like the loon plot it was built from (e.g. the title is centred in this ggplot).

  loon.ggplot() gives us a second way to produce a static version of an interactive loon plot.

  • plot(lp) produces a grid graphic object (or grob)

  • loon.ggplot(lp) produces a ggplot graphic object.

  Either reproduces the current loon plot as a static snapshot of its present appearence (ideally wysiwyg).

  Which is preferred depends on the use intended for the static plot .

  The ggplot version is easier to work with and trivial to adapt using the grammar.

  gp <- loon.ggplot(lp)  # loon to ggplot
  class(gp)
  #> [1] "gg"     "ggplot"
  gp + geom_smooth()

  

  Alternatively, a new interactive plot can be generated from an ordinary ggplot as

  new_lp <- loon.ggplot(gp + geom_smooth())

  and this interactive plot is turned into a new static ggplot with the same function, as shown below

  loon.ggplot(new_lp)

  

  Note that the grey polygon emphasizing the confidence region does not appear. It is there, but as a hidden layer of the loon plot that can be revealed at any time (via the loon inspector or programmatically). The polygon is not shown by default because colours do not (yet) have an alpha channel (for transparency) in tcltk.

The bridge: loon.ggplot() turns ggplots to interactive loon plots and loon plots to ggplots.

+ linking()

+ linking(linkingGroup = NULL, linkingKey = NULL, linkedStates = NULL, sync = NULL)

loon implements a group-key-state linking model.

Interactive plots having the same linkingGroup are linked, in that each plot changes its display in response to display changes of the linkedStates of any plot in the same linkingGroup. Only those linkedStates in common are changed and display elements are matched by values of the linkingKey.

• linkingGroup

  A string naming the group or NULL for no linking.

• linkedStates

  A character vector of the states to be linked.

  By default these include selected, active, and others peculiar to each type of plot such as color and size.

• linkingKey

  A length n character vector of unique strings, one for each observation; default is "0", "1", …, "n-1".

• sync

  Specifies the direction of synchronizing the linked states at the time the plot is created.
  The value "pull" pulls the values of the linked states from plots in the linking group and assigns them to the new plot; value "push" pushes the newly created plot’s linked states values out to the others in the linking group.

  Default is "pull" unless some aesthetics matching the linked states are specified in the plot creation; then the default will be "push".

Each plot will propogate, and respond to, only changes in those states named in its linkedStates. Display elements associated with the unique set of keys in each plot’s linkingKey will change together.

+ hover()

+ hover(itemLabel = NULL, showItemLabels = NULL)

Provides a pop up display as the mouse hovers over a plot element in the interactive plot.

• itemLabel

  A character vector of length n with a string to be used to pop up when the mouse hovers above that element.

• showItemLabels

  A single logical value: TRUE if pop up labels are to appear on hover, FALSE (the default) if they are not.

+ selection()

+ selection(selected = NULL, selectBy = NULL, selectionLogic = NULL)

Set which elements (i.e., observations) are "selected". These are shown highlighted in the plot.

• selected

  a logical or a logical vector of length n that determines which observations are selected (TRUE and hence appear highlighted in the plot) and which are not. Default is FALSE and no points are highlighted.

• selectBy

  A string determining how selection will occur in the interactive plot. Default is "sweeping" where a rectangular region is reshaped or “swept” out to select observations.; alternately "brushing" will indicate that a fixed rectangular region is moved about the display to select observations.

• selectionLogic

  One of "select" (the default), "deselect", and "invert". The first highlights observations as selected, the second downlights them, and the third inverts them (downlighting highlighted observations and highlighting downlighted ones).

+ active()

+ active(active = NULL, activeGeomLayers = NULL)

Set active and/or activeGeomLayers

• active

  a logical, or a logical vector of length n, determining which observations are active (hence appear in the plot) and which are inactive (FALSE and hence do not appear). Default is TRUE.

• activeGeomLayers

  determine which geom layer is interactive by its geom_... position in the grammar of the expression. Currently, only geom_point() and geom_histogram() can be set as the active geom layer(s) so far. (N.B. more than one geom_point() layer can be set as an active layer, but only one geom_histogram() can be set as an active geom layer and it can be the only active layer)

+ zoom()

+ zoom(layerId = NULL, scaleToFun = NULL)

Change the visible plot region by scaling to different elements of the display.

• layerId

  numerical; which layer to scale the plot by. If the layerId is set as NULL (default), the region of the interactive graphics loon will be determined by the ggplot object (i.e. coord_cartesian, xlim, etc); else one can use scaleToFun to modify the region of the layer.

• scaleToFun

  scale function to be used. If NULL (default), based on different layers, different scale functions will be applied. For example, if the layer is the main graphic model, i.e. l_plot l_hist, then the default scaleToFun is l_scaleto_plot; else if the layer is a general l_layer widget, the default scaleToFun would be loon::l_scaleto_layer.

  If it is not NULL, any of the following scaleToFun functions could be used

  scale to	Subfunction
  plot	l_scaleto_plot
  world	l_scaleto_world
  active	l_scaleto_active
  selected	l_scaleto_selected
  layer	l_scaleto_layer

  Alternatively, scaleToFun can be any function whose arguments match those of the functions above.

+ interactivity()

+ interactivity(linkingGroup, linkingKey, linkedStates, sync,  # linking
                active, activeGeomLayers,                      # active
                selected, selectBy, selectionLogic,            # selection
                layerId, scaleToFun,                           # zoom
                itemLabel,  showItemLabels,                    # hover
                ... )

Set interactive components (e.g. linking, selection, etc) in one clause. All named arguments are as described in the other clauses.

• ... other named arguments to modify loon plot states. See l_info_states().