\documentclass[a4paper]{article}
%\VignetteIndexEntry{gridBase}
\newcommand{\grid}{{\tt grid}}
\newcommand{\gridBase}{{\tt gridBase}}
\newcommand{\lattice}{{\tt lattice}}
\newcommand{\R}{{\tt R}}
\setlength{\parindent}{0in}
\setlength{\parskip}{.1in}

\newcommand{\aside}[1]{\begin{list}{}
                                   {\setlength{\leftmargin}{1in}
                                    \setlength{\rightmargin}{1in}
                                    \setlength{\itemindent}{0in}}
                       \item {\sc Aside:} {\it #1}
                       \end{list}}

\title{Integrating Grid Graphics Output \\ with Base Graphics Output}
\author{Paul Murrell}

\begin{document}
\maketitle

@
The \grid{} graphics package\cite{Rnews:Murrell:2002}
 is much more powerful than the standard \R{} graphics system
(hereafter ``base 
graphics'') when it comes to combining and arranging graphical elements.
It is possible to create a greater variety of graphs more easily with 
\grid{} (see, for example, Deepayan Sarkar's \lattice{} 
package\cite{Rnews:Sarkar:2002}).
However,  there are very many plots based on base graphics (e.g., 
biplots), that have not been implemented in \grid{}, and the
task of reimplementing these in \grid{} is extremely daunting.
It would be nice to be able to combine the 
ready-made base plots with the sophisticated arrangement features
of grid.

This document describes the \gridBase{} package which provides
 some support for combining grid and base
graphics output.

\section*{Annotating base graphics using \grid{}}

The \gridBase{} package has one function, \verb|baseViewports()|, 
that supports 
adding \grid{} output to a base graphics plot.
This function creates a set of \grid{} 
viewports that correspond to the current
base plot.
This allows simple annotations such as adding lines and text using \grid{}'s
units to locate them relative to 
a wide variety of coordinate systems, or something
more complex involving
pushing further \grid{} viewports.

{\tt baseViewports()} returns a list of three grid viewports.  The first 
corresponds to the base ``inner'' region.  This viewport is relative to
 the entire device; it only makes sense to push this viewport
from the ``top level'' (i.e., only when no other viewports have been 
pushed).
The second viewport corresponds to the base ``figure'' region
and is relative to the inner region;  it only makes sense to push it
after the ``inner'' viewport has been pushed.  The third 
viewport corresponds to the 
base ``plot'' region  and is relative to the figure region;  it only
makes sense to push it after the other two viewports have been pushed in the
correct order.  

A simple application of this facility involves adding text to 
the margins of a base plot at an arbitrary orientation.  The base
function \verb|mtext()| allows text to be located  in terms of a number
of lines away from the plot region, but only at rotations of 0 or
90 degrees.  The base \verb|text()| function allows arbitrary rotations,
but only locates text relative to the user coordinate system in effect
in the plot region (which is inconvenient for locating text in the
margins of the plot).  By contrast, the \grid{} function 
\verb|grid.text()| allows arbitrary rotations and can be used in 
any \grid{} viewport.  In the following code we first create a base plot,
leaving off the tick labels. 

<<echo=FALSE, results=hide>>=
library(grid)
library(gridBase)

<<basesetup, eval=FALSE>>=
midpts <- barplot(1:10, axes=FALSE)
axis(2)
axis(1, at=midpts, labels=FALSE)

@
Next we  use \verb|baseViewports()| to 
create grid viewports that correspond to the base plot and we push
those viewports.

<<baseviewport, eval=FALSE>>=
vps <- baseViewports()
pushViewport(vps$inner, vps$figure, vps$plot)

@
Finally, we draw rotated labels using 
\verb|grid.text()| (and pop the viewports to clean up after ourselves).

<<gridtext, eval=FALSE>>=
grid.text(c("one", "two", "three", "four", "five",
            "six", "seven", "eight", "nine", "ten"), 
          x=unit(midpts, "native"), y=unit(-1, "lines"),
	  just="right", rot=60)
popViewport(3)

<<fig=TRUE, echo=FALSE, results=hide>>=
<<basesetup>>
<<baseviewport>>
<<gridtext>>

@ 

The next example is a bit more complicated because it involves 
embedding \grid{} viewports within a base graphics plot.
The dataset is a snapshot of wind speed, wind direction, and temperature
at several weather stations in the South China Sea, south west of 
Japan\footnote{Obtained from the CODIAC web site:
{\tt http://www.joss.ucar.edu/codiac/codiac-www.html}.  The file
{\tt chinasea.txt} is in the {\tt gridBase/doc} directory.}.
\grid{} is used to produce novel plotting symbols for a standard
base plot.

First of all, we need to define the novel plotting symbol.  This consists
of a dot at the data location, with a thermometer extending ``below''
and an arrow extending ``above''.  The thermometer is used to encode 
temperature 
and the arrow is used to indicate wind speed 
(both scaled to [0, 1]).

<<plotsymbol, eval=FALSE>>=
novelsym <- function(speed, temp, 
                     width=unit(3, "mm"),
                     length=unit(0.5, "inches")) {
  grid.rect(height=length, y=0.5,
            just="top", width=width,
            gp=gpar(fill="white"))
  grid.rect(height=temp*length,
            y=unit(0.5, "npc") - length,
            width=width,
            just="bottom", gp=gpar(fill="grey"))
  grid.lines(x=0.5, 
             y=unit.c(unit(0.5, "npc"), unit(0.5, "npc") + speed*length),
	     arrow=arrow(length=unit(3, "mm"), type="closed"), 
             gp=gpar(fill="black"))
  grid.points(unit(0.5, "npc"), unit(0.5, "npc"), size=unit(2, "mm"), 
              pch=16)
}

@ 
Now we read in the data and generate a base plot, but plot no points.

<<baseplot, eval=FALSE>>=
chinasea <- read.table(system.file("doc", "chinasea.txt", 
                                   package="gridBase"),
                       header=TRUE)
plot(chinasea$lat, chinasea$long, type="n",
  xlab="latitude", ylab="longitude", 
  main="China Sea Wind Speed/Direction and Temperature")

@
Now we use \verb|baseViewports()| to align a \grid{} viewport
with the plot region, and draw the symbols by creating a 
\grid{} viewport per $(x, y)$ location (we rotate the viewport to
represent the wind direction).

<<gridsym, eval=FALSE>>=
speed <- 0.8*chinasea$speed/14 + 0.2 
temp <- chinasea$temp/40
vps <- baseViewports()
pushViewport(vps$inner, vps$figure, vps$plot)
for (i in 1:25) {
  pushViewport(viewport(x=unit(chinasea$lat[i], "native"),
                         y=unit(chinasea$long[i], "native"),
                         angle=chinasea$dir[i]))
  novelsym(speed[i], temp[i])
  popViewport() 
}
popViewport(3)

<<echo=FALSE, fig=TRUE, results=hide>>=
<<plotsymbol>>
<<baseplot>>
<<gridsym>>

@
\section*{Embedding base graphics plots in \grid{} viewports}

\gridBase{} provides several functions for adding base graphics 
output to \grid{} output.  There are three functions that allow
base plotting regions to be aligned with the current \grid{} 
viewport;  this makes it possible to draw one or more base graphics plots 
within
a \grid{} viewport.  The fourth function provides a set of
graphical parameter settings so that base {\tt par()} settings
can be made to correspond to some of\footnote{Only {\tt lwd},
{\tt lty}, {\tt col} are available yet.  More should be available in
future versions.} the current \grid{} graphical parameter settings.

The first three functions are \verb|gridOMI()|, \verb|gridFIG()|,
and \verb|gridPLT()|.  They return the appropriate
\verb|par()| values for setting the base ``inner'', ``figure'',
and ``plot'' regions, respectively.

The main usefulness of these functions is to allow you to create a
complex layout using \grid{} and then draw a base plot within 
relevant elements of that layout.  The following example
uses this idea to create a \lattice{} plot where the panels contain 
dendrograms drawn using base graphics functions\footnote{Recall
that \lattice{} is built on \grid{} so the panel region in
a \lattice{} plot is a \grid{} viewport.}.

First of all, we create a dendrogram and cut it into four 
subtrees\footnote{the data and cluster analysis are copied from the example
in {\tt help(plot.dendrogram)}.}.

<<eval=TRUE>>=  
     data(USArrests)
     hc <- hclust(dist(USArrests), "ave")
     dend1 <- as.dendrogram(hc)
     dend2 <- cut(dend1, h=70)

@
Now we create some dummy variables which correspond to the four subtrees.

<<>>=
x <- 1:4
y <- 1:4
height <- factor(round(unlist(lapply(dend2$lower, attr, "height"))))

@ 
Next we define a \lattice{} panel function to draw the dendrograms.
The first thing this panel function does is push a viewport
that is smaller than the viewport \lattice{} creates for the panel;
the purpose is to ensure there is enough room for the labels on
the dendrogram.  The \verb|space| variable contains a measure
of the length of the longest label.
The panel function then calls \verb|gridPLT()|
and makes the base plot region correspond to the 
viewport we have just pushed.  Finally, we
call the base \verb|plot()| function to draw the 
dendrogram (and pop the viewport we pushed)\footnote{The {\tt grid.rect()}
call is just to show the extent of the extra viewport we pushed.}.

<<>>=
space <- max(unit(rep(1, 50), "strwidth",
             as.list(rownames(USArrests))))
dendpanel <- function(x, y, subscripts, ...) {
  pushViewport(viewport(y=space, width=0.9,
                         height=unit(0.9, "npc") - space,
                         just="bottom"))
  grid.rect(gp=gpar(col="grey", lwd=5))
  par(plt=gridPLT(), new=TRUE, ps=10)
  plot(dend2$lower[[subscripts]], axes=FALSE)
  popViewport()
}

@
Finally, we draw a \lattice{} xyplot, using \lattice{} to set up the
arrangement of panels and strips and our panel function to draw
a base dendrogram in each panel.

<<echo=FALSE, results=hide, fig=TRUE>>=
library(lattice)
plot.new()
print(xyplot(y ~ x | height, subscripts=TRUE, xlab="", ylab="",
             strip=function(...) { strip.default(style=4, ...) },
             scales=list(draw=FALSE), panel=dendpanel),
      newpage=FALSE)

@

The \verb|gridPLT()| function is useful for embedding just the
plot region of a base graphics function (i.e., without labels and
axes;  another example of this usage 
is given in the next section).  If labelling
and axes are to be included it will make more sense to use
\verb|gridFIG()|.  The \verb|gridOMI()| function has pretty much
the same effect as \verb|gridFIG()| except that it allows for the
possibility of embedding multiple base plots at once.  In the
following code, a \lattice{} plot is placed alongside 
base diagnostic plots arranged in a 2-by-2 array.

We use the data from page 93 of
``An Introduction to Generalized Linear Models'' (Annette Dobson, 1990).

<<>>=
     counts <- c(18,17,15,20,10,20,25,13,12)
     outcome <- gl(3,1,9)
     treatment <- gl(3,3)

@ 
We create two regions using \grid{} viewports;  the left region
is for the \lattice{} plot and the right region is for the diagnostic
plots.  There is a middle column of 1cm to provide a gap between
the two regions.

% Save and restore settings so that vignette building will work(?)
<<echo=FALSE>>=
oldpar <- par(no.readonly=TRUE)

<<regions, eval=FALSE>>=
pushViewport(viewport(layout=grid.layout(1, 3,
  widths=unit(rep(1, 3), c("null", "cm", "null")))))

@
We draw a \lattice{} plot in the left region.

<<lattice, eval=FALSE>>=
pushViewport(viewport(layout.pos.col=1))
library(lattice)
bwplot <- bwplot(counts ~ outcome | treatment)
print(bwplot, newpage=FALSE)
popViewport()

@
We draw the diagnostic plots in the right region.  Here
we use \verb|gridOMI()| to set the base inner region and
\verb|par(mfrow)| and 
\verb|par(mfg)| to insert multiple plots\footnote{We use
{\tt par(mfrow)} to specify the 2-by-2 array
and {\tt par(mfg)} to start at position $(1,1)$ in the 
array.}.

<<diagnostic, eval=FALSE>>=
pushViewport(viewport(layout.pos.col=3))
     glm.D93 <- glm(counts ~ outcome + treatment, family=poisson())
     par(omi=gridOMI(), mfrow=c(2, 2), new=TRUE)
     par(cex=0.5, mar=c(5, 4, 1, 2))
     par(mfg=c(1, 1))
     plot(glm.D93, caption="", ask=FALSE) 
popViewport(2)

<<multiplot, echo=FALSE, results=hide, fig=TRUE, width=8, height=4, include=FALSE>>=
<<regions>>
<<lattice>>
<<diagnostic>>

@
\includegraphics[width=5in]{gridBase-multiplot}

% Save and restore settings so that vignette building will work(?)
<<echo=FALSE>>=
par(oldpar)

@
Notice that because there is only ever one current \grid{} viewport, it only 
makes sense to use one of \verb|gridOMI()|, \verb|gridFIG()|, or
\verb|gridPLT()|.  In other words, it only makes sense to 
align either the inner region, or the figure region, or the plot
region with the current \grid{} viewport.

@
\section*{A more complex example}

We will now look at a reasonably complex example involving
embedding base graphics within grid viewports which are themselves
embedded within a base plot.  This example is motivated by
 the following problem\footnote{This description is from an email to 
R-help from Adam Langley, 18 July 2003}:

\begin{quote}
I am looking at a way of plotting a series of pie charts at specified
locations on an existing plot. The size of the pie chart would be proportion
to the magnitude of the total value of each vector (x) and the values in x
are displayed as the areas of pie slices.
\end{quote}

First of all, we construct some fake data, consisting of four
$(x, y)$ values, and four $(z_1, z_2)$ values :

<<>>=
x <- c(0.88, 1.00, 0.67, 0.34)
y <- c(0.87, 0.43, 0.04, 0.94)
z <- matrix(runif(4*2), ncol=2)

@ 
Before we start any plotting, we save the current \verb|par()| 
settings so that at the end 
we can ``undo'' some of the complicated settings
that we need to apply.

<<>>=
oldpar <- par(no.readonly=TRUE)

@
Now we do a standard base plot of the $(x, y)$ values, but do not
plot  anything at these locations (we're just setting up the
user coordinate system).

<<plot1, eval=FALSE>>=
plot(x, y, xlim=c(-0.2, 1.2), ylim=c(-0.2, 1.2), type="n")

@
Now we make use of \verb|baseViewports|.
This will create a list of grid viewports that correspond to the 
inner, figure, and plot regions set up by the base plot.
By pushing these viewports, we establish a grid viewport that aligns
exactly with the plot region created by the base plot, including a
(grid) ``native'' coordinate system that matches the
(base) user coordinate system\footnote{
The {\tt grid.segments} call is just drawing some 
dashed lines to show that the pie charts we end up with 
are centred correctly at the appropriate $(x, y)$ locations.}.

<<plot2, eval=FALSE>>=
vps <- baseViewports()
pushViewport(vps$inner, vps$figure, vps$plot)
grid.segments(x0=unit(c(rep(0, 4), x),
                      rep(c("npc", "native"), each=4)),
              x1=unit(c(x, x), rep("native", 8)),
              y0=unit(c(y, rep(0, 4)),
                      rep(c("native", "npc"), each=4)),
              y1=unit(c(y, y), rep("native", 8)),
              gp=gpar(lty="dashed", col="grey"))
 
@ 
Before we draw the pie charts, we need to perform a couple of
calculations to determine their size.  In this case, we specify that
the largest pie will be 1\verb|"| in diameter and the others will be 
a proportion of that size based on $\sum_i{z_{.i}} /
{\mathrm{max}}\left( \sum_i{z_{.i}} \right)$

<<>>=
maxpiesize <- unit(1, "inches")
totals <- apply(z, 1, sum)
sizemult <- totals/max(totals)

@
We now enter a loop to draw a pie at each $(x, y)$ location
representing the corresponding $(z_1, z_2)$ values.  The first
step is to create a grid viewport at the $(x, y)$ location,
then we use \verb|gridPLT()|
to set the base plot region to correspond to the grid viewport.
With that done, we can use the base \verb|pie| function to draw a pie
chart within the grid viewport\footnote{We draw a {\tt grid.rect} 
with a dashed border just to show the extent of each grid viewport.
It is crucial that we again call {\tt par(new=TRUE)} so that
we do not move on to a new page.}.  

<<plot3, eval=FALSE>>=
for (i in 1:4) {
  pushViewport(viewport(x=unit(x[i], "native"),
                         y=unit(y[i], "native"),
                         width=sizemult[i]*maxpiesize,
                         height=sizemult[i]*maxpiesize))
  grid.rect(gp=gpar(col="grey", fill="white", lty="dashed"))
  par(plt=gridPLT(), new=TRUE)
  pie(z[i,], radius=1, labels=rep("", 2))
  popViewport()
}

@
Finally, we clean up after ourselves by popping the grid viewports
and restoring the initial \verb|par| settings.

<<plot4, eval=FALSE>>=
popViewport(3)
par(oldpar)

@
The final plot is shown below.

<<complex, echo=FALSE, fig=TRUE, results=hide>>=
<<plot1>>
<<plot2>>
<<plot3>>
<<plot4>>

@
\section*{Problems and limitations}

The functions provided by the \gridBase{} package allow the user
to mix output from two quite different graphics systems and there 
are limits to how much the systems can be combined.  It is important
that users are aware that they are mixing two not wholly compatible
systems (which is why these functions are provided in a separate 
package) and it is of course important to know what the limitations
are: 

\begin{itemize}
\item 
The \gridBase{} functions attempt to
match \grid{} graphics settings with base graphics settings (and vice versa). 
 This 
is only possible under certain conditions.  For a start, it is only 
possible if the device size does not change.  If these functions are
used to draw into a window,  then the window is resized, the base and 
\grid{} settings will almost certainly no longer match and the graph
will become a complete mess.  This also applies to copying output between
devices of different sizes.

\item
It is not possible to embed base graphics output within a 
\grid{} viewport that is rotated.

\item
There are certain base graphics functions 
which modify settings
like \verb|par(omi)| and \verb|par(fig)| themselves (e.g., \verb|coplot()|).
  Output from
these functions may not embed properly
within \grid{} viewports.

\item
\grid{} output cannot be
saved and restored so any attempts to save a mixture of \grid{} and
base output are likely
to end in disappointment.

\end{itemize}

\section*{Summary}

The functions in the \gridBase{} package provide a simple mechanism
for combining base graphics output with \grid{} graphics output
for static, fixed-size plots.  This is not a full integration
of the two graphics systems, but it does provide a useful bridge
between the existing large body of base graphics functions and the
powerful new features of \grid{}.


\subsubsection*{Availability}

The \grid{} package is now part of the base distribution of \R{}
(from \R{} version 1.8.0).  \\
Additional information on \grid{}
is available from:\\
 {\tt http://www.stat.auckland.ac.nz/~paul/grid/grid.html}. \\
The \gridBase{} package
is available from \verb|CRAN| (e.g., {\tt http://cran.us.r-project.org}).

\bibliographystyle{plain}
\bibliography{gridBase}

\end{document}

We use the Plant Weight Data from 
``An Introduction to Generalized Linear Models'' (Annette Dobson, 1990).

<<>>=
     ctl <- c(4.17,5.58,5.18,6.11,4.50,4.61,5.17,4.53,5.33,5.14)
     trt <- c(4.81,4.17,4.41,3.59,5.87,3.83,6.03,4.89,4.32,4.69)
     group <- gl(2,10,20, labels=c("Ctl","Trt"))
     weight <- c(ctl, trt)

@ 
We create two regions using \grid{} viewports;  the left region
is for the \lattice{} plot and the right region is for the diagnostic
plots.  There is a middle column of 1cm to provide a gap between
the two regions.

% Save and restore settings so that vignette building will work(?)
<<echo=FALSE>>=
oldpar <- par(no.readonly=TRUE)

<<regions, eval=FALSE>>=
pushViewport(viewport(layout=grid.layout(1, 3,
  widths=unit(rep(1, 3), c("null", "cm", "null")))))

@
We draw a \lattice{} plot in the left region.

<<lattice, eval=FALSE>>=
pushViewport(viewport(layout.pos.col=1))
library(lattice)
bwplot <- bwplot(weight ~ group)
print(bwplot, newpage=FALSE)
popViewport()

@
We draw the diagnostic plots in the right region.  Here
we use \verb|gridOMI()| to set the base inner region and
\verb|par(mfrow)| and 
\verb|par(mfg)| to insert multiple plots\footnote{We use
{\tt par(mfrow)} to specify the 2-by-2 array
and {\tt par(mfg)} to start at position $(1,1)$ in the 
array.}.

<<diagnostic, eval=FALSE>>=
pushViewport(viewport(layout.pos.col=3))
     lm.D9 <- lm(weight ~ group)
     par(omi=gridOMI(), mfrow=c(2, 2), new=TRUE)
     par(cex=0.5)
     par(mfg=c(1, 1))
     plot(lm.D9, caption="", ask=FALSE) 
popViewport(2)

