\begin{comment}
 
Basic idea is to say that while these projects are wonderful in their
own way, they provide varying levels of integration with commonly used
data analysis environments such as R/S-Plus, Matlab, SAS.
Furthermore, most of them do not use R's native graphics facilities
but rather provide their own graphics systems.  As a result, there is
a divide for the user. One cannot create non-standard graphics in R
and then make them interactive.  GGobi does provide facilities in R to
respond to both low-level events such as mouse motion and clicks, and
also ggobi-level events such as changes to the identification or brush
set

Special mention should go to XLisp-Stat as being both conceived and
implemented in an intelligent fashion that introduces dynamic,
interactive graphics in the design of the system itself.  As a result,
the graphics system that produces static plots is the same as that
used for interactive plots.  And these interactive graphics are
tightly integrated with a rich programming language for data analysis
and simulation.  As a result, it satisfies all the criteria that we
would want, except one - being a commonly used environment for data
analysis. So, rather unfortunately, XLisp-Stat has not had the impact
on interactive graphics that it might have had in the statistics
community. And it provides an important lesson for us when developing
tools and infrastructure for interactive dynamic graphics.
Specifically, we need to tightly integrate the framework into
languages with which statisticians work and provide facilities for
them to extend the basics that are provided.
The remainder of this paper discusses one approach to this, 
consciously working from the existing graphics systems
in R, and creating an adaptable and  extensible, 
\end{comment}


\begin{itemize}
\item MANET and MONDRIAN

  When each of these was developed, the researchers decided to focus
  on under-represented areas of interactive statistical graphics,
  specifically categorical data and geographical displays.  For good
  reasons, these tools were developed as stand-alone applications.
  MANET was written in C++ for use on the older Macintosh systems (OS
  9).  It deals with missing values and provides interactive mosaic
  plots which allows users to reorder the variables and provide 
  links between different displays 
%%% FIXME is this true?
  MONDRIAN is written in Java and therefore comes much closer to
  providing platform-neutral software for interactive data
  visualization.  It was developed at a time when Java may have
  emerged as a dominant language and environment for high-level
  scientific computation.  However, since that has not occurred to any
  large extent, MONDRIAN has become a somewhat niche tool, isolated
  from commonly used data analysis systems.  In theory, it could be
  connected to R via the various general R-Java interfaces
  (i.e. SJava, rJava, arji) and its facilities made available to R
  programmers.  However, this would give rise to two separate graphics
  systems and the systems would only be very weakly integrated.
  
\item XGobi is a stand-alone tool developed in the early 1990s that
  provides the basic interactive facilities such as point
  identification and brushing for scatterplots, scatterplot matrices
  and average shifted histograms \cite{DavidScott}.  One of XGobi's
  strengths is its grand tour facilities. These show the data being
  projected into intelligently chosen sub-spaces via a smooth
  trajectory from one sub-space to another.  These sub-spaces are
  selected by optimizing an index function that identifies features of
  interest.  Users can interact with the plots, including the grand
  tours and spin and rotate the data manually to view different
  perspectives. 
  
  As with other systems, XGobi suffered from being a stand-alone
  application that was only weakly connected with data analysis
  systems such as R and S-Plus.  There is very limited communication,
  allowing the host system only to launch an instance of XGobi with a
  particular dataset.  After that, the user had to manage all
  communication between the systems.  GGobi is an upgrade of XGobi to
  use a more modern GUI toolkit.  In addition, GGobi was designed to
  explicitly support a much tighter integration between the data
  analysis system and the interactive plots.  GGobi was written to be
  a compiled library that provided classes for interactive displays.
  It can be dynamically loaded into R via the Rggobi package.  R users
  can then create new displays via the GGobi menus or the R command
  language.  At any time, R users can query certain information from
  GGobi.  The design allows for R programmers to provide actions for
  different events and so customize the linking of the interaction.
  Actions can be specified for both low-level events such as mouse
  motion and clicks, and also higher-level events such as changes to
  the set of brushed/identified points, new variables or datasets
  being added, and so on. 

  As described above, the R-GGobi interface that uses dynamic
  reflection via the RGtk package provides a potentially very powerful
  and customizable framework for exploring interactive graphics within
  a data analysis system.  However, there are several limitations. On
  an implementation level, the interface was not pushed as far as its
  potential permitted, primarily because it required the developers to
  be familiar with both R and GGobi and so greatly reduced the pool of
  potential implementors. (Fortunately, more people are working on
  this now.)  This is not a serious technical problem, but more one of
  resources, but it does identify the limitations of integrating
  sophisticated, specialized tools.

  A more conceptual limitation is that adding new types of plots to
  GGobi is significantly more complex than developing them in R.  The
  GGobi and R graphics systems are entirely separate and users cannot
  add arbitrary annotations such as text, lines, etc. to GGobi plots
  from within R.  GGobi is extensible via an object-oriented design
  and a plugin mechanism for externally added modules, it is not
  trivial to add new features without understanding GGobi's design.
  So while it is relatively easy to add new interactive linking rules,
  it is difficult to add new plot types and interactive rules for such
  plot types that connect them to other built-in plot types in GGobi.
  

\item XLisp-Stat

  XLisp-Stat was both conceived and implemented in an intelligent
  fashion that introduces dynamic, interactive graphics into the
  design of the data analysis system itself.  As a result, the
  graphics system that produces static plots is the same as that used
  for interactive plots.  And these interactive graphics are tightly
  integrated with a rich programming language for data analysis and
  simulation.  As a result, the design satisfies all the criteria that
  we would want, except one, that is being a commonly used environment
  for data analysis. Accordingly, rather unfortunately, XLisp-Stat has
  not had the impact on interactive graphics that it might have had in
  the statistics community. And it provides an important lesson for us
  when developing tools and infrastructure for interactive dynamic
  graphics.  Specifically, we need to tightly integrate the framework
  into languages with which statisticians work and provide facilities
  for them to extend the basics that are provided.  The remainder of
  this paper discusses one approach to this, consciously working from
  the existing graphics systems in R, and creating an adaptable and
  extensible, interactive graphics system.

\item{iPlots} iPlots is a Java-based graphics system that is connected
  to R and provides linked plots for a shared data set.  The choice of
  Java makes the rendering and interactivity relatively
  platform-independent. The connection with R is explicitly designed
  to allow R users to draw plots and add annotations using R functions
  that mirror the regular graphics functions, e.g. \Rfunction{itext}
  rather than \Rfunction{text}.  While this is a good approach, the
  end user cannot dynamically change or add event handlers to control
  the interactivity and rules for linking plots. As a result, the
  interactivity is hard coded, and any changes must be made by the
  programmer using Java and before the session is started. This is not
  a consequence of the design of iPlots, but due to the fact that it
  does not exploit a bi-directional interface between R and Java.  It
  uses either the \Rpackage{rJava} or \Rpackage{SJava} package as the
  underlying connection mechanism.  The \Rpackage{SJava} package does
  provide a facility for using R functions to implement Java class
  methods and dynamically defining Java classes within a session. This
  approach would allow R users to dynamically program new linking
  rules entirely within R, but this has not been pursued.


\end{itemize}

Each of these systems has several merits and advantages over the
approach we describe in this paper. Separate, specialized components
is an important and effective design in software.  However, it is
essential that such components be tightly integrated into larger
systems in which they are used. Because of the popularity and
acceptance of R in different communities, we feel that it is important
to at least explore the possibilities of adding interactivity to the
existing R graphics systems and to allow users to easily specify their
own rules for interaction.  This will allow for a flexible,
self-contained system that can work for non-standard graphics, and it
will also greatly facilitate experiments in interactive dynamic
graphics for data analysis.


\endinput


There are numerous research projects which have explored dynamic and
interactive graphics for statistical data analysis.  Most, if not all,
have resulted in software for analysts to use with general or
sometimes specific types of data.  These different projects have
focused on various aspects of dynamic graphics.  The most widely
recognized software from these efforts in the past several years
include 
\begin{itemize}
\item GGobi, 
\item iPlots,
\item Manet,
\item MONDRIAN, and
\item XLisp-Stat and related projects such as Vista.
\end{itemize}


Each of these projects has definite advantages

\section{XLisp-Stat}
XLisp-Stat is  an entire statistical environment that has many of the
same characteristics as R, S-Plus and Matlab.
Specifically, XLisp-Stat is a general programming language and 
interpreted environment for data analysis,  visualization
and simulation.  It is built-on top of a Lisp
interpreter and many additions for statistics added.

XLisp-Stat boasts an impressive site of tools for
developing interactive graphics applications,
especially considering the time at which it was
developed.
The user can create the common types of
data plots such as scatterplots, histograms,
boxplots and so on.  By default, some of
these are interactive so that one can ``spin'' and
rotate the axes to see the data from different perspectives.

More importantly, in many regards, than the built-in interactivity is
the user's and programmer's ability to easily ``link'' two plots.  Two
different plots displaying variables from the same data are readily
connected so that identifying points in one plot show the
corresponding points in the other.
The graphics facilities allow the user to create new
types of plots using lower-level graphics primitives.

Furthermore, one can program different linking models
using the XLisp-Stat language itself. There is no need
to move to external libraries or software to add
new features. A low-level event system allows programmers
a great deal of control in accessing user interaction
on a plot  and arbitrary responses to these inputs can be
implemented.  Indeed, users can create simple graphical user
interfaces (GUIs) using menus, buttons, sliders, etc.
that are all directly available in XLisp-Stat
and connect these with interactive, dynamic plots
to create sophisticated and compelling interaction to
explore data.

The coupling of the data analysis programming language, 
data analysis tools and programmable interactive graphics
is highly desirable.
In short, one goal of the work described in this paper
is to establish the foundations to mimic XLisp-Stat's interactive
graphics facilities.
They provide users with good tools for common data analytic
tasks, and importantly allow researchers to \textit{easily} investigate new
forms of interaction and dynamic graphics.
For various reasons, XLisp-Stat has not emerged as the \textit{de
  facto} language for statistical computing.  As a result, these
excellent tools and the opportunities they provide for new research
are outside the mainstream.  It is difficult to harness
them and garner much interest within the community
unless we use commonly used tools.
Hence, it is important that we can introduce these facilities into R.


\section{}
GGobi is another system that, in different forms, has been 
available for over a decade.  Originally, it started
out as a stand-alone program. At that time, it was 


\section{MONDRIAN and Manet}

\section{iPlots}
Again, a very good start but without the callbacks,
this is limited. 
Dynamic or static compilation of Java classes are
entirely feasible, but have yet to be done.






One of the key characteristic differences between  these 
various projects has been the level of integration 
with common, popular statistical environments
such as R, Matlab, SAS, etc.
One of the primary drawbacks of several of these approaches is
that
Unfortunately, there has been 

%%% Local Variables: 
%%% mode: latex
%%% TeX-master: t
%%% End: 
