| R version 3.6.2 Patched (2020-02-12 r77795) -- "Dark and Stormy Night" | |
| Copyright (C) 2020 The R Foundation for Statistical Computing | |
| Platform: x86_64-pc-linux-gnu (64-bit) | |
| R 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. | |
| Natural language support but running in an English locale | |
| 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, | |
| + w=unit(1, "inches"), h=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] 1 | |
| attr(,"class") | |
| [1] "arrow" | |
| > | |
| > | |
| > | |
| > 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.65::A::C::D | |
| > upViewport(1) | |
| > current.vpPath() | |
| GRID.VP.65::A::C | |
| > current.vpTree() | |
| viewport[ROOT]->(viewport[GRID.VP.65]->(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] 1in | |
| $y | |
| [1] 1in | |
| > | |
| > ## 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.7in | |
| $y | |
| [1] 2.75in | |
| > 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.39165408813987in | |
| $y | |
| [1] 3.20650635094611in | |
| > 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.171" "GRID.rect.172" "GRID.circle.173" | |
| [4] "GRID.circle.174" "GRID.rect.175" "GRID.rect.176" | |
| [7] "GRID.segments.177" "GRID.segments.178" | |
| > | |
| > | |
| > | |
| > 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(w = .8, h = .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.253 | |
| xax | |
| > # Force xaxis | |
| > grid.force() | |
| > grid.ls() | |
| GRID.text.253 | |
| xax | |
| major | |
| ticks | |
| labels | |
| > # Revert xaxis | |
| > grid.revert() | |
| > grid.ls() | |
| GRID.text.253 | |
| xax | |
| > # Draw and force yaxis | |
| > grid.force(yaxisGrob(), draw=TRUE) | |
| forcedgrob[GRID.yaxis.254] | |
| > grid.ls() | |
| GRID.text.253 | |
| xax | |
| GRID.yaxis.254 | |
| major | |
| ticks | |
| labels | |
| > # Revert yaxis | |
| > grid.revert() | |
| > grid.ls() | |
| GRID.text.253 | |
| xax | |
| GRID.yaxis.254 | |
| > # Force JUST xaxis | |
| > grid.force("xax") | |
| > grid.ls() | |
| GRID.text.253 | |
| xax | |
| major | |
| ticks | |
| labels | |
| GRID.yaxis.254 | |
| > # Force ALL | |
| > grid.force() | |
| > grid.ls() | |
| GRID.text.253 | |
| xax | |
| major | |
| ticks | |
| labels | |
| GRID.yaxis.254 | |
| major | |
| ticks | |
| labels | |
| > # Revert JUST xaxis | |
| > grid.revert("xax") | |
| > grid.ls() | |
| GRID.text.253 | |
| xax | |
| GRID.yaxis.254 | |
| major | |
| ticks | |
| labels | |
| > | |
| > | |
| > | |
| > 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(w=.5, h=.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 | |
| > ### 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.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) | |
| parent | |
| child | |
| > # Show viewports too | |
| > grid.ls(sampleGTree, view=TRUE) | |
| parent | |
| vp1 | |
| vp2 | |
| 2 | |
| vp1 | |
| vp2 | |
| child | |
| 2 | |
| > # Only show viewports | |
| > grid.ls(sampleGTree, view=TRUE, grob=FALSE) | |
| vp1 | |
| vp2 | |
| 2 | |
| vp1 | |
| vp2 | |
| 2 | |
| > # Alternate displays | |
| > # nested listing, custom indent | |
| > grid.ls(sampleGTree, view=TRUE, print=nestedListing, gindent="--") | |
| parent | |
| --vp1 | |
| ----vp2 | |
| ------2 | |
| --vp1 | |
| ----vp2 | |
| ------child | |
| ------2 | |
| > # path listing | |
| > grid.ls(sampleGTree, view=TRUE, print=pathListing) | |
| | parent | |
| vp1 | |
| vp1::vp2 | |
| vp1::vp2::2 | |
| vp1 | |
| vp1::vp2 | |
| vp1::vp2 | parent::child | |
| vp1::vp2::2 | |
| > # path listing, without grobs aligned | |
| > grid.ls(sampleGTree, view=TRUE, print=pathListing, gAlign=FALSE) | |
| | parent | |
| vp1 | |
| vp1::vp2 | |
| vp1::vp2::2 | |
| vp1 | |
| vp1::vp2 | |
| vp1::vp2 | parent::child | |
| vp1::vp2::2 | |
| > # grob path listing | |
| > grid.ls(sampleGTree, view=TRUE, print=grobPathListing) | |
| | parent | |
| vp1::vp2 | parent::child | |
| > # path listing, grobs only | |
| > grid.ls(sampleGTree, print=pathListing) | |
| | parent | |
| | parent::child | |
| > # path listing, viewports only | |
| > grid.ls(sampleGTree, view=TRUE, grob=FALSE, print=pathListing) | |
| vp1 | |
| vp1::vp2 | |
| vp1::vp2::2 | |
| vp1 | |
| vp1::vp2 | |
| vp1::vp2::2 | |
| > # raw flat listing | |
| > str(grid.ls(sampleGTree, view=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, w=0.25, h=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, w=.1, interp=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=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, | |
| + w=unit(1, "inches"), h=unit(1, "inches"))) | |
| > grid.show.viewport(viewport(layout.pos.row=2, layout.pos.col=2:3), | |
| + grid.layout(3, 4)) | |
| > | |
| > | |
| > | |
| > 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=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 | |
| > ### 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] 0.25npc+1inches 0.5npc+1inches 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 2inches+0.25npc 2inches+0.5npc 2inches+0.75npc | |
| [5] 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 | |
| > ### 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] 1npc+1inches 2npc+1inches 3npc+1inches 1npc+1inches 2npc+1inches | |
| [6] 3npc+1inches 1npc+1inches 2npc+1inches 3npc+1inches | |
| > rep(max(unit(1:3, "npc") + unit(1, "inches")), 3) | |
| [1] max(1npc+1inches, 2npc+1inches, 3npc+1inches) | |
| [2] max(1npc+1inches, 2npc+1inches, 3npc+1inches) | |
| [3] max(1npc+1inches, 2npc+1inches, 3npc+1inches) | |
| > rep(max(unit(1:3, "npc") + unit(1, "strwidth", "a"))*4, 3) | |
| [1] 4*max(1npc+1strwidth, 2npc+1strwidth, 3npc+1strwidth) | |
| [2] 4*max(1npc+1strwidth, 2npc+1strwidth, 3npc+1strwidth) | |
| [3] 4*max(1npc+1strwidth, 2npc+1strwidth, 3npc+1strwidth) | |
| > rep(unit(1:3, "npc") + unit(1, "strwidth", "a")*4, 3) | |
| [1] 1npc+4*1strwidth 2npc+4*1strwidth 3npc+4*1strwidth 1npc+4*1strwidth | |
| [5] 2npc+4*1strwidth 3npc+4*1strwidth 1npc+4*1strwidth 2npc+4*1strwidth | |
| [9] 3npc+4*1strwidth | |
| > | |
| > | |
| > | |
| > 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, | |
| + w=unit(1, "inches"), h=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(w=.5, h=.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(w=0.8, h=0.8, name="A"), | |
| + vpList(vpStack(viewport(x=0.1, y=0.1, w=0.5, h=0.5, | |
| + just=c("left", "bottom"), name="B"), | |
| + viewport(x=0.1, y=0.1, w=0.5, h=0.5, | |
| + just=c("left", "bottom"), name="C"), | |
| + viewport(x=0.1, y=0.1, w=0.5, h=0.5, | |
| + just=c("left", "bottom"), name="D")), | |
| + viewport(x=0.5, w=0.4, h=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("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: 1.675 0.023 1.706 0 0 | |
| > grDevices::dev.off() | |
| null device | |
| 1 | |
| > ### | |
| > ### Local variables: *** | |
| > ### mode: outline-minor *** | |
| > ### outline-regexp: "\\(> \\)?### [*]+" *** | |
| > ### End: *** | |
| > quit('no') |