The R Project SVN
R
(root)/trunk/tests/Examples/grid-Ex.Rout.save – Rev 89461
Rev 86192 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed
R Under development (unstable) (2026-02-10 r89394) -- "Unsuffered Consequences"Copyright (C) 2026 The R Foundation for Statistical ComputingPlatform: aarch64-apple-darwin23.3.0R is free software and comes with ABSOLUTELY NO WARRANTY.You are welcome to redistribute it under certain conditions.Type 'license()' or 'licence()' for distribution details.R is a collaborative project with many contributors.Type 'contributors()' for more information and'citation()' on how to cite R or R packages in publications.Type 'demo()' for some demos, 'help()' for on-line help, or'help.start()' for an HTML browser interface to help.Type 'q()' to quit R.> pkgname <- "grid"> source(file.path(R.home("share"), "R", "examples-header.R"))> options(warn = 1)> library('grid')>> base::assign(".oldSearch", base::search(), pos = 'CheckExEnv')> base::assign(".old_wd", base::getwd(), pos = 'CheckExEnv')> cleanEx()> nameEx("Grid")> ### * Grid>> flush(stderr()); flush(stdout())>> ### Name: Grid> ### Title: Grid Graphics> ### Aliases: Grid> ### Keywords: dplot>> ### ** Examples>> ## Diagram of a simple layout> grid.show.layout(grid.layout(4,2,+ heights=unit(rep(1, 4),+ c("lines", "lines", "lines", "null")),+ widths=unit(c(1, 1), "inches")))> ## Diagram of a sample viewport> grid.show.viewport(viewport(x=0.6, y=0.6,+ width=unit(1, "inches"), height=unit(1, "inches")))> ## A flash plotting example> grid.multipanel(vp=viewport(0.5, 0.5, 0.8, 0.8))>>>> cleanEx()> nameEx("arrow")> ### * arrow>> flush(stderr()); flush(stdout())>> ### Name: arrow> ### Title: Describe arrows to add to a line> ### Aliases: arrow> ### Keywords: dplot>> ### ** Examples>> arrow()$angle[1] 30$length[1] 0.25inches$ends[1] 2$type[1] 1attr(,"class")[1] "arrow"> str(arrow(type = "closed"), give.attr=FALSE)"arrow" (pkg {grid}) object:$ angle : num 30$ length: 'simpleUnit' num 0.25inches$ ends : int 2$ type : int 2>>>> cleanEx()> nameEx("as.mask")> ### * as.mask>> flush(stderr()); flush(stdout())>> ### Name: as.mask> ### Title: Define a Soft Mask> ### Aliases: as.mask> ### Keywords: dplot>> ### ** Examples>> ## NOTE: on devices without support for masks normal line segments> ## will be drawn> grid.newpage()> ## Alpha mask> grid.segments(y0=1, y1=0, gp=gpar(col=2, lwd=100))> pushViewport(viewport(mask=circleGrob(gp=gpar(fill=rgb(0,0,0,.5)))))> grid.segments(gp=gpar(col=3, lwd=100))> grid.newpage()> ## Luminance mask> grid.segments(y0=1, y1=0, gp=gpar(col=2, lwd=100))> pushViewport(viewport(mask=as.mask(circleGrob(gp=gpar(fill="grey50")),+ "luminance")))> grid.segments(gp=gpar(col=3, lwd=100))>>>> cleanEx()> nameEx("calcStringMetric")> ### * calcStringMetric>> flush(stderr()); flush(stdout())>> ### Name: calcStringMetric> ### Title: Calculate Metric Information for Text> ### Aliases: calcStringMetric> ### Keywords: dplot>> ### ** Examples>> grid.newpage()> grid.segments(.01, .5, .99, .5, gp=gpar(col="grey"))> metrics <- calcStringMetric(letters)> grid.rect(x=1:26/27,+ width=unit(metrics$width, "inches"),+ height=unit(metrics$ascent, "inches"),+ just="bottom",+ gp=gpar(col="red"))> grid.rect(x=1:26/27,+ width=unit(metrics$width, "inches"),+ height=unit(metrics$descent, "inches"),+ just="top",+ gp=gpar(col="red"))> grid.text(letters, x=1:26/27, just="bottom")>> test <- function(x) {+ grid.text(x, just="bottom")+ metric <- calcStringMetric(x)+ if (is.character(x)) {+ grid.rect(width=unit(metric$width, "inches"),+ height=unit(metric$ascent, "inches"),+ just="bottom",+ gp=gpar(col=rgb(1,0,0,.5)))+ grid.rect(width=unit(metric$width, "inches"),+ height=unit(metric$descent, "inches"),+ just="top",+ gp=gpar(col=rgb(1,0,0,.5)))+ } else {+ grid.rect(width=unit(metric$width, "inches"),+ y=unit(.5, "npc") + unit(metric[2], "inches"),+ height=unit(metric$ascent, "inches"),+ just="bottom",+ gp=gpar(col=rgb(1,0,0,.5)))+ grid.rect(width=unit(metric$width, "inches"),+ height=unit(metric$descent, "inches"),+ just="bottom",+ gp=gpar(col=rgb(1,0,0,.5)))+ }+ }>> tests <- list("t",+ "test",+ "testy",+ "test\ntwo",+ expression(x),+ expression(y),+ expression(x + y),+ expression(a + b),+ expression(atop(x + y, 2)))>> grid.newpage()> nrowcol <- n2mfrow(length(tests))> pushViewport(viewport(layout=grid.layout(nrowcol[1], nrowcol[2]),+ gp=gpar(cex=5, lwd=.5)))> for (i in 1:length(tests)) {+ col <- (i - 1) %% nrowcol[2] + 1+ row <- (i - 1) %/% nrowcol[2] + 1+ pushViewport(viewport(layout.pos.row=row, layout.pos.col=col))+ test(tests[[i]])+ popViewport()+ }>>>>> cleanEx()> nameEx("current.viewport")> ### * current.viewport>> flush(stderr()); flush(stdout())>> ### Name: Querying the Viewport Tree> ### Title: Get the Current Grid Viewport (Tree)> ### Aliases: current.viewport current.parent current.vpTree current.vpPath> ### current.transform current.rotation> ### Keywords: dplot>> ### ** Examples>> grid.newpage()> pushViewport(viewport(width=0.8, height=0.8, name="A"))> pushViewport(viewport(x=0.1, width=0.3, height=0.6,+ just="left", name="B"))> upViewport(1)> pushViewport(viewport(x=0.5, width=0.4, height=0.8,+ just="left", name="C"))> pushViewport(viewport(width=0.8, height=0.8, name="D"))> current.vpPath()GRID.VP.69::A::C::D> upViewport(1)> current.vpPath()GRID.VP.69::A::C> current.vpTree()viewport[ROOT]->(viewport[GRID.VP.69]->(viewport[A]->(viewport[B], viewport[C]->(viewport[D]))))> current.viewport()viewport[C]> current.vpTree(all=FALSE)viewport[C]->(viewport[D])> popViewport(0)>>>> cleanEx()> nameEx("depth")> ### * depth>> flush(stderr()); flush(stdout())>> ### Name: depth> ### Title: Determine the number of levels in an object> ### Aliases: depth depth.viewport depth.path> ### Keywords: dplot>> ### ** Examples>> vp <- viewport()> depth(vp)[1] 1> depth(vpStack(vp, vp))[1] 2> depth(vpList(vpStack(vp, vp), vp))[1] 1> depth(vpPath("vp"))[1] 1> depth(vpPath("vp1", "vp2"))[1] 2>>>> cleanEx()> nameEx("deviceLoc")> ### * deviceLoc>> flush(stderr()); flush(stdout())>> ### Name: deviceLoc> ### Title: Convert Viewport Location to Device Location> ### Aliases: deviceLoc deviceDim> ### Keywords: dplot>> ### ** Examples>> ## A tautology> grid.newpage()> pushViewport(viewport())> deviceLoc(unit(1, "inches"), unit(1, "inches"))$x[1] 1inches$y[1] 1inches>> ## Something less obvious> grid.newpage()> pushViewport(viewport(width=.5, height=.5))> grid.rect()> x <- unit(1, "in")> y <- unit(1, "in")> grid.circle(x, y, r=unit(2, "mm"))> loc <- deviceLoc(x, y)> loc$x[1] 2.7inches$y[1] 2.75inches> upViewport()> grid.circle(loc$x, loc$y, r=unit(1, "mm"), gp=gpar(fill="black"))>> ## Something even less obvious> grid.newpage()> pushViewport(viewport(width=.5, height=.5, angle=30))> grid.rect()> x <- unit(.2, "npc")> y <- unit(2, "in")> grid.circle(x, y, r=unit(2, "mm"))> loc <- deviceLoc(x, y)> loc$x[1] 2.39165408813987inches$y[1] 3.20650635094611inches> upViewport()> grid.circle(loc$x, loc$y, r=unit(1, "mm"), gp=gpar(fill="black"))>>>> cleanEx()> nameEx("explode")> ### * explode>> flush(stderr()); flush(stdout())>> ### Name: explode> ### Title: Explode a path into its components> ### Aliases: explode explode.character explode.path> ### Keywords: dplot>> ### ** Examples>> explode("vp1::vp2")[1] "vp1" "vp2"> explode(vpPath("vp1", "vp2"))[1] "vp1" "vp2">>>> cleanEx()> nameEx("gEdit")> ### * gEdit>> flush(stderr()); flush(stdout())>> ### Name: gEdit> ### Title: Create and Apply Edit Objects> ### Aliases: gEdit gEditList applyEdit applyEdits> ### Keywords: dplot>> ### ** Examples>> grid.rect(gp=gpar(col="red"))> # same thing, but more verbose> grid.draw(applyEdit(rectGrob(), gEdit(gp=gpar(col="red"))))>>>> cleanEx()> nameEx("gPath")> ### * gPath>> flush(stderr()); flush(stdout())>> ### Name: gPath> ### Title: Concatenate Grob Names> ### Aliases: gPath> ### Keywords: dplot>> ### ** Examples>> gPath("g1", "g2")g1::g2>>>> cleanEx()> nameEx("getNames")> ### * getNames>> flush(stderr()); flush(stdout())>> ### Name: getNames> ### Title: List the names of grobs on the display list> ### Aliases: getNames> ### Keywords: dplot>> ### ** Examples>> grid.grill()> getNames()[1] "GRID.text.179" "GRID.rect.180" "GRID.circle.181"[4] "GRID.circle.182" "GRID.rect.183" "GRID.rect.184"[7] "GRID.segments.185" "GRID.segments.186">>>> cleanEx()> nameEx("gpar")> ### * gpar>> flush(stderr()); flush(stdout())>> ### Name: gpar> ### Title: Handling Grid Graphical Parameters> ### Aliases: gpar get.gpar> ### Keywords: dplot>> ### ** Examples>> gp <- get.gpar()> utils::str(gp)List of 14$ fill : chr "transparent"$ col : chr "black"$ lty : chr "solid"$ lwd : num 1$ cex : num 1$ fontsize : num 12$ lineheight: num 1.2$ font : int 1$ fontfamily: chr ""$ alpha : num 1$ lineend : chr "round"$ linejoin : chr "round"$ linemitre : num 10$ lex : num 1- attr(*, "class")= chr "gpar"> ## These *do* nothing but produce a "gpar" object:> gpar(col = "red")$col[1] "red"> gpar(col = "blue", lty = "solid", lwd = 3, fontsize = 16)$col[1] "blue"$lty[1] "solid"$lwd[1] 3$fontsize[1] 16> get.gpar(c("col", "lty"))$col[1] "black"$lty[1] "solid"> grid.newpage()> vp <- viewport(width = .8, height = .8, gp = gpar(col="blue"))> grid.draw(gTree(children=gList(rectGrob(gp = gpar(col="red")),+ textGrob(paste("The rect is its own colour (red)",+ "but this text is the colour",+ "set by the gTree (green)",+ sep = "\n"))),+ gp = gpar(col="green"), vp = vp))> grid.text("This text is the colour set by the viewport (blue)",+ y = 1, just = c("center", "bottom"),+ gp = gpar(fontsize=20), vp = vp)> grid.newpage()> ## example with multiple values for a parameter> pushViewport(viewport())> grid.points(1:10/11, 1:10/11, gp = gpar(col=1:10))> popViewport()>>>> cleanEx()> nameEx("grid.DLapply")> ### * grid.DLapply>> flush(stderr()); flush(stdout())>> ### Name: grid.DLapply> ### Title: Modify the Grid Display List> ### Aliases: grid.DLapply> ### Keywords: dplot>> ### ** Examples>> grid.newpage()> grid.rect(width=.4, height=.4, x=.25, y=.75, gp=gpar(fill="black"), name="r1")> grid.rect(width=.4, height=.4, x=.5, y=.5, gp=gpar(fill="grey"), name="r2")> grid.rect(width=.4, height=.4, x=.75, y=.25, gp=gpar(fill="white"), name="r3")> grid.DLapply(function(x) { if (is.grob(x)) x$gp <- gpar(); x })NULL> grid.refresh()>>>> cleanEx()> nameEx("grid.bezier")> ### * grid.bezier>> flush(stderr()); flush(stdout())>> ### Name: grid.bezier> ### Title: Draw a Bezier Curve> ### Aliases: grid.bezier bezierGrob> ### Keywords: dplot>> ### ** Examples>> x <- c(0.2, 0.2, 0.4, 0.4)> y <- c(0.2, 0.4, 0.4, 0.2)>> grid.newpage()> grid.bezier(x, y)> grid.bezier(c(x, x + .4), c(y + .4, y + .4),+ id=rep(1:2, each=4))> grid.segments(.4, .6, .6, .6)> grid.bezier(x, y,+ gp=gpar(lwd=3, fill="black"),+ arrow=arrow(type="closed"),+ vp=viewport(x=.9))>>>> cleanEx()> nameEx("grid.cap")> ### * grid.cap>> flush(stderr()); flush(stdout())>> ### Name: grid.cap> ### Title: Capture a raster image> ### Aliases: grid.cap> ### Keywords: dplot>> ### ** Examples>>>>> cleanEx()> nameEx("grid.clip")> ### * grid.clip>> flush(stderr()); flush(stdout())>> ### Name: grid.clip> ### Title: Set the Clipping Region> ### Aliases: grid.clip clipGrob> ### Keywords: dplot>> ### ** Examples>> # draw across entire viewport, but clipped> grid.clip(x = 0.3, width = 0.1)> grid.lines(gp=gpar(col="green", lwd=5))> # draw across entire viewport, but clipped (in different place)> grid.clip(x = 0.7, width = 0.1)> grid.lines(gp=gpar(col="red", lwd=5))> # Viewport sets new clip region> pushViewport(viewport(width=0.5, height=0.5, clip=TRUE))> grid.lines(gp=gpar(col="grey", lwd=3))> # Return to original viewport; get> # clip region from previous grid.clip()> # (NOT from previous viewport clip region)> popViewport()> grid.lines(gp=gpar(col="black"))>>>> cleanEx()> nameEx("grid.convert")> ### * grid.convert>> flush(stderr()); flush(stdout())>> ### Name: grid.convert> ### Title: Convert Between Different grid Coordinate Systems> ### Aliases: convertUnit convertX convertY convertWidth convertHeight> ### Keywords: dplot>> ### ** Examples>> ## A tautology> convertX(unit(1, "inches"), "inches")[1] 1inches> ## The physical units> convertX(unit(2.54, "cm"), "inches")[1] 1inches> convertX(unit(25.4, "mm"), "inches")[1] 1inches> convertX(unit(72.27, "points"), "inches")[1] 1inches> convertX(unit(1/12*72.27, "picas"), "inches")[1] 1inches> convertX(unit(72, "bigpts"), "inches")[1] 1inches> convertX(unit(1157/1238*72.27, "dida"), "inches")[1] 1inches> convertX(unit(1/12*1157/1238*72.27, "cicero"), "inches")[1] 1inches> convertX(unit(65536*72.27, "scaledpts"), "inches")[1] 1inches> convertX(unit(1/2.54, "inches"), "cm")[1] 1cm> convertX(unit(1/25.4, "inches"), "mm")[1] 1mm> convertX(unit(1/72.27, "inches"), "points")[1] 1points> convertX(unit(1/(1/12*72.27), "inches"), "picas")[1] 1picas> convertX(unit(1/72, "inches"), "bigpts")[1] 1bigpts> convertX(unit(1/(1157/1238*72.27), "inches"), "dida")[1] 1dida> convertX(unit(1/(1/12*1157/1238*72.27), "inches"), "cicero")[1] 1cicero> convertX(unit(1/(65536*72.27), "inches"), "scaledpts")[1] 1scaledpts>> pushViewport(viewport(width=unit(1, "inches"),+ height=unit(2, "inches"),+ xscale=c(0, 1),+ yscale=c(1, 3)))> ## Location versus dimension> convertY(unit(2, "native"), "inches")[1] 1inches> convertHeight(unit(2, "native"), "inches")[1] 2inches> ## From "x" to "y" (the conversion is via "inches")> convertUnit(unit(1, "native"), "native",+ axisFrom="x", axisTo="y")[1] 2native> ## Convert several values at once> convertX(unit(c(0.5, 2.54), c("npc", "cm")),+ c("inches", "native"))[1] 0.5inches 1native> popViewport()> ## Convert a complex unit> convertX(unit(1, "strwidth", "Hello"), "native")[1] 0.0558333333333333native>>>> cleanEx()> nameEx("grid.curve")> ### * grid.curve>> flush(stderr()); flush(stdout())>> ### Name: grid.curve> ### Title: Draw a Curve Between Locations> ### Aliases: grid.curve curveGrob arcCurvature> ### Keywords: dplot>> ### ** Examples>> curveTest <- function(i, j, ...) {+ pushViewport(viewport(layout.pos.col=j, layout.pos.row=i))+ do.call("grid.curve", c(list(x1=.25, y1=.25, x2=.75, y2=.75), list(...)))+ grid.text(sub("list\\((.*)\\)", "\\1",+ deparse(substitute(list(...)))),+ y=unit(1, "npc"))+ popViewport()+ }> # grid.newpage()> pushViewport(plotViewport(c(0, 0, 1, 0),+ layout=grid.layout(2, 1, heights=c(2, 1))))> pushViewport(viewport(layout.pos.row=1,+ layout=grid.layout(3, 3, respect=TRUE)))> curveTest(1, 1)> curveTest(1, 2, inflect=TRUE)> curveTest(1, 3, angle=135)> curveTest(2, 1, arrow=arrow())> curveTest(2, 2, ncp=8)> curveTest(2, 3, shape=0)> curveTest(3, 1, curvature=-1)> curveTest(3, 2, square=FALSE)> curveTest(3, 3, debug=TRUE)> popViewport()> pushViewport(viewport(layout.pos.row=2,+ layout=grid.layout(3, 3)))> curveTest(1, 1)> curveTest(1, 2, inflect=TRUE)> curveTest(1, 3, angle=135)> curveTest(2, 1, arrow=arrow())> curveTest(2, 2, ncp=8)> curveTest(2, 3, shape=0)> curveTest(3, 1, curvature=-1)> curveTest(3, 2, square=FALSE)> curveTest(3, 3, debug=TRUE)> popViewport(2)>>>> cleanEx()> nameEx("grid.delay")> ### * grid.delay>> flush(stderr()); flush(stdout())>> ### Name: grid.delay> ### Title: Encapsulate calculations and generating a grob> ### Aliases: grid.delay delayGrob> ### Keywords: dplot>> ### ** Examples>> grid.delay({+ w <- convertWidth(unit(1, "inches"), "npc")+ rectGrob(width=w)+ },+ list())>>>> cleanEx()> nameEx("grid.draw")> ### * grid.draw>> flush(stderr()); flush(stdout())>> ### Name: grid.draw> ### Title: Draw a grid grob> ### Aliases: grid.draw> ### Keywords: dplot>> ### ** Examples>> grid.newpage()> ## Create a graphical object, but don't draw it> l <- linesGrob()> ## Draw it> grid.draw(l)>>>> cleanEx()> nameEx("grid.edit")> ### * grid.edit>> flush(stderr()); flush(stdout())>> ### Name: grid.edit> ### Title: Edit the Description of a Grid Graphical Object> ### Aliases: grid.edit grid.gedit editGrob> ### Keywords: dplot>> ### ** Examples>> grid.newpage()> grid.xaxis(name = "xa", vp = viewport(width=.5, height=.5))> grid.edit("xa", gp = gpar(col="red"))> # won't work because no ticks (at is NULL)> try(grid.edit(gPath("xa", "ticks"), gp = gpar(col="green")))Error in editDLfromGPath(gPath, specs, strict, grep, global, redraw) :'gPath' (xa::ticks) not found> grid.edit("xa", at = 1:4/5)> # Now it should work> try(grid.edit(gPath("xa", "ticks"), gp = gpar(col="green")))>>>> cleanEx()> nameEx("grid.force")> ### * grid.force>> flush(stderr()); flush(stdout())>> ### Name: grid.force> ### Title: Force a grob into its components> ### Aliases: grid.force grid.force.default grid.force.gPath grid.force.grob> ### forceGrob grid.revert grid.revert.gPath grid.revert.grob> ### Keywords: dplot>> ### ** Examples>> grid.newpage()> pushViewport(viewport(width=.5, height=.5))> # Draw xaxis> grid.xaxis(name="xax")> grid.ls()GRID.text.261xax> # Force xaxis> grid.force()> grid.ls()GRID.text.261xaxmajortickslabels> # Revert xaxis> grid.revert()> grid.ls()GRID.text.261xax> # Draw and force yaxis> grid.force(yaxisGrob(), draw=TRUE)forcedgrob[GRID.yaxis.262]> grid.ls()GRID.text.261xaxGRID.yaxis.262majortickslabels> # Revert yaxis> grid.revert()> grid.ls()GRID.text.261xaxGRID.yaxis.262> # Force JUST xaxis> grid.force("xax")> grid.ls()GRID.text.261xaxmajortickslabelsGRID.yaxis.262> # Force ALL> grid.force()> grid.ls()GRID.text.261xaxmajortickslabelsGRID.yaxis.262majortickslabels> # Revert JUST xaxis> grid.revert("xax")> grid.ls()GRID.text.261xaxGRID.yaxis.262majortickslabels>>>> cleanEx()> nameEx("grid.frame")> ### * grid.frame>> flush(stderr()); flush(stdout())>> ### Name: grid.frame> ### Title: Create a Frame for Packing Objects> ### Aliases: grid.frame frameGrob> ### Keywords: dplot>> ### ** Examples>> grid.newpage()> grid.frame(name="gf", draw=TRUE)> grid.pack("gf", rectGrob(gp=gpar(fill="grey")), width=unit(1, "null"))> grid.pack("gf", textGrob("hi there"), side="right")>>>> cleanEx()> nameEx("grid.function")> ### * grid.function>> flush(stderr()); flush(stdout())>> ### Name: grid.function> ### Title: Draw a curve representing a function> ### Aliases: grid.function functionGrob grid.abline> ### Keywords: dplot>> ### ** Examples>> # abline> # NOTE: in ROOT viewport on screen, (0, 0) at top-left> # and "native" is pixels!> grid.function(function(x) list(x=x, y=0 + 1*x))> # a more "normal" viewport with default normalized "native" coords> grid.newpage()> pushViewport(viewport())> grid.function(function(x) list(x=x, y=0 + 1*x))> # slightly simpler> grid.newpage()> pushViewport(viewport())> grid.abline()> # sine curve> grid.newpage()> pushViewport(viewport(xscale=c(0, 2*pi), yscale=c(-1, 1)))> grid.function(function(x) list(x=x, y=sin(x)))> # constrained sine curve> grid.newpage()> pushViewport(viewport(xscale=c(0, 2*pi), yscale=c(-1, 1)))> grid.function(function(x) list(x=x, y=sin(x)),+ range=0:1)> # inverse sine curve> grid.newpage()> pushViewport(viewport(xscale=c(-1, 1), yscale=c(0, 2*pi)))> grid.function(function(y) list(x=sin(y), y=y),+ range="y")> # parametric function> grid.newpage()> pushViewport(viewport(xscale=c(-1, 1), yscale=c(-1, 1)))> grid.function(function(t) list(x=cos(t), y=sin(t)),+ range=c(0, 9*pi/5))> # physical abline> grid.newpage()> grid.function(function(x) list(x=x, y=0 + 1*x),+ units="in")>>>> cleanEx()> nameEx("grid.get")> ### * grid.get>> flush(stderr()); flush(stdout())>> ### Name: grid.get> ### Title: Get a Grid Graphical Object> ### Aliases: grid.get grid.gget getGrob> ### Keywords: dplot>> ### ** Examples>> grid.xaxis(name="xa")> grid.get("xa")xaxis[xa]> grid.get(gPath("xa", "ticks"))NULL>> grid.draw(gTree(name="gt", children=gList(xaxisGrob(name="axis"))))> grid.get(gPath("gt", "axis", "ticks"))NULL>>>> cleanEx()> nameEx("grid.grab")> ### * grid.grab>> flush(stderr()); flush(stdout())>> ### Name: grid.grab> ### Title: Grab the current grid output> ### Aliases: grid.grab grid.grabExpr> ### Keywords: dplot>> ### ** Examples>> pushViewport(viewport(width=.5, height=.5))> grid.rect()> grid.points(stats::runif(10), stats::runif(10))> popViewport()> grab <- grid.grab()> grid.newpage()> grid.draw(grab)>>>> cleanEx()> nameEx("grid.grep")> ### * grid.grep>> flush(stderr()); flush(stdout())>> ### Name: grid.grep> ### Title: Search for Grobs and/or Viewports> ### Aliases: grid.grep> ### Keywords: dplot>> ### ** Examples>> # A gTree, called "grandparent", with child gTree,> # called "parent", with childrenvp vpStack (vp2 within vp1)> # and child grob, called "child", with vp vpPath (down to vp2)> sampleGTree <- gTree(name="grandparent",+ children=gList(gTree(name="parent",+ children=gList(grob(name="child", vp="vp1::vp2")),+ childrenvp=vpStack(viewport(name="vp1"),+ viewport(name="vp2")))))> # Searching for grobs> grid.grep("parent", sampleGTree)grandparent::parent> grid.grep("parent", sampleGTree, strict=TRUE)character(0)> grid.grep("grandparent", sampleGTree, strict=TRUE)grandparent> grid.grep("grandparent::parent", sampleGTree)grandparent::parent> grid.grep("parent::child", sampleGTree)grandparent::parent::child> grid.grep("[a-z]", sampleGTree, grep=TRUE)grandparent> grid.grep("[a-z]", sampleGTree, grep=TRUE, global=TRUE)[[1]]grandparent[[2]]grandparent::parent[[3]]grandparent::parent::child> # Searching for viewports> grid.grep("vp1", sampleGTree, viewports=TRUE)vp1> grid.grep("vp2", sampleGTree, viewports=TRUE)vp1::vp2> grid.grep("vp", sampleGTree, viewports=TRUE, grep=TRUE)vp1> grid.grep("vp2", sampleGTree, viewports=TRUE, strict=TRUE)character(0)> grid.grep("vp1::vp2", sampleGTree, viewports=TRUE)vp1::vp2> # Searching for both> grid.grep("[a-z]", sampleGTree, viewports=TRUE, grep=TRUE, global=TRUE)[[1]]grandparent[[2]]grandparent::parent[[3]]vp1[[4]]vp1::vp2[[5]]grandparent::parent::child>>>> cleanEx()> nameEx("grid.group")> ### * grid.group>> flush(stderr()); flush(stdout())>> ### Name: grid.group> ### Title: Draw a Group> ### Aliases: grid.group groupGrob grid.define defineGrob grid.use useGrob> ### Keywords: dplot>> ### ** Examples>> ## NOTE: on devices without support for groups (or masks or patterns),> ## there will only be two overlapping opaque circles> grid.newpage()> pat <- pattern(rasterGrob(matrix(c(.5, 1, 1, .5), nrow=2),+ width=unit(1, "cm"),+ height=unit(1, "cm"),+ interpolate=FALSE),+ width=unit(1, "cm"), height=unit(1, "cm"),+ extend="repeat")> grid.rect(gp=gpar(col=NA, fill=pat))> masks <- dev.capabilities()$masks> if (is.character(masks) && "luminance" %in% masks) {+ mask <- as.mask(rectGrob(gp=gpar(col=NA, fill="grey50")), type="luminance")+ } else {+ mask <- rectGrob(gp=gpar(col=NA, fill=rgb(0,0,0,.5)))+ }> pushViewport(viewport(mask=mask))> pushViewport(viewport(y=.5, height=.5, just="bottom"))> grid.circle(1:2/3, r=.45, gp=gpar(fill=2:3))> popViewport()> pushViewport(viewport(y=0, height=.5, just="bottom"))> grid.group(circleGrob(1:2/3, r=.45, gp=gpar(fill=2:3)))> popViewport()>>>> cleanEx()> nameEx("grid.layout")> ### * grid.layout>> flush(stderr()); flush(stdout())>> ### Name: grid.layout> ### Title: Create a Grid Layout> ### Aliases: grid.layout> ### Keywords: dplot>> ### ** Examples>> ## A variety of layouts (some a bit mid-bending ...)> layout.torture()> ## Demonstration of layout justification> grid.newpage()> testlay <- function(just="centre") {+ pushViewport(viewport(layout=grid.layout(1, 1, widths=unit(1, "inches"),+ heights=unit(0.25, "npc"),+ just=just)))+ pushViewport(viewport(layout.pos.col=1, layout.pos.row=1))+ grid.rect()+ grid.text(paste(just, collapse="-"))+ popViewport(2)+ }> testlay()> testlay(c("left", "top"))> testlay(c("right", "top"))> testlay(c("right", "bottom"))> testlay(c("left", "bottom"))> testlay(c("left"))> testlay(c("right"))> testlay(c("bottom"))> testlay(c("top"))>>>> cleanEx()> nameEx("grid.lines")> ### * grid.lines>> flush(stderr()); flush(stdout())>> ### Name: grid.lines> ### Title: Draw Lines in a Grid Viewport> ### Aliases: grid.lines linesGrob grid.polyline polylineGrob> ### Keywords: dplot>> ### ** Examples>> grid.lines()> # Using id (NOTE: locations are not in consecutive blocks)> grid.newpage()> grid.polyline(x=c((0:4)/10, rep(.5, 5), (10:6)/10, rep(.5, 5)),+ y=c(rep(.5, 5), (10:6/10), rep(.5, 5), (0:4)/10),+ id=rep(1:5, 4),+ gp=gpar(col=1:5, lwd=3))> # Using id.lengths> grid.newpage()> grid.polyline(x=outer(c(0, .5, 1, .5), 5:1/5),+ y=outer(c(.5, 1, .5, 0), 5:1/5),+ id.lengths=rep(4, 5),+ gp=gpar(col=1:5, lwd=3))>>>> cleanEx()> nameEx("grid.locator")> ### * grid.locator>> flush(stderr()); flush(stdout())>> ### Name: grid.locator> ### Title: Capture a Mouse Click> ### Aliases: grid.locator> ### Keywords: dplot>> ### ** Examples>> if (dev.interactive()) {+ ## Need to write a more sophisticated unit as.character method+ unittrim <- function(unit) {+ sub("^([0-9]+|[0-9]+[.][0-9])[0-9]*", "\\1", as.character(unit))+ }+ do.click <- function(unit) {+ click.locn <- grid.locator(unit)+ grid.segments(unit.c(click.locn$x, unit(0, "npc")),+ unit.c(unit(0, "npc"), click.locn$y),+ click.locn$x, click.locn$y,+ gp=gpar(lty="dashed", col="grey"))+ grid.points(click.locn$x, click.locn$y, pch=16, size=unit(1, "mm"))+ clickx <- unittrim(click.locn$x)+ clicky <- unittrim(click.locn$y)+ grid.text(paste0("(", clickx, ", ", clicky, ")"),+ click.locn$x + unit(2, "mm"), click.locn$y,+ just="left")+ }++ grid.newpage() # (empty slate)+ ## device+ do.click("inches")+ Sys.sleep(1)++ pushViewport(viewport(width=0.5, height=0.5,+ xscale=c(0, 100), yscale=c(0, 10)))+ grid.rect()+ grid.xaxis()+ grid.yaxis()+ do.click("native")+ popViewport()+ }>>>> cleanEx()> nameEx("grid.ls")> ### * grid.ls>> flush(stderr()); flush(stdout())>> ### Name: grid.ls> ### Title: List the names of grobs or viewports> ### Aliases: grid.ls nestedListing pathListing grobPathListing> ### Keywords: dplot>> ### ** Examples>> # A gTree, called "parent", with childrenvp vpTree (vp2 within vp1)> # and child grob, called "child", with vp vpPath (down to vp2)> sampleGTree <- gTree(name="parent",+ children=gList(grob(name="child", vp="vp1::vp2")),+ childrenvp=vpTree(parent=viewport(name="vp1"),+ children=vpList(viewport(name="vp2"))))> grid.ls(sampleGTree)parentchild> # Show viewports too> grid.ls(sampleGTree, viewports=TRUE)parentvp1vp22vp1vp2child2> # Only show viewports> grid.ls(sampleGTree, viewports=TRUE, grobs=FALSE)vp1vp22vp1vp22> # Alternate displays> # nested listing, custom indent> grid.ls(sampleGTree, viewports=TRUE, print=nestedListing, gindent="--")parent--vp1----vp2------2--vp1----vp2------child------2> # path listing> grid.ls(sampleGTree, viewports=TRUE, print=pathListing)| parentvp1vp1::vp2vp1::vp2::2vp1vp1::vp2vp1::vp2 | parent::childvp1::vp2::2> # path listing, without grobs aligned> grid.ls(sampleGTree, viewports=TRUE, print=pathListing, gAlign=FALSE)| parentvp1vp1::vp2vp1::vp2::2vp1vp1::vp2vp1::vp2 | parent::childvp1::vp2::2> # grob path listing> grid.ls(sampleGTree, viewports=TRUE, print=grobPathListing)| parentvp1::vp2 | parent::child> # path listing, grobs only> grid.ls(sampleGTree, print=pathListing)| parent| parent::child> # path listing, viewports only> grid.ls(sampleGTree, viewports=TRUE, grobs=FALSE, print=pathListing)vp1vp1::vp2vp1::vp2::2vp1vp1::vp2vp1::vp2::2> # raw flat listing> str(grid.ls(sampleGTree, viewports=TRUE, print=FALSE))List of 6$ name : chr [1:8] "parent" "vp1" "vp2" "2" ...$ gDepth : num [1:8] 0 1 1 1 1 1 1 1$ vpDepth: num [1:8] 0 0 1 2 0 1 2 2$ gPath : chr [1:8] "" "parent" "parent" "parent" ...$ vpPath : chr [1:8] "" "" "vp1" "vp1::vp2" ...$ type : chr [1:8] "gTreeListing" "vpListing" "vpListing" "vpUpListing" ...- attr(*, "class")= chr "flatGridListing">>>> cleanEx()> nameEx("grid.move.to")> ### * grid.move.to>> flush(stderr()); flush(stdout())>> ### Name: grid.move.to> ### Title: Move or Draw to a Specified Position> ### Aliases: grid.move.to grid.line.to moveToGrob lineToGrob> ### Keywords: dplot>> ### ** Examples>> grid.newpage()> grid.move.to(0.5, 0.5)> grid.line.to(1, 1)> grid.line.to(0.5, 0)> pushViewport(viewport(x=0, y=0, width=0.25, height=0.25, just=c("left", "bottom")))> grid.rect()> grid.grill()> grid.line.to(0.5, 0.5)> popViewport()>>>> cleanEx()> nameEx("grid.null")> ### * grid.null>> flush(stderr()); flush(stdout())>> ### Name: grid.null> ### Title: Null Graphical Object> ### Aliases: grid.null nullGrob> ### Keywords: dplot>> ### ** Examples>> grid.newpage()> grid.null(name="ref")> grid.rect(height=grobHeight("ref"))> grid.segments(0, 0, grobX("ref", 0), grobY("ref", 0))>>>> cleanEx()> nameEx("grid.path")> ### * grid.path>> flush(stderr()); flush(stdout())>> ### Name: grid.path> ### Title: Draw a Path> ### Aliases: grid.path pathGrob> ### Keywords: dplot>> ### ** Examples>> pathSample <- function(x, y, rule, gp = gpar()) {+ if (is.na(rule))+ grid.path(x, y, id = rep(1:2, each = 4), gp = gp)+ else+ grid.path(x, y, id = rep(1:2, each = 4), rule = rule, gp = gp)+ if (!is.na(rule))+ grid.text(paste("Rule:", rule), y = 0, just = "bottom")+ }>> pathTriplet <- function(x, y, title) {+ pushViewport(viewport(height = 0.9, layout = grid.layout(1, 3),+ gp = gpar(cex = .7)))+ grid.rect(y = 1, height = unit(1, "char"), just = "top",+ gp = gpar(col = NA, fill = "grey"))+ grid.text(title, y = 1, just = "top")+ pushViewport(viewport(layout.pos.col = 1))+ pathSample(x, y, rule = "winding",+ gp = gpar(fill = "grey"))+ popViewport()+ pushViewport(viewport(layout.pos.col = 2))+ pathSample(x, y, rule = "evenodd",+ gp = gpar(fill = "grey"))+ popViewport()+ pushViewport(viewport(layout.pos.col = 3))+ pathSample(x, y, rule = NA)+ popViewport()+ popViewport()+ }>> pathTest <- function() {+ grid.newpage()+ pushViewport(viewport(layout = grid.layout(5, 1)))+ pushViewport(viewport(layout.pos.row = 1))+ pathTriplet(c(.1, .1, .9, .9, .2, .2, .8, .8),+ c(.1, .9, .9, .1, .2, .8, .8, .2),+ "Nested rectangles, both clockwise")+ popViewport()+ pushViewport(viewport(layout.pos.row = 2))+ pathTriplet(c(.1, .1, .9, .9, .2, .8, .8, .2),+ c(.1, .9, .9, .1, .2, .2, .8, .8),+ "Nested rectangles, outer clockwise, inner anti-clockwise")+ popViewport()+ pushViewport(viewport(layout.pos.row = 3))+ pathTriplet(c(.1, .1, .4, .4, .6, .9, .9, .6),+ c(.1, .4, .4, .1, .6, .6, .9, .9),+ "Disjoint rectangles")+ popViewport()+ pushViewport(viewport(layout.pos.row = 4))+ pathTriplet(c(.1, .1, .6, .6, .4, .4, .9, .9),+ c(.1, .6, .6, .1, .4, .9, .9, .4),+ "Overlapping rectangles, both clockwise")+ popViewport()+ pushViewport(viewport(layout.pos.row = 5))+ pathTriplet(c(.1, .1, .6, .6, .4, .9, .9, .4),+ c(.1, .6, .6, .1, .4, .4, .9, .9),+ "Overlapping rectangles, one clockwise, other anti-clockwise")+ popViewport()+ popViewport()+ }>> pathTest()>> # Drawing multiple paths at once> holed_rect <- cbind(c(.15, .15, -.15, -.15, .1, .1, -.1, -.1),+ c(.15, -.15, -.15, .15, .1, -.1, -.1, .1))> holed_rects <- rbind(+ holed_rect + matrix(c(.7, .2), nrow = 8, ncol = 2, byrow = TRUE),+ holed_rect + matrix(c(.7, .8), nrow = 8, ncol = 2, byrow = TRUE),+ holed_rect + matrix(c(.2, .5), nrow = 8, ncol = 2, byrow = TRUE)+ )> grid.newpage()> grid.path(x = holed_rects[, 1], y = holed_rects[, 2],+ id = rep(1:6, each = 4), pathId = rep(1:3, each = 8),+ gp = gpar(fill = c('red', 'blue', 'green')),+ rule = 'evenodd')>> # Not specifying pathId will treat all points as part of the same path, thus> # having same fill> grid.newpage()> grid.path(x = holed_rects[, 1], y = holed_rects[, 2],+ id = rep(1:6, each = 4),+ gp = gpar(fill = c('red', 'blue', 'green')),+ rule = 'evenodd')>>>> cleanEx()> nameEx("grid.plot.and.legend")> ### * grid.plot.and.legend>> flush(stderr()); flush(stdout())>> ### Name: grid.plot.and.legend> ### Title: A Simple Plot and Legend Demo> ### Aliases: grid.plot.and.legend> ### Keywords: dplot>> ### ** Examples>> grid.plot.and.legend()>>>> cleanEx()> nameEx("grid.polygon")> ### * grid.polygon>> flush(stderr()); flush(stdout())>> ### Name: grid.polygon> ### Title: Draw a Polygon> ### Aliases: grid.polygon polygonGrob> ### Keywords: dplot>> ### ** Examples>> grid.polygon()> # Using id (NOTE: locations are not in consecutive blocks)> grid.newpage()> grid.polygon(x=c((0:4)/10, rep(.5, 5), (10:6)/10, rep(.5, 5)),+ y=c(rep(.5, 5), (10:6/10), rep(.5, 5), (0:4)/10),+ id=rep(1:5, 4),+ gp=gpar(fill=1:5))> # Using id.lengths> grid.newpage()> grid.polygon(x=outer(c(0, .5, 1, .5), 5:1/5),+ y=outer(c(.5, 1, .5, 0), 5:1/5),+ id.lengths=rep(4, 5),+ gp=gpar(fill=1:5))>>>> cleanEx()> nameEx("grid.raster")> ### * grid.raster>> flush(stderr()); flush(stdout())>> ### Name: grid.raster> ### Title: Render a raster object> ### Aliases: grid.raster rasterGrob> ### Keywords: dplot>> ### ** Examples>> redGradient <- matrix(hcl(0, 80, seq(50, 80, 10)),+ nrow=4, ncol=5)> # interpolated> grid.newpage()> grid.raster(redGradient)> # blocky> grid.newpage()> grid.raster(redGradient, interpolate=FALSE)> # blocky and stretched> grid.newpage()> grid.raster(redGradient, interpolate=FALSE, height=unit(1, "npc"))>> # The same raster drawn several times> grid.newpage()> grid.raster(0, x=1:3/4, y=1:3/4, width=.1, interpolate=FALSE)>>>> cleanEx()> nameEx("grid.record")> ### * grid.record>> flush(stderr()); flush(stdout())>> ### Name: grid.record> ### Title: Encapsulate calculations and drawing> ### Aliases: grid.record recordGrob> ### Keywords: dplot>> ### ** Examples>> grid.record({+ w <- convertWidth(unit(1, "inches"), "npc")+ grid.rect(width=w)+ },+ list())>>>> cleanEx()> nameEx("grid.reorder")> ### * grid.reorder>> flush(stderr()); flush(stdout())>> ### Name: grid.reorder> ### Title: Reorder the children of a gTree> ### Aliases: grid.reorder reorderGrob> ### Keywords: dplot>> ### ** Examples>> # gTree with two children, "red-rect" and "blue-rect" (in that order)> gt <- gTree(children=gList(+ rectGrob(gp=gpar(col=NA, fill="red"),+ width=.8, height=.2, name="red-rect"),+ rectGrob(gp=gpar(col=NA, fill="blue"),+ width=.2, height=.8, name="blue-rect")),+ name="gt")> grid.newpage()> grid.draw(gt)> # Spec entire order as numeric (blue-rect, red-rect)> grid.reorder("gt", 2:1)> # Spec entire order as character> grid.reorder("gt", c("red-rect", "blue-rect"))> # Only spec the one I want behind as character> grid.reorder("gt", "blue-rect")> # Only spec the one I want in front as character> grid.reorder("gt", "blue-rect", back=FALSE)>>>> cleanEx()> nameEx("grid.roundrect")> ### * grid.roundrect>> flush(stderr()); flush(stdout())>> ### Name: roundrect> ### Title: Draw a rectangle with rounded corners> ### Aliases: roundrect grid.roundrect roundrectGrob> ### Keywords: dplot>> ### ** Examples>> grid.roundrect(width=.5, height=.5, name="rr")> theta <- seq(0, 360, length.out=50)> for (i in 1:50)+ grid.circle(x=grobX("rr", theta[i]),+ y=grobY("rr", theta[i]),+ r=unit(1, "mm"),+ gp=gpar(fill="black"))>>>> cleanEx()> nameEx("grid.show.layout")> ### * grid.show.layout>> flush(stderr()); flush(stdout())>> ### Name: grid.show.layout> ### Title: Draw a Diagram of a Grid Layout> ### Aliases: grid.show.layout> ### Keywords: dplot>> ### ** Examples>> ## Diagram of a simple layout> grid.show.layout(grid.layout(4,2,+ heights=unit(rep(1, 4),+ c("lines", "lines", "lines", "null")),+ widths=unit(c(1, 1), "inches")))>>>> cleanEx()> nameEx("grid.show.viewport")> ### * grid.show.viewport>> flush(stderr()); flush(stdout())>> ### Name: grid.show.viewport> ### Title: Draw a Diagram of a Grid Viewport> ### Aliases: grid.show.viewport> ### Keywords: dplot>> ### ** Examples>> ## Diagram of a sample viewport> grid.show.viewport(viewport(x=0.6, y=0.6,+ width=unit(1, "inches"), height=unit(1, "inches")))> grid.show.viewport(viewport(layout.pos.row=2, layout.pos.col=2:3),+ grid.layout(3, 4))>>>> cleanEx()> nameEx("grid.stroke")> ### * grid.stroke>> flush(stderr()); flush(stdout())>> ### Name: grid.stroke> ### Title: Stroke or Fill a Path> ### Aliases: grid.stroke strokeGrob strokeGrob.grob strokeGrob.GridPath> ### grid.fill fillGrob fillGrob.grob fillGrob.GridPath grid.fillStroke> ### fillStrokeGrob fillStrokeGrob.grob fillStrokeGrob.GridPath as.path> ### Keywords: dplot>> ### ** Examples>> ## NOTE: on devices without support for stroking and filling> ## nothing will be drawn> grid.newpage()> grid.stroke(textGrob("hello", gp=gpar(cex=10)))> grid.fill(circleGrob(1:2/3, r=.3), gp=gpar(fill=rgb(1,0,0,.5)))>>>> cleanEx()> nameEx("grid.text")> ### * grid.text>> flush(stderr()); flush(stdout())>> ### Name: grid.text> ### Title: Draw Text> ### Aliases: grid.text textGrob> ### Keywords: dplot>> ### ** Examples>> grid.newpage()> x <- stats::runif(20)> y <- stats::runif(20)> rot <- stats::runif(20, 0, 360)> grid.text("SOMETHING NICE AND BIG", x=x, y=y, rot=rot,+ gp=gpar(fontsize=20, col="grey"))> grid.text("SOMETHING NICE AND BIG", x=x, y=y, rot=rot,+ gp=gpar(fontsize=20), check.overlap=TRUE)>> grid.newpage() ## plotmath example> grid.text(quote(frac(e^{-x^2/2}, sqrt(2*pi))), x=x, y=y, rot=stats::runif(20, -45,45),+ gp=gpar(fontsize=17, col=4), check.overlap=TRUE)>> grid.newpage()> draw.text <- function(just, i, j) {+ grid.text("ABCD", x=x[j], y=y[i], just=just)+ grid.text(deparse(substitute(just)), x=x[j], y=y[i] + unit(2, "lines"),+ gp=gpar(col="grey", fontsize=8))+ }> x <- unit(1:4/5, "npc")> y <- unit(1:4/5, "npc")> grid.grill(h=y, v=x, gp=gpar(col="grey"))> draw.text(c("bottom"), 1, 1)> draw.text(c("left", "bottom"), 2, 1)> draw.text(c("right", "bottom"), 3, 1)> draw.text(c("centre", "bottom"), 4, 1)> draw.text(c("centre"), 1, 2)> draw.text(c("left", "centre"), 2, 2)> draw.text(c("right", "centre"), 3, 2)> draw.text(c("centre", "centre"), 4, 2)> draw.text(c("top"), 1, 3)> draw.text(c("left", "top"), 2, 3)> draw.text(c("right", "top"), 3, 3)> draw.text(c("centre", "top"), 4, 3)> draw.text(c(), 1, 4)> draw.text(c("left"), 2, 4)> draw.text(c("right"), 3, 4)> draw.text(c("centre"), 4, 4)>>>> cleanEx()> nameEx("grid.xspline")> ### * grid.xspline>> flush(stderr()); flush(stdout())>> ### Name: grid.xspline> ### Title: Draw an Xspline> ### Aliases: grid.xspline xsplineGrob> ### Keywords: dplot>> ### ** Examples>> x <- c(0.25, 0.25, 0.75, 0.75)> y <- c(0.25, 0.75, 0.75, 0.25)>> xsplineTest <- function(s, i, j, open) {+ pushViewport(viewport(layout.pos.col=j, layout.pos.row=i))+ grid.points(x, y, default.units="npc", pch=16, size=unit(2, "mm"))+ grid.xspline(x, y, shape=s, open=open, gp=gpar(fill="grey"))+ grid.text(s, gp=gpar(col="grey"),+ x=unit(x, "npc") + unit(c(-1, -1, 1, 1), "mm"),+ y=unit(y, "npc") + unit(c(-1, 1, 1, -1), "mm"),+ hjust=c(1, 1, 0, 0),+ vjust=c(1, 0, 0, 1))+ popViewport()+ }>> pushViewport(viewport(width=.5, x=0, just="left",+ layout=grid.layout(3, 3, respect=TRUE)))> pushViewport(viewport(layout.pos.row=1))> grid.text("Open Splines", y=1, just="bottom")> popViewport()> xsplineTest(c(0, -1, -1, 0), 1, 1, TRUE)> xsplineTest(c(0, -1, 0, 0), 1, 2, TRUE)> xsplineTest(c(0, -1, 1, 0), 1, 3, TRUE)> xsplineTest(c(0, 0, -1, 0), 2, 1, TRUE)> xsplineTest(c(0, 0, 0, 0), 2, 2, TRUE)> xsplineTest(c(0, 0, 1, 0), 2, 3, TRUE)> xsplineTest(c(0, 1, -1, 0), 3, 1, TRUE)> xsplineTest(c(0, 1, 0, 0), 3, 2, TRUE)> xsplineTest(c(0, 1, 1, 0), 3, 3, TRUE)> popViewport()> pushViewport(viewport(width=.5, x=1, just="right",+ layout=grid.layout(3, 3, respect=TRUE)))> pushViewport(viewport(layout.pos.row=1))> grid.text("Closed Splines", y=1, just="bottom")> popViewport()> xsplineTest(c(-1, -1, -1, -1), 1, 1, FALSE)> xsplineTest(c(-1, -1, 0, -1), 1, 2, FALSE)> xsplineTest(c(-1, -1, 1, -1), 1, 3, FALSE)> xsplineTest(c( 0, 0, -1, 0), 2, 1, FALSE)> xsplineTest(c( 0, 0, 0, 0), 2, 2, FALSE)> xsplineTest(c( 0, 0, 1, 0), 2, 3, FALSE)> xsplineTest(c( 1, 1, -1, 1), 3, 1, FALSE)> xsplineTest(c( 1, 1, 0, 1), 3, 2, FALSE)> xsplineTest(c( 1, 1, 1, 1), 3, 3, FALSE)> popViewport()>>>> cleanEx()> nameEx("legendGrob")> ### * legendGrob>> flush(stderr()); flush(stdout())>> ### Name: legendGrob> ### Title: Constructing a Legend Grob> ### Aliases: legendGrob grid.legend> ### Keywords: aplot>> ### ** Examples>> ## Data:> n <- 10> x <- stats::runif(n) ; y1 <- stats::runif(n) ; y2 <- stats::runif(n)> ## Construct the grobs :> plot <- gTree(children=gList(rectGrob(),+ pointsGrob(x, y1, pch=21, gp=gpar(col=2, fill="gray")),+ pointsGrob(x, y2, pch=22, gp=gpar(col=3, fill="gray")),+ xaxisGrob(),+ yaxisGrob()))> legd <- legendGrob(c("Girls", "Boys", "Other"), pch=21:23,+ gp=gpar(col = 2:4, fill = "gray"))> gg <- packGrob(packGrob(frameGrob(), plot),+ legd, height=unit(1,"null"), side="right")>> ## Now draw it on a new device page:> grid.newpage()> pushViewport(viewport(width=0.8, height=0.8))> grid.draw(gg)>>>> cleanEx()> nameEx("resolveRasterSize")> ### * resolveRasterSize>> flush(stderr()); flush(stdout())>> ### Name: resolveRasterSize> ### Title: Utility function to resolve the size of a raster grob> ### Aliases: resolveRasterSize> ### Keywords: dplot>> ### ** Examples>> # Square raster> rg <- rasterGrob(matrix(0))> # Fill the complete page (if page is square)> grid.newpage()> resolveRasterSize(rg)$height[1] 6.8inches> grid.draw(rg)> # Forced to fit tall thin region> grid.newpage()> pushViewport(viewport(width=.1))> resolveRasterSize(rg)$height[1] 0.68inches> grid.draw(rg)>>>> cleanEx()> nameEx("showGrob")> ### * showGrob>> flush(stderr()); flush(stdout())>> ### Name: showGrob> ### Title: Label grid grobs> ### Aliases: showGrob> ### Keywords: dplot>> ### ** Examples>> grid.newpage()> gt <- gTree(childrenvp=vpStack(+ viewport(x=0, width=.5, just="left", name="vp"),+ viewport(y=.5, height=.5, just="bottom", name="vp2")),+ children=gList(rectGrob(vp="vp::vp2", name="child")),+ name="parent")> grid.draw(gt)> showGrob()> showGrob(gPath="child")> showGrob(recurse=FALSE)> showGrob(depth=1)> showGrob(depth=2)> showGrob(depth=1:2)> showGrob(gt)> showGrob(gt, gPath="child")> showGrob(just="left", gp=gpar(col="red", cex=.5), rot=45)> showGrob(labelfun=function(grob, ...) {+ x <- grobX(grob, "west")+ y <- grobY(grob, "north")+ gTree(children=gList(rectGrob(x=x, y=y,+ width=stringWidth(grob$name) + unit(2, "mm"),+ height=stringHeight(grob$name) + unit(2, "mm"),+ gp=gpar(col=NA, fill=rgb(1, 0, 0, .5)),+ just=c("left", "top")),+ textGrob(grob$name,+ x=x + unit(1, "mm"), y=y - unit(1, "mm"),+ just=c("left", "top"))))+ })>> ## Not run:> ##D # Examples from higher-level packages> ##D> ##D library(lattice)> ##D # Ctrl-c after first example> ##D example(histogram)> ##D showGrob()> ##D showGrob(gPath="plot_01.ylab")> ##D> ##D library(ggplot2)> ##D # Ctrl-c after first example> ##D example(qplot)> ##D showGrob()> ##D showGrob(recurse=FALSE)> ##D showGrob(gPath="panel-3-3")> ##D showGrob(gPath="axis.title", grep=TRUE)> ##D showGrob(depth=2)> ## End(Not run)>>>> cleanEx()> nameEx("showViewport")> ### * showViewport>> flush(stderr()); flush(stdout())>> ### Name: showViewport> ### Title: Display grid viewports> ### Aliases: showViewport> ### Keywords: dplot>> ### ** Examples>> showViewport(viewport(width=.5, height=.5, name="vp"))>> grid.newpage()> pushViewport(viewport(width=.5, height=.5, name="vp"))> upViewport()> showViewport(vpPath("vp"))>> showViewport(vpStack(viewport(width=.5, height=.5, name="vp1"),+ viewport(width=.5, height=.5, name="vp2")),+ newpage=TRUE)>> showViewport(vpStack(viewport(width=.5, height=.5, name="vp1"),+ viewport(width=.5, height=.5, name="vp2")),+ fill=rgb(1:0, 0:1, 0, .1),+ newpage=TRUE)>>>> cleanEx()> nameEx("unit")> ### * unit>> flush(stderr()); flush(stdout())>> ### Name: unit> ### Title: Function to Create a Unit Object> ### Aliases: unit is.unit> ### Keywords: dplot>> ### ** Examples>> unit(1, "npc")[1] 1npc> unit(1:3/4, "npc")[1] 0.25npc 0.5npc 0.75npc> unit(1:3/4, "npc") + unit(1, "inches")[1] sum(0.25npc, 1inches) sum(0.5npc, 1inches) sum(0.75npc, 1inches)> min(unit(0.5, "npc"), unit(1, "inches"))[1] min(0.5npc, 1inches)> unit.c(unit(0.5, "npc"), unit(2, "inches") + unit(1:3/4, "npc"),+ unit(1, "strwidth", "hi there"))[1] 0.5npc sum(2inches, 0.25npc) sum(2inches, 0.5npc)[4] sum(2inches, 0.75npc) 1strwidth> x <- unit(1:5, "npc")> x[2:4][1] 2npc 3npc 4npc> x[2:4] <- unit(1, "mm")> x[1] 1npc 1mm 1mm 1mm 5npc>>>> cleanEx()> nameEx("unit.length")> ### * unit.length>> flush(stderr()); flush(stdout())>> ### Name: unit.length> ### Title: Length of a Unit Object> ### Aliases: unit.length> ### Keywords: dplot>> ### ** Examples>> length(unit(1:3, "npc"))[1] 3> length(unit(1:3, "npc") + unit(1, "inches"))[1] 3> length(max(unit(1:3, "npc") + unit(1, "inches")))[1] 1> length(max(unit(1:3, "npc") + unit(1, "strwidth", "a"))*4)[1] 1> length(unit(1:3, "npc") + unit(1, "strwidth", "a")*4)[1] 3>>>> cleanEx()> nameEx("unit.pmin")> ### * unit.pmin>> flush(stderr()); flush(stdout())>> ### Name: unit.pmin> ### Title: Parallel Unit Minima and Maxima> ### Aliases: unit.pmin unit.pmax unit.psum> ### Keywords: dplot>> ### ** Examples>> max(unit(1:3, "cm"), unit(0.5, "npc"))[1] max(1cm, 2cm, 3cm, 0.5npc)> unit.pmax(unit(1:3, "cm"), unit(0.5, "npc"))[1] max(1cm, 0.5npc) max(2cm, 0.5npc) max(3cm, 0.5npc)>>>> cleanEx()> nameEx("unit.rep")> ### * unit.rep>> flush(stderr()); flush(stdout())>> ### Name: unit.rep> ### Title: Replicate Elements of Unit Objects> ### Aliases: unit.rep> ### Keywords: dplot>> ### ** Examples>> rep(unit(1:3, "npc"), 3)[1] 1npc 2npc 3npc 1npc 2npc 3npc 1npc 2npc 3npc> rep(unit(1:3, "npc"), 1:3)[1] 1npc 2npc 2npc 3npc 3npc 3npc> rep(unit(1:3, "npc") + unit(1, "inches"), 3)[1] sum(1npc, 1inches) sum(2npc, 1inches) sum(3npc, 1inches) sum(1npc, 1inches)[5] sum(2npc, 1inches) sum(3npc, 1inches) sum(1npc, 1inches) sum(2npc, 1inches)[9] sum(3npc, 1inches)> rep(max(unit(1:3, "npc") + unit(1, "inches")), 3)[1] max(sum(1npc, 1inches), sum(2npc, 1inches), sum(3npc, 1inches))[2] max(sum(1npc, 1inches), sum(2npc, 1inches), sum(3npc, 1inches))[3] max(sum(1npc, 1inches), sum(2npc, 1inches), sum(3npc, 1inches))> rep(max(unit(1:3, "npc") + unit(1, "strwidth", "a"))*4, 3)[1] 4*max(sum(1npc, 1strwidth), sum(2npc, 1strwidth), sum(3npc, 1strwidth))[2] 4*max(sum(1npc, 1strwidth), sum(2npc, 1strwidth), sum(3npc, 1strwidth))[3] 4*max(sum(1npc, 1strwidth), sum(2npc, 1strwidth), sum(3npc, 1strwidth))> rep(unit(1:3, "npc") + unit(1, "strwidth", "a")*4, 3)[1] sum(1npc, 4strwidth) sum(2npc, 4strwidth) sum(3npc, 4strwidth)[4] sum(1npc, 4strwidth) sum(2npc, 4strwidth) sum(3npc, 4strwidth)[7] sum(1npc, 4strwidth) sum(2npc, 4strwidth) sum(3npc, 4strwidth)>>>> cleanEx()> nameEx("unitType")> ### * unitType>> flush(stderr()); flush(stdout())>> ### Name: unitType> ### Title: Return the Units of a Unit Object> ### Aliases: unitType> ### Keywords: dplot>> ### ** Examples>> u <- unit(1:5, c("cm", "mm", "in", "pt", "null"))>> unitType(u)[1] "cm" "mm" "inches" "points" "null"> unitType(unit(1, "npc"))[1] "npc"> unitType(unit(1:3/4, "npc"))[1] "npc" "npc" "npc"> unitType(unit(1:3/4, "npc") + unit(1, "inches"))[1] "sum" "sum" "sum"> unitType(min(unit(0.5, "npc"), unit(1, "inches")))[1] "min"> unitType(unit.c(unit(0.5, "npc"), unit(2, "inches") + unit(1:3/4, "npc"),+ unit(1, "strwidth", "hi there")))[1] "npc" "sum" "sum" "sum" "strwidth"> unitType(min(unit(1, "in"), unit(1, "npc") + unit(1, "mm")))[1] "min">> unitType(u, recurse=TRUE)$cm[1] "cm"$mm[1] "mm"$inches[1] "inches"$points[1] "points"$null[1] "null"> unitType(unit(1, "npc"), recurse=TRUE)$npc[1] "npc"> unitType(unit(1:3/4, "npc"), recurse=TRUE)$npc[1] "npc"$npc[1] "npc"$npc[1] "npc"> unitType(unit(1:3/4, "npc") + unit(1, "inches"), recurse=TRUE)$sum$sum$npc[1] "npc"$sum$inches[1] "inches"$sum$sum$npc[1] "npc"$sum$inches[1] "inches"$sum$sum$npc[1] "npc"$sum$inches[1] "inches"> unitType(min(unit(0.5, "npc"), unit(1, "inches")), recurse=TRUE)$min$min$npc[1] "npc"$min$inches[1] "inches"> unitType(unit.c(unit(0.5, "npc"), unit(2, "inches") + unit(1:3/4, "npc"),+ unit(1, "strwidth", "hi there")), recurse=TRUE)$npc[1] "npc"$sum$sum$inches[1] "inches"$sum$npc[1] "npc"$sum$sum$inches[1] "inches"$sum$npc[1] "npc"$sum$sum$inches[1] "inches"$sum$npc[1] "npc"$strwidth[1] "strwidth"> unitType(min(unit(1, "in"), unit(1, "npc") + unit(1, "mm")), recurse=TRUE)$min$min$inches[1] "inches"$min$sum$min$sum$npc[1] "npc"$min$sum$mm[1] "mm"> unlist(unitType(min(unit(1, "in"), unit(1, "npc") + unit(1, "mm")),+ recurse=TRUE))min.inches min.sum.npc min.sum.mm"inches" "npc" "mm">>>> cleanEx()> nameEx("viewport")> ### * viewport>> flush(stderr()); flush(stdout())>> ### Name: Grid Viewports> ### Title: Create a Grid Viewport> ### Aliases: viewport vpList vpStack vpTree> ### Keywords: dplot>> ### ** Examples>> # Diagram of a sample viewport> grid.show.viewport(viewport(x=0.6, y=0.6,+ width=unit(1, "inches"), height=unit(1, "inches")))> # Demonstrate viewport clipping> clip.demo <- function(i, j, clip1, clip2) {+ pushViewport(viewport(layout.pos.col=i,+ layout.pos.row=j))+ pushViewport(viewport(width=0.6, height=0.6, clip=clip1))+ grid.rect(gp=gpar(fill="white"))+ grid.circle(r=0.55, gp=gpar(col="red", fill="pink"))+ popViewport()+ pushViewport(viewport(width=0.6, height=0.6, clip=clip2))+ grid.polygon(x=c(0.5, 1.1, 0.6, 1.1, 0.5, -0.1, 0.4, -0.1),+ y=c(0.6, 1.1, 0.5, -0.1, 0.4, -0.1, 0.5, 1.1),+ gp=gpar(col="blue", fill="light blue"))+ popViewport(2)+ }>> grid.newpage()> grid.rect(gp=gpar(fill="grey"))> pushViewport(viewport(layout=grid.layout(2, 2)))> clip.demo(1, 1, FALSE, FALSE)> clip.demo(1, 2, TRUE, FALSE)> clip.demo(2, 1, FALSE, TRUE)> clip.demo(2, 2, TRUE, TRUE)> popViewport()> # Demonstrate turning clipping off> grid.newpage()> pushViewport(viewport(width=.5, height=.5, clip="on"))> grid.rect()> grid.circle(r=.6, gp=gpar(lwd=10))> pushViewport(viewport(clip="inherit"))> grid.circle(r=.6, gp=gpar(lwd=5, col="grey"))> pushViewport(viewport(clip="off"))> grid.circle(r=.6)> popViewport(3)> # Demonstrate vpList, vpStack, and vpTree> grid.newpage()> tree <- vpTree(viewport(width=0.8, height=0.8, name="A"),+ vpList(vpStack(viewport(x=0.1, y=0.1, width=0.5, height=0.5,+ just=c("left", "bottom"), name="B"),+ viewport(x=0.1, y=0.1, width=0.5, height=0.5,+ just=c("left", "bottom"), name="C"),+ viewport(x=0.1, y=0.1, width=0.5, height=0.5,+ just=c("left", "bottom"), name="D")),+ viewport(x=0.5, width=0.4, height=0.9,+ just="left", name="E")))> pushViewport(tree)> for (i in LETTERS[1:5]) {+ seekViewport(i)+ grid.rect()+ grid.text(current.vpTree(FALSE),+ x=unit(1, "mm"), y=unit(1, "npc") - unit(1, "mm"),+ just=c("left", "top"),+ gp=gpar(fontsize=8))+ }>>>> cleanEx()> nameEx("viewportTransform")> ### * viewportTransform>> flush(stderr()); flush(stdout())>> ### Name: viewportTransform> ### Title: Define a Group Transformation> ### Aliases: viewportTransform viewportTranslate viewportScale> ### viewportRotate defnTranslate defnScale defnRotate useTranslate> ### useScale useRotate groupTranslate groupScale groupRotate groupShear> ### groupFlip> ### Keywords: dplot>> ### ** Examples>> ## NOTE: on devices without support for groups nothing will be drawn> grid.newpage()> ## Define and use group in same viewport> pushViewport(viewport(width=.2, height=.2))> grid.define(circleGrob(gp=gpar(lwd=5)), name="circle")> grid.use("circle")> popViewport()> ## Use group in viewport that is translated and scaled> pushViewport(viewport(x=.2, y=.2, width=.1, height=.1))> grid.use("circle")> popViewport()> ## Use group in viewport that is translated and scaled> ## BUT only make use of the translation> pushViewport(viewport(x=.2, y=.8, width=.1, height=.1))> grid.use("circle", transform=viewportTranslate)> popViewport()> ## Use group in viewport that is translated and scaled> ## unevenly (distorted)> pushViewport(viewport(x=.8, y=.7, width=.2, height=.4))> grid.use("circle")> popViewport()>>>> cleanEx()> nameEx("viewports")> ### * viewports>> flush(stderr()); flush(stdout())>> ### Name: Working with Viewports> ### Title: Maintaining and Navigating the Grid Viewport Tree> ### Aliases: pushViewport downViewport seekViewport popViewport upViewport> ### Keywords: dplot>> ### ** Examples>> # push the same viewport several times> grid.newpage()> vp <- viewport(width=0.5, height=0.5)> pushViewport(vp)> grid.rect(gp=gpar(col="blue"))> grid.text("Quarter of the device",+ y=unit(1, "npc") - unit(1, "lines"), gp=gpar(col="blue"))> pushViewport(vp)> grid.rect(gp=gpar(col="red"))> grid.text("Quarter of the parent viewport",+ y=unit(1, "npc") - unit(1, "lines"), gp=gpar(col="red"))> popViewport(2)> # push several viewports then navigate amongst them> grid.newpage()> grid.rect(gp=gpar(col="grey"))> grid.text("Top-level viewport",+ y=unit(1, "npc") - unit(1, "lines"), gp=gpar(col="grey"))> if (interactive()) Sys.sleep(1.0)> pushViewport(viewport(width=0.8, height=0.7, name="A"))> grid.rect(gp=gpar(col="blue"))> grid.text("1. Push Viewport A",+ y=unit(1, "npc") - unit(1, "lines"), gp=gpar(col="blue"))> if (interactive()) Sys.sleep(1.0)> pushViewport(viewport(x=0.1, width=0.3, height=0.6,+ just="left", name="B"))> grid.rect(gp=gpar(col="red"))> grid.text("2. Push Viewport B (in A)",+ y=unit(1, "npc") - unit(1, "lines"), gp=gpar(col="red"))> if (interactive()) Sys.sleep(1.0)> upViewport(1)> grid.text("3. Up from B to A",+ y=unit(1, "npc") - unit(2, "lines"), gp=gpar(col="blue"))> if (interactive()) Sys.sleep(1.0)> pushViewport(viewport(x=0.5, width=0.4, height=0.8,+ just="left", name="C"))> grid.rect(gp=gpar(col="green"))> grid.text("4. Push Viewport C (in A)",+ y=unit(1, "npc") - unit(1, "lines"), gp=gpar(col="green"))> if (interactive()) Sys.sleep(1.0)> pushViewport(viewport(width=0.8, height=0.6, name="D"))> grid.rect()> grid.text("5. Push Viewport D (in C)",+ y=unit(1, "npc") - unit(1, "lines"))> if (interactive()) Sys.sleep(1.0)> upViewport(0)> grid.text("6. Up from D to top-level",+ y=unit(1, "npc") - unit(2, "lines"), gp=gpar(col="grey"))> if (interactive()) Sys.sleep(1.0)> downViewport("D")> grid.text("7. Down from top-level to D",+ y=unit(1, "npc") - unit(2, "lines"))> if (interactive()) Sys.sleep(1.0)> seekViewport("B")> grid.text("8. Seek from D to B",+ y=unit(1, "npc") - unit(2, "lines"), gp=gpar(col="red"))> pushViewport(viewport(width=0.9, height=0.5, name="A"))> grid.rect()> grid.text("9. Push Viewport A (in B)",+ y=unit(1, "npc") - unit(1, "lines"))> if (interactive()) Sys.sleep(1.0)> seekViewport("A")> grid.text("10. Seek from B to A (in ROOT)",+ y=unit(1, "npc") - unit(3, "lines"), gp=gpar(col="blue"))> if (interactive()) Sys.sleep(1.0)> seekViewport(vpPath("B", "A"))> grid.text("11. Seek from\nA (in ROOT)\nto A (in B)")> popViewport(0)>>>> cleanEx()> nameEx("vpPath")> ### * vpPath>> flush(stderr()); flush(stdout())>> ### Name: vpPath> ### Title: Concatenate Viewport Names> ### Aliases: vpPath> ### Keywords: dplot>> ### ** Examples>> vpPath("vp1", "vp2")vp1::vp2>>>> cleanEx()> nameEx("xsplinePoints")> ### * xsplinePoints>> flush(stderr()); flush(stdout())>> ### Name: xsplinePoints> ### Title: Return the points that would be used to draw an xspline (or a> ### Bezier curve)> ### Aliases: xsplinePoints bezierPoints> ### Keywords: dplot>> ### ** Examples>> grid.newpage()> xsg <- xsplineGrob(c(.1, .1, .9, .9), c(.1, .9, .9, .1), shape=1)> grid.draw(xsg)> trace <- xsplinePoints(xsg)> grid.circle(trace$x, trace$y, default.units="inches", r=unit(.5, "mm"))>> grid.newpage()> vp <- viewport(width=.5)> xg <- xsplineGrob(x=c(0, .2, .4, .2, .5, .7, .9, .7),+ y=c(.5, 1, .5, 0, .5, 1, .5, 0),+ id=rep(1:2, each=4),+ shape=1,+ vp=vp)> grid.draw(xg)> trace <- xsplinePoints(xg)> pushViewport(vp)> invisible(lapply(trace, function(t) grid.lines(t$x, t$y, gp=gpar(col="red"))))> popViewport()>> grid.newpage()> bg <- bezierGrob(c(.2, .2, .8, .8), c(.2, .8, .8, .2))> grid.draw(bg)> trace <- bezierPoints(bg)> grid.circle(trace$x, trace$y, default.units="inches", r=unit(.5, "mm"))>>>> ### * <FOOTER>> ###> cleanEx()> options(digits = 7L)> base::cat("Time elapsed: ", proc.time() - base::get("ptime", pos = 'CheckExEnv'),"\n")Time elapsed: 0.464 0.026 0.493 0 0> grDevices::dev.off()null device1> ###> ### Local variables: ***> ### mode: outline-minor ***> ### outline-regexp: "\\(> \\)?### [*]+" ***> ### End: ***> quit('no')