diff --git a/.travis.yml b/.travis.yml
index e55fb0c5..009c43a9 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -12,6 +12,9 @@ addons:
sudo: false
+os:
+ - linux
+
apt_packages:
- r-cran-rjava
diff --git a/R/DESCRIPTION b/R/DESCRIPTION
index 80854abc..092006de 100755
--- a/R/DESCRIPTION
+++ b/R/DESCRIPTION
@@ -1,8 +1,8 @@
Package: loon
Type: Package
Title: Interactive Statistical Data Visualization
-Version: 1.3.3
-Date: 2021-02-24
+Version: 1.3.4
+Date: 2021-03-15
Authors@R: c(person(given = "Adrian", family = "Waddell",
email = "adrian@waddell.ch",
role = c("aut")),
diff --git a/R/NEWS.md b/R/NEWS.md
index a53aee5f..701b6644 100755
--- a/R/NEWS.md
+++ b/R/NEWS.md
@@ -1,3 +1,52 @@
+# loon 1.3.4
+
+* A new vignette
+
+ - "Logical queries in interactive graphics"
+
+ Explains how to use loon's interactive plots and inspector to construct logical
+ queries on the displayed data.
+
+ An *enriched* version of `mtcars` is used for illustration.
+
+ How a plot's `linkingKey` (from Loon's linking model) can be used to access the correct
+ elements of any logical operation is also described.
+
+* minor bug fixes and improvements
+
+ - Three minor bug fixes on **facets**
+
+ - If the `by` is a formula with `loon` n-dimensional states, no need to provide additional data,
+ the formula should be able to be converted to a data frame given by the states info.
+
+ - When `by` has missing values, it is treated as other n-dimensional states:
+
+ drop NAs, leave warnings (which one are removed)
+
+ - Removed unnecessary warnings.
+
+ - `l_pairs()` has a progress bar for constructing, linking, and connecting the scales of the plots.
+
+ there is now a new argument `showProgressBar` that allows this to be suppressed (e.g. in RMarkdown files)
+
+ - for histograms of factors and character vectors: default setting of arg `showFactors`
+
+ - previously: `TRUE` whenever number of factor levels (or equivalent unique strings) < 10
+ - now: `TRUE` whenever < 25 to accomodate common factors like `month` or the 24 hours in a day.
+
+ - updated documentation on `l_layer()`
+
+
+* testing
+
+ - As all examples are wrapped in `if(interactive)`, check all interactive examples to ensure they work well
+
+ - hexadecimal colours seem to get slightly (generally ignorable) different hexadecimal values for colours in `tcltk` on Solaris (see 1.3.3 comments). this caused problems in testing for exact colours on Solaris.
+
+ Until this is sorted out, the testing for colour hex values in the test suite were commented out to prevent loon from being unnecessarily archived on CRAN. (The colours are correct, but our previous solution generated warnings, which may cause problems for CRAN acceptance.) Likely, in the future, we suppress the warning from `l_hexcolor()` when testing.
+
+ - for iris dataset in tests, we drop an observation so that for each species, the number of observations are different.
+
# loon 1.3.3
* an extremely minor update
diff --git a/R/R/datasets.R b/R/R/datasets.R
index 86a9ccc8..31fd148e 100755
--- a/R/R/datasets.R
+++ b/R/R/datasets.R
@@ -64,7 +64,6 @@
#' Research and Data Analysis (Martens, H., Russwurm, H., eds.), p. 189,
#' Applied Science Publ., Barking.
#'
-#' Wikipedia \url{https://en.wikipedia.org/}
#'
#'
"olive"
diff --git a/R/R/graphutils.R b/R/R/graphutils.R
index 10c6ee96..9975b6e2 100755
--- a/R/R/graphutils.R
+++ b/R/R/graphutils.R
@@ -178,10 +178,8 @@ as.graph <- function(loongraph) {
#' @export
#'
#' @examples
-#' if (requireNamespace("Rgraphviz", quietly = TRUE)) {
#' g <- loongraph(letters[1:4], letters[1:3], letters[2:4], FALSE)
-#' plot(g)
-#' }
+#'
plot.loongraph <- function(x, ...) {
requireNamespace("Rgraphviz", quietly = TRUE) || stop("Rgraphviz library required")
@@ -443,11 +441,8 @@ graphproduct <- function(U,V, type=c("product", "tensor", "strong"), separator='
#'
#' LLG <- linegraph(LG)
#'
-#' graphreduce(LLG)
+#' R_LLG <- graphreduce(LLG)
#'
-#' if (requireNamespace("Rgraphviz", quietly = TRUE)) {
-#' plot(graphreduce(LLG))
-#' }
#'
graphreduce <- function(graph, separator) {
diff --git a/R/R/l_layer.R b/R/R/l_layer.R
index f9039bc8..b69f97c8 100755
--- a/R/R/l_layer.R
+++ b/R/R/l_layer.R
@@ -143,7 +143,8 @@ l_layer <- function(widget, x, ...) {
#' @seealso \code{\link[stats]{density}}
#' @export
#' @export l_layer.density
-#' @examples {
+#' @examples
+#' if(interactive()){
#' d <- density(faithful$eruptions, bw = "sj")
#' h <- l_hist(x = faithful$eruptions, yshows="density")
#' l <- l_layer.density(h, d, color="steelblue", linewidth=3)
diff --git a/R/README.md b/R/README.md
index 74bb4801..c20cee91 100755
--- a/R/README.md
+++ b/R/README.md
@@ -1,7 +1,9 @@
## loon
-[](https://travis-ci.org/great-northern-diver/loon) [](https://cran.r-project.org/package=loon)
+[](https://travis-ci.org/great-northern-diver/loon)
+[](https://cran.r-project.org/package=loon)
+[](https://cran.r-project.org/package=loon)
loon is an extendible interactive data visualization system designed for exploratory visualization.
diff --git a/R/_pkgdown.yml b/R/_pkgdown.yml
index 31936ca8..90b12a0a 100755
--- a/R/_pkgdown.yml
+++ b/R/_pkgdown.yml
@@ -13,12 +13,14 @@ navbar:
menu:
- text: Introduction
href: articles/introduction.html
+ - text: Saving loon plots
+ href: articles/savingLoonPlots.html
+ - text: Logical queries in interactive graphics
+ href: articles/logicalQueries.html
- text: Analysis example
href: articles/minorities.html
- text: Teaching example
href: articles/teaching-example-smoothing.html
- - text: Saving loon plots
- href: articles/savingLoonPlots.html
- text: Videos
menu:
- text: the (not so) humble (interactive) histogram
diff --git a/R/cran-comments.md b/R/cran-comments.md
index c1447532..9d47ca41 100755
--- a/R/cran-comments.md
+++ b/R/cran-comments.md
@@ -1,18 +1,72 @@
## Test evironments
-* local OS X, R 3.5.1
-* local Ubuntu 18.04 R 3.5.1 and R-devel (2018-09-29 r75381)
-* local Windows 10 R 3.5.1
-* Ubuntu 14.04.5 (on travis-ci) R 3.5.1 and R-devel (2018-09-29 r75381)
+* local OSX, Big Sur 11.2.1, R 4.0.2
+* Ubuntu Xenial 16.04 (on travis-ci)
+* check_win_devel
+ - using R Under development (unstable) (2021-03-14 r80087)
+ - using platform: x86_64-w64-mingw32 (64-bit)
+ - using session charset: ISO8859-1
+
+* Windows Server 2008 R2 SP1, R-devel, 32/64 bit
+* Ubuntu Linux 20.04.1 LTS, R-release, GCC
+* Fedora Linux, R-devel, clang, gfortran
## R CMD check results
-There were no ERRORs or WARNINGs.
+0 errors
+0 warnings
+1 NOTE about maintainer
-## Downstream dependencies
+ ... NOTE
+ Maintainer: 'R. Wayne Oldford '
+
+### Solaris and bioconductor package RgraphViz
+
+**rhub::check_on_solaris()**:
+
+1 Error (cannot find/install suggested package `Rgraphviz)`
+
+ - Unable to determine a solution. (have tried adding BiocViews: to DESCRIPTION with no luck)
+
+- Preparing build, see status at
-Sometimes R CMD check fails with the ERROR:
+ https://builder.r-hub.io/status/loon_1.3.4.tar.gz-a8636ac65fcf46899d204dc1c39bafce
-Error in MASS::isoMDS(d = D, k = 5) : object 'VR_mds_init_data' not found
+...
-This error seems to disappear when I re-install MASS with `install.packages('MASS')`.
+ E checking package dependencies (3.5s)
+ Package suggested but not available: ‘Rgraphviz’
+
+ The suggested packages are required for a complete check.
+ Checking can be attempted without them by setting the environment
+ variable _R_CHECK_FORCE_SUGGESTS_ to a false value.
+
+ See section ‘The DESCRIPTION file’ in the ‘Writing R Extensions’
+ manual.
+
+
+**Relevant Snippet from Rhub**:
+
+- Installing package dependencies\
+
+- Running R CMD check
+
+ setting _R_CHECK_FORCE_SUGGESTS_ to false
+
+ setting R_COMPILE_AND_INSTALL_PACKAGES to never
+
+ setting _R_CHECK_THINGS_IN_CHECK_DIR_ to false
+
+ setting R_REMOTES_STANDALONE to true
+
+ setting R_REMOTES_NO_ERRORS_FROM_WARNINGS to true
+
+ setting _R_CHECK_FORCE_SUGGESTS_ to true
+
+ setting _R_CHECK_CRAN_INCOMING_USE_ASPELL_ to true
+
+- using log directory 'C:/Users/USERzVBgqDuhyS/loon.Rcheck'
+- using R Under development (unstable) (2021-02-15 r80013)
+- using platform: x86_64-w64-mingw32 (64-bit)
+
+## Downstream dependencies
diff --git a/R/inst/images/Apulia.png b/R/inst/images/Apulia.png
deleted file mode 100755
index 20716487..00000000
Binary files a/R/inst/images/Apulia.png and /dev/null differ
diff --git a/R/inst/images/Calabria.png b/R/inst/images/Calabria.png
deleted file mode 100755
index c6a3aaf2..00000000
Binary files a/R/inst/images/Calabria.png and /dev/null differ
diff --git a/R/inst/images/Liguria.png b/R/inst/images/Liguria.png
deleted file mode 100755
index 36618224..00000000
Binary files a/R/inst/images/Liguria.png and /dev/null differ
diff --git a/R/inst/images/Sardinia.png b/R/inst/images/Sardinia.png
deleted file mode 100755
index fe4a917e..00000000
Binary files a/R/inst/images/Sardinia.png and /dev/null differ
diff --git a/R/inst/images/Sicily.png b/R/inst/images/Sicily.png
deleted file mode 100755
index 3f7f23f6..00000000
Binary files a/R/inst/images/Sicily.png and /dev/null differ
diff --git a/R/inst/images/Umbria.png b/R/inst/images/Umbria.png
deleted file mode 100755
index b140cd17..00000000
Binary files a/R/inst/images/Umbria.png and /dev/null differ
diff --git a/R/man/figures/gestures_move.png b/R/man/figures/gestures_move.png
old mode 100755
new mode 100644
index cd86ffe2..e2eb768e
Binary files a/R/man/figures/gestures_move.png and b/R/man/figures/gestures_move.png differ
diff --git a/R/man/figures/gestures_rotate.png b/R/man/figures/gestures_rotate.png
old mode 100755
new mode 100644
index 5623541e..93c2f594
Binary files a/R/man/figures/gestures_rotate.png and b/R/man/figures/gestures_rotate.png differ
diff --git a/R/man/figures/gestures_select.png b/R/man/figures/gestures_select.png
old mode 100755
new mode 100644
index 31c839c2..d1a927de
Binary files a/R/man/figures/gestures_select.png and b/R/man/figures/gestures_select.png differ
diff --git a/R/man/figures/gestures_zoom_pan.png b/R/man/figures/gestures_zoom_pan.png
old mode 100755
new mode 100644
index 5ef245f4..d7eef8ea
Binary files a/R/man/figures/gestures_zoom_pan.png and b/R/man/figures/gestures_zoom_pan.png differ
diff --git a/R/man/graphreduce.Rd b/R/man/graphreduce.Rd
index f6667c60..62389e7e 100755
--- a/R/man/graphreduce.Rd
+++ b/R/man/graphreduce.Rd
@@ -27,10 +27,7 @@ LG <- linegraph(G)
LLG <- linegraph(LG)
-graphreduce(LLG)
+R_LLG <- graphreduce(LLG)
-if (requireNamespace("Rgraphviz", quietly = TRUE)) {
- plot(graphreduce(LLG))
-}
}
diff --git a/R/man/l_layer.density.Rd b/R/man/l_layer.density.Rd
index 745d4d22..cd8d2f0a 100755
--- a/R/man/l_layer.density.Rd
+++ b/R/man/l_layer.density.Rd
@@ -21,7 +21,7 @@ layer object handle, layer id
Layer a line that represents a kernel density estimate.
}
\examples{
-{
+if(interactive()){
d <- density(faithful$eruptions, bw = "sj")
h <- l_hist(x = faithful$eruptions, yshows="density")
l <- l_layer.density(h, d, color="steelblue", linewidth=3)
diff --git a/R/man/l_plot.Rd b/R/man/l_plot.Rd
old mode 100755
new mode 100644
diff --git a/R/man/l_plot3D.Rd b/R/man/l_plot3D.Rd
old mode 100755
new mode 100644
diff --git a/R/man/l_plot_ts.Rd b/R/man/l_plot_ts.Rd
old mode 100755
new mode 100644
diff --git a/R/man/olive.Rd b/R/man/olive.Rd
index 341a43fc..bf904295 100755
--- a/R/man/olive.Rd
+++ b/R/man/olive.Rd
@@ -49,8 +49,6 @@ Forina, M., Armanino, C., Lanteri, S., and Tiscornia, E. (1983)
"Classification of Olive Oils from their Fatty Acid Composition", in Food
Research and Data Analysis (Martens, H., Russwurm, H., eds.), p. 189,
Applied Science Publ., Barking.
-
- Wikipedia \url{https://en.wikipedia.org/}
}
\seealso{
\code{\link{oliveLocations}}
diff --git a/R/man/plot.loongraph.Rd b/R/man/plot.loongraph.Rd
index 3d732c71..b594e860 100755
--- a/R/man/plot.loongraph.Rd
+++ b/R/man/plot.loongraph.Rd
@@ -16,8 +16,6 @@ This function converts the loongraph object to one of class
graph and the plots it with its respective plot method.
}
\examples{
-if (requireNamespace("Rgraphviz", quietly = TRUE)) {
g <- loongraph(letters[1:4], letters[1:3], letters[2:4], FALSE)
- plot(g)
-}
+
}
diff --git a/R/vignettes/SavingLoonPlots.Rmd b/R/vignettes/SavingLoonPlots.Rmd
index 24ac56fa..3ee6b076 100644
--- a/R/vignettes/SavingLoonPlots.Rmd
+++ b/R/vignettes/SavingLoonPlots.Rmd
@@ -29,15 +29,8 @@ library(loon.data)
library(loon)
library(gridExtra)
-imageDirectory <- "./images/savingLoonPlots"
-dataDirectory <- "./data/savingLoonPlots"
-path_concat <- function(path1, ..., sep="/") {
- # The "/" is standard unix directory separator and so will
- # work on Macs and Linux.
- # In windows the separator might have to be sep = "\" or
- # even sep = "\\" or possibly something else.
- paste(path1, ..., sep = sep)
- }
+imageDirectory <- file.path(".", "images", "savingLoonPlots")
+dataDirectory <- file.path(".", "data", "savingLoonPlots")
```
---
@@ -201,12 +194,12 @@ knitr::include_graphics("myplot_via_R.png")
```{r load the saved plots, echo = FALSE, eval=FALSE}
# The one exported from RStudio
-knitr::include_graphics(path_concat(imageDirectory, "myplot_via_RStudio.png"))
+knitr::include_graphics(file.path(imageDirectory, "myplot_via_RStudio.png"))
# Followed by the one saved using l_export
# (note that background grid is missing)
-knitr::include_graphics(path_concat(imageDirectory, "myplot_via_l_export.pdf"))
+knitr::include_graphics(file.path(imageDirectory, "myplot_via_l_export.pdf"))
# And finally, the one saved using R's png device
-knitr::include_graphics(path_concat(imageDirectory, "myplot_via_R.png"))
+knitr::include_graphics(file.path(imageDirectory, "myplot_via_R.png"))
```
Alternatively, you could use **LaTeX** if you want more control. For example, the following
@@ -274,7 +267,7 @@ p_savedStates <- l_getSavedStates(file = "p_savedStates")
```
```{r get p states back, echo = FALSE}
-p_savedStates <- l_getSavedStates(file = path_concat(dataDirectory, "p_savedStates"))
+p_savedStates <- l_getSavedStates(file = file.path(dataDirectory, "p_savedStates"))
```
A new plot is constructed and the saved states transferred to it.
@@ -330,7 +323,7 @@ Now all of the states are available when this file is read back in.
p_focusOnVersicolor <- l_getSavedStates(file = "p_focusOnVersicolor")
```
```{r, echo = FALSE}
-p_focusOnVersicolor <- l_getSavedStates(file = path_concat(dataDirectory, "p_focusOnVersicolor"))
+p_focusOnVersicolor <- l_getSavedStates(file = file.path(dataDirectory, "p_focusOnVersicolor"))
```
When it comes to transferring the states to a new plot there are many choices. We could go with a large collection of display states (more than the default states but still excluding more "basic" states about panning and zooming for example). To see which states, we add the argument `returnNames = TRUE`:
diff --git a/R/vignettes/images/intro/panning.png b/R/vignettes/images/intro/panning.png
old mode 100755
new mode 100644
index cff49d32..29f3e16f
Binary files a/R/vignettes/images/intro/panning.png and b/R/vignettes/images/intro/panning.png differ
diff --git a/R/vignettes/images/intro/selecting.png b/R/vignettes/images/intro/selecting.png
old mode 100755
new mode 100644
index 8a5c64ba..1cefcd40
Binary files a/R/vignettes/images/intro/selecting.png and b/R/vignettes/images/intro/selecting.png differ
diff --git a/R/vignettes/images/intro/zooming.png b/R/vignettes/images/intro/zooming.png
old mode 100755
new mode 100644
index b7a5d725..79ed9ded
Binary files a/R/vignettes/images/intro/zooming.png and b/R/vignettes/images/intro/zooming.png differ
diff --git a/R/vignettes/introduction.Rmd b/R/vignettes/introduction.Rmd
index 14cbc59a..b7c49f14 100755
--- a/R/vignettes/introduction.Rmd
+++ b/R/vignettes/introduction.Rmd
@@ -20,9 +20,8 @@ knitr::opts_chunk$set(
set.seed(12314159)
-imageDirectory <- "./images/intro"
-dataDirectory <- "data"
-path_concat <- function(path1, path2, sep="/") {paste(path1, path2, sep = sep)}
+imageDirectory <- file.path(".", "images", "intro")
+# dataDirectory <- file.path(".", "data", "intro")
```
> "Exposure, the effective laying open of the data to display the unanticipated,
@@ -73,13 +72,13 @@ two windows to appear.
One is the scatterplot:
```{r loonQuakeOriginal, out.width= "60%", fig.align="center", echo=FALSE}
-knitr::include_graphics(path_concat(imageDirectory, "quakesOriginal.png"))
+knitr::include_graphics(file.path(imageDirectory, "quakesOriginal.png"))
```
and the other a "loon inspector":
```{r looninspectorQuakeOriginal, out.width= "30%", fig.align="center", echo=FALSE}
-knitr::include_graphics(path_concat(imageDirectory, "inspectorQuakesOriginal.png"))
+knitr::include_graphics(file.path(imageDirectory, "inspectorQuakesOriginal.png"))
```
@@ -106,7 +105,7 @@ To pan the plot, select the plot interior with the right (or secondary) mouse bu
\vspace{-0.05\textheight}
```{r panning, out.width= "40%", fig.align="center", echo=FALSE}
-knitr::include_graphics(path_concat(imageDirectory, "panning.png"))
+knitr::include_graphics(file.path(imageDirectory, "panning.png"))
```
Try it. Select anywhere on the scatterplot and move it
@@ -130,7 +129,7 @@ Another way to dynamically focus on different parts of the plot is by zooming, u
\vspace{-0.05\textheight}
```{r zooming, out.width= "40%", fig.align="center", echo=FALSE}
-knitr::include_graphics(path_concat(imageDirectory, "zooming.png"))
+knitr::include_graphics(file.path(imageDirectory, "zooming.png"))
```
To try it, note that there is a small cluster of 16 points towards the top left of the scatterplot.
@@ -157,7 +156,7 @@ Using zooming and panning on the "World View"
There are two ways to directly select points on the scatterplot using the mouse: either by selection (one at a time or multiple selections) or by "sweep selection" as shown below:
```{r point selection, out.width= "40%", fig.align="center", echo=FALSE}
-knitr::include_graphics(path_concat(imageDirectory, "selecting.png"))
+knitr::include_graphics(file.path(imageDirectory, "selecting.png"))
```
To try this out, on the scatterplot (which should contain only 16 points)
@@ -254,7 +253,7 @@ You should now have four different coloured groups or clusters.
When done, turn the selection back to the defaults:
```{r select defaults, out.width= "40%", fig.align="left", echo=FALSE}
-knitr::include_graphics(path_concat(imageDirectory, "inspectorSelectDefaults.png"))
+knitr::include_graphics(file.path(imageDirectory, "inspectorSelectDefaults.png"))
```
That is,
@@ -305,7 +304,7 @@ For example:
### adding colours to the inspector
```{r looninspector plus 10 cols, out.width= "30%", fig.align="center", echo=FALSE}
-knitr::include_graphics(path_concat(imageDirectory, "inspectorQuakesPlus10Cols.png"))
+knitr::include_graphics(file.path(imageDirectory, "inspectorQuakesPlus10Cols.png"))
```
More colours can be added directly by clicking on the `+` or the `+5` in the colour modification section of the inspector.
@@ -755,11 +754,11 @@ Try this out.
```{r quakesGuidesMapInspector, out.width= "30%", fig.align="center", echo=FALSE}
-knitr::include_graphics(path_concat(imageDirectory, "quakesGuidesMapInspector.png"))
+knitr::include_graphics(file.path(imageDirectory, "quakesGuidesMapInspector.png"))
```
```{r quakesGuidesMap, out.width= "50%", fig.align="center", echo=FALSE}
-knitr::include_graphics(path_concat(imageDirectory, "quakesGuidesMap.png"))
+knitr::include_graphics(file.path(imageDirectory, "quakesGuidesMap.png"))
```
As can be seen in the world view, much of the map is outside of the plot display (shown as the black-bordered rectangle in the world view).
@@ -776,7 +775,7 @@ Adding the map allows us to see the effect of all three plot scaling choices ava
The effect is best seen on the world view:
```{r worldViewScaling, out.width= "90%", fig.align="center", echo=FALSE}
-knitr::include_graphics(path_concat(imageDirectory, "quakesWorldViewScaling.png"))
+knitr::include_graphics(file.path(imageDirectory, "quakesWorldViewScaling.png"))
```
Note that the plot in the world view matches that of the actual plot. Also the aspect ratio changes with the scaling.
@@ -789,7 +788,7 @@ Note that the plot in the world view matches that of the actual plot. Also the
The map is added as a layer, which can be seen by selecting the "Layers" tab in the inspector:
```{r quakesLayersInspector, out.width= "70%", fig.align="center", echo=FALSE}
-knitr::include_graphics(path_concat(imageDirectory, "quakesLayersInspector.png"))
+knitr::include_graphics(file.path(imageDirectory, "quakesLayersInspector.png"))
```
This allows a lot of interaction with the layers - for example changing their display order, making some of them invisible, grouping layers, and so on.
@@ -957,7 +956,7 @@ Note that selection effectively shows the relations in one plot **conditional**
Observations in a `loon` plot are uniquely identified (for the purpose of linking) by their `linkingKey`. Pardon the pun but this is the key to linking in `loon`.
For the most part, the default linking is all that you ever need do.
-Trouble may arise, however, if you want to link two different plots that were created with different data frames whose rows so not match row for row. For example, one `data.frame` might be a re-ordering of the rows of the other. Or, it might be a subset of the rows of the other.
+Trouble may arise, however, if you want to link two different plots that were created with different data frames whose rows do not match row for row. For example, one `data.frame` might be a re-ordering of the rows of the other. Or, it might be a subset of the rows of the other.
In either case, to have linking work properly the `linkingKey` of the plots associated with the two data frames need to be managed.
diff --git a/R/vignettes/logicalQueries.Rmd b/R/vignettes/logicalQueries.Rmd
new file mode 100755
index 00000000..33e40069
--- /dev/null
+++ b/R/vignettes/logicalQueries.Rmd
@@ -0,0 +1,318 @@
+---
+title: "Logical queries in interactive graphics"
+author: "R.W. Oldford"
+date: "`r Sys.Date()`"
+output:
+ html_vignette:
+ toc: true
+vignette: >
+ %\VignetteIndexEntry{Logical queries}
+ %\VignetteEngine{knitr::rmarkdown}
+ %\VignetteEncoding{UTF-8}
+
+---
+
+```{r setup, include=FALSE}
+knitr::opts_chunk$set(
+ echo = TRUE,
+ tidy.opts = list(width.cutoff = 65),
+ tidy = FALSE)
+
+set.seed(12314159)
+
+imageDirectory <- "./images/logic"
+dataDirectory <- "data"
+```
+
+One of the principal strengths of linked plots is the ease with which one can form complex logical queries on the data.
+
+```{r library_loon, eval = FALSE, echo = TRUE, fig.align="center", fig.width = 6, fig.height = 4, out.width = "75%", warning=FALSE, message=FALSE}
+library(loon)
+```
+
+## The cars of the 1974 Motor Trends magazine
+
+Begin with a classic data set in `R` -- `mtcars`.
+For the sake of illustration, some enrichment of the variables and their values will be made:
+
+```{r new variates}
+data(mtcars, package = "datasets")
+
+mtcars$country <- c("Japan", "Japan", "Japan", "USA", "USA", "USA", "USA",
+ "Germany", "Germany", "Germany", "Germany", "Germany",
+ "Germany", "Germany", "USA", "USA", "USA", "Italy",
+ "Japan", "Japan", "Japan", "USA", "USA", "USA", "USA",
+ "Italy", "Germany", "UK", "USA", "Italy", "italy", "Sweden")
+mtcars$continent <- c("Asia", "Asia", "Asia", "North America", "North America",
+ "North America", "North America", "Europe", "Europe",
+ "Europe", "Europe", "Europe", "Europe", "Europe",
+ "North America", "North America", "North America",
+ "Europe", "Asia", "Asia", "Asia", "North America",
+ "North America", "North America", "North America",
+ "Europe", "Europe", "Europe", "North America",
+ "Europe", "Europe", "Europe" )
+mtcars$company <- c("Mazda", "Mazda", "Nissan", "AMC", "AMC", "Chrysler",
+ "Chrysler", "Mercedes", "Mercedes", "Mercedes", "Mercedes",
+ "Mercedes", "Mercedes", "Mercedes", "GM", "Ford",
+ "Chrysler", "Fiat", "Honda", "Toyota", "Toyota", "Chrysler",
+ "AMC", "GM", "GM", "Fiat", "Porsche", "Lotus", "Ford",
+ "Ferrari", "Maserati", "Volvo")
+
+mtcars$Engine <- factor(c("V-shaped", "Straight")[mtcars$vs +1],
+ levels = c("V-shaped", "Straight"))
+mtcars$Transmission <- factor(c("automatic", "manual")[mtcars$am +1],
+ levels = c("automatic", "manual"))
+
+mtcars$vs <- NULL # These are redundant now
+mtcars$am <- NULL #
+```
+
+For this illustration, it will be convenient to separate categorical from continuous data.
+
+```{r define variable types}
+varTypes <- split(names(mtcars),
+ sapply(mtcars,
+ FUN = function(x){
+ if(is.factor(x)|is.character(x)){
+ "categorical"
+ } else {"numeric"} } ))
+```
+
+`varTypes` is a list with two named components: `categorical` and `numeric`.
+
+## Some interactive plots
+
+To explore the data, several interactive plots will likely have been constructed.
+Typically, these will have been constructed one at a time and assigned to the same linking group (perhaps via the inspector).
+
+Below, histograms/barplots are constructed for each categorical variable and assigned to that variable name now prefixed by `h_` for "histogram".
+
+```{r histograms of categorical variates, eval = FALSE}
+for (varName in varTypes$categorical) {
+ assign(paste0("h_", varName),
+ l_hist(mtcars[ , varName], showFactors = TRUE,
+ xlabel = varName, title = varName,
+ linkingGroup = "Motor Trend"))
+}
+```
+
+These are not evaluated in this vignette. Note that all are in the same `linkingGroup`.
+
+Other linked plots might exist as well -- for example, a scatterplot of `gear` (the number of forward gears) versus `disp` (the engine displacement in cubic inches).
+
+```{r, eval = FALSE}
+p <- with(mtcars, l_plot(disp, cyl,
+ xlabel = "engine displacement", ylabel = "number of cylinders",
+ title = "1974 Motor Trend cars",
+ linkingGroup = "Motor Trend",
+ size = 10, showScales = TRUE,
+ itemLabel = rownames(mtcars), showItemLabels = TRUE
+ ))
+```
+
+Note that
+- each car's name appears as the `itemLabel` for that point in the plot (to be revealed as a "tooltip" style pop up), and that
+- the plot `p` is in the same linking group as the histograms.
+
+Through a combination of selection, inversion, deactivation, and reactivation, logical queries may be made interactively on the data.
+
+For simplicity, the basic logical operators are illustrated below using only the histograms.
+More generally, these apply to any interactive `loon` graphic.
+
+
+
+## Interactive logical operations
+
+Five logical conditions/operations illustrated here are the basic ones:
+
+1. `A` is `TRUE`
+2. Negation: (NOT `A`) is `TRUE`
+3. Inclusive OR: (`A` OR `B`) is `TRUE` (one or the other or both),
+4. Conjunction: (`A` AND `B`) are both `TRUE`
+5. Exclusive OR: (`A` XOR `B`) meaning (`A` is `TRUE`) or (`B` is `TRUE`) but (`A` AND `B`) is FALSE
+
+
+Each of these corresponds to a sequence of actions on the plots and/or inspector.
+Whatever is highlighted in the end corresponds to the result.
+
+Again, for simplicity all operations are illustrated by interacting with values of categorical variates in the various histograms.
+Any of the logical elements could also have been that satisfying numerical constraints by undertaking the corresponding actions on a scatterplot (or histogram of continuous values).
+
+Each logical operator is illustrated in turn:
+
+1. `A` ($= A$)
+
+ *on the plot* select `A`,
+
+ - e.g., click on `"manual"` bar from the `Transmission` histogram
+
+ - highlighted $\iff$ `Transmission == "manual"` is `TRUE`
+
+
+2. **NOT** `A` ($= \overline{A}~~$ or $~~\neg A$)
+
+ *on a plot* select `A`,
+
+ *from the inspector* click `invert`
+
+ - e.g., click on `"North America"` bar from the `continent` histogram,
+
+ then invert
+
+ - highlighted $\iff$ `continent == "North America"` is `FALSE`
+
+ - all that is highlighted is **not** `"North America"`, namely `"Asia"` or `"Europe"`
+
+3. `A` **OR** `B` ($= A \cup B~~$ or $~~A \lor B$),
+
+ *on a plot* select `A`,
+
+ *on the same (or a different but linked) plot* ``- select `B`
+
+ - e.g., click on `"manual"` bar from `Transmission` histogram,
+
+ then while holding down the `` key,
+
+ click on the `Mercedes` bar in the `company` histogram
+
+
+ - highlighted $\iff$ `Transmission == "manual"` is `TRUE`
+ **OR** `company = "Mercedes"` is `TRUE` (or both)
+
+
+4. `A` **AND** `B` ($= A \cap B$ or $A \land B$)
+
+ lots of solutions, here is one that always works
+
+ *on a plot* select `A`,
+
+ *from the inspector*, `invert` then `deactivate` (only `A` remains),
+
+ *from a plot of the remaining* select `B`,
+
+ *from the inspector* `reactivate` all
+
+ - elements are highlighted $\iff A \cap B$
+
+ - e.g. try highlighting all European cars with manual transmissions.
+
+
+
+5. `A` **XOR** `B` ($= (A \cup B) \cap (\overline{A \cap B})$ or $(A \lor B) \land \neg({A \land B})$)
+
+ *following steps in 4*, select `A` **AND** `B`,
+
+ *from the inspector* `invert` then `deactivate` (only $\neg({A \land B})$ remains)
+
+ *following steps in 3*, select `A` **OR** `B`,
+
+ *from the inspector* `reactivate` (only `A` **XOR** `B` is highlighted)
+
+
+Other logical conditions (including numerical ones such as `disp > 300` on the scatterplot `p`) are constructed as a combination of the above (as in exclusive or).
+
+These can be quite complex and it may help, after some number of steps, to mark intermediary results by colour (or also glyph in scatterplots).
+
+**Note** that because of possibly missing data, not all linked plots may share the same set of observations.
+
+## Missing data and linking keys
+
+The `mtcars` data is an example of a complete data set.
+Had there been missing values, then these would not appear in loon plots that require them.
+
+For example, suppose `data` has four variables `A`, `B`, `C`, and `D`, and
+```{r, eval = FALSE}
+data <- data.frame(A = sample(c(rnorm(10), NA), 10, replace = FALSE),
+ B = sample(c(rnorm(10), NA), 10, replace = FALSE),
+ C = sample(c("firebrick", "steelblue", NA), 10, replace = TRUE),
+ D = sample(c(1:10, NA), 10, replace = FALSE))
+p_test <- l_plot(x = data$A, y = data$B, color = data$C, linkingGroup = "test missing")
+h_test <- l_hist(x = data$D, color = data$C, linkingGroup = "test missing")
+```
+
+Then
+
+- wherever an `NA` appears in any of `A`, `B`, or `C`, that point will be missing from `p_test`
+
+ Note that it is generally *not a good idea* to use `C` for any simple display characteristic like `color` if indeed `C` has missing values since this will remove non-missing `x` and `y` values from the plot. Not all values of `x` and `y` would then be accessible from the plot for logical queries,
+
+
+- wherever an `NA` appears in either of `C` or `D`, that point will be missing from `h_test`
+
+Using logical operations on the original `data` to change plot properties (e.g. select values) can be challenging when data values are missing in the plot (since what is missing depends on what was missing at the time of its construction).
+
+For example,
+```{r, eval = FALSE}
+p_test["selected"] <- (data$A > 0)
+```
+**may not work**!
+
+- The logical operation on the data (`data$A > 0`) will typically be longer than the corresponding x value `p_test["x"]` in the plot and so will not work.
+
+- Even if the logical vector is of the right length (and contains no `NA`s itself), the values may not correctly match the data points.
+
+There are **two general approaches** to logical queries when `data` contains `NA`s.
+
+1. Using **complete data**
+
+ If, like `mtcars`, the data being used contains no `NA`s then conducting logical queries on the plot will be identical to conducting them on the data.
+
+ If the data is not complete (contains one or more `NA`), it can be made complete by removing all observations (rows) that contain an `NA`. E.g. replacing `data` by `c_data <- na.omit(data)`.
+
+ - any logic on `c_data` will match that on plots made from `c_data`.
+
+ - depending on the amount and pattern of missing data, *this could critically reduce the amount of data in the analysis*.
+
+2. Using **the information in the loon plots**. Of course, this is the **recommended** approach when data is missing.
+
+ Logical queries can then be made
+
+ a. **directly on the plots**, either
+
+ - interactively as described in the previous sections, or,
+ - programmatically as in `p_test["x"] > 0` in place of `data$A > 0`.
+
+ or
+
+ b. **directly on the data and applied to the plots**
+
+ To help manage this, the `linkingKey` *of each plot* can be used.
+
+ - the default value for each plot is a character vector with entries
+
+ from `"0"` to `"n-1"` where `n = `nrow(data)`.
+
+ These are easily turned into the row numbers for the original data.
+
+ E.g. in `p_test` the row numbers of `data` that correspond to the points is
+
+ `1 + as.numeric(p_test["linkingKey"])`
+
+ Logical values for the rows of `data` can then select points in `p` as follows
+
+ ```{r, eval = FALSE}
+ LogVal <- data$A > data$B
+ p["selected"] <- logVal[1 + as.numeric(p_test["linkingKey"])]
+ ```
+
+ Similarly for `h_test`. E.g., compare `p_test["linkingKey"]` and `h_test["linkingKey]"`.
+
+ - **Note**: the user can always provide their own character vector `linkingKey` for their plots.
+
+ - E.g., `linkingKey = rownames(data)`
+
+ If so, then more care may be needed to use these to identify rows in a logical vector.
+
+### loon's linking model
+
+Loon's linking model has the following three parts
+
+- a `linkingGroup` which identifies which plots are linked
+- a `linkingKey`, a character vector where each element is a key uniquely identifying a single observation in the plot (no two observations in the same plot can have the same value in the linking key), and
+- the *linked display states* each plot has declared (e.g. see `l_getlinkedStates()`).
+
+Observations in different plots (in the same linking group) are linked (in that their linked states change together) if and only if they have the same linking key.
+
+Points appearing in different plots (in the same `linkingGroup`) which matched on the value of their `linkingKey` will share the same value for their linked states.
+
+
diff --git a/R/vignettes/teaching-example-smoothing.Rmd b/R/vignettes/teaching-example-smoothing.Rmd
index dc92105a..f29a4fad 100755
--- a/R/vignettes/teaching-example-smoothing.Rmd
+++ b/R/vignettes/teaching-example-smoothing.Rmd
@@ -27,16 +27,8 @@ set.seed(12314159)
library(loon.data)
library(loon)
library(knitr)
-
-imageDirectory <- "./images/teaching-example-smoothing"
-dataDirectory <- "./data/teaching-example-smoothing"
-path_concat <- function(path1, ..., sep="/") {
- # The "/" is standard unix directory separator and so will
- # work on Macs and Linux.
- # In windows the separator might have to be sep = "\" or
- # even sep = "\\" or possibly something else.
- paste(path1, ..., sep = sep)
- }
+imageDirectory <- file.path(".", "images", "teaching-example-smoothing")
+dataDirectory <- file.path(".", "data", "teaching-example-smoothing")
```
diff --git a/Readme.md b/Readme.md
index 6d8a3513..249bfc01 100755
--- a/Readme.md
+++ b/Readme.md
@@ -1,6 +1,7 @@
# loon
[](https://travis-ci.org/great-northern-diver/loon) [](https://cran.r-project.org/package=loon)
+[](https://cran.r-project.org/package=loon)
[](https://cran.r-project.org/package=loon)
`loon` is a toolkit for interactive data visualization and
diff --git a/copyTcl2Python.sh b/copyTcl2Python.sh
index f2fc58f7..ff5142cc 100755
--- a/copyTcl2Python.sh
+++ b/copyTcl2Python.sh
@@ -1,11 +1,11 @@
#!/bin/sh
-if [ -d "Python/diver/Tcl/images"]; then
+if [ -d "Python/diver/Tcl/images" ]; then
echo "Delete Python Tcl images folder"
rm -R Python/diver/Tcl/images
fi
-if [ -d "Python/diver/Tcl/library"]; then
+if [ -d "Python/diver/Tcl/library" ]; then
echo "Delete Python Tcl library folder"
rm -R Python/diver/Tcl/library
fi
diff --git a/copyTcl2R.sh b/copyTcl2R.sh
index 62d08fed..7d5ab46b 100755
--- a/copyTcl2R.sh
+++ b/copyTcl2R.sh
@@ -1,6 +1,6 @@
#!/bin/sh
-if [ -d "R/inst"]; then
+if [ -d "R/inst" ]; then
echo "Delete inst folder"
rm -R R/inst
fi
diff --git a/docs/404.html b/docs/404.html
index 4ae24ad9..26ef0005 100755
--- a/docs/404.html
+++ b/docs/404.html
@@ -79,7 +79,7 @@
loon
- 1.3.3
+ 1.3.4
@@ -102,13 +102,16 @@
Introduction
“Exposure, the effective laying open of the data to display the unanticipated, is to us a major portion of data analysis.” … John Tukey and Martin Wilk (1966)
Because loon is an interactive visualization system, this introduction is meant as a “hands on” tutorial. Not all interactions are from the command line (programmatic). Suggestions for interactions will also be given and questions that draw attention to the outcome of interactions.
After completing the tutorial, there are numerous other examples of using loon which can be explored. These include
demos on particular topics given by demo(package = "loon"). These are especially useful because the source code for creating them appears in the console, and
@@ -141,15 +143,14 @@
2021-03-10
l_plot() the basic loon plot
Begin with a simple scatterplot of the quakes data from R
-
-l_plot(x =quakes$long,
- y =quakes$lat,
- xlabel ="longitude",
- ylabel ="latitude",
- title ="Tonga trench earthquakes")
like the R palette, the loon inspector palette persists.
@@ -372,16 +371,15 @@
changing the inspector palette of colours
-
At the beginning of a loon session (that is, immediately after executing library(loon)) you might choose to change the default palette for the inspector to something that suits your tastes/problem.
+
At the beginning of a loon session (that is, immediately after executing library(loon)) you might choose to change the default palette for the inspector to something that suits your tastes/problem.
Note: There may be unintended side effects to changing the inspector colours after a plot (and hence the inspector) has been created so this should be avoided.
A variety of functions exist to change an inspector’s palette of colours:
The plot itself is a (tcl) data structure and can be assigned to an R variable.
Either at construction (the preferable way):
-
-# loon graphics (note that the result is assigned to p)
-p<-l_plot(x =quakes$long, y =quakes$lat,
- xlabel ="longitude", ylabel ="latitude",
- title ="Tonga trench earthquakes")
+
# loon graphics (note that the result is assigned to p)
+p<-l_plot(x=quakes$long, y=quakes$lat,
+ xlabel="longitude", ylabel="latitude",
+ title="Tonga trench earthquakes")
or, if (as we did) you forgot to do that or reassigned something else to that variable (more likely), by accessing the plot from its tcl string:
-
-# accessing the plot from its string representation
-p<-l_create_handle(".l0.plot")
+
# accessing the plot from its string representation
+p<-l_create_handle(".l0.plot")
Note that this string ".l0.plot" appears on the right side of the window title of an l_plot.
Do this and assign your plot to p. You might have to look at the window to get the string if you have created more than one l_plot().
we get the string name of the plot, but with a class attribute. This is the value of p and provides us access to a very rich data structure, but one whose values reside in tcl.
For example, we can access this value and, like plots from lattice or ggplot2 produce a grid data structure that can then be displayed as a grid graphic in R.
-
The simplest way to achieve this is to use the generic R function plot()
unique_cols<-unique(p['color'])
+group1<-p['color'] ==unique_cols[1]
# Number in group 1 (e.g. as you might have -- here from saved colours)
-sum(group1)
-
[1] 425
-
-# Data on first few quakes in group 1.
-head(quakes[group1,])
-
lat long depth mag stations
-1-20.42181.625624.841
-2-20.62181.036504.215
-4-17.97181.666264.119
-5-20.42181.966494.011
-10-17.47179.596224.319
-11-21.44180.695834.413
Alternatively, a function could be written to save the groups as a list of logical vectors (one for each group):
-
-getGroups<-function(loonplot){
+
getGroups<-function(loonplot){
# make sure it is an "l_plot"
- if(!is(loonplot, "l_plot"))stop("loonplot must be an l_plot")
-
+ if (!is(loonplot, "l_plot")) stop("loonplot must be an l_plot")
+
# use color to identify groups
- unique_cols<-unique(loonplot['color'])
- lapply(unique_cols,
- FUN =function(col){loonplot['color']==col}
- )
-}
-
-myGroups<-getGroups(p)# returns groups identified by unique colour in p
-nGroups<-length(myGroups)# number of groups
-group1<-myGroups[[1]]# each group is an element of the list myGroups
+ unique_cols<-unique(loonplot['color'])
+ lapply(unique_cols,
+ FUN=function(col){loonplot['color'] ==col}
+ )
+}
+
+myGroups<-getGroups(p) # returns groups identified by unique colour in p
+nGroups<-length(myGroups) # number of groups
+group1<-myGroups[[1]] # each group is an element of the list myGroups
Similarly, other point symbol characteristics (e.g. size, glyph) might be used to define groups. This is particularly handy when these are first determined interactively.
@@ -484,33 +473,32 @@
setting plot contents
In addition to accessing the state values of a loon plot using [], its values may also be set using []. For example, try these:
-
-p["showGuides"]<-TRUE
+
p["showGuides"] <-TRUE
-p["size"]<-sample(1:30, size =length(p["x"]), replace =TRUE)
+p["size"] <-sample(1:30, size=length(p["x"]), replace=TRUE)
-for(iin1:length(myGroups)){
- p["selected"]<-myGroups[[i]]
- Sys.sleep(1)
-}
-p["selected"]<-FALSE
+for (iin1:length(myGroups)) {
+ p["selected"] <-myGroups[[i]]
+ Sys.sleep(1)
+}
+p["selected"] <-FALSE# something a little more involved for up to 6 groups
-myCols<-c("firebrick", "steelblue", "purple",
- "orange", "grey10", "grey80")
-for(iin1:length(myGroups)){
- p["color"][myGroups[[i]]]<-myCols[i]
-}
+myCols<-c("firebrick", "steelblue", "purple",
+ "orange", "grey10", "grey80")
+for (iin1:length(myGroups)) {
+ p["color"][myGroups[[i]]] <-myCols[i]
+}
# something crazy
-for(jin1:10){
- p["xTemp"]<-p["x"]+runif(length(p["x"]), min =-0.5, max =0.5)
- Sys.sleep(0.1)
-}
+for (jin1:10) {
+ p["xTemp"] <-p["x"] + runif(length(p["x"]), min= -0.5, max=0.5)
+ Sys.sleep(0.1)
+}
# putting locations and size back
-p["xTemp"]<-p["x"]
-p["size"]<-4
+p["xTemp"] <-p["x"]
+p["size"] <-4
@@ -524,16 +512,15 @@
Example: adding maps
For example, we can add a map to the current loon plot p.
First get the relevant map:
-
-library(maps)
-NZFijiMap<-map("world2", regions =c("New Zealand", "Fiji"), plot =FALSE)
l_layer(p, NZFijiMap,
-label ="New Zealand and Fiji",
-color ="forestgreen",
-index ="end")
-loon layer "New Zealand and Fiji" of type polygons of plot .l0.plot
-[1] "layer0"
+
l_layer(p, NZFijiMap,
+ label = "New Zealand and Fiji",
+ color = "forestgreen",
+ index = "end")
+loon layer "New Zealand and Fiji" of type polygons of plot .l0.plot
+[1] "layer0"
Try this out.
@@ -563,24 +550,23 @@
Syntax: loon’s l_plot() is like base graphics plot()
-
loon’s l_plot() syntax intentionally resembles that of plot() from the base graphics package:
-
-# Base graphics
-plot(x =quakes$long, y =quakes$lat,
- xlab ="longitude", ylab ="latitude",
- main ="Tonga trench earthquakes")
+
loon’s l_plot() syntax intentionally resembles that of plot() from the base graphics package:
+
# Base graphics
+plot(x=quakes$long, y=quakes$lat,
+ xlab="longitude", ylab="latitude",
+ main="Tonga trench earthquakes")
# loon graphics
-l_plot(x =quakes$long, y =quakes$lat,
- xlabel ="longitude", ylabel ="latitude",
- title ="Tonga trench earthquakes")
In loon, the function plot.loon() is a method of the base plot() generic function that turns the loon plot (as the first argument of plot.loon()) into a grid object and plots it on the current R graphics device.
+
In loon, the function plot.loon() is a method of the base plot() generic function that turns the loon plot (as the first argument of plot.loon()) into a grid object and plots it on the current R graphics device.
@@ -603,10 +589,9 @@
As seen earlier, the quakes data has some other variates in addition to the latitude and longitude of the quakes.
Before starting, make sure that you have the four groups coloured in the loon plot p as described earlier. If you don’t, then colour them again now.
Let’s consider a histogram of the depth of each earthquake.
-
-h<-l_hist(quakes$depth,
- xlabel ="depth",
- title ="Tonga trench earthquakes")
but this would have resulted in an error. The problem is that the synchronization must be set at the same time to determine where the linked states are to be drawn from. To effect this, the loon command l_confiure() must be used whenever two or more states are to be set simultaneously. The correct programmatic setting of the “linkingGroup” is
This causes h to push its linked states to the “quakes” group and p to pull them from the “quakes” group. (In this example, “pull” could have been used in both cases and is generally recommended.)
brush the scatterplot and observe the effects in the histogram
@@ -657,12 +640,11 @@
could also set colours programmatically on the histogram. Here we colour the histogram bars so that those earthquakes that are deepest are darkest.
-
-blues5<-blues9[c(2,4,6,8,9)]# select 5 from light blue to dark
-h["color"]<-blues5[cut(quakes$depth, breaks=5)]# assign colours by depth
-p["glyph"]<-"ccircle"
-p["showGuides"]<-TRUE
-# plot(p) # will print the plot
+
blues5<-blues9[c(2,4,6,8,9)] # select 5 from light blue to dark
+h["color"] <-blues5[cut(quakes$depth, breaks=5)] # assign colours by depth
+p["glyph"] <-"ccircle"
+p["showGuides"] <-TRUE
+# plot(p) # will print the plot
@@ -672,28 +654,26 @@
linking many plots
Arbitrarily many plots may be created and linked in loon.
Consider, for example, adding two more histograms to the same linkingGroup. Note that the linking is done at creation and that the synchronization is by default a “pull”.
Brushing any one of these plots will cause the other plots to highlight in response.
Note that selection effectively shows the relations in one plot conditional upon the values actively being selected (e.g. brushed) in another.
@@ -703,17 +683,16 @@
Observations in a loon plot are uniquely identified (for the purpose of linking) by their linkingKey. Pardon the pun but this is the key to linking in loon.
For the most part, the default linking is all that you ever need do.
-Trouble may arise, however, if you want to link two different plots that were created with different data frames whose rows so not match row for row. For example, one data.frame might be a re-ordering of the rows of the other. Or, it might be a subset of the rows of the other.
+Trouble may arise, however, if you want to link two different plots that were created with different data frames whose rows do not match row for row. For example, one data.frame might be a re-ordering of the rows of the other. Or, it might be a subset of the rows of the other.
In either case, to have linking work properly the linkingKey of the plots associated with the two data frames need to be managed.
For example,
-
-new_order<-sample(1:nrow(quakes), nrow(quakes), replace =FALSE)
-some_quakes<-sample(1:nrow(quakes), 100, replace =FALSE)
-quakes_linkingKey<-p["linkingKey"]
-p_new<-with(quakes[new_order, ], l_plot(long, lat, title ="quakes reordered",
- linkingGroup ="quakes", linkingKey =quakes_linkingKey[new_order]))
-p_subset<-with(quakes[some_quakes, ], l_plot(long, lat, title ="quakes reordered",
- linkingGroup ="quakes", linkingKey =quakes_linkingKey[some_quakes]))
The new plots p_new and p_subset will link correctly with all the rest.
Rather than the default values, the linkingKey can be any vector of unique strings used in any newly created plot as above. Of course, not using the default linking keys from loon may require a little more care in management from the user.
@@ -724,16 +703,15 @@
Three dimensional plots - l_plot3D
Given that the quakes data has three spatial dimensions (long, lat, and depth), it would be natural to view this in a three dimensional scatterplot.
-
-# First, scale the data
-scaled_quakes<-l_scale3D(quakes)
-
-p_mag_stations<-l_plot3D(x =scaled_quakes$long,
- y =scaled_quakes$lat,
- z =scaled_quakes$depth,
- showGuides =TRUE,
- linkingGroup ="quakes",
- title ="Three dimensional plot of quakes")
+
# First, scale the data
+scaled_quakes<-l_scale3D(quakes)
+
+p_mag_stations<-l_plot3D(x=scaled_quakes$long,
+ y=scaled_quakes$lat,
+ z=scaled_quakes$depth,
+ showGuides=TRUE,
+ linkingGroup="quakes",
+ title="Three dimensional plot of quakes")
Select the plot, type r to turn on the rotation mode. Press the down arrow on the keyboard until the darkest points (deepest quakes) are at the bottom of the display. Press r again to turn off the rotation mode.
Selecting the plot, the key r toggles the rotation mode; arrow keys rotate the plot vertically and horizontally. In rotation mode the plot may also be rotated free hand using the mouse. When rotation mode is toggled off (with the key r), the plot can again be brushed et cetera as with any l_plot. See help("l_plot3D") for more details.
Being able to get and set the plot contents means that it is possible to capture different plot states as grobs. There are a variety of ways to see how you might put loon to use.
There are of course many smaller examples available through the loon’s R documentation available via
This illustrates a variety of loon features including map layers, parallel coordinate axes, and radial axes glyphs in the context of an exploratory analysis of the distribution of visible minorities in 33 Canadian cities.
New interactive graphics in loon in a teaching example: “Smoothers and Bone Mineral Density” available via
This illustrates how to create new interactions in loon through more general bindings. This is done by developing a teaching tool for explaining how smoothing works. The example data set is bone from the loon.data package.
Some suggestions on integrating loon plots into an Rmarkdown document: “Loon in RMarkdown” via
-### teaching demos
-demo("l_regression", package ="loon")# lots using the Old Faithful geyser
-demo("l_regression_influential", package ="loon")# change points change the regression fit
+
### teaching demos
+demo("l_regression", package="loon") # lots using the Old Faithful geyser
+demo("l_regression_influential", package="loon") # change points change the regression fit### gapminder
-demo("l_us_and_them", package ="loon")# basic demo
-demo("l_us_and_them_slider", package ="loon")# year selected on a slider
-demo("l_us_and_them_choropleth", package ="loon")# world map and linked with a scatterplot
+demo("l_us_and_them", package="loon") # basic demo
+demo("l_us_and_them_slider", package="loon") # year selected on a slider
+demo("l_us_and_them_choropleth", package="loon") # world map and linked with a scatterplot### the spatial package sp
-demo("l_polygons_sp", package ="loon")# layer polygons with class sp
+demo("l_polygons_sp", package="loon") # layer polygons with class sp ### layering and custom layouts
-demo("l_layers")# demonstrate layer types
-demo("l_layout")# custom layout widgets
-demo("l_widgets")# inspector and plot in one window
+demo("l_layers") # demonstrate layer types
+demo("l_layout") # custom layout widgets
+demo("l_widgets") # inspector and plot in one window### novel brushing and linking
-demo("l_knn")# brushing by k nearest points in some subspace
-demo("l_us_and_them_choropleth")# many to one linking
+demo("l_knn") # brushing by k nearest points in some subspace
+demo("l_us_and_them_choropleth") # many to one linking ### high dimensional data and dimensionality reduction
-demo("l_ng_images_frey_LLE")# navigation graphs, image data, LLE
-demo("l_ng_dimred")# comparing dimension reduction methods
Provides a means for compact layout of alternating 1d (e.g. histograms) and 2d (e.g. scatterplots) plots. In will layout base graphics plots, grid graphics plots, and loon plots.
It is similar to pairs plots but allows many many more plots to be displayed. From the introductory vignette:
@@ -854,22 +824,18 @@
Graphics in the grid package are built up from graphical objects or grobs.
In loon, the functions grid.loon() and loonGrob() construct grobs from loon plots which can then be used as any other grob in grid
For example, when transformed to grid, the loon plot p structure becomes a gTree in grid.
This simply produces the grid data structure corresponding to the current state of the loon plot p, as can be seen from listing its contents:
-
-library(grid)
-grid.ls(gp)# lists the contents of the grob
+
library(grid)
+grid.ls(gp) # lists the contents of the grob
The grob gp could now be used with all the functionality of the grid package.
Note that all of the elements of a loon plot appear in the grob, either explicitly or, if they were not drawn in the loon plot, as an empty grob containing the relevant arguments to drawing them.
Another function in loon to help that is the grid.loon() function
varTypes is a list with two named components: categorical and numeric.
+
+
+
+Some interactive plots
+
To explore the data, several interactive plots will likely have been constructed. Typically, these will have been constructed one at a time and assigned to the same linking group (perhaps via the inspector).
+
Below, histograms/barplots are constructed for each categorical variable and assigned to that variable name now prefixed by h_ for “histogram”.
These are not evaluated in this vignette. Note that all are in the same linkingGroup.
+
Other linked plots might exist as well – for example, a scatterplot of gear (the number of forward gears) versus disp (the engine displacement in cubic inches).
Note that - each car’s name appears as the itemLabel for that point in the plot (to be revealed as a “tooltip” style pop up), and that - the plot p is in the same linking group as the histograms.
+
Through a combination of selection, inversion, deactivation, and reactivation, logical queries may be made interactively on the data.
+
For simplicity, the basic logical operators are illustrated below using only the histograms. More generally, these apply to any interactive loon graphic.
+
+
+
+Interactive logical operations
+
Five logical conditions/operations illustrated here are the basic ones:
+
+
+A is TRUE
+
+
Negation: (NOT A) is TRUE
+
+
Inclusive OR: (A OR B) is TRUE (one or the other or both),
+
Conjunction: (A AND B) are both TRUE
+
+
Exclusive OR: (A XOR B) meaning (A is TRUE) or (B is TRUE) but (A AND B) is FALSE
+
+
Each of these corresponds to a sequence of actions on the plots and/or inspector. Whatever is highlighted in the end corresponds to the result.
+
Again, for simplicity all operations are illustrated by interacting with values of categorical variates in the various histograms. Any of the logical elements could also have been that satisfying numerical constraints by undertaking the corresponding actions on a scatterplot (or histogram of continuous values).
+
Each logical operator is illustrated in turn:
+
+
+
A (\(= A\))
+
on the plot select A,
+
+
e.g., click on "manual" bar from the Transmission histogram
+
highlighted \(\iff\)Transmission == "manual" is TRUE
+
+
+
+
NOTA (\(= \overline{A}~~\) or \(~~\neg A\))
+
on a plot select A,
+
from the inspector click invert
+
+
+
e.g., click on "North America" bar from the continent histogram,
+
then invert
+
+
highlighted \(\iff\)continent == "North America" is FALSE
+
all that is highlighted is not"North America", namely "Asia" or "Europe"
+
+
+
+
AORB (\(= A \cup B~~\) or \(~~A \lor B\)),
+
on a plot select A,
+
on the same (or a different but linked) plot<SHIFT>- select B
+
+
+
e.g., click on "manual" bar from Transmission histogram,
+
then while holding down the <SHIFT> key,
+
click on the Mercedes bar in the company histogram
+
+
highlighted \(\iff\)Transmission == "manual" is TRUEORcompany = "Mercedes" is TRUE (or both)
+
+
+
+
AANDB (\(= A \cap B\) or \(A \land B\))
+
lots of solutions, here is one that always works
+
on a plot select A,
+
from the inspector, invert then deactivate (only A remains),
+
from a plot of the remaining select B,
+
from the inspectorreactivate all
+
+
elements are highlighted \(\iff A \cap B\)
+
e.g. try highlighting all European cars with manual transmissions.
+
+
+
+
AXORB (\(= (A \cup B) \cap (\overline{A \cap B})\) or \((A \lor B) \land \neg({A \land B})\))
+
following steps in 4, select AANDB,
+
from the inspectorinvert then deactivate (only \(\neg({A \land B})\) remains)
+
following steps in 3, select AORB,
+
from the inspectorreactivate (only AXORB is highlighted)
+
+
+
Other logical conditions (including numerical ones such as disp > 300 on the scatterplot p) are constructed as a combination of the above (as in exclusive or).
+
These can be quite complex and it may help, after some number of steps, to mark intermediary results by colour (or also glyph in scatterplots).
+
Note that because of possibly missing data, not all linked plots may share the same set of observations.
+
+
+
+Missing data and linking keys
+
The mtcars data is an example of a complete data set. Had there been missing values, then these would not appear in loon plots that require them.
+
For example, suppose data has four variables A, B, C, and D, and
wherever an NA appears in any of A, B, or C, that point will be missing from p_test
+
Note that it is generally not a good idea to use C for any simple display characteristic like color if indeed C has missing values since this will remove non-missing x and y values from the plot. Not all values of x and y would then be accessible from the plot for logical queries,
+
+
wherever an NA appears in either of C or D, that point will be missing from h_test
+
+
Using logical operations on the original data to change plot properties (e.g. select values) can be challenging when data values are missing in the plot (since what is missing depends on what was missing at the time of its construction).
+
For example,
+
p_test["selected"] <- (data$A>0)
+
may not work!
+
+
The logical operation on the data (data$A > 0) will typically be longer than the corresponding x value p_test["x"] in the plot and so will not work.
+
Even if the logical vector is of the right length (and contains no NAs itself), the values may not correctly match the data points.
+
+
There are two general approaches to logical queries when data contains NAs.
+
+
+
Using complete data
+
If, like mtcars, the data being used contains no NAs then conducting logical queries on the plot will be identical to conducting them on the data.
+
If the data is not complete (contains one or more NA), it can be made complete by removing all observations (rows) that contain an NA. E.g. replacing data by c_data <- na.omit(data).
+
+
any logic on c_data will match that on plots made from c_data.
+
depending on the amount and pattern of missing data, this could critically reduce the amount of data in the analysis.
+
+
+
+
Using the information in the loon plots. Of course, this is the recommended approach when data is missing.
+
Logical queries can then be made
+
+
+
directly on the plots, either
+
+
interactively as described in the previous sections, or,
+
programmatically as in p_test["x"] > 0 in place of data$A > 0.
+
+
or
+
+
+
directly on the data and applied to the plots
+
To help manage this, the linkingKeyof each plot can be used.
+
+
+
the default value for each plot is a character vector with entries
+
from "0" to "n-1" where n =nrow(data)`.
+
These are easily turned into the row numbers for the original data.
+
E.g. in p_test the row numbers of data that correspond to the points is
+
1 + as.numeric(p_test["linkingKey"])
+
Logical values for the rows of data can then select points in p as follows
Similarly for h_test. E.g., compare p_test["linkingKey"] and h_test["linkingKey]".
+
+
+
+
+
+
+
Note: the user can always provide their own character vector linkingKey for their plots.
+
+
E.g., linkingKey = rownames(data)
+
+
+
If so, then more care may be needed to use these to identify rows in a logical vector.
+
+
+
+
+
+
+loon’s linking model
+
Loon’s linking model has the following three parts
+
+
a linkingGroup which identifies which plots are linked
+
a linkingKey, a character vector where each element is a key uniquely identifying a single observation in the plot (no two observations in the same plot can have the same value in the linking key), and
+
the linked display states each plot has declared (e.g. see l_getlinkedStates()).
+
+
Observations in different plots (in the same linking group) are linked (in that their linked states change together) if and only if they have the same linking key.
+
Points appearing in different plots (in the same linkingGroup) which matched on the value of their linkingKey will share the same value for their linked states.
When carrying out an interactive analysis, you might want to save some pictures to include in any later report. You might also want to save the state of some interactive plot so that you can pause your analysis, quit R, and later return to your analysis where you left off.
To illustrate how to do this, consider the classic data set iris. Here are three different linked plots that might be displayed.
library(loon)
# First, make sure you always assign a loon plot to a variable# at the same time that you create it. This will give you access# to it later. # (NB: If you haven't assigned it, you can later using l_getFromPath(). )# # A histogram, the name for the linkingGroup is arbitrary
-h<-l_hist(iris$Sepal.Length, color ="grey", xlabel ="Sepal length",
- linkingGroup ="flowers")
+h<-l_hist(iris$Sepal.Length, color="grey", xlabel="Sepal length",
+ linkingGroup="flowers")
## A scatterplot
-p<-l_plot(iris$Petal.Width, iris$Petal.Length,
- color ="grey", size =10,
- xlabel ="Petal Width", ylabel ="Petal Length",
- linkingGroup ="flowers")
+p<-l_plot(iris$Petal.Width, iris$Petal.Length,
+ color="grey", size=10,
+ xlabel="Petal Width", ylabel="Petal Length",
+ linkingGroup="flowers")
## A serial axes plot using the first 4 columns of iris (i.e. no Species info).
-sa<-l_serialaxes(iris[, 1:4],
- color ="grey", linkingGroup ="flowers")
+sa<-l_serialaxes(iris[, 1:4],
+ color="grey", linkingGroup="flowers")
## A static version of the plot can be easily produced.
-plot(h)
# First get the data stuctures corresponding to the static snapshots# of the current plots. Because we want to arrange them, we don't# draw them at first.
-plot_h<-plot(h, draw =FALSE)
-plot_p<-plot(p, draw =FALSE)
-plot_sa<-plot(sa, draw =FALSE)
+plot_h<-plot(h, draw=FALSE)
+plot_p<-plot(p, draw=FALSE)
+plot_sa<-plot(sa, draw=FALSE)
# Now we draw them
-grid.arrange(plot_h, plot_p, plot_sa, nrow =1)
This works fine when what you want to display has been entirely determined by programming done inside the RMarkdown code. For example, if the colours had been changed programmatically, the linked plots would change and plotting them again would reflect that change.
-
-# Change the colour by changing it *programmatically* on the plot
+
# Change the colour by changing it *programmatically* on the plot#
-h["color"]<-iris$Species# use species to determine the colours
-plot_h<-plot(h, draw =FALSE)
-plot_p<-plot(p, draw =FALSE)
-plot_sa<-plot(sa, draw =FALSE)
+h["color"] <-iris$Species# use species to determine the colours
+plot_h<-plot(h, draw=FALSE)
+plot_p<-plot(p, draw=FALSE)
+plot_sa<-plot(sa, draw=FALSE)
# And draw them again
-grid.arrange(plot_h, plot_p, plot_sa, nrow =1)
First, the plots had to be redrawn because they are static snapshots reflecting what the interactive plot looked like at the time the snapshot was taken using plot().
+
First, the plots had to be redrawn because they are static snapshots reflecting what the interactive plot looked like at the time the snapshot was taken using plot().
Second, all linked plots changed when the colour was only directly changed on the histogram.
Finally, there are numerous states that can be programmatically accessed and set on an interactive plot. These states can be found by calling names() on the plot in question.
e.g. names(h) returns the state names for the histogram h.
Knowing the state names provides the user a programmatic means to access and/or to set their values. The values can be queried at any time, whether they were set programmatically or interactively. For example,
-
-# Accessing values
-head(sa["color"])# will show the current colours of sa
+
# Accessing values
+head(sa["color"]) # will show the current colours of sa# Note that these colours are expressed as 12 hexadecimal digits # This is what is used in TCL. To turn them into R's 6 digit hexadecimal # (to use in other R static plots, for example) just use hex12tohex6()
-hex12tohex6(sa["color"][1:3])
+hex12tohex6(sa["color"][1:3])
# Setting values ... make only specied iris versicolor active
-sa["active"]<-iris$Species=="versicolor"
-plot(sa)
+sa["active"] <-iris$Species=="versicolor"
+plot(sa)
# Setting values ... make everything active
-sa["active"]<-TRUE
-plot(sa)
A problem with doing things interactively is that any direct manipulation of the plots using the inspector or brushing, panning, zooming, etc. is not being recorded.
If you want to have the values of states (which were set interactively) to appear later in a report, these values will need to be recorded somewhere first.
It will be necessary to save the state somehow, either as a snapshot or as data in a separate file to be recovered later (saving plot states like colours, selections, etc.).
@@ -208,8 +206,8 @@
Export from RStudio
-
Simply plot(p) and select the Export button above the static plot. Choose a file name and location for your plot.
-
Because plot() actually turns the loon plot into a grid graphic, the picture saves will be close but not necessarily exactly as it appears on screen. Typical differences include font sizes and names.
+
Simply plot(p) and select the Export button above the static plot. Choose a file name and location for your plot.
+
Because plot() actually turns the loon plot into a grid graphic, the picture saves will be close but not necessarily exactly as it appears on screen. Typical differences include font sizes and names.
@@ -217,35 +215,32 @@
This is a loon function to export a loon plot to a file. On the plus side, what you see is what you get. The loon plot saved to the file will be the same as it appears on the display.
Trouble is, depending on your OS, you might not be able to save the picture as any type of image. For example, pdf images will be available to nearly all OSes, png will not. You do need to specify the file suffix:
In R, there are a variety of graphics “devices”. These identify where R will draw a static plot. The call dev.cur() will tell you what the current device is.
One such device is png() which allows R plots to be drawn as a png graphic. It would work like this
-
-# turn the png graphics device on with name of the file
-png(file ="myplot_via_R.png", width =600, height =500)
+
# turn the png graphics device on with name of the file
+png(file="myplot_via_R.png", width=600, height=500)
# Draw the static plot
-plot(p)
+plot(p)
# Turn the device off/close the file
-dev.off()
Having saved various snapshots to various files, you can now include them in your Rmarkdown file using the include_graphics() function from knitr.
Of course, this means that the various files mentioned above were previously saved (not created in the markdown file) and so can now be read into your RMarkdown report as follows:
-
-# The one exported from RStudio
-knitr::include_graphics("myplot_via_RStudio.png")
+
# The one exported from RStudio
+knitr::include_graphics("myplot_via_RStudio.png")
# Followed by the one saved using l_export # (note that background grid is missing)
-knitr::include_graphics("myplot_via_l_export.pdf")
+knitr::include_graphics("myplot_via_l_export.pdf")
# And finally, the one saved using R's png device
-knitr::include_graphics("myplot_via_R.png")
Alternatively, you could use LaTeX if you want more control. For example, the following LaTeX code would centre the three plots in each column of a tabular lay out:
\begin{center}
@@ -276,14 +271,14 @@
Reconstruct the plot from saved states
-
loon also provides some functionality to save the current states of a loon plot. As with saving snapshots, this would be done at any time during the interactive analysis. Then later, when it is time to write the report, the saved states of the plot could be read back in and the plot reconstructed programmatically to be displayed in the report using plot() as above.
+
loon also provides some functionality to save the current states of a loon plot. As with saving snapshots, this would be done at any time during the interactive analysis. Then later, when it is time to write the report, the saved states of the plot could be read back in and the plot reconstructed programmatically to be displayed in the report using plot() as above.
The use model is
Use l_saveStates() to save the current states of the loon plot to a file (repeat as often as desirable, saving to a different file each time).
Later, use l_getStates() to recover the saved states from the named file/
Construct a new loon plot of the desired type.
Copy the saved states to the new plot using l_copyStates() (alternatively, assign selected saved states of the new plot using $).
-
Produce a static picture of the new loon plot using plot() as above.
+
Produce a static picture of the new loon plot using plot() as above.
Note that only the first step happens in the interactive part of the analysis. Steps 2 through 5 programmatically recover the plot and its picture for incorporation in a report.
Of course in place of step 5, one could use steps 2 through 4 to restart an interactive analysis where one left off.
@@ -292,26 +287,21 @@
A simple example
A typical use will be simply recording the plot after some interaction with the display, usually involving linking between two displays, say the scatterplot and histogram above.
Sometimes, the interactive analysis will have been more involved. It could, for example, have involved panning and zooming, changing of glyphs, particular choices for labels and titles, and so on.
@@ -319,31 +309,25 @@
Here, the analyst zoomed in on the species “versicolor”, jittered the locations of the points, and changed some of the glyphs to be large closed triangles. This involves many more states, all of which must be saved to reproduce the plot.
The states to be saved can be named explicitly to be most efficient in storage, providing of course one knows which are the states that need to be saved.
All of the states of a loon plot p are given by names(p). At the risk of saving more information than necessary, we could choose to save all of the states of p, as in
When it comes to transferring the states to a new plot there are many choices. We could go with a large collection of display states (more than the default states but still excluding more “basic” states about panning and zooming for example). To see which states, we add the argument returnNames = TRUE:
This excluded “basic” states through the argument excludeBasicStates whose default value is TRUE.
More, or different, states could be excluded by using the argument exclude to list them in a vector. Alternatively, the only states to be transferred could be made explicit by naming them in the value of the argument states.
Because the “basic” states were excluded by default, the new plot now looks like
As can be seen, the glyph sizes and shapes were transferred but not the zooming or the jittering. To ensure we get an exact copy, we need to include all of the states, that is to exclude none of them.
The data consists of measurements of spinal bone mineral density. Several such measurements were taken from 261 North American adolescents over a few years. The entire dataset is called bone and can be found in the R package loon.data.
As can be seen, there are five variates. The idnum uniquely identifies each of the 261 adolescents (N.B. these are not numbered 1 to 261), sex identifies their sex, and ethnic their “ethnicity/race”. The response variate of interest is rspnbmd which is a relative measure of spinal bone mineral density determined as the ratio of the difference in bone mineral density as measured on two consecutive visits divided by their average. Similarly, the explanatory variate age is the average of the adolescent’s age in years on those two visits.
In this vignette we investigate the fit of smoothing splines to this data.
@@ -144,21 +145,20 @@
The scatterplot
To begin, execute the following code:
-
-# The plot
-x<-bone$age
-y<-bone$rspnbmd
+
# The plot
+x<-bone$age
+y<-bone$rspnbmd# A scatterplot
-p<-l_plot(x, y,
- color="darkgrey",
- xlabel="age", ylabel="rspnbmd",
- showGuides =TRUE, showScales =TRUE,
- itemLabel =paste0("IDnum = ", bone$idnum, "\n",
- bone$sex, "\n",
- "Age: ", bone$age),
- showItemLabels =TRUE,
- linkingGroup="Bone density",
- title ="Spinal bone mineral density (rspnbmd)")
+p<-l_plot(x, y,
+ color="darkgrey",
+ xlabel="age", ylabel="rspnbmd",
+ showGuides=TRUE, showScales=TRUE,
+ itemLabel=paste0("IDnum = ", bone$idnum, "\n",
+ bone$sex, "\n",
+ "Age: ", bone$age),
+ showItemLabels=TRUE,
+ linkingGroup="Bone density",
+ title="Spinal bone mineral density (rspnbmd)")
Two windows will have appeared once the above code has been executed. One is the plot p, the other the inspector of the plot p.
The plot is interactive. Hovering the mouse over a point in the plot, for example, will pop up the itemLabel for that point. Scrolling on mouse wheel (or equivalent) over the plot zooms in (or out) on the plot; note that the zoom is centred at the mouse position. For horizontal zooming only, hold the “control” key down while scrolling; for vertical zooming only hold the “alt” (or cmd on a Mac) key while scrolling.
Zoom in anywhere on the plot. Notice that the inspector displays a miniature version of the whole plot as its World View at the top of its display. The plot is bounded in the World View by a grey rectangle and the region of the plot that is displayed is shown as a brighter region bounded by a black rectangle. This bright display region can be grabbed by clicking (and holding depressed) the left (or primary) mouse button. Moving the mouse around while keeping the left button depressed moves the bright region in the inspector which in turn cause the display in the plot to update accordingly. In this way, the inspector World View can be used to pan the entire display. Alternatively, panning may also be effected by right (or secondary) button clicking on the interior of the plot, holding that mouse button down and moving the mouse. In the inspector the region moves with the mouse, in the plot the background does.
In the inspector window, immediately below the World View there are several tabs, the first of which is the Analysis tab. The first subsection of the analysis tab contains plot attributes. The values here were determined when the plot p was created according to the values of the arguments given to l_plot(...). These can be changed in the inspector by toggling the check boxes.
The complete set of arguments that could have been used at the time of creation can be had by querying the plot p as names(l_info_states). The values can also be accessed and changed programmatically for example as in
The vertical variate, rspnbmd, measured the change in spinal bone mineral density. Anything above zero indicates an increase, anything below a decrease; the magnitude is the rate of change in density. It might be of interest, then, to add a horizontal line to the plot at zero. This is accomplished by layering a line on the plot p as follows:
-
-axis<-l_layer_line(p,
- x=extendrange(x, f=0.5), y=c(0,0),
- label="axis", linewidth=2,
- color ="black",
- dash=c(10,10),
- index="end")# last argument places axis behind other layers
This “axis” can be turned on and off via the inspector or programmatically. On the inspector, click on the Layers tab. The layers appear in a list ordered from top to bottom in the inspector in the order in which they are displayed in the plot. The axis appears below the Scatterplot and hence is displayed behind the points.
Selecting the axis, the up and down buttons at the bottom of the list allow the axis to be placed above or below the Scatterplot. The axis (or Scatterplot) can be moved up or down in the display. Either can be made (temporarily) invisible by clicking on the icon showing a cartoon eye with a stroke through it and made visible again by clicking on the cartoon eye. Try it.
The axis (or any other layer, e.g. the Scatterplot), could be removed entirely with the minus sign. Don’t do this right now; click on the “Analysis” tab instead.
@@ -188,12 +186,11 @@
Histogram
A histogram can be constructed in the same way as for numeric values. Now, because sex is a factor, the result is essentially a simple bar plot with a layer labelling the bars by the corresponding sex:
Note that the inspector now shows the histogram (i.e. barplot) in the World View and that the plot section of the Analysis now has options peculiar to a histogram.
The histogram and the scatterplot both have the same linkingGroup “Bone density” and the inspector shows that the 2 plots are linked. Selecting the left most bar of the histogram highlights all of the females in both plots. Switching back and forth between the two bars while observing the scatterplot shows that the pattern for males seems to be shifted slightly to the right of those for the females.
Similarly, selecting any point in the scatterplot causes a corresponding slice of the bar in which it appears in the histogram to be highlighted.
@@ -207,11 +204,10 @@
Panning and brushing
A second scatterplot could display other variates. For example, plotting the age versus the patient ID number gives:
-
-p2<-l_plot(bone$idnum, bone$age,
- xlabel="idnum", ylabel="age",
- linkingGroup="Bone density",
- title ="ID numbers and age")
Ideally this plot would look like fairly uniform scatter. Assuming that idnum was assigned with recruitment there are some patterns. In the middle of the idnum range, for example, there appears to be a preponderance of older ages followed immediately by a preponderance of younger ages.
We might investigate how the change in idnum from low to high manifests itself in the relationship between bone mineral density and age by brushing the points in p2 and observing the effect in p. To do this, click on p2 so that the inspector has p2 as its focus (appears in the inspector World View). In the inspector Select panel (on the Analysis tab) select by: brushing. A rectangle will appear in p2; this is the brush.
Since we are interested in observing the relationship between bone density and age conditional on idnum, we need to shape the brush to be a long, relatively thin, vertical brush. The brush is reshaped by selecting the box in its lower-right corner and moving it until you get the shape desired. The brush will maintain that shape (unique to p2) until it is again changed.
@@ -224,75 +220,72 @@
Adding a (dynamically changing) smooth
To summarize the relationship, a smooth curve could be added to any scatterplot. Here, we will add a smoothing spline fitted to bone mineral density as a function of time (i.e. to the data of p).
The smooth shows that the change in spinal bone mineral density rises up to about 12 years of age and then declines thereafter ultimately hitting zero.
Of course this is the aggregate behaviour, over both sexes. It might be interesting to see how this changes for males and for females. We could do this by adding a smooth for each sex but there may be other subgroups of the data that we would like to investigate. To that end we introduce a dynamic update to the smooth.
-
-
+
## Define the update function
-updateSmooth<-function(myPlot, minpts, df, color="blue"){
+updateSmooth<-function(myPlot, minpts, df, color="blue") {
## Get the values for x and y from the plot#### For x
- xnew<-myPlot["xTemp"]
- if(length(xnew)==0){xnew<-myPlot["x"]}
-
+ xnew<-myPlot["xTemp"]
+ if (length(xnew) ==0) {xnew<-myPlot["x"]}
+
## For y
- ynew<-myPlot["yTemp"]
- if(length(ynew)==0){ynew<-myPlot["y"]}
-
+ ynew<-myPlot["yTemp"]
+ if (length(ynew) ==0) {ynew<-myPlot["y"]}
+
## Now **only** use the active selected points to construct the smooth
- sel<-myPlot["selected"]&myPlot["active"]
- xnew<-xnew[sel]
- ynew<-ynew[sel]
- Nsel<-sum(sel)
-
- if(Nsel>3&diff(range(xnew))>0){
+ sel<-myPlot["selected"] &myPlot["active"]
+ xnew<-xnew[sel]
+ ynew<-ynew[sel]
+ Nsel<-sum(sel)
+
+ if (Nsel>3&diff(range(xnew)) >0) {
## Find the range of the selected x values
- xrng<-extendrange(xnew)
- xvals.temp<-seq(from=min(xrng),
- to=max(xrng),
- length.out=100)
-
+ xrng<-extendrange(xnew)
+ xvals.temp<-seq(from=min(xrng),
+ to=max(xrng),
+ length.out=100)
+
## Redo our smooth **only** if we have enough points
- if((Nsel>minpts)&(minpts>(df+1))){
- fit.temp<-smooth.spline(xnew, ynew, df=df)
- ypred.temp<-predict(fit.temp,x=xvals.temp)$y
+ if ((Nsel>minpts) & (minpts> (df + 1))){
+ fit.temp<-smooth.spline(xnew, ynew, df=df)
+ ypred.temp<-predict(fit.temp,x=xvals.temp)$y## update the smooth
- if(smooth%in%l_layer_ids(myPlot)){
+ if (smooth%in%l_layer_ids(myPlot)) {
## reconfigure the smooth with new data
- l_configure(smooth, x=xvals.temp, y=ypred.temp)
- }else{
+ l_configure(smooth, x=xvals.temp, y=ypred.temp)
+ } else {
## If the smooth has been deleted, then we recreate it ## (N.B. in the global environment)
- smooth<<-l_layer_line(myPlot,
- x=xvals.temp,
- y=ypred.temp,
- label="smooth fit",
- linewidth=4,
- color =color)
- }
- }
- }
+ smooth<<-l_layer_line(myPlot,
+ x=xvals.temp,
+ y=ypred.temp,
+ label="smooth fit",
+ linewidth=4,
+ color=color)
+ }
+ }
+ }
## Update the tcl language's event handler
- tcl("update", "idletasks")
-}
+ tcl("update", "idletasks")
+}
Now, we would like to have this update called whenever any interesting change in state occurs. There are numerous such possible states (see names(p), names(l_info_states(p)), or l_help("learn_R_bind") ). Here we bind an anonymous function of no arguments to be called whenever there is any change in the values of p contained in its selected state. This means that the function is called if any point in p is selected or deselected.
Note also that the smooth is based on the temporaryx and y values. Points in a scatterplot may be moved by selecting them with the control button depressed (as well as shift for multiple selection). Alternatively, selected points may be pushed together, distributed vertically or horizontally, arranged on a grid, or jittered by selecting the corresponding move button from the Modify panel of the inspector. All points can be returned to their original position by clicking the recover button
-
-# Here we "bind" the anonymous to the named state changes of p
-l_bind_state(p, c("selected"),
- function(){updateSmooth(p, 10, 5, "blue")}
-)
+
# Here we "bind" the anonymous to the named state changes of p
+l_bind_state(p, c("selected"),
+ function() {updateSmooth(p, 10, 5, "blue")}
+)
Now go to the histogram and select first the female bar, then the make bar, and watch how the smoothing spline adapts to the sex. Clearly, females have greater changes in spinal bone mineral density at a younger age than do males. No doubt this is a consequence of the different ages at which girls and boys sexually mature.
Brushing any set of points, from any of the linked plots will now cause the smooth function to automatically recalculate and redisplay. In this way one might pursue, for example how the smooth changes over subsets of idnum values.
Note that the points must be both active and selected. We could, for example, focus on how the smooth changes only for any subset of females by first deactivating all males and then brushing the subset of the females.
@@ -304,86 +297,81 @@
Linear smoothers can be thought of as the connected predicted values of locally fitted linear models having weights which are maximal at the point \(x\) where the prediction is being made and which drop off to zero for \(x\) values far away from it.
To illustrate this we add a straight line to the scatterplot that is fitted to the data via weighted least squares using Gaussian weights. For any collection of \(x\) values, the prediction will be made at their median.
The Gaussian weight function will be centred at the median:
-
-GaussWt<-function(x){
+
GaussWt<-function(x) {
# Get an estimated standard deviation
- h<-diff(range(x))/4
+ h<-diff(range(x))/4# Centre at median
- xloc<-median(x)
+ xloc<-median(x)
# Gaussian density
- dnorm(x, mean=xloc, sd=h)
-}
-# Fit a local line using some Gaussian weights.
+
# Fit a local line using some Gaussian weights.# Prediction will be at the median of x, fit by### weights that decrease with x's# distance from the median.
-fitwls<-lm(y~x, weights=GaussWt(x))
-linewls<-l_layer_line(p,
- x=x,
- y=predict(fitwls,
- newdata=data.frame(x=x)),
- label="Fitted line",
- linewidth=4,
- color ="blue")
Clicking on the Layers tab in the inspector shows the scatterplot, the axis, the smooth fit, and the Gaussian weight straight line. Select the last of these and render it invisible by clicking on that button, or, by programmatically by executing the following.
updateLocalLine<-function(myPlot, minpts, df, volor="blue") {
## Get the values for x and y from the plot## For x
- xnew<-myPlot["xTemp"]
- if(length(xnew)==0){xnew<-myPlot["x"]}
-
+ xnew<-myPlot["xTemp"]
+ if (length(xnew) ==0) {xnew<-myPlot["x"]}
+
## For y
- ynew<-myPlot["yTemp"]
- if(length(ynew)==0){ynew<-myPlot["y"]}
+ ynew<-myPlot["yTemp"]
+ if (length(ynew) ==0) {ynew<-myPlot["y"]}
## Now **only** use the active selected points to construct the smooth
- sel<-myPlot["selected"]&myPlot["active"]
- xnew<-xnew[sel]
- ynew<-ynew[sel]
- Nsel<-sum(sel)
- if(Nsel>3&diff(range(xnew))>0){
- xrng<-extendrange(xnew)
- xvals.temp<-seq(from=min(xrng),
- to=max(xrng),
- length.out=100)
+ sel<-myPlot["selected"] &myPlot["active"]
+ xnew<-xnew[sel]
+ ynew<-ynew[sel]
+ Nsel<-sum(sel)
+ if (Nsel>3&diff(range(xnew)) >0) {
+ xrng<-extendrange(xnew)
+ xvals.temp<-seq(from=min(xrng),
+ to=max(xrng),
+ length.out=100)
## Redo line if more than two points.
- if(Nsel>2){
- fit.wls<-lm(ynew~xnew, weights=GaussWt(xnew))
- ywls.temp<-predict(fit.wls,
- newdata=data.frame(xnew=xvals.temp))
+ if (Nsel>2) {
+ fit.wls<-lm(ynew ~ xnew, weights=GaussWt(xnew))
+ ywls.temp<-predict(fit.wls,
+ newdata=data.frame(xnew=xvals.temp))
## update the fit
- if(linewls%in%l_layer_ids(myPlot)){
- l_configure(linewls, x=xvals.temp, y=ywls.temp)
- }else{
+ if (linewls%in%l_layer_ids(myPlot)) {
+ l_configure(linewls, x=xvals.temp, y=ywls.temp)
+ } else {
## If it's been deleted, we recreate it (in the global environment).
- linewls<<-l_layer_line(myPlot,
- x=xvals.temp,
- y=predict(fitwls,
- newdata=data.frame(x=xvals.temp)
- ),
- label="GaussWt at median line",
- linewidth=4,
- color="blue"
- )
- }
- }
-
- }
+ linewls<<-l_layer_line(myPlot,
+ x=xvals.temp,
+ y=predict(fitwls,
+ newdata=data.frame(x=xvals.temp)
+ ),
+ label="GaussWt at median line",
+ linewidth=4,
+ color="blue"
+ )
+ }
+ }
+
+ }
## Update the tcl language's event handler
- tcl("update", "idletasks")
-}
+ tcl("update", "idletasks")
+}
And now bind this update function to change in p of either the select or the active states.
-
-# Here we "bind" the anonymous to the named state changes of p
-l_bind_state(p, c("active","selected"),
- function(){updateLocalLine(p, 10, 5, "blue")}
-)
+
# Here we "bind" the anonymous to the named state changes of p
+l_bind_state(p, c("active","selected"),
+ function() {updateLocalLine(p, 10, 5, "blue")}
+)
Selecting the male or female sex in the histograms will show the weighted least squares line for that sex. Brushing a tall thin vertical brush on p2 will show how the fitted line changes (or not) as the similar idnums change. But most interestingly, and the object of this lesson, is to brush p2 with a short very wide brush so that the age can be kept roughly constant. As age increases or decreases, the line segment changes its fit: both in height and in slope. The smooth seen earlier is essentially the connected midpoints of these line segments.
In addition to the R package documentation we also have both TCL and R documentation here.
Once in R, these are accessible from loon as
-
# Combined TCL and R documentation (a learning document)
-l_help()
-
-# R only manual
-l_web()
-
-l_web(directory ="articles")
-
-# R system documentation
-help(package = loon")
-
-vignette(package = "loon")
-
-demo(package = "loon")
+
# Combined TCL and R documentation (a learning document)
+l_help()
+
+# R only manual
+l_web()
+
+l_web(directory = "articles")
+
+# R system documentation
+help(package = loon")
+
+vignette(package = "loon")
+
+demo(package = "loon")
Installation
The interactive graphics in loon are written on TCL, accessible to R via the tcltk R package. Be sure to have a version of R that includes Tcl/Tk 8.6.6 (which happens by default but might be missing if you have a custom R build).
# The easiest way to install loon
+install.packages("loon")
# You could also install the latest development release directly from GitHub
-devtools::install_github("great-northern-diver/loon", subdir ="R")
+devtools::install_github("great-northern-diver/loon", subdir="R")
# Or, to ensure you have the vignettes as well # ( also accessible via l_web(directory = "articles") )
-devtools::install_github("great-northern-diver/loon", subdir ="R",
- build_opts =c("--no-resave-data"))
library(loon)
## from the vignette in R
-vignette("introduction", package ="loon")
+vignette("introduction", package="loon")
## or via the web
-l_web("introduction", directory ="articles")
Explains how to use loon’s interactive plots and inspector to construct logical queries on the displayed data.
+
An enriched version of mtcars is used for illustration.
+
How a plot’s linkingKey (from Loon’s linking model) can be used to access the correct elements of any logical operation is also described.
+
+
+
+
+
minor bug fixes and improvements
+
+
+
Three minor bug fixes on facets
+
+
If the by is a formula with loon n-dimensional states, no need to provide additional data, the formula should be able to be converted to a data frame given by the states info.
+
+
When by has missing values, it is treated as other n-dimensional states:
+
drop NAs, leave warnings (which one are removed)
+
+
Removed unnecessary warnings.
+
+
+
+
l_pairs() has a progress bar for constructing, linking, and connecting the scales of the plots.
+
there is now a new argument showProgressBar that allows this to be suppressed (e.g. in RMarkdown files)
+
+
+
for histograms of factors and character vectors: default setting of arg showFactors
+
+
previously: TRUE whenever number of factor levels (or equivalent unique strings) < 10
+
now: TRUE whenever < 25 to accomodate common factors like month or the 24 hours in a day.
As all examples are wrapped in if(interactive), check all interactive examples to ensure they work well
+
+
hexadecimal colours seem to get slightly (generally ignorable) different hexadecimal values for colours in tcltk on Solaris (see 1.3.3 comments). this caused problems in testing for exact colours on Solaris.
+
Until this is sorted out, the testing for colour hex values in the test suite were commented out to prevent loon from being unnecessarily archived on CRAN. (The colours are correct, but our previous solution generated warnings, which may cause problems for CRAN acceptance.) Likely, in the future, we suppress the warning from l_hexcolor() when testing.
+
+
for iris dataset in tests, we drop an observation so that for each species, the number of observations are different.
+
+
+
+
loon 1.3.3 2021-02-25
@@ -360,7 +420,7 @@
added condGrob() to effect the conditional construction of either the desired grob (if it is visible in the loon plot) or the empty grob as placeholder containing relevant arguments
-
introduced the method plot.loon() so that plot(p) of a loon plot p will now draw the corresponding grid object on the current device
+
introduced the method plot.loon() so that plot(p) of a loon plot p will now draw the corresponding grid object on the current device
x<-l_colRemoveAlpha(rainbow(6))
# Also works with ordinary color string representations# since it just extracts the rgb values from the colors.
-x<-l_colRemoveAlpha(c("red", "blue", "green", "orange"))
-x
-
if (FALSE) {
+ l_pairs(iris, showHistogram=TRUE)
# The path can be found at the top of tk title# Suppose it is the first loon widget, this path should be ".l0.pairs"
- p<-l_create_handle(".l0.pairs")# error
- p<-l_getFromPath(".l0.pairs")
-}
-
For the target compound loon plot, determines location (only and excluding t
arguments to pass to `gridExtra::arrangeGrob()`
-
l_getLocations(target)
+
l_getLocations(target)
# S3 method for l_facet
-l_getLocations(target)
+l_getLocations(target)
# S3 method for l_pairs
-l_getLocations(target)
+l_getLocations(target)
# S3 method for l_ts
-l_getLocations(target)
+l_getLocations(target)
Arguments
@@ -194,17 +197,15 @@
Value
Examples
-if(interactive()){
+if(interactive()) {
-pp<-l_pairs(iris, showHistograms =TRUE)
-ll<-l_getLocations(pp)
-nplots<-length(l_getPlots(pp))
+pp<-l_pairs(iris, showHistograms=TRUE)
+ll<-l_getLocations(pp)
+nplots<-length(l_getPlots(pp))
# the plots returned by l_getPlots(pp) are positioned# in order by the layout_matrix
-ll$layout_matrix
-}
-
-
if(interactive()){
## Suppose you have some plot that you created like
-p<-l_plot(iris, showGuides =TRUE)
+p<-l_plot(iris, showGuides=TRUE)
## and coloured groups by hand (using the mouse and inspector)# so that you ended up with these colours:
-p["color"]<-rep(c("lightgreen", "firebrick","skyblue"),
- each =50)
+p["color"] <-rep(c( "lightgreen", "firebrick","skyblue"),
+ each=50)
## Having determined the colours you could save them (and other states)# in a file of your choice, here some tempfile:
-myFileName<-tempfile("myPlot", fileext =".rds")
+myFileName<-tempfile("myPlot", fileext=".rds")
## Save the named states of p
-l_saveStates(p,
- states =c("color", "active", "selected"),
- file =myFileName)
+l_saveStates(p,
+ states=c("color", "active", "selected"),
+ file=myFileName)
## These can later be retrieved and used on a new plot# (say in RMarkdown) to set the new plot's values to those# previously determined interactively.
-p_new<-l_plot(iris, showGuides =TRUE)
-p_saved_info<-l_getSavedStates(myFileName)
+p_new<-l_plot(iris, showGuides=TRUE)
+p_saved_info<-l_getSavedStates(myFileName)
## We can tell what kind of plot was saved
-attr(p_saved_info, "l_plot_class")
+attr(p_saved_info, "l_plot_class")
## The result is a list of class "l_savedStates" which# contains the names of the
-p_new["color"]<-p_saved_info$color
+p_new["color"] <-p_saved_info$color## The result is that p_new looks like p did# (after your interactive exploration)# and can now be plotted as part of the document
-plot(p_new)
+plot(p_new)
## For compound plots, the info_states are saved for each plot
-pp<-l_pairs(iris)
-myPairsFile<-tempfile("myPairsPlot", fileext =".rds")
+pp<-l_pairs(iris)
+myPairsFile<-tempfile("myPairsPlot", fileext=".rds")
## Save the names states of pp
-l_saveStates(pp,
- states =c("color", "active", "selected"),
- file =myPairsFile)
-pairs_info<-l_getSavedStates(myPairsFile)
+l_saveStates(pp,
+ states=c("color", "active", "selected"),
+ file=myPairsFile)
+pairs_info<-l_getSavedStates(myPairsFile)
## For compound plots, the info states for all constitutent# plots are saved. The result is a list of class "l_savedStates"
@@ -251,11 +254,11 @@
Examp
# themselves.## The names of the plots which were saved
-names(pairs_info)
+names(pairs_info)
## And the names of the info states whose values were saved for# the first plot
-names(pairs_info$x2y1)
+names(pairs_info$x2y1)
## While it is generally recommended to access (or assign) saved# state values using the $ sign accessor, paying attention to the
@@ -265,31 +268,31 @@
Examp
# access to the contents of an l_savedStates object.## For example,
-p_saved_info["color"]
+p_saved_info["color"]
## returns the saved "color" as a vector of colours.## In contrast,
-pairs_info["x2y1"]
+pairs_info["x2y1"]
# returns the l_savedStates object of the states of the plot named "x2y1",# but
-pairs_info["color"]
+pairs_info["color"]
# returns a LIST of colour vectors, by plot as they were named in pairs_info## As a consequence, the following two are equivalent,
-pairs_info["x2y1"]["color"]
+pairs_info["x2y1"]["color"]
# finds the value of "color" from an "l_savedStates" object# whereas
-pairs_info["color"][["x2y1"]]
+pairs_info["color"][["x2y1"]]
# finds the value of "x2y1" from a "list" object## Also, setting a state of an "l_savedStates" is possible# (though not generally recommended; better to save the states again)#
-p_saved_info["color"]<-rep("red", 150)
+p_saved_info["color"] <-rep("red", 150)
# changes the saved state "color" on p_saved_info# whereas
-pairs_info["color"]<-rep("red", 150)
+pairs_info["color"] <-rep("red", 150)
# will set the red color for any plot within pairs_info having "color" saved.# In this way the assignment function via [] is trying to be clever# for l_savedStates for compound plots and so may have unintentional
@@ -300,9 +303,7 @@
Examp
# if change is necessary.# Alternatively, more nuanced and careful control is maintained using# the $ selectors for lists.
-}
-
-
if(interactive()){
-h<-l_hist(iris$Sepal.Length)
+h<-l_hist(iris$Sepal.Length)
-names(h)
-h["xlabel"]<-"Sepal length"
-h["showOutlines"]<-FALSE
+names(h)
+h["xlabel"] <-"Sepal length"
+h["showOutlines"] <-FALSE
-h["yshows"]
-h["yshows"]<-"density"
-l_scaleto_plot(h)
+h["yshows"]
+h["yshows"] <-"density"
+l_scaleto_plot(h)
-h["showStackedColors"]<-TRUE
-h['color']<-iris$Species
-h["showStackedColors"]<-FALSE
-h["showOutlines"]<-TRUE
-h["showGuides"]<-FALSE
+h["showStackedColors"] <-TRUE
+h['color'] <-iris$Species
+h["showStackedColors"] <-FALSE
+h["showOutlines"] <-TRUE
+h["showGuides"] <-FALSE# link another plot with the previous plot
-h['linkingGroup']<-"iris_data"
-h2<-with(iris, l_hist(Petal.Width,
- linkingGroup="iris_data",
- showStackedColors =TRUE))
+h['linkingGroup'] <-"iris_data"
+h2<-with(iris, l_hist(Petal.Width,
+ linkingGroup="iris_data",
+ showStackedColors=TRUE))
# Get an R (grid) graphics plot of the current loon plot
-plot(h)
+plot(h)
# or with more control about grid parameters
-grid.loon(h)
+grid.loon(h)
# or to save the grid data structure (grob) for later use
-hg<-loonGrob(h)
+hg<-loonGrob(h)
-}
-
Prints the layer tree (i.e. the layer ids) to the prompt. Group
- layers are prefixed with a '+'. The 'root' layer is not
+ layers are prefixed with a '+'. The 'root' layer is not
listed.
if(interactive()){
+l_plot(iris)
+l_hist(iris)
+l_hist(mtcars)
+l_pairs(iris)
# The following will not be loonWidgets (neither is the inspector)
-tt<-tktoplevel()
-tkpack(l1<-tklabel(tt, text ="Heave"), l2<-tklabel(tt, text ="Ho"))
+tt<-tktoplevel()
+tkpack(l1<-tklabel(tt, text="Heave"), l2<-tklabel(tt, text="Ho"))
## This will return loon widgets corresponding to plots
-loonPlots<-l_loonWidgets()
-names(loonPlots)
-firstPlot<-loonPlots[[1]]
-firstPlot["color"]<-"red"
-histograms<-l_loonWidgets("hist")
-lapply(histograms,
- FUN =function(hist){
- hist["binwidth"]<-hist["binwidth"]/2
- l_scaleto_world(hist)
- }
- )
-}
-
-
Like plot in R, l_plot is
the generic plotting function for objects in loon.
The default method l_plot.default produces the interactive
scatterplot in loon.
@@ -493,94 +496,92 @@
if (FALSE) {
# default use as scatterplot
- p1<-with(iris, l_plot(x =Sepal.Length,
- y =Sepal.Width,
- color=Species,
- title ="Sepal sizes"))
+ p1<-with(iris, l_plot(x=Sepal.Length,
+ y=Sepal.Width,
+ color=Species,
+ title="Sepal sizes"))
# The names of the info states that can be# accessed or set. They can also be given values as# arguments to l_plot.default()
- names(p1)
- versicolor<-(iris$Species=="versicolor")
- p1["size"]<-10
- p1["glyph"][versicolor]<-"csquare"
- p1["minimumMargins"][1]<-100
- }
-
-[](https://travis-ci.org/great-northern-diver/loon) [](https://cran.r-project.org/package=loon)
+[](https://travis-ci.org/great-northern-diver/loon)
+[](https://cran.r-project.org/package=loon)
+[](https://cran.r-project.org/package=loon)
loon is an extendible interactive data visualization system designed for exploratory visualization.
diff --git a/R/_pkgdown.yml b/R/_pkgdown.yml
index 31936ca8..90b12a0a 100755
--- a/R/_pkgdown.yml
+++ b/R/_pkgdown.yml
@@ -13,12 +13,14 @@ navbar:
menu:
- text: Introduction
href: articles/introduction.html
+ - text: Saving loon plots
+ href: articles/savingLoonPlots.html
+ - text: Logical queries in interactive graphics
+ href: articles/logicalQueries.html
- text: Analysis example
href: articles/minorities.html
- text: Teaching example
href: articles/teaching-example-smoothing.html
- - text: Saving loon plots
- href: articles/savingLoonPlots.html
- text: Videos
menu:
- text: the (not so) humble (interactive) histogram
diff --git a/R/cran-comments.md b/R/cran-comments.md
index c1447532..9d47ca41 100755
--- a/R/cran-comments.md
+++ b/R/cran-comments.md
@@ -1,18 +1,72 @@
## Test evironments
-* local OS X, R 3.5.1
-* local Ubuntu 18.04 R 3.5.1 and R-devel (2018-09-29 r75381)
-* local Windows 10 R 3.5.1
-* Ubuntu 14.04.5 (on travis-ci) R 3.5.1 and R-devel (2018-09-29 r75381)
+* local OSX, Big Sur 11.2.1, R 4.0.2
+* Ubuntu Xenial 16.04 (on travis-ci)
+* check_win_devel
+ - using R Under development (unstable) (2021-03-14 r80087)
+ - using platform: x86_64-w64-mingw32 (64-bit)
+ - using session charset: ISO8859-1
+
+* Windows Server 2008 R2 SP1, R-devel, 32/64 bit
+* Ubuntu Linux 20.04.1 LTS, R-release, GCC
+* Fedora Linux, R-devel, clang, gfortran
## R CMD check results
-There were no ERRORs or WARNINGs.
+0 errors
+0 warnings
+1 NOTE about maintainer
-## Downstream dependencies
+ ... NOTE
+ Maintainer: 'R. Wayne Oldford 
+
