Title: | A 'ggplot2' Extension for Consistent Axis Alignment |
Version: | 1.0.2 |
Description: | A 'ggplot2' extension offers various tools the creation of complex, multi-plot visualizations. Built on the familiar grammar of graphics, it provides intuitive tools to align and organize plots, making it ideal for complex visualizations. It excels in multi-omics research—such as genomics and microbiomes—by simplifying the visualization of intricate relationships between datasets, for example, linking genes to pathways. Whether you need to stack plots, arrange them around a central figure, or create a circular layout, 'ggalign' delivers flexibility and accuracy with minimal effort. |
License: | MIT + file LICENSE |
URL: | https://github.com/Yunuuuu/ggalign, https://yunuuuu.github.io/ggalign/ |
BugReports: | https://github.com/Yunuuuu/ggalign/issues |
Depends: | ggplot2 (≥ 3.5.0) |
Imports: | vctrs (≥ 0.5.0), rlang, cli, grDevices, grid, gtable, scales, methods, stats, utils, lifecycle |
Suggests: | gridGraphics, ragg, magick, testthat (≥ 3.0.0), vdiffr |
Enhances: | patchwork, ggrastr, maftools |
ByteCompile: | true |
Config/Needs/website: | bench, pheatmap, gplots, maftools, ComplexHeatmap |
Config/testthat/edition: | 3 |
Encoding: | UTF-8 |
RoxygenNote: | 7.3.2 |
Language: | en-GB |
Collate: | 'active.R' 'alignpatch-.R' 'alignpatch-align_plots.R' 'alignpatch-alignpatches.R' 'alignpatch-area.R' 'alignpatch-build.R' 'alignpatch-free-align.R' 'alignpatch-free-border.R' 'alignpatch-free-guide.R' 'alignpatch-free-lab.R' 'alignpatch-free-space.R' 'alignpatch-free-vp.R' 'alignpatch-ggplot2.R' 'alignpatch-guides.R' 'alignpatch-inset.R' 'alignpatch-patch.R' 'alignpatch-patchwork.R' 'alignpatch-title.R' 'alignpatch-wrap.R' 'attributes.R' 'craftbox-.R' 'craft-align-.R' 'craft-align-hclust.R' 'craft-align-dendrogram.R' 'craft-align-group.R' 'craft-align-kmeans.R' 'craft-align-order.R' 'craft-align-order2.R' 'craft-align-phylo.R' 'craft-cross-.R' 'craft-cross-link.R' 'craft-cross-mark.R' 'craft-cross-none.R' 'fortify-data-frame-.R' 'fortify-data-frame-dendrogram.R' 'fortify-matrix-.R' 'fortify-matrix-list.R' 'fortify-matrix-maftools.R' 'fortify-matrix-matrix.R' 'ggalign-package.R' 'ggalign.R' 'ggcross.R' 'ggfree.R' 'ggmark.R' 'ggplot-coord-circle.R' 'ggplot-facet-sector.R' 'ggplot-geom-draw.R' 'ggplot-geom-gshape.R' 'ggplot-geom-pie.R' 'ggplot-geom-rect3d.R' 'ggplot-geom-subrect.R' 'ggplot-helper.R' 'ggplot-theme.R' 'ggplot-utils.R' 'grid-grob-channel.R' 'grid-grob-magick.R' 'grid-utils.R' 'import-standalone-assert.R' 'import-standalone-obj-type.R' 'import-standalone-pkg.R' 'import-standalone-purrr.R' 'import-standalone-tibble.R' 'layer-order.R' 'layout-.R' 'layout-align.R' 'layout-chain-.R' 'layout-chain-circle-.R' 'layout-chain-circle-build.R' 'layout-chain-circle-switch.R' 'layout-chain-operator.R' 'layout-chain-stack-.R' 'layout-chain-stack-build.R' 'layout-chain-stack-composer.R' 'layout-chain-stack-cross.R' 'layout-chain-stack-switch.R' 'layout-quad-.R' 'layout-heatmap-.R' 'layout-heatmap-build.R' 'layout-heatmap-oncoplot.R' 'layout-quad-operator.R' 'layout-operator.R' 'layout-quad-add.R' 'layout-quad-build.R' 'layout-quad-switch.R' 'layout-quad-upset.R' 'link.R' 'mark.R' 'object-name.R' 'pair-links.R' 'raster-magick.R' 'rasterise.R' 'scheme-.R' 'scheme-align.R' 'scheme-data.R' 'scheme-theme.R' 'tune.R' 'utils-assert.R' 'utils-rd.R' 'utils.R' 'with_quad.R' 'zzz.R' |
NeedsCompilation: | no |
Packaged: | 2025-05-14 13:40:56 UTC; yun |
Author: | Yun Peng |
Maintainer: | Yun Peng <yunyunp96@163.com> |
Repository: | CRAN |
Date/Publication: | 2025-05-14 14:00:08 UTC |
ggalign: A 'ggplot2' Extension for Consistent Axis Alignment
Description
A 'ggplot2' extension offers various tools the creation of complex, multi-plot visualizations. Built on the familiar grammar of graphics, it provides intuitive tools to align and organize plots, making it ideal for complex visualizations. It excels in multi-omics research—such as genomics and microbiomes—by simplifying the visualization of intricate relationships between datasets, for example, linking genes to pathways. Whether you need to stack plots, arrange them around a central figure, or create a circular layout, 'ggalign' delivers flexibility and accuracy with minimal effort.
Author(s)
Maintainer: Yun Peng yunyunp96@163.com (ORCID)
Authors:
Shixiang Wang w_shixiang@163.com (ORCID)
Other contributors:
Guangchuang Yu guangchuangyu@gmail.com (ORCID) [thesis advisor]
See Also
Useful links:
Report bugs at https://github.com/Yunuuuu/ggalign/issues
Subset a Layout
object
Description
Used by ggplot_build
and
ggsave
Usage
## S4 method for signature 'LayoutProto'
x$name
Arguments
x |
A |
name |
A string of slot name in |
Value
The slot value.
Add custom objects to ggalign plot
Description
Add custom objects to ggalign plot
Usage
## S4 method for signature 'CraftBox,ANY'
e1 + e2
Define the links to connect a pair of observations
Description
A base version of link_draw()
, optimized for performance. This function
serves as the foundation for building other link_*
functions that manage
the drawing of links between pairs of observations.
Usage
.link_draw(.draw, ...)
Arguments
.draw |
A function used to draw the links. The function must return a
|
... |
<dyn-dots> A list of formulas, where each side
of the formula should be an |
See Also
Define the links to connect the marked observations
Description
A base version of mark_draw
, designed for performance optimization. This
function is used to build other mark_*
functions that manage the drawing of
links between marked observations.
Usage
.mark_draw(.draw, ...)
Arguments
.draw |
A function used to draw the links. The function must return a
|
... |
<dyn-dots> A list of formulas, where each side
of the formula should be an |
See Also
A Layout
object
Description
A Layout
object defines how to place the plots.
Plot Adding Context Settings
Description
These settings control the behavior of the plot when added to a layout, as well as the arrangement of individual plot areas within the layout.
Usage
active(order = waiver(), use = waiver(), name = waiver())
Arguments
order |
An integer specifying the order of the plot area within the layout. |
use |
A logical ( |
name |
A string specifying the plot's name, useful for switching active
contexts through the |
Details
By default, the active context is set only for functions that add plot areas.
This allows other ggplot2
elements-such as geoms
, stats
, scales
, or
themes
- to be seamlessly added to the current plot area.
The default ordering of the plot areas is from top to bottom or from left to
right, depending on the layout orientation. However, users can customize this
order using the order
argument.
Create a New CraftBox
Object with CraftAlign
craftsman
Description
An CraftAlign
object interacts with the Layout
object to reorder or split
observations and, in some cases, add plot components to the Layout
.
Usage
align(
align,
data = NULL,
...,
plot = NULL,
size = NULL,
schemes = NULL,
no_axes = NULL,
active = NULL,
call = caller_call()
)
Arguments
align |
An |
data |
The following options can be used:
|
... |
Additional fields passed to the |
plot |
A ggplot object. |
size |
The relative size of the plot, can be specified as a
|
schemes |
Options for
|
no_axes |
|
active |
A |
call |
The |
Details
Each of the Align*
objects is just a ggproto()
object, descended from the top-level CraftAlign
, and each implements
various methods and fields.
To create a new type of Align*
object, you typically will want to
override one or more of the following:
-
setup_params
: Prepare parameter or check parameters used by this plot. -
setup_data
: Prepare data used by this plot. -
compute
: A method used to compute statistics. -
align
: A method used to group observations into panel or reorder observations. -
draw
: A method used to draw the plot. Must return aggplot
object.
Value
A new CraftBox
object.
Discrete Axis Alignment
It is important to note that we consider rows as observations, meaning
vec_size(data)
/NROW(data)
must match the number of observations along the
axis used for alignment (x-axis for a vertical stack layout, y-axis for a
horizontal stack layout).
Examples
align_dendro()
Plot dendrogram tree
Description
Plot dendrogram tree
Usage
align_dendro(
mapping = aes(),
...,
distance = "euclidean",
method = "complete",
use_missing = "pairwise.complete.obs",
reorder_dendrogram = FALSE,
merge_dendrogram = FALSE,
reorder_group = FALSE,
k = NULL,
h = NULL,
cutree = NULL,
plot_dendrogram = TRUE,
plot_cut_height = NULL,
root = NULL,
center = FALSE,
type = "rectangle",
size = NULL,
data = NULL,
no_axes = NULL,
active = NULL
)
Arguments
mapping |
Default list of aesthetic mappings to use for plot. If not specified, must be supplied in each layer added to the plot. |
... |
<dyn-dots> Additional arguments passed to
|
distance |
A string of distance measure to be used. This must be one of
|
method |
A string of the agglomeration method to be used. This should be
(an unambiguous abbreviation of) one of |
use_missing |
An optional character string giving a method for computing
covariances in the presence of missing values. This must be (an abbreviation
of) one of the strings |
reorder_dendrogram |
A single boolean value indicating whether to
reorder the dendrogram based on the means. Alternatively, you can provide a
custom function that accepts an |
merge_dendrogram |
A single boolean value, indicates whether we should
merge multiple dendrograms, only used when previous groups have been
established. Default: |
reorder_group |
A single boolean value, indicates whether we should do
Hierarchical Clustering between groups, only used when previous groups have
been established. Default: |
k |
An integer scalar indicates the desired number of groups. |
h |
A numeric scalar indicates heights where the tree should be cut. |
cutree |
A function used to cut the |
plot_dendrogram |
A boolean value indicates whether plot the dendrogram tree. |
plot_cut_height |
A boolean value indicates whether plot the cut height. |
root |
A length one string or numeric indicates the root branch. |
center |
A boolean value. if |
type |
A string indicates the plot type, |
size |
The relative size of the plot, can be specified as a
|
data |
A matrix-like object. By default, it inherits from the layout
|
no_axes |
|
active |
A |
ggplot2 specification
align_dendro
initializes a ggplot data
and mapping
.
The internal ggplot
object will always use a default mapping of
aes(x = .data$x, y = .data$y)
.
The default ggplot data is the node
coordinates with edge
data attached
in ggalign
attribute, in addition, a
geom_segment
layer with a data frame of the edge
coordinates will be added when plot_dendrogram = TRUE
.
See fortify_data_frame.dendrogram()
for details.
Discrete Axis Alignment
It is important to note that we consider rows as observations, meaning
vec_size(data)
/NROW(data)
must match the number of observations along the
axis used for alignment (x-axis for a vertical stack layout, y-axis for a
horizontal stack layout).
Examples
# align_dendro will always add a plot area
ggheatmap(matrix(rnorm(81), nrow = 9)) +
anno_top() +
align_dendro()
ggheatmap(matrix(rnorm(81), nrow = 9)) +
anno_top() +
align_dendro(k = 3L)
Group and align observations based on a group vector
Description
Splits observations into groups, with slice ordering based on group levels.
Usage
align_group(group, active = NULL)
Arguments
group |
A character define the groups of the observations. |
active |
A |
Examples
set.seed(1L)
small_mat <- matrix(rnorm(81), nrow = 9)
ggheatmap(small_mat) +
anno_top() +
align_group(sample(letters[1:4], ncol(small_mat), replace = TRUE))
Reorder or Group observations based on hierarchical clustering
Description
This function aligns observations within the layout according to a hierarchical clustering tree, enabling reordering or grouping of elements based on clustering results.
Usage
align_hclust(
distance = "euclidean",
method = "complete",
use_missing = "pairwise.complete.obs",
reorder_dendrogram = FALSE,
reorder_group = FALSE,
k = NULL,
h = NULL,
cutree = NULL,
data = NULL,
active = NULL
)
Arguments
distance |
A string of distance measure to be used. This must be one of
|
method |
A string of the agglomeration method to be used. This should be
(an unambiguous abbreviation of) one of |
use_missing |
An optional character string giving a method for computing
covariances in the presence of missing values. This must be (an abbreviation
of) one of the strings |
reorder_dendrogram |
A single boolean value indicating whether to
reorder the dendrogram based on the means. Alternatively, you can provide a
custom function that accepts an |
reorder_group |
A single boolean value, indicates whether we should do
Hierarchical Clustering between groups, only used when previous groups have
been established. Default: |
k |
An integer scalar indicates the desired number of groups. |
h |
A numeric scalar indicates heights where the tree should be cut. |
cutree |
A function used to cut the |
data |
A matrix-like object. By default, it inherits from the layout
|
active |
A |
Discrete Axis Alignment
It is important to note that we consider rows as observations, meaning
vec_size(data)
/NROW(data)
must match the number of observations along the
axis used for alignment (x-axis for a vertical stack layout, y-axis for a
horizontal stack layout).
See Also
Examples
# align_hclust won't add a dendrogram
ggheatmap(matrix(rnorm(81), nrow = 9)) +
anno_top() +
align_hclust(k = 3L)
Split observations by k-means clustering groups.
Description
Aligns and groups observations based on k-means clustering, enabling observation splits by cluster groups.
Usage
align_kmeans(..., data = NULL, active = NULL)
Arguments
... |
Arguments passed on to
|
data |
A numeric matrix to be used by k-means. By default, it will inherit from the layout matrix. |
active |
A |
Discrete Axis Alignment
It is important to note that we consider rows as observations, meaning
vec_size(data)
/NROW(data)
must match the number of observations along the
axis used for alignment (x-axis for a vertical stack layout, y-axis for a
horizontal stack layout).
Examples
ggheatmap(matrix(rnorm(81), nrow = 9)) +
anno_top() +
align_kmeans(3L)
Order observations based on weights
Description
Ordering observations based on summary weights or a specified ordering character or integer index.
Usage
align_order(
weights = rowMeans,
...,
reverse = FALSE,
strict = TRUE,
data = NULL,
active = NULL
)
Arguments
weights |
A summary function which accepts a data and returns the
weights for each observations. Alternatively, you can provide an ordering
index as either an integer or a character. Since characters have been
designated as character indices, if you wish to specify a function name as a
string, you must enclose it with |
... |
<dyn-dots> Additional arguments passed to
function provided in |
reverse |
A boolean value. Should the sort order be in reverse? |
strict |
A boolean value indicates whether the order should be strict.
If previous groups has been established, and strict is |
data |
A |
active |
A |
Discrete Axis Alignment
It is important to note that we consider rows as observations, meaning
vec_size(data)
/NROW(data)
must match the number of observations along the
axis used for alignment (x-axis for a vertical stack layout, y-axis for a
horizontal stack layout).
Examples
ggheatmap(matrix(rnorm(81), nrow = 9)) +
anno_left() +
align_order(I("rowMeans"))
Reorders layout observations based on specific statistics.
Description
Reorders layout observations based on specific statistics.
Usage
align_order2(
stat,
...,
reverse = FALSE,
strict = TRUE,
data = NULL,
active = NULL
)
Arguments
stat |
A statistical function which accepts a data and returns the
statistic, which we'll call |
... |
<dyn-dots> Additional arguments passed to
function provided in |
reverse |
A boolean value. Should the sort order be in reverse? |
strict |
A boolean value indicates whether the order should be strict.
If previous groups has been established, and strict is |
data |
A |
active |
A |
Details
The align_order2()
function differs from align_order()
in that the
weights
argument in align_order()
must return atomic weights for each
observation. In contrast, the stat
argument in align_order2()
can
return more complex structures, such as hclust or
dendrogram, among others.
Typically, you can achieve the functionality of align_order2()
using
align_order()
by manually extracting the ordering information from
the statistic.
Discrete Axis Alignment
It is important to note that we consider rows as observations, meaning
vec_size(data)
/NROW(data)
must match the number of observations along the
axis used for alignment (x-axis for a vertical stack layout, y-axis for a
horizontal stack layout).
See Also
Examples
ggheatmap(matrix(rnorm(81), nrow = 9)) +
anno_left() +
align_order2(hclust2)
Create ggplot object with layout panel data
Description
This function was deprecated because we realised that it's a special case of
the ggalign()
function. Please use ggalign(data = NULL)
instead.
Usage
align_panel(...)
ggpanel(...)
Plot Phylogenetics tree
Description
Plot Phylogenetics tree
Usage
align_phylo(
phylo,
...,
ladderize = NULL,
type = "rectangle",
center = FALSE,
tree_type = NULL,
no_axes = NULL,
active = NULL,
size = NULL
)
Arguments
phylo |
A |
... |
<dyn-dots> Additional arguments passed to
|
ladderize |
A single string of |
type |
A string indicates the plot type, |
center |
A boolean value. if |
tree_type |
A single string, one of
Usually, you don't need to modify this. |
no_axes |
|
active |
A |
size |
The relative size of the plot, can be specified as a
|
Arrange multiple plots into a grid
Description
Arrange multiple plots into a grid
Usage
align_plots(
...,
ncol = NULL,
nrow = NULL,
byrow = TRUE,
widths = NA,
heights = NA,
design = NULL,
guides = waiver(),
theme = NULL
)
Arguments
... |
<dyn-dots> A list of plots, ususally the
ggplot object. Use |
ncol , nrow |
The dimensions of the grid to create - if both are |
byrow |
If |
widths , heights |
The relative widths and heights of each column and row
in the grid. Will get repeated to match the dimensions of the grid. The
special value of |
design |
Specification of the location of areas in the layout. Can
either be specified as a text string or by concatenating calls to
|
guides |
A string with one or more of |
theme |
A |
Value
An alignpatches
object.
See Also
Examples
# directly copied from patchwork
p1 <- ggplot(mtcars) +
geom_point(aes(mpg, disp))
p2 <- ggplot(mtcars) +
geom_boxplot(aes(gear, disp, group = gear))
p3 <- ggplot(mtcars) +
geom_bar(aes(gear)) +
facet_wrap(~cyl)
p4 <- ggplot(mtcars) +
geom_bar(aes(carb))
p5 <- ggplot(mtcars) +
geom_violin(aes(cyl, mpg, group = cyl))
# Either add the plots as single arguments
align_plots(p1, p2, p3, p4, p5)
# Or use bang-bang-bang to add a list
align_plots(!!!list(p1, p2, p3), p4, p5)
# Match plots to areas by name
design <- "#BB
AA#"
align_plots(B = p1, A = p2, design = design)
# Compare to not using named plot arguments
align_plots(p1, p2, design = design)
Prepare plots to be aligned with align_plots
Description
Prepare plots to be aligned with align_plots
Usage
alignpatch(x)
Arguments
x |
A plot object to be prepared for alignment. |
Details
ggalign
has implement alignpatch
method for following objects:
Value
A Patch
object.
See Also
Examples
alignpatch(ggplot())
Define the plotting areas in align_plots
Description
This is a small helper used to specify a single area in a rectangular grid
that should contain a plot. Objects constructed with area()
can be
concatenated together with c()
in order to specify multiple areas.
Usage
area(t, l, b = t, r = l)
Arguments
t , b |
The top and bottom bounds of the area in the grid |
l , r |
The left and right bounds of the area int the grid |
Details
The grid that the areas are specified in reference to enumerate rows from top
to bottom, and coloumns from left to right. This means that t
and l
should always be less or equal to b
and r
respectively. Instead of
specifying area placement with a combination of area()
calls, it is
possible to instead pass in a single string
areas <- c(area(1, 1, 2, 1), area(2, 3, 3, 3))
is equivalent to
areas < -"A## A#B ##B"
Value
A ggalign_area
object.
Examples
p1 <- ggplot(mtcars) +
geom_point(aes(mpg, disp))
p2 <- ggplot(mtcars) +
geom_boxplot(aes(gear, disp, group = gear))
p3 <- ggplot(mtcars) +
geom_bar(aes(gear)) +
facet_wrap(~cyl)
layout <- c(
area(1, 1),
area(1, 3, 3),
area(3, 1, 3, 2)
)
# Show the layout to make sure it looks as it should
plot(layout)
# Apply it to a alignpatches
align_plots(p1, p2, p3, design = layout)
Create a Grob That Spans Multiple Viewports
Description
This function initializes a communication channel to share location signals
across different viewports. It returns a channelSenderGrob
object, which
can transmit multiple signals using its $signal
method (see the "Signal"
section below for details). When drawn, all collected signals are passed to
the make_content
function to generate the final grob
.
Usage
channelGrob(make_content, ..., name = NULL, vp = NULL)
Arguments
make_content |
A function that accepts the list of signal locations and
returns a |
... |
Additional arguments passed to |
name |
a character identifier for the grob. Used to find the grob on the display list and/or as a child of another grob. |
vp |
a |
Value
A channelSenderGrob
object.
Signal
A channelSenderGrob
can emit multiple location signals using the $signal
method. This method accepts the following arguments:
-
x
: X-coordinate. -
y
: Y-coordinate. -
default.units
: The default units forx
andy
. -
tag
: A character string used to identify the location. -
name
: A name for the returned grob. -
vp
: Aviewport
for the returned grob.
The $signal
method returns a channelSignalGrob
.
Examples
# we create a new channel, we will emit two singals
# here: we just add a line between the two signals
channel <- channelGrob(function(locations) {
# you can also use `tag` to identify the locations
loc1 <- .subset2(locations, 1L)
loc2 <- .subset2(locations, 2L)
grid::segmentsGrob(loc1$x, loc1$y, loc2$x, loc2$y)
})
gt <- gtable::gtable(unit(1:2, c("cm")), unit(5, "cm"))
gt <- gtable::gtable_add_grob(
gt,
list(
grid::rectGrob(gp = gpar(color = "black", fill = NA)),
channel$signal(0.5, 0.5, "npc")
),
t = 1, l = 1, name = c("rect1", "signal1")
)
gt <- gtable::gtable_add_grob(
gt,
list(
grid::rectGrob(gp = gpar(color = "red", fill = NA)),
channel$signal(0.5, 0.5, "npc")
),
t = 1, l = 2, name = c("rect2", "signal2")
)
grid::grid.newpage()
grid::grid.draw(gt)
Arrange plots in a circular layout
Description
If limits
is provided, a continuous variable will be required and aligned
in the direction specified (circle_continuous
). Otherwise, a discrete
variable will be required and aligned (circle_discrete
).
Usage
circle_layout(
data = NULL,
...,
radial = NULL,
direction = "outward",
sector_spacing = NULL,
limits = waiver(),
theme = NULL,
spacing_theta = deprecated()
)
circle_discrete(
data = NULL,
...,
radial = NULL,
direction = "outward",
sector_spacing = NULL,
theme = NULL,
spacing_theta = deprecated()
)
circle_continuous(
data = NULL,
...,
radial = NULL,
direction = "outward",
sector_spacing = NULL,
limits = NULL,
theme = NULL,
spacing_theta = deprecated()
)
Arguments
data |
Default dataset to use for the layout. If not specified, it must be supplied in each plot added to the layout:
|
... |
Additional arguments passed to |
radial |
A |
direction |
A single string of
|
sector_spacing |
The size of spacing between different panel. A numeric
of the radians or a |
limits |
A |
theme |
A |
spacing_theta |
Value
A CircleLayout
object.
Examples
set.seed(123)
small_mat <- matrix(rnorm(56), nrow = 7)
rownames(small_mat) <- paste0("row", seq_len(nrow(small_mat)))
colnames(small_mat) <- paste0("column", seq_len(ncol(small_mat)))
# circle_layout
# same for circle_discrete()
circle_layout(small_mat) +
ggalign() +
geom_tile(aes(y = .column_index, fill = value)) +
scale_fill_viridis_c() +
align_dendro(aes(color = branch), k = 3L) +
scale_color_brewer(palette = "Dark2")
# same for circle_continuous()
circle_layout(mpg, limits = continuous_limits(c(3, 5))) +
ggalign(mapping = aes(displ, hwy, colour = class)) +
geom_point(size = 2) +
ggalign(mapping = aes(displ, hwy, colour = class)) +
geom_point(size = 2) &
scale_color_brewer(palette = "Dark2") &
theme_bw()
# circle_discrete()
# direction outward
circle_discrete(small_mat) +
align_dendro(aes(color = branch), k = 3L) +
scale_color_brewer(palette = "Dark2") +
ggalign() +
geom_tile(aes(y = .column_index, fill = value)) +
scale_fill_viridis_c()
# direction inward
circle_discrete(small_mat, direction = "inward") +
ggalign() +
geom_tile(aes(y = .column_index, fill = value)) +
scale_fill_viridis_c() +
align_dendro(aes(color = branch), k = 3L) +
scale_color_brewer(palette = "Dark2")
# circle_continuous()
circle_continuous(mpg, limits = continuous_limits(c(3, 5))) +
ggalign(mapping = aes(displ, hwy, colour = class)) +
geom_point(size = 2) +
ggalign(mapping = aes(displ, hwy, colour = class)) +
geom_point(size = 2) &
scale_color_brewer(palette = "Dark2") &
theme_bw()
Determine the active context of circle layout
Description
Usage
circle_switch(radial = waiver(), direction = NULL, what = waiver(), ...)
Arguments
radial |
A |
direction |
A single string of
|
what |
What should get activated for the |
... |
These dots are for future extensions and must be empty. |
Value
A circle_switch
object which can be added to circle_layout()
.
Examples
set.seed(123)
small_mat <- matrix(rnorm(56), nrow = 7)
rownames(small_mat) <- paste0("row", seq_len(nrow(small_mat)))
colnames(small_mat) <- paste0("column", seq_len(ncol(small_mat)))
circle_discrete(small_mat) +
ggalign() +
geom_tile(aes(y = .column_index, fill = value)) +
scale_fill_viridis_c() +
align_dendro(aes(color = branch), k = 3L) +
scale_color_brewer(palette = "Dark2")
Set continuous limits for the layout
Description
To align continuous axes, it is important to keep the limits consistent
across all plots in the layout. You can set the limits by passing a function
directly to the limits
or xlim
/ylim
argument, using ...
only.
Alternatively, you can add a continuous_limits()
object to the layout. For
the quad_layout()
function, you must specify x
/y
arguments. For other
layouts, you should pass the limits using ...
directly.
Usage
continuous_limits(..., x = waiver(), y = waiver())
Arguments
... |
A list of two numeric values, specifying the left/lower limit and the right/upper limit of the scale. |
x , y |
Same as |
Polar Coordinates with Enhanced Controls
Description
An extended version of coord_radial()
, providing
additional customization options.
Usage
coord_circle(
theta = "x",
start = 0,
end = NULL,
thetalim = NULL,
rlim = NULL,
expand = FALSE,
direction = 1,
clip = "off",
r.axis.inside = NULL,
rotate.angle = FALSE,
inner.radius = 0,
outer.radius = 0.95
)
Arguments
theta |
variable to map angle to ( |
start |
Offset of starting point from 12 o'clock in radians. Offset
is applied clockwise or anticlockwise depending on value of |
end |
Position from 12 o'clock in radians where plot ends, to allow
for partial polar coordinates. The default, |
thetalim , rlim |
Limits for the |
expand |
If |
direction |
1, clockwise; -1, anticlockwise |
clip |
Should drawing be clipped to the extent of the plot panel? A
setting of |
r.axis.inside |
If |
rotate.angle |
If |
inner.radius |
A numeric in |
outer.radius |
A numeric in |
Examples
ggplot(mtcars, aes(disp, mpg)) +
geom_point() +
coord_circle(
start = -0.4 * pi, end = 0.4 * pi,
inner.radius = 0.3, outer.radius = 1
)
ggplot(mtcars, aes(disp, mpg)) +
geom_point() +
coord_circle(
start = -0.4 * pi, end = 0.4 * pi,
inner.radius = 0.3, outer.radius = 0.5
)
Add a plot to connect selected observations
Description
Add a plot to connect selected observations
Usage
cross_link(
link,
data = waiver(),
...,
on_top = TRUE,
obs_size = 1,
inherit_index = NULL,
inherit_panel = NULL,
inherit_nobs = NULL,
size = NULL,
active = NULL
)
Arguments
link |
A |
data |
The dataset to use for the layout. By default,
|
... |
<dyn-dots> Additional arguments passed to
|
on_top |
A boolean value indicating whether to draw the link on top of
the plot panel ( |
obs_size |
A single numeric value that indicates the size of a single
observation, ranging from |
inherit_index |
A boolean value indicating whether to inherit the
ordering index. If |
inherit_panel |
A boolean value indicating whether to inherit the
panel group. If |
inherit_nobs |
A boolean value indicating whether to inherit the
number of observations (nobs). If |
size |
The relative size of the plot, can be specified as a
|
active |
A |
ggplot2 Specification
The cross_link
function initializes a ggplot
object but does not
initialize any data. Using scheme_data()
to change the internal data if
needed.
Add a plot to annotate observations
Description
Add a plot to annotate observations
Usage
cross_mark(
mark,
data = waiver(),
...,
obs_size = 1,
inherit_index = NULL,
inherit_panel = NULL,
inherit_nobs = NULL,
size = NULL,
active = NULL
)
Arguments
mark |
A |
data |
The dataset to use for the layout. By default,
|
... |
<dyn-dots> Additional arguments passed to
|
obs_size |
A single numeric value that indicates the size of a single
observation, ranging from |
inherit_index |
A boolean value indicating whether to inherit the
ordering index. If |
inherit_panel |
A boolean value indicating whether to inherit the
panel group. If |
inherit_nobs |
A boolean value indicating whether to inherit the
number of observations (nobs). If |
size |
The relative size of the plot, can be specified as a
|
active |
A |
ggplot2 Specification
The cross_mark
function initializes a ggplot
object. The underlying data
contains following columns:
-
.panel
: the panel for the aligned axis. It meansx-axis
for vertical stack layout (including top and bottom annotation),y-axis
for horizontal stack layout (including left and right annotation). -
.names
(vec_names()
) and.index
(vec_size()
/NROW()
): a character names (only applicable when names exists) and an integer of index of the original data. -
.hand
: A factor with levelsc("left", "right")
for horizontal stack layouts, orc("top", "bottom")
for vertical stack layouts, indicating the position of the linked observations.
You can use scheme_data()
to modify the internal data if needed.
Reset layout ordering and panel group
Description
Reset layout ordering and panel group
Usage
cross_none(
data = waiver(),
...,
inherit_index = NULL,
inherit_panel = NULL,
inherit_nobs = NULL
)
Arguments
data |
The dataset to use for the layout. By default,
|
... |
<dyn-dots> Additional arguments passed to
|
inherit_index |
A boolean value indicating whether to inherit the
ordering index. If |
inherit_panel |
A boolean value indicating whether to inherit the
panel group. If |
inherit_nobs |
A boolean value indicating whether to inherit the
number of observations (nobs). If |
Key glyphs for legends
Description
Each geom has an associated function that draws the key when the geom needs
to be displayed in a legend. These functions are called draw_key_*()
, where
*
stands for the name of the respective key glyph. The key glyphs can be
customized for individual geoms by providing a geom with the key_glyph
argument. The draw_key_gshape
function provides this interface for custom
key glyphs used with geom_gshape()
.
Usage
draw_key_gshape(data, params, size)
Arguments
data |
A single row data frame containing the scaled aesthetics to display in this key |
params |
A list of additional parameters supplied to the geom. |
size |
Width and height of key in mm. |
Value
A grid grob.
Examples
p <- ggplot(economics, aes(date, psavert, color = "savings rate"))
# key glyphs can be specified by their name
p + geom_line(key_glyph = "timeseries")
# key glyphs can be specified via their drawing function
p + geom_line(key_glyph = draw_key_rect)
Theme curve elements
Description
Draw curve.
Usage
element_curve(
colour = NULL,
linewidth = NULL,
linetype = NULL,
lineend = NULL,
color = NULL,
curvature = NULL,
angle = NULL,
ncp = NULL,
shape = NULL,
arrow = NULL,
arrow.fill = NULL,
inherit.blank = FALSE
)
Arguments
colour , color |
Line/border colour. Color is an alias for colour. |
linewidth |
Line/border size in mm. |
linetype |
Line type. An integer (0:8), a name (blank, solid, dashed, dotted, dotdash, longdash, twodash), or a string with an even number (up to eight) of hexadecimal digits which give the lengths in consecutive positions in the string. |
lineend |
Line end Line end style (round, butt, square) |
curvature |
A numeric value giving the amount of curvature. Negative values produce left-hand curves, positive values produce right-hand curves, and zero produces a straight line. |
angle |
A numeric value between 0 and 180, giving an amount to skew the control points of the curve. Values less than 90 skew the curve towards the start point and values greater than 90 skew the curve towards the end point. |
ncp |
The number of control points used to draw the curve. More control points creates a smoother curve. |
shape |
A numeric vector of values between -1 and 1, which
control the shape of the curve relative to its control points.
See |
arrow |
A list describing arrow heads to place at either end
of the curve, as produced by the |
arrow.fill |
Fill colour for arrows. |
inherit.blank |
Should this element inherit the existence of an
|
Value
A element_curve
object
Theme Polygon elements
Description
Draw polygon.
Usage
element_polygon(
fill = NULL,
colour = NULL,
linewidth = NULL,
linetype = NULL,
alpha = NULL,
lineend = NULL,
linejoin = NULL,
linemitre = NULL,
color = NULL,
inherit.blank = FALSE
)
Arguments
fill |
Fill colour. |
colour , color |
Line/border colour. Color is an alias for colour. |
linewidth |
Line/border size in mm. |
linetype |
Line type. An integer (0:8), a name (blank, solid, dashed, dotted, dotdash, longdash, twodash), or a string with an even number (up to eight) of hexadecimal digits which give the lengths in consecutive positions in the string. |
alpha |
A transparency value between 0 (transparent) and 1 (opaque),
parallel to |
lineend |
Line end Line end style (round, butt, square) |
linejoin |
Line join style (round, mitre, bevel). |
linemitre |
Line mitre limit (number greater than 1). |
inherit.blank |
Should this element inherit the existence of an
|
Value
A element_polygon
object
See Also
Apply a function to the fields of an element object
Description
For an element
object, some fields are
vectorized, while others are not. This function allows you to apply a
function to the vectorized fields.
The following helper functions are available:
-
element_rep
: Appliesrep()
. -
element_rep_len
: Appliesrep_len()
. -
element_vec_recycle
: Appliesvec_recycle()
. -
element_vec_rep
: Appliesvec_rep()
. -
element_vec_rep_each
: Appliesvec_rep_each()
. -
element_vec_slice
: Appliesvec_slice()
.
Usage
element_vec(.el, .fn, ...)
element_rep(.el, ...)
element_rep_len(.el, length.out, ...)
element_vec_recycle(.el, size, ...)
element_vec_rep(.el, times, ...)
element_vec_rep_each(.el, times, ...)
element_vec_slice(.el, i, ...)
Arguments
.el |
An |
.fn |
The function to be applied to the vectorized fields of the element object. |
... |
Additional arguments passed on to |
length.out |
Non-negative integer. The desired length of the output
vector. Other inputs will be coerced to a double vector and the first element
taken. Ignored if |
size |
Desired output size. |
times |
For For |
i |
An integer, character or logical vector specifying the
locations or names of the observations to get/set. Specify
|
Polar coordinates with Facet support
Description
Draw each panel in a sector of the polar coordinate system. If
facet_sector()
is used in a ggplot, the coordinate system must be created
with coord_circle()
or coord_radial()
.
Usage
facet_sector(
facets,
sector_spacing = pi/180,
drop = TRUE,
radial = deprecated(),
spacing_theta = deprecated()
)
Arguments
facets |
A set of variables or expressions quoted by For compatibility with the classic interface, can also be a
formula or character vector. Use either a one sided formula, |
sector_spacing |
The size of spacing between different panel. A numeric
of the radians or a |
drop |
If |
radial |
|
spacing_theta |
Examples
ggplot(mtcars, aes(disp, mpg)) +
geom_point() +
facet_sector(vars(cyl)) +
coord_circle(
start = -0.4 * pi, end = 0.4 * pi, inner.radius = 0.3,
outer.radius = 0.8, expand = TRUE
)
Build a data frame
Description
This function converts various objects to a data frame.
Usage
fortify_data_frame(data, ..., data_arg = NULL, call = NULL)
Arguments
data |
An object to be converted to a data frame. |
... |
Arguments passed to methods. |
data_arg |
The argument name for |
call |
The execution environment where |
Value
A data frame.
fortify_data_frame
method collections
Build a data frame
Description
This function converts various objects to a data frame.
Usage
## S3 method for class 'character'
fortify_data_frame(data, ..., data_arg = NULL, call = NULL)
## S3 method for class 'numeric'
fortify_data_frame(data, ..., data_arg = NULL, call = NULL)
## S3 method for class 'logical'
fortify_data_frame(data, ..., data_arg = NULL, call = NULL)
## S3 method for class 'complex'
fortify_data_frame(data, ..., data_arg = NULL, call = NULL)
Arguments
data |
An object to be converted to a data frame. |
... |
These dots are for future extensions and must be empty. |
data_arg |
The argument name for |
call |
The execution environment where |
Value
A data frame with following columns:
-
.names
: the names for the vector (only applicable if names exist). -
value
: the actual value of the vector.
See Also
Other fortify_data_frame()
methods:
fortify_data_frame.default()
,
fortify_data_frame.dendrogram()
,
fortify_data_frame.matrix()
,
fortify_data_frame.phylo()
Build a data frame
Description
This function converts various objects to a data frame.
Usage
## Default S3 method:
fortify_data_frame(data, ..., data_arg = NULL, call = NULL)
Arguments
data |
An object to be converted to a data frame. |
... |
Additional arguments passed to |
data_arg |
The argument name for |
call |
The execution environment where |
Details
By default, it calls fortify()
to build the
data frame.
See Also
Other fortify_data_frame()
methods:
fortify_data_frame.character()
,
fortify_data_frame.dendrogram()
,
fortify_data_frame.matrix()
,
fortify_data_frame.phylo()
Build a data frame
Description
This function converts various objects to a data frame.
Usage
## S3 method for class 'dendrogram'
fortify_data_frame(
data,
...,
priority = "right",
center = FALSE,
type = "rectangle",
leaf_pos = NULL,
leaf_braches = NULL,
reorder_branches = TRUE,
branch_gap = NULL,
root = NULL,
double = TRUE,
data_arg = NULL,
call = NULL
)
## S3 method for class 'hclust'
fortify_data_frame(data, ...)
Arguments
data |
A |
... |
Additional arguments passed to |
priority |
A string of "left" or "right". if we draw from |
center |
A boolean value. if |
type |
A string indicates the plot type, |
leaf_pos |
The x-coordinates of the leaf node. Must be the same length
of the number of observations in |
leaf_braches |
Branches of the leaf node. Must be the same length of the
number of observations in |
reorder_branches |
A single boolean value, indicates whether reorder the
provided |
branch_gap |
A single numeric value indicates the gap between different branches. |
root |
A length one string or numeric indicates the root branch. |
double |
A single logical value indicating whether horizontal lines
should be doubled when segments span multiple branches. If |
data_arg |
The argument name for |
call |
The execution environment where |
Value
A data frame
with the node coordinates:
-
.panel
: Similar withpanel
column, but always give the correct branch for usage of the ggplot facet. -
.index
: the original index in the tree for the the node -
label
: node label text -
x
andy
: x-axis and y-axis coordinates for the node -
branch
: which branch the node is. You can use this column to color different groups. -
panel
: which panel the node is, if we split the plot into panel using facet_grid, this column will show which panel the node is from. Note: some nodes may fall outside panel (between two panels), so there are possibleNA
values in this column. -
leaf
: A logical value indicates whether the node is a leaf.
ggalign attributes
edge
: A data frame
for edge coordinates:
-
.panel
: Similar withpanel
column, but always give the correct branch for usage of the ggplot facet. -
x
andy
: x-axis and y-axis coordinates for the start node of the edge. -
xend
andyend
: the x-axis and y-axis coordinates of the terminal node for edge. -
branch
: which branch the edge is. You can use this column to color different groups. -
panel1
andpanel2
: The panel1 and panel2 columns have the same functionality aspanel
, but they are specifically for theedge
data and correspond to both nodes of each edge.
See Also
Other fortify_data_frame()
methods:
fortify_data_frame.character()
,
fortify_data_frame.default()
,
fortify_data_frame.matrix()
,
fortify_data_frame.phylo()
Examples
fortify_data_frame(hclust(dist(USArrests), "ave"))
Build a data frame
Description
This function converts various objects to a data frame.
Usage
## S3 method for class 'matrix'
fortify_data_frame(data, lvls = NULL, ..., data_arg = NULL, call = NULL)
## S3 method for class 'DelayedMatrix'
fortify_data_frame(data, ...)
## S3 method for class 'Matrix'
fortify_data_frame(data, ...)
Arguments
data |
A matrix-like object. |
lvls |
A logical value indicating whether to restore factor levels using
those stored in |
... |
These dots are for future extensions and must be empty. |
data_arg |
The argument name for |
call |
The execution environment where |
Value
Matrix will be transformed into a long-form data frame, where each row represents a unique combination of matrix indices and their corresponding values. The resulting data frame will contain the following columns:
-
.row_names
and.row_index
: the row names (only applicable when names exist) and an integer representing the row index of the original matrix. -
.column_names
and.column_index
: the column names (only applicable when names exist) and column index of the original matrix. -
value
: the matrix value, returned as a factor if levels are specified or restored.
See Also
Other fortify_data_frame()
methods:
fortify_data_frame.character()
,
fortify_data_frame.default()
,
fortify_data_frame.dendrogram()
,
fortify_data_frame.phylo()
Build a data frame
Description
This function converts various objects to a data frame.
Usage
## S3 method for class 'phylo'
fortify_data_frame(
data,
...,
type = "rectangle",
center = FALSE,
tree_type = NULL,
tip_pos = NULL,
data_arg = NULL,
call = NULL
)
Arguments
data |
A |
... |
These dots are for future extensions and must be empty. |
type |
A string indicates the plot type, |
center |
A boolean value. if |
tree_type |
A single string, one of
Usually, you don't need to modify this. |
tip_pos |
The x-coordinates of the tip. Must be the same length
of the number of tips in |
data_arg |
The argument name for |
call |
The execution environment where |
Value
A data frame
with the node coordinates:
-
.index
: the original index in the tree for the the tip/node. -
label
: the tip/node label text. -
x
andy
: x-axis and y-axis coordinates for the tip/node. -
tip
: A logical value indicates whether current node is a tip.
ggalign attributes
edge
: A data frame
for edge coordinates:
-
x
andy
: x-axis and y-axis coordinates for the start node of the edge. -
xend
andyend
: the x-axis and y-axis coordinates of the terminal node for edge.
See Also
Other fortify_data_frame()
methods:
fortify_data_frame.character()
,
fortify_data_frame.default()
,
fortify_data_frame.dendrogram()
,
fortify_data_frame.matrix()
Build a Matrix
Description
This function converts various objects into a matrix format. By default, it
calls as.matrix()
to build a matrix.
Usage
fortify_matrix(data, ..., data_arg = NULL, call = NULL)
Arguments
data |
An object to be converted into a matrix. |
... |
Additional arguments passed to methods. |
data_arg |
The argument name for |
call |
The execution environment where |
Value
A matrix.
fortify_matrix
method collections
Build a matrix from a maftools object
Description
Build a matrix from a maftools object
Usage
## S3 method for class 'GISTIC'
fortify_matrix(
data,
...,
n_top = NULL,
bands = NULL,
ignored_bands = NULL,
sample_anno = NULL,
remove_empty_samples = TRUE,
data_arg = NULL,
call = NULL
)
Arguments
data |
A |
... |
These dots are for future extensions and must be empty. |
n_top |
A single number indicates how many top bands to be drawn. |
bands |
An atomic character defines the bands to draw. |
ignored_bands |
An atomic character defines the bands to be ignored. |
sample_anno |
A data frame of sample clinical features to be added. |
remove_empty_samples |
A single boolean value indicating whether to drop samples without any genomic alterations. |
data_arg |
The argument name for |
call |
The execution environment where |
ggalign attributes
-
sample_anno
: sample clinical informations provided insample_anno
. -
sample_summary
: sample copy number summary informations. Seedata@cnv.summary
for details. -
cytoband_summary
: cytoband summary informations. Seedata@cytoband.summary
for details. -
gene_summary
: gene summary informations. Seedata@gene.summary
for details. -
summary
: A data frame of summary information. Seedata@summary
for details.
See Also
Other fortify_matrix()
methods:
fortify_matrix.MAF()
,
fortify_matrix.default()
,
fortify_matrix.list_upset()
,
fortify_matrix.matrix()
,
fortify_matrix.matrix_oncoplot()
,
fortify_matrix.matrix_upset()
,
fortify_matrix.phylo()
Build a Matrix for OncoPrint
Description
Convert MAF
object to a matrix:
-
fortify_matrix.MAF
: Extract genomic alterations for genes. -
fortify_matrix.MAF_pathways
: Extract genomic alterations for pathways.tune.MAF()
helps convertMAF
object to aMAF_pathways
object.
Usage
## S3 method for class 'MAF'
fortify_matrix(
data,
...,
genes = NULL,
n_top = NULL,
remove_empty_genes = TRUE,
remove_empty_samples = TRUE,
collapse_vars = TRUE,
use_syn = TRUE,
missing_genes = "error",
data_arg = NULL,
call = NULL
)
## S3 method for class 'MAF_pathways'
fortify_matrix(
data,
...,
pathdb = "smgbp",
remove_empty_pathways = TRUE,
remove_empty_samples = TRUE,
data_arg = NULL,
call = NULL
)
Arguments
data |
A |
... |
These dots are for future extensions and must be empty. |
genes |
An atomic character defines the genes to draw. |
n_top |
A single number indicates how many top genes to be drawn. |
remove_empty_genes |
A single boolean value indicats whether to drop genes without any genomic alterations. |
remove_empty_samples |
A single boolean value indicats whether to drop samples without any genomic alterations. |
collapse_vars |
A single boolean value indicating whether to collapse
multiple alterations in the same sample and gene into a single value
|
use_syn |
A single boolean value indicates whether to include synonymous variants when Classifies SNPs into transitions and transversions. |
missing_genes |
A string, either |
data_arg |
The argument name for |
call |
The execution environment where |
pathdb |
A string of |
remove_empty_pathways |
A single boolean value indicats whether to drop pathways without any genomic alterations. |
ggalign attributes
For fortify_matrix.MAF
:
-
gene_summary
: A data frame of gene summary informations. Seemaftools::getGeneSummary()
for details. -
sample_summary
: A data frame of sample summary informations. Seemaftools::getSampleSummary()
for details. -
sample_anno
: A data frame of sample clinical informations. Seemaftools::getClinicalData()
for details. -
variant_weights
: A data frame of variant weights. Each gene in a sample is assigned a total weight of1
. When multiple variants occur in the same gene-sample pair, the weight for each variant reflects its proportion of the total. -
n_genes
: Total number of genes. -
n_samples
: Total number of samples. -
titv
: A list of data frame with Transitions and Transversions summary. Seemaftools::titv()
for details.
The levels of Variant_Classification
will be stored in ggalign_lvls()
.
If they do not exist, alphabetical ordering will be used.
For fortify_matrix.MAF_pathways
:
-
gene_list
: the pathway contents. -
pathway_summary
: pathway summary informations. Seemaftools::pathways()
for details. -
sample_summary
: sample summary informations. Seemaftools::getSampleSummary()
for details. -
sample_anno
: sample clinical informations. Seemaftools::getClinicalData()
for details.
See Also
Other fortify_matrix()
methods:
fortify_matrix.GISTIC()
,
fortify_matrix.default()
,
fortify_matrix.list_upset()
,
fortify_matrix.matrix()
,
fortify_matrix.matrix_oncoplot()
,
fortify_matrix.matrix_upset()
,
fortify_matrix.phylo()
Build a Matrix
Description
By default, it calls as.matrix()
to build a matrix.
Usage
## Default S3 method:
fortify_matrix(data, ..., data_arg = NULL, call = NULL)
Arguments
data |
An object to be converted into a matrix. |
... |
These dots are for future extensions and must be empty. |
data_arg |
The argument name for |
call |
The execution environment where |
Value
A matrix.
See Also
Other fortify_matrix()
methods:
fortify_matrix.GISTIC()
,
fortify_matrix.MAF()
,
fortify_matrix.list_upset()
,
fortify_matrix.matrix()
,
fortify_matrix.matrix_oncoplot()
,
fortify_matrix.matrix_upset()
,
fortify_matrix.phylo()
Build a Matrix for UpSet plot
Description
This function converts a list into a matrix format suitable for creating an
UpSet plot. It always returns a matrix for a horizontal
UpSet plot.
Usage
## S3 method for class 'list_upset'
fortify_matrix(data, mode = "distinct", ..., data_arg = NULL, call = NULL)
Arguments
data |
A list of sets. |
mode |
A string of |
... |
These dots are for future extensions and must be empty. |
data_arg |
The argument name for |
call |
The execution environment where |
ggalign attributes
-
intersection_sizes
: An integer vector indicating the size of each intersection. -
set_sizes
: An integer vector indicating the size of each set.
See Also
Other fortify_matrix()
methods:
fortify_matrix.GISTIC()
,
fortify_matrix.MAF()
,
fortify_matrix.default()
,
fortify_matrix.matrix()
,
fortify_matrix.matrix_oncoplot()
,
fortify_matrix.matrix_upset()
,
fortify_matrix.phylo()
Build a matrix
Description
Build a matrix
Usage
## S3 method for class 'matrix'
fortify_matrix(data, ..., data_arg = NULL, call = NULL)
Arguments
data |
A matrix object. |
... |
These dots are for future extensions and must be empty. |
data_arg |
The argument name for |
call |
The execution environment where |
shape
-
oncoplot
:fortify_matrix.matrix_oncoplot()
See Also
Other fortify_matrix()
methods:
fortify_matrix.GISTIC()
,
fortify_matrix.MAF()
,
fortify_matrix.default()
,
fortify_matrix.list_upset()
,
fortify_matrix.matrix_oncoplot()
,
fortify_matrix.matrix_upset()
,
fortify_matrix.phylo()
Build a Matrix for OncoPrint
Description
Converts a matrix suitable for creating an OncoPrint. tune.matrix()
helps convert matrix
object to a matrix_oncoplot
object.
Usage
## S3 method for class 'matrix_oncoplot'
fortify_matrix(
data,
...,
genes = NULL,
n_top = NULL,
remove_empty_genes = TRUE,
remove_empty_samples = TRUE,
missing_genes = "error",
data_arg = NULL,
call = NULL
)
Arguments
data |
A matrix where each row represents an genes, and each column represents samples. The values in the matrix indicate whether the element is part of the set. |
... |
These dots are for future extensions and must be empty. |
genes |
An atomic character defines the genes to draw. |
n_top |
A single number indicates how many top genes to be drawn. |
remove_empty_genes |
A single boolean value indicats whether to drop genes without any genomic alterations. |
remove_empty_samples |
A single boolean value indicats whether to drop samples without any genomic alterations. |
missing_genes |
A string, either |
data_arg |
The argument name for |
call |
The execution environment where |
ggalign attributes
-
gene_summary
: An integer vector of the altered samples for each gene. -
sample_summary
: An integer vector of the altered genes for each sample. -
n_genes
: Total number of genes. -
n_samples
: Total number of samples.
See Also
Other fortify_matrix()
methods:
fortify_matrix.GISTIC()
,
fortify_matrix.MAF()
,
fortify_matrix.default()
,
fortify_matrix.list_upset()
,
fortify_matrix.matrix()
,
fortify_matrix.matrix_upset()
,
fortify_matrix.phylo()
Build a Matrix for UpSet plot
Description
Converts a matrix suitable for creating an UpSet plot. tune.matrix()
helps convert matrix
object to a matrix_upset
object.
Usage
## S3 method for class 'matrix_upset'
fortify_matrix(data, ..., data_arg = NULL, call = NULL)
Arguments
data |
A matrix where each row represents an element, and each column defines a set. The values in the matrix indicate whether the element is part of the set. Any non-missing value signifies that the element exists in the set. |
... |
Arguments passed on to
|
data_arg |
The argument name for |
call |
The execution environment where |
ggalign attributes
-
intersection_sizes
: An integer vector indicating the size of each intersection. -
set_sizes
: An integer vector indicating the size of each set.
See Also
Other fortify_matrix()
methods:
fortify_matrix.GISTIC()
,
fortify_matrix.MAF()
,
fortify_matrix.default()
,
fortify_matrix.list_upset()
,
fortify_matrix.matrix()
,
fortify_matrix.matrix_oncoplot()
,
fortify_matrix.phylo()
Build a matrix from phylo
object
Description
This method allows a phylo
object to be
directly input into stack_discrete()
or circle_discrete()
. This makes it
possible to add align_phylo()
to the stack independently, as
align_phylo()
requires the layout to have labels.
Usage
## S3 method for class 'phylo'
fortify_matrix(data, ..., data_arg = caller_arg(data), call = NULL)
Arguments
data |
A |
... |
These dots are for future extensions and must be empty. |
data_arg |
The argument name for |
call |
The execution environment where |
Value
A one-column matrix where the tip labels are the values, and the row names will also be the tip labels.
See Also
Other fortify_matrix()
methods:
fortify_matrix.GISTIC()
,
fortify_matrix.MAF()
,
fortify_matrix.default()
,
fortify_matrix.list_upset()
,
fortify_matrix.matrix()
,
fortify_matrix.matrix_oncoplot()
,
fortify_matrix.matrix_upset()
Free from alignment
Description
align_plots will try to align plot panels, and every elements of the plot, following functions romove these restrictions:
-
free_align
: if we want to compose plots without alignment of some panel axes (panel won't be aligned). we can wrap the plot withfree_align
. -
free_border
: If we want to compose plots without alignment of the panel borders (but still align the panels themselves), we can wrap the plot withfree_border
. -
free_lab
: If we want to compose plots without alignment of the axis title, we can wrap the plot withfree_lab
. -
free_space
: Removing the ggplot element sizes when aligning. -
free_vp
: Customize the viewport when aligning. -
free_guide
: If we want to override the behaviour of the overall guides behaviour, we can wrap the plot withfree_guide
.
Usage
free_align(plot, axes = "tlbr")
free_border(plot, borders = "tlbr")
free_guide(plot, guides = "tlbr")
free_lab(plot, labs = "tlbr")
free_space(plot, spaces = "tlbr")
free_vp(plot, x = 0.5, y = 0.5, width = NA, height = NA, ...)
Arguments
plot |
A ggplot or alignpatches object. |
axes |
Which axes shouldn't be aligned? A string containing
one or more of |
borders |
Which border shouldn't be aligned? A string containing one or
more of |
guides |
A string containing one or more of
|
labs |
Which axis labs to be free? A string containing one or more of
|
spaces |
Which border spaces should be removed? A string containing one
or more of |
x |
A numeric vector or unit object specifying x-location. |
y |
A numeric vector or unit object specifying y-location. |
width |
A numeric vector or unit object specifying width. |
height |
A numeric vector or unit object specifying height. |
... |
Arguments passed on to
|
Value
-
free_align
: A modified version ofplot
with afree_align
class.
-
free_border
: A modified version ofplot
with afree_border
class.
-
free_guide
: A modified version ofplot
with afree_guide
class.
-
free_lab
: A modified version ofplot
with afree_lab
class.
-
free_space
: A modified version ofplot
with afree_space
class.
-
free_vp
: A modified version ofplot
with afree_vp
class.
Examples
# directly copied from `patchwork`
# Sometimes you have a plot that defies good composition alginment, e.g. due
# to long axis labels
p1 <- ggplot(mtcars) +
geom_bar(aes(y = factor(gear), fill = factor(gear))) +
scale_y_discrete(
"",
labels = c(
"3 gears are often enough",
"But, you know, 4 is a nice number",
"I would def go with 5 gears in a modern car"
)
)
# When combined with other plots it ends up looking bad
p2 <- ggplot(mtcars) +
geom_point(aes(mpg, disp))
align_plots(p1, p2, ncol = 1L)
# We can fix this be using `free_align`
align_plots(free_align(p1), p2, ncol = 1L)
# If we still want the panels to be aligned to the right, we can choose to
# free only the left side
align_plots(free_align(p1, axes = "l"), p2, ncol = 1L)
# We could use `free_lab` to fix the layout in a different way
align_plots(p1, free_lab(p2), ncol = 1L)
# `free_border` is similar with `free_lab`, they have a distinction in terms
# of placement on either the top or bottom side of the panel. Specifically,
# the top side contains the `title` and `subtitle`, while the bottom side
# contains the `caption`. free_lab() does not attach these elements in the
# panel area.
p3 <- ggplot(mtcars) +
geom_point(aes(hp, wt, colour = mpg)) +
ggtitle("Plot 3")
p_axis_top <- ggplot(mtcars) +
geom_point(aes(mpg, disp)) +
ggtitle("Plot axis in top") +
scale_x_continuous(position = "top")
align_plots(p_axis_top, free_lab(p3))
align_plots(p_axis_top, free_border(p3))
# Another issue is that long labels can occupy much spaces
align_plots(NULL, p1, p2, p2)
# This can be fixed with `free_space`
align_plots(NULL, free_space(p1, "l"), p2, p2)
Layer with Grid or Function
Description
Draw a ggplot2 layer using a grob or a function.
Usage
geom_draw(
draw,
mapping = NULL,
data = NULL,
type = "group",
stat = "identity",
position = "identity",
...,
na.rm = FALSE,
show.legend = FALSE,
inherit.aes = TRUE
)
Arguments
draw |
Either a grob object or a function (can be purrr-style) that accepts at least one argument (a data frame of transformed coordinates) and returns a grob. |
mapping |
Set of aesthetic mappings created by |
data |
The data to be displayed in this layer. There are three options: If A A |
type |
A single string of |
stat |
The statistical transformation to use on the data for this layer.
When using a
|
position |
A position adjustment to use on the data for this layer. This
can be used in various ways, including to prevent overplotting and
improving the display. The
|
... |
Other arguments passed on to
|
na.rm |
If |
show.legend |
logical. Should this layer be included in the legends?
|
inherit.aes |
If |
Details
If you want to combine the functionality of multiple geoms, it can
typically be achieved by preparing the data for each geom inside the
draw_*()
call and sending it off to the different geoms, collecting the
output in a grid::gList
(a list of grobs) for draw_group()
or a
grid::gTree
(a grob containing multiple child grobs) for
draw_panel()
.
See Also
https://ggplot2.tidyverse.org/reference/ggplot2-ggproto.html
Examples
text <- grid::textGrob(
"ggdraw",
x = c(0, 0, 0.5, 1, 1),
y = c(0, 1, 0.5, 0, 1),
hjust = c(0, 0, 0.5, 1, 1),
vjust = c(0, 1, 0.5, 0, 1)
)
ggplot(data.frame(x = 1, y = 2)) +
geom_draw(text)
Layer with a customized shape graphic using grid functions.
Description
geom_gshape
depends on the new aesthetics gshape
(shape with grid
functions), which should always be provided with scale_gshape_manual()
,
in which, we can provide a list of grobs or functions that define how each
value should be drawn. Any ggplot2 aesthetics can be used as the arguments.
Usage
geom_gshape(
mapping = NULL,
data = NULL,
stat = "identity",
position = "identity",
...,
na.rm = FALSE,
show.legend = NA,
inherit.aes = TRUE
)
Arguments
mapping |
Set of aesthetic mappings created by |
data |
The data to be displayed in this layer. There are three options: If A A |
stat |
The statistical transformation to use on the data for this layer.
When using a
|
position |
A position adjustment to use on the data for this layer. This
can be used in various ways, including to prevent overplotting and
improving the display. The
|
... |
Other arguments passed on to
|
na.rm |
If |
show.legend |
logical. Should this layer be included in the legends?
|
inherit.aes |
If |
Life cycle
We're unsure whether this function is truly necessary, which is why it is
marked as questioning. So far, we've found that geom_subrect()
and
geom_subtile()
handle most use cases effectively.
Aesthetics
geom_gshape()
understands the following aesthetics (required aesthetics are in bold):
Learn more about setting these aesthetics in vignette("ggplot2-specs", package = "ggplot2")
.
Examples
library(grid)
ggplot(data.frame(value = letters[seq_len(5)], y = seq_len(5))) +
geom_gshape(aes(x = 1, y = y, gshape = value, fill = value)) +
scale_gshape_manual(values = list(
a = function(x, y, width, height, fill) {
rectGrob(x, y,
width = width, height = height,
gp = gpar(fill = fill),
default.units = "native"
)
},
b = function(x, y, width, height, fill) {
rectGrob(x, y,
width = width, height = height,
gp = gpar(fill = fill),
default.units = "native"
)
},
c = function(x, y, width, height, fill) {
rectGrob(x, y,
width = width, height = height,
gp = gpar(fill = fill),
default.units = "native"
)
},
d = function(x, y, width, height, shape) {
gList(
pointsGrob(x, y, pch = shape),
# To ensure the rectangle color is shown in the legends, you
# must explicitly provide a color argument and include it in
# the `gpar()` of the graphical object
rectGrob(x, y, width, height,
gp = gpar(col = "black", fill = NA)
)
)
},
e = function(xmin, xmax, ymin, ymax) {
segmentsGrob(
xmin, ymin,
xmax, ymax,
gp = gpar(lwd = 2)
)
}
)) +
scale_fill_brewer(palette = "Dark2") +
theme_void()
Pie charts
Description
Pie charts
Usage
geom_pie(
mapping = NULL,
data = NULL,
stat = "identity",
position = "identity",
...,
clockwise = TRUE,
steps = 100,
lineend = "butt",
linejoin = "round",
linemitre = 10,
na.rm = FALSE,
show.legend = NA,
inherit.aes = TRUE
)
Arguments
mapping |
Set of aesthetic mappings created by |
data |
The data to be displayed in this layer. There are three options: If A A |
stat |
The statistical transformation to use on the data for this layer.
When using a
|
position |
A position adjustment to use on the data for this layer. This
can be used in various ways, including to prevent overplotting and
improving the display. The
|
... |
Other arguments passed on to
|
clockwise |
A single boolean value indicates clockwise or not. |
steps |
An integer indicating the number of steps to generate the pie chart radian. Increasing this value results in a smoother pie circular. |
lineend |
Line end style (round, butt, square). |
linejoin |
Line join style (round, mitre, bevel). |
linemitre |
Line mitre limit (number greater than 1). |
na.rm |
If |
show.legend |
logical. Should this layer be included in the legends?
|
inherit.aes |
If |
new aesthetics
-
angle
: the pie circle angle. -
angle0
: the initial pie circle angle. -
radius
: the circle radius.
Aesthetics
geom_pie()
understands the following aesthetics (required aesthetics are in bold):
Learn more about setting these aesthetics in vignette("ggplot2-specs", package = "ggplot2")
.
Examples
ggplot(data.frame(x = 1:10, y = 1:10, value = 1:10 / sum(1:10))) +
geom_pie(aes(x, y, angle = value * 360))
Add z-aesthetic for geom_tile
Description
Add z-aesthetic for geom_tile
Usage
geom_rect3d(
mapping = NULL,
data = NULL,
stat = "identity",
position = "identity",
...,
lineend = "butt",
linejoin = "round",
linemitre = 10,
na.rm = FALSE,
show.legend = NA,
inherit.aes = TRUE
)
geom_tile3d(
mapping = NULL,
data = NULL,
stat = "identity",
position = "identity",
...,
lineend = "butt",
linejoin = "round",
linemitre = 10,
na.rm = FALSE,
show.legend = NA,
inherit.aes = TRUE
)
Arguments
mapping |
Set of aesthetic mappings created by |
data |
The data to be displayed in this layer. There are three options: If A A |
stat |
The statistical transformation to use on the data for this layer.
When using a
|
position |
A position adjustment to use on the data for this layer. This
can be used in various ways, including to prevent overplotting and
improving the display. The
|
... |
Other arguments passed on to
|
lineend |
Line end style (round, butt, square). |
linejoin |
Line join style (round, mitre, bevel). |
linemitre |
Line mitre limit (number greater than 1). |
na.rm |
If |
show.legend |
logical. Should this layer be included in the legends?
|
inherit.aes |
If |
new aesthetics
-
z
: the third dimention (in the z direction), usescale_z_continuous()
to control the ranges. -
theta
: Angle between x-axis and z-axis.
Aesthetics
geom_rect3d()
understands the following aesthetics (required aesthetics are in bold):
Learn more about setting these aesthetics in vignette("ggplot2-specs", package = "ggplot2")
.
geom_tile3d()
understands the following aesthetics (required aesthetics are in bold):
Learn more about setting these aesthetics in vignette("ggplot2-specs", package = "ggplot2")
.
Examples
set.seed(123)
small_mat <- matrix(rnorm(81), nrow = 9)
rownames(small_mat) <- paste0("row", seq_len(nrow(small_mat)))
colnames(small_mat) <- paste0("column", seq_len(ncol(small_mat)))
ggheatmap(small_mat,
filling = FALSE,
theme = theme(
legend.box.spacing = unit(10, "mm"),
plot.margin = margin(t = 15, unit = "mm")
)
) +
geom_tile3d(
aes(fill = value, z = value, width = 0.8, height = 0.8),
color = "black"
) +
scale_fill_viridis_c(
option = "plasma",
breaks = scales::breaks_pretty(3L)
) +
coord_cartesian(clip = "off")
Subdivide Rectangles
Description
These geoms subdivide rectangles with shared borders into a grid. Both geoms achieve the same result but differ in how the rectangles are parameterized:
-
geom_subrect()
: Defines rectangles using their four corners (xmin
,xmax
,ymin
,ymax
). -
geom_subtile()
: Defines rectangles using the center (x
,y
) and dimensions (width
,height
).
Usage
geom_subrect(
mapping = NULL,
data = NULL,
stat = "identity",
position = "identity",
...,
byrow = FALSE,
nrow = NULL,
ncol = NULL,
lineend = "butt",
linejoin = "mitre",
na.rm = FALSE,
show.legend = NA,
inherit.aes = TRUE,
direction = deprecated()
)
geom_subtile(
mapping = NULL,
data = NULL,
stat = "identity",
position = "identity",
...,
byrow = TRUE,
nrow = NULL,
ncol = NULL,
lineend = "butt",
linejoin = "mitre",
na.rm = FALSE,
show.legend = NA,
inherit.aes = TRUE,
direction = deprecated()
)
Arguments
mapping |
Set of aesthetic mappings created by |
data |
The data to be displayed in this layer. There are three options: If A A |
stat |
The statistical transformation to use on the data for this layer.
When using a
|
position |
A position adjustment to use on the data for this layer. This
can be used in various ways, including to prevent overplotting and
improving the display. The
|
... |
Other arguments passed on to
|
byrow |
A single boolean value indicates whether we should arrange the divided rectangles in the row-major order. |
nrow , ncol |
A single positive integer specifying the number of rows or
columns in the layout of the subdivided cell. By default, the layout
dimensions are determined automatically using logic similar to
|
lineend |
Line end style (round, butt, square). |
linejoin |
Line join style (round, mitre, bevel). |
na.rm |
If |
show.legend |
logical. Should this layer be included in the legends?
|
inherit.aes |
If |
direction |
|
Aesthetics
geom_subrect()
understands the following aesthetics (required aesthetics are in bold):
Learn more about setting these aesthetics in vignette("ggplot2-specs", package = "ggplot2")
.
geom_subtile()
understands the following aesthetics (required aesthetics are in bold):
Learn more about setting these aesthetics in vignette("ggplot2-specs", package = "ggplot2")
.
Examples
# arranges by row
ggplot(data.frame(value = letters[seq_len(5)])) +
geom_subtile(aes(x = 1, y = 1, fill = value), byrow = TRUE)
# arranges by column
ggplot(data.frame(value = letters[seq_len(9)])) +
geom_subtile(aes(x = 1, y = 1, fill = value))
# one-row
ggplot(data.frame(value = letters[seq_len(4)])) +
geom_subtile(aes(x = 1, y = 1, fill = value), nrow = 1)
# one-column
ggplot(data.frame(value = letters[seq_len(4)])) +
geom_subtile(aes(x = 1, y = 1, fill = value), ncol = 1)
Add ggplot by Aligning discrete or continuous variable
Description
ggalign()
is similar to ggplot
in that it initializes a ggplot
data and
mapping
. ggalign()
allowing you to provide data in various formats,
including matrices, data frames, or simple vectors. By default, it will
inherit from the layout. If a function, it will apply with the layout matrix.
ggalign()
focuses on integrating plots into a layout by aligning the axes.
Usage
ggalign(
data = waiver(),
mapping = aes(),
...,
size = NULL,
no_axes = NULL,
active = NULL
)
Arguments
data |
The following options can be used:
|
mapping |
Default list of aesthetic mappings to use for plot. If not specified, must be supplied in each layer added to the plot. |
... |
<dyn-dots> Additional arguments passed to
|
size |
The relative size of the plot, can be specified as a
|
no_axes |
|
active |
A |
ggplot2 specification
ggalign
initializes a ggplot object. The underlying data is created using
fortify_data_frame()
. Please refer to it for more details.
When aligning discrete variables, ggalign()
always applies a default
mapping for the axis of the data index in the layout. Specifically:
-
aes(y = .data$.y)
is used for the horizontalstack_layout()
(including left and right annotations). -
aes(x = .data$.x)
is used for the verticalstack_layout()
(including top and bottom annotations) andcircle_layout()
.
The following columns will be added to the data frame to align discrete variables:
-
.panel
: The panel for the aligned axis. Refers to thex-axis
for verticalstack_layout()
(including top and bottom annotations), and they-axis
for horizontalstack_layout()
(including left and right annotations). -
.names
(vec_names()
) and.index
(vec_size()
/NROW()
): Character names (if available) and the integer index of the original data. -
.x
/.y
and.discrete_x
/.discrete_y
: Integer indices forx
/y
coordinates, and a factor of the data labels (only applicable when names exist).
It is recommended to use .x
/.y
, or .discrete_x
/.discrete_y
as the
x
/y
mapping.
If the data inherits from quad_layout()
/ggheatmap()
, additional
columns will be added:
-
.extra_panel
: Provides the panel information for the column (left or right annotation) or row (top or bottom annotation). -
.extra_index
: The index information for the column (left or right annotation) or row (top or bottom annotation).
Discrete Axis Alignment
It is important to note that we consider rows as observations, meaning
vec_size(data)
/NROW(data)
must match the number of observations along the
axis used for alignment (x-axis for a vertical stack layout, y-axis for a
horizontal stack layout).
Examples
ggheatmap(matrix(rnorm(81), nrow = 9)) +
anno_top() +
ggalign() +
geom_point(aes(y = value))
ggheatmap(matrix(rnorm(81), nrow = 9)) +
anno_top(size = 0.5) +
align_dendro(k = 3L) +
ggalign(data = NULL, size = 0.2) +
geom_tile(aes(y = 1L, fill = .panel))
Generate a plot grob.
Description
Generate a plot grob.
Usage
ggalignGrob(x)
Arguments
x |
An object to be converted into a grob. |
Value
A grob()
object.
Examples
ggalignGrob(ggplot())
Get Data from the Attribute Attached by ggalign
Description
ggalign_attr
retrieves supplementary information stored as attributes
during the layout rendering process. These attributes—typically added during
data transformation by functions such as fortify_matrix()
or
fortify_data_frame()
—may contain filtered data, auxiliary metadata, or
other context essential for downstream operations.
Factor level information, stored as a separate attribute, can be accessed via
ggalign_lvls
.
Usage
ggalign_attr(x, field = NULL, check = TRUE)
ggalign_lvls(x)
Arguments
x |
Data used, typically inherited from the layout |
field |
A string specifying the particular data to retrieve from the
attached attribute. If |
check |
A boolean indicating whether to check if the |
Details
Attributes attached to the data are especially useful when the input data is
transformed in ways that limit access to the complete dataset. For example,
fortify_matrix.MAF()
might filter mutation data while adding attributes
that retain important context, such as the total number of observations, for
detailed or aggregated analyses. Additionally, it stores the levels of
Variant_Classification
for further usage.
Value
-
ggalign_attr
: The specified data from the attached supplementary data orNULL
if it is unavailable. -
ggalign_lvls
: The attached supplementary levels orNULL
if it is unavailable.
Attach supplementary data and levels for ggalign
Description
Attach supplementary data and levels for ggalign
Usage
ggalign_data_set(.data, ..., .lvls = NULL)
Arguments
.data |
Input data for the layout. |
... |
<dyn-dots> A list of data to be attached. |
.lvls |
A character vector representing the attached levels. |
Note
Used by developers in fortify_matrix()
, fortify_data_frame()
,
and other related methods.
See Also
Get the statistics from the layout
Description
Get the statistics from the layout
Usage
ggalign_stat(x, ...)
## S3 method for class 'QuadLayout'
ggalign_stat(x, position, ...)
## S3 method for class 'StackLayout'
ggalign_stat(x, what, ...)
Arguments
x |
A |
... |
Arguments passed to methods. |
position |
A string of |
what |
A single number or string of the plot elements in the stack layout. |
Value
The statistics
Connect two layout crosswise
Description
ggcross
resets the layout ordering index of a stack_cross()
. This
allows you to add other align_*
objects to define a new layout ordering
index. Any objects added after ggcross
will use this updated layout
ordering index. This feature is particularly useful for creating tanglegram
visualizations. ggcross()
is an alias of ggcross()
.
Usage
ggcross(mapping = aes(), size = NULL, no_axes = NULL, active = NULL)
Arguments
mapping |
Default list of aesthetic mappings to use for plot. If not specified, must be supplied in each layer added to the plot. |
size |
The relative size of the plot, can be specified as a
|
no_axes |
|
active |
A |
ggplot2 specification
ggcross()
initializes a ggplot data
and mapping
.
ggcross()
always applies a default mapping for the axis of the data index
in the layout. This mapping is aes(y = .data$.y)
for horizontal stack
layout (including left and right annotation) and aes(x = .data$.x)
for
vertical stack layout (including top and bottom annotation).
The data in the underlying ggplot
object will contain following columns:
-
.panel
: The panel for the aligned axis. Refers to thex-axis
for verticalstack_layout()
(including top and bottom annotations), and they-axis
for horizontalstack_layout()
(including left and right annotations). -
.names
(vec_names()
) and.index
(vec_size()
/NROW()
): Character names (if available) and the integer index of the original data. -
.hand
: a factor indicates the index groups. -
.x
/.y
and.discrete_x
/.discrete_y
: Integer indices forx
/y
coordinates, and a factor of the data labels (only applicable when names exist).
It is recommended to use .x
/.y
, or .discrete_x
/.discrete_y
as the
x
/y
mapping.
Add ggplot to layout without alignment
Description
The ggfree()
function allows you to incorporate a ggplot object into your
layout. Unlike ggalign()
, which aligns every axis value precisely,
ggfree()
focuses on integrating plots into the layout without enforcing
strict axis alignment.
Usage
ggfree(data = waiver(), ..., size = NULL, active = NULL)
## Default S3 method:
ggfree(data = waiver(), mapping = aes(), ..., size = NULL, active = NULL)
Arguments
data |
The following options can be used:
|
... |
<dyn-dots> Additional arguments passed to
|
size |
The relative size of the plot, can be specified as a
|
active |
A |
mapping |
Default list of aesthetic mappings to use for plot. If not specified, must be supplied in each layer added to the plot. |
ggplot2 specification
ggalign
initializes a ggplot object. The underlying data is created using
fortify_data_frame()
. Please refer to this method for more details.
When used in quad_layout()
/ggheatmap()
, if the data is inherited from the
quad_layout()
and the other direction aligns discrete variables, following
columns will be added:
-
.extra_panel
: Provides the panel information for the column (left or right annotation) or row (top or bottom annotation). -
.extra_index
: The index information for the column (left or right annotation) or row (top or bottom annotation).
Examples
ggheatmap(matrix(rnorm(56), nrow = 7)) +
anno_top() +
align_dendro() +
ggfree(mtcars, aes(wt, mpg)) +
geom_point()
Add a plot to annotate selected observations
Description
Add a plot to annotate selected observations
Usage
ggmark(
mark,
data = waiver(),
mapping = aes(),
...,
group1 = NULL,
group2 = NULL,
obs_size = 1,
size = NULL,
active = NULL
)
Arguments
mark |
A |
data |
The following options can be used:
|
mapping |
Default list of aesthetic mappings to use for plot. If not specified, must be supplied in each layer added to the plot. |
... |
<dyn-dots> Additional arguments passed to
|
group1 , group2 |
A single boolean value indicating whether to use the
panel group information from the layout as the paired groups. By default,
if no specific observations are selected in |
obs_size |
A single numeric value that indicates the size of a single
observation, ranging from |
size |
The relative size of the plot, can be specified as a
|
active |
A |
ggplot2 specification
ggmark
initializes a ggplot object. The underlying data is created using
fortify_data_frame()
. Please refer to it for more details.
In addition, the following columns will be added to the data frame:
-
.panel
: the panel for the aligned axis. It meansx-axis
for vertical stack layout (including top and bottom annotation),y-axis
for horizontal stack layout (including left and right annotation). -
.names
(vec_names()
) and.index
(vec_size()
/NROW()
): a character names (only applicable when names exists) and an integer of index of the original data. -
.hand
: A factor with levelsc("left", "right")
for horizontal stack layouts, orc("top", "bottom")
for vertical stack layouts, indicating the position of the linked observations.
Examples
set.seed(123)
small_mat <- matrix(rnorm(56), nrow = 7)
rownames(small_mat) <- paste0("row", seq_len(nrow(small_mat)))
colnames(small_mat) <- paste0("column", seq_len(ncol(small_mat)))
# mark_line
ggheatmap(small_mat) +
theme(axis.text.x = element_text(hjust = 0, angle = -60)) +
anno_right() +
align_kmeans(3L) +
ggmark(mark_line(I(1:3) ~ NULL)) +
geom_boxplot(aes(.names, value)) +
theme(plot.margin = margin(l = 0.1, t = 0.1, unit = "npc"))
# mark_tetragon
ggheatmap(small_mat) +
theme(axis.text.x = element_text(hjust = 0, angle = -60)) +
anno_right() +
align_kmeans(3L) +
ggmark(mark_tetragon(I(1:3) ~ NULL)) +
geom_boxplot(aes(.names, value)) +
theme(plot.margin = margin(l = 0.1, t = 0.1, unit = "npc"))
Create an OncoPrint
Description
The ggoncoplot()
function generates oncoPrint
visualizations that display
genetic alterations in a matrix format. This function is especially useful
for visualizing complex genomic data, such as mutations, copy number
variations, and other genomic alterations in cancer research.
Usage
ggoncoplot(
data = NULL,
mapping = aes(),
...,
map_width = NULL,
map_height = NULL,
reorder_row = reorder_column,
reorder_column = TRUE,
remove_duplicates = FALSE,
width = NA,
height = NA,
filling = waiver(),
theme = NULL,
active = NULL
)
## Default S3 method:
ggoncoplot(
data = NULL,
mapping = aes(),
...,
map_width = NULL,
map_height = NULL,
reorder_row = reorder_column,
reorder_column = TRUE,
remove_duplicates = FALSE,
width = NA,
height = NA,
filling = waiver(),
theme = NULL,
active = NULL
)
Arguments
data |
A character matrix which encodes the alterations, you can use
|
mapping |
Default list of aesthetic mappings to use for main plot in the layout. If not specified, must be supplied in each layer added to the main plot. |
... |
Additional arguments passed to |
map_width , map_height |
A named numeric value defines the width/height of each alterations. |
reorder_row |
A boolean value indicating whether to reorder the rows
based on the frequency of alterations. You can set this to |
reorder_column |
A boolean value indicating whether to reorder the
columns based on the characteristics of the alterations. You can set this to
|
remove_duplicates |
A logical value indicating whether to remove duplicated variants within the same cell. |
width , height |
The relative width/height of the main plot, can be a
|
filling |
Same as |
theme |
A |
active |
A |
Details
ggoncoplot()
is a wrapper around the ggheatmap()
function, designed to
simplify the creation of OncoPrint
-style visualizations. The function
automatically processes the input character matrix by splitting the encoded
alterations (delimited by ";"
, ":"
, ","
, or "|"
) into
individual genomic events and unnesting the columns for visualization.
Value
A HeatmapLayout
object.
Examples
# A simple example from `ComplexHeatmap`
mat <- read.table(textConnection(
"s1,s2,s3
g1,snv;indel,snv,indel
g2,,snv;indel,snv
g3,snv,,indel;snv"
), row.names = 1, header = TRUE, sep = ",", stringsAsFactors = FALSE)
ggoncoplot(mat, map_width = c(snv = 0.5), map_height = c(indel = 0.9)) +
guides(fill = "none") +
anno_top(size = 0.5) +
ggalign() +
geom_bar(aes(fill = value), data = function(x) {
subset(x, !is.na(value))
}) +
anno_right(size = 0.5) +
ggalign() +
geom_bar(aes(fill = value), orientation = "y", data = function(x) {
subset(x, !is.na(value))
}) &
scale_fill_brewer(palette = "Dark2", na.translate = FALSE)
Create an UpSet plot
Description
ggupset
is a specialized version of quad_discrete()
, which simplifies
the creation of Upset plot.
Usage
ggupset(
data = NULL,
mapping = aes(),
...,
direction = "h",
point = NULL,
line = NULL,
rect = NULL,
width = NA,
height = NA,
theme = NULL,
active = NULL
)
Arguments
data |
Data used to create the UpSet plot. |
mapping |
Default list of aesthetic mappings to use for main plot in the layout. If not specified, must be supplied in each layer added to the main plot. |
... |
Additional arguments passed to |
direction |
A string indicating the direction of the UpSet plot,
|
point |
A list of parameters passed to
|
line |
A list of parameters passed to
|
rect |
A list of parameters passed to
|
width , height |
The relative width/height of the main plot, can be a
|
theme |
A |
active |
A |
ggplot2 specification
The data input will be converted to a matrix using fortify_matrix()
, and
the data in the underlying main plot will contain the following columns:
-
.panel_x
and.panel_y
: the column and row panel groups. -
.x
and.y
: an integer index ofx
andy
coordinates -
.discrete_x
and.discrete_y
: a factor of the data labels (only applicable when.row_names
and.column_names
exists). -
.row_names
and.column_names
: A character of the row and column names of the original matrix (only applicable when names exist). -
.row_index
and.column_index
: the row and column index of the original matrix. -
value
: the actual matrix value.
Examples
set.seed(123)
lt <- list(
a = sample(letters, 5),
b = sample(letters, 10),
c = sample(letters, 15)
)
ggupset(tune(lt)) +
scale_fill_manual(values = c("#F0F0F0", "white"), guide = "none") +
scale_color_manual(values = c("grey", "black"), guide = "none") +
anno_top() +
ggalign(data = function(d) ggalign_attr(d, "intersection_sizes")) +
ggplot2::geom_bar(aes(y = .data$value), stat = "identity") +
anno_right() +
ggalign(data = function(d) ggalign_attr(d, "set_sizes")) +
ggplot2::geom_bar(aes(x = .data$value),
stat = "identity",
orientation = "y"
)
Wrap Arbitrary Graphics to ggplot
Description
The ggwrap()
function allows non-ggplot2 elements to be converted into a
compliant representation for use with align_plots()
. This is useful for
adding any graphics that can be converted into a grob
with
the patch()
method.
Usage
ggwrap(plot, ..., align = "panel", on_top = FALSE, clip = TRUE, vp = NULL)
Arguments
plot |
Any graphic that can be converted into a |
... |
Additional arguments passed to the |
align |
A string specifying the area to place the plot: |
on_top |
A single boolean value indicates whether the graphic plot should be put frontmost. Note: the graphic plot will always put above the background. |
clip |
A single boolean value indicating whether the grob should be clipped if they expand outside their designated area. |
vp |
A |
Value
A wrapped_plot
object that can be directly placed into
align_plots()
.
Examples
library(grid)
ggwrap(rectGrob(gp = gpar(fill = "goldenrod")), align = "full") +
inset(rectGrob(gp = gpar(fill = "steelblue")), align = "panel") +
inset(textGrob("Here are some text", gp = gpar(color = "black")),
align = "panel"
)
p1 <- ggplot(mtcars) +
geom_point(aes(mpg, disp)) +
ggtitle("Plot 1")
align_plots(p1, ggwrap(
~ plot(mtcars$mpg, mtcars$disp),
mar = c(0, 2, 0, 0), bg = NA
))
Generate Tree Structures with Hierarchical Clustering
Description
Generate Tree Structures with Hierarchical Clustering
Usage
hclust2(
matrix,
distance = "euclidean",
method = "complete",
use_missing = "pairwise.complete.obs"
)
Arguments
matrix |
A numeric matrix, or data frame. |
distance |
A string of distance measure to be used. This must be one of
|
method |
A string of the agglomeration method to be used. This should be
(an unambiguous abbreviation of) one of |
use_missing |
An optional character string giving a method for computing
covariances in the presence of missing values. This must be (an abbreviation
of) one of the strings |
Value
A hclust object.
See Also
Examples
hclust2(dist(USArrests), method = "ward.D")
Create a heatmap
Description
heatmap_layout
is a specialized version of quad_discrete()
, which
simplifies the creation of heatmap plots by integrating essential elements
for a standard heatmap layout, ensuring that the appropriate data mapping and
visualization layers are automatically applied. ggheatmap
is an alias for
heatmap_layout
.
Usage
heatmap_layout(
data = NULL,
mapping = aes(),
...,
width = NA,
height = NA,
filling = waiver(),
theme = NULL,
active = NULL
)
Arguments
data |
Default dataset to use for the layout. If not specified, it must be supplied in each plot added to the layout. By default, it will try to inherit from
parent layout. |
mapping |
Default list of aesthetic mappings to use for main plot in the layout. If not specified, must be supplied in each layer added to the main plot. |
... |
Additional arguments passed to |
width , height |
The relative width/height of the main plot, can be a
|
filling |
A single string of For backward compatibility, a single boolean value is acceptable: By default, the classic heatmap color scheme
You can use the options
|
theme |
A |
active |
A |
Value
A HeatmapLayout
object.
ggplot2 specification
The data input will be converted to a matrix using fortify_matrix()
, and
the data in the underlying main plot will contain the following columns:
-
.panel_x
and.panel_y
: the column and row panel groups. -
.x
and.y
: an integer index ofx
andy
coordinates -
.discrete_x
and.discrete_y
: a factor of the data labels (only applicable when.row_names
and.column_names
exists). -
.row_names
and.column_names
: A character of the row and column names of the original matrix (only applicable when names exist). -
.row_index
and.column_index
: the row and column index of the original matrix. -
value
: the actual matrix value.
Examples
ggheatmap(1:10)
ggheatmap(letters)
ggheatmap(matrix(rnorm(81), nrow = 9L))
Create a ggplot inset
Description
Create a ggplot inset
Usage
inset(plot, ..., align = "panel", on_top = TRUE, clip = TRUE, vp = NULL)
Arguments
plot |
Any graphic that can be converted into a |
... |
Additional arguments passed to the |
align |
A string specifying the area to place the plot: |
on_top |
A single boolean value indicates whether the graphic plot should be put frontmost. Note: the graphic plot will always put above the background. |
clip |
A single boolean value indicating whether the grob should be clipped if they expand outside their designated area. |
vp |
A |
Value
A patch_inset
object, which can be added in ggplot.
Examples
library(grid)
p1 <- ggplot(mtcars) +
geom_point(aes(mpg, disp))
p2 <- ggplot(mtcars) +
geom_boxplot(aes(gear, disp, group = gear))
p1 + inset(p2, vp = viewport(0.6, 0.6,
just = c(0, 0), width = 0.4, height = 0.4
))
Reports whether x
is layout object
Description
Reports whether x
is layout object
Usage
is_layout(x)
is_quad_layout(x)
is_stack_layout(x)
is_stack_cross(x)
is_circle_layout(x)
is_heatmap_layout(x)
is_ggheatmap(x)
Arguments
x |
An object to test. |
Value
A single boolean value.
Examples
is_layout(ggheatmap(1:10))
# for quad_layout()
is_quad_layout(quad_alignb(1:10))
is_quad_layout(quad_alignh(1:10))
is_quad_layout(quad_alignv(1:10))
is_quad_layout(quad_free(mtcars))
# for stack_layout()
is_stack_layout(stack_discrete("h", 1:10))
is_stack_layout(stack_continuous("h", 1:10))
# for heatmap_layout()
is_heatmap_layout(ggheatmap(1:10))
is_ggheatmap(ggheatmap(1:10))
Change the layer adding order
Description
This function allows you to change the order in which layers are added to a ggplot.
Usage
layer_order(layer, order = 0)
Arguments
layer |
A |
order |
An integer indicating the position at which the layer should be
added. If |
Value
A layer_order
object.
Examples
ggplot(faithfuld, aes(waiting, eruptions)) +
geom_raster(aes(fill = density)) +
geom_point(color = "red", size = 1)
ggplot(faithfuld, aes(waiting, eruptions)) +
geom_raster(aes(fill = density)) +
layer_order(geom_point(color = "red", size = 1))
Layout operator
Description
-
+
: Adds elements to the active plot in the active layout. -
&
: Applies elements to all plots in the layout. -
-
: Adds elements to multiple plots in the layout.
Arguments
e1 |
A |
e2 |
An object to be added to the plot. |
Details
The +
operator is straightforward and should be used as needed.
In order to reduce code repetition ggalign
provides two operators for
adding ggplot elements (geoms, themes, facets, etc.) to multiple/all plots in
quad_layout()
/ggheatmap()
or stack_layout()
object: -
and &
.
Value
A modified Layout
object.
Examples
set.seed(123)
small_mat <- matrix(rnorm(56), nrow = 7)
ggheatmap(small_mat) +
anno_top() +
ggalign() +
geom_point(aes(y = value))
# `&` operator apply it to all plots
ggheatmap(small_mat) +
anno_top() +
align_dendro() &
theme(panel.border = element_rect(
colour = "red", fill = NA, linewidth = unit(2, "mm")
))
# If the active layout is the annotation stack, the `-` operator will only
# add the elements to all plots in the active annotation stack:
ggheatmap(small_mat) +
anno_left(size = 0.2) +
align_dendro(aes(color = branch), k = 3L) +
align_dendro(aes(color = branch), k = 3L) -
# Modify the the color scales of all plots in the left annotation
scale_color_brewer(palette = "Dark2")
# If the active layout is the `stack_layout()` itself, `-`
# applies the elements to all plots in the layout except the nested
# `ggheatmap()`/`quad_layout()`.
stack_alignv(small_mat) +
align_dendro() +
ggtitle("I'm from the parent stack") +
ggheatmap() +
# remove any active context
stack_active() +
align_dendro() +
ggtitle("I'm from the parent stack") -
# Modify the the color scales of all plots in the stack layout except the
# heatmap layout
scale_color_brewer(palette = "Dark2") -
# set the background of all plots in the stack layout except the heatmap
# layout
theme(plot.background = element_rect(fill = "red"))
Modify components of the layout
Description
modify the theme of the layout
Usage
layout_annotation(theme = waiver(), ...)
Arguments
theme |
A |
... |
These dots are for future extensions and must be empty. |
Details
-
guides
,panel.border
, andbackground
will always be used even for the nestedalignpatches
object. -
title
,subtitle
,caption
, andmargins
will be added for the top-levelalignpatches
object only.
Examples
p1 <- ggplot(mtcars) +
geom_point(aes(mpg, disp))
p2 <- ggplot(mtcars) +
geom_boxplot(aes(gear, disp, group = gear))
p3 <- ggplot(mtcars) +
geom_bar(aes(gear)) +
facet_wrap(~cyl)
align_plots(
p1 + theme(plot.background = element_blank()),
p2 + theme(plot.background = element_blank()),
p3 + theme(plot.background = element_blank())
) +
layout_annotation(
theme = theme(plot.background = element_rect(fill = "red"))
)
Define the grid to compose plots in
Description
To control how different plots are laid out, you need to add a layout design specification. If you are nesting grids, the layout is scoped to the current nesting level.
Usage
layout_design(
ncol = waiver(),
nrow = waiver(),
byrow = waiver(),
widths = waiver(),
heights = waiver(),
design = waiver(),
guides = NA
)
Arguments
ncol , nrow |
The dimensions of the grid to create - if both are |
byrow |
If |
widths , heights |
The relative widths and heights of each column and row
in the grid. Will get repeated to match the dimensions of the grid. The
special value of |
design |
Specification of the location of areas in the layout. Can
either be specified as a text string or by concatenating calls to
|
guides |
A string with one or more of |
Value
A layout_design
object.
Examples
p1 <- ggplot(mtcars) +
geom_point(aes(mpg, disp))
p2 <- ggplot(mtcars) +
geom_boxplot(aes(gear, disp, group = gear))
p3 <- ggplot(mtcars) +
geom_bar(aes(gear)) +
facet_wrap(~cyl)
align_plots(p1, p2, p3) +
layout_design(nrow = 1L)
align_plots(p1, p2, p3) +
layout_design(ncol = 1L)
Set Expansion for the Layout
Description
To align axes, it is important to keep the expansion consistent across all
plots in the layout. You can add a layout_expand
object to the layout. For
the quad_layout()
function, you must specify x
and y
arguments. For
other layouts, you can pass the expansion values using ...
directly.
Usage
layout_expand(..., x = waiver(), y = waiver())
Arguments
... |
A list of range expansion constants, used to add padding around
the data to ensure they are placed some distance away from the axes. Use the
convenience function |
x , y |
Same as |
Annotate the whole layout
Description
Annotate the whole layout
Usage
layout_title(title = waiver(), subtitle = waiver(), caption = waiver())
Arguments
title |
The text for the title. |
subtitle |
The text for the subtitle for the plot which will be displayed below the title. |
caption |
The text for the caption which will be displayed in the bottom-right of the plot by default. |
Value
A layout_title
object.
Examples
p1 <- ggplot(mtcars) +
geom_point(aes(mpg, disp))
p2 <- ggplot(mtcars) +
geom_boxplot(aes(gear, disp, group = gear))
p3 <- ggplot(mtcars) +
geom_bar(aes(gear)) +
facet_wrap(~cyl)
align_plots(p1, p2, p3) +
layout_title(title = "I'm title")
Define the links to connect a pair of observations
Description
This function allows users to define links between a pair of observations, facilitating the visualization of connections between related data points.
Usage
link_draw(.draw, ...)
Arguments
.draw |
A function used to draw the links. The function must return a
|
... |
<dyn-dots> A list of formulas, where each side
of the formula should be an |
See Also
Link the paired observations with a line
Description
Link the paired observations with a line
Usage
link_line(..., .element = NULL)
Arguments
... |
<dyn-dots> A list of formulas, where each side
of the formula should be an |
.element |
A |
Link the paired observations with a quadrilateral
Description
Link the paired observations with a quadrilateral
Usage
link_tetragon(..., .element = NULL)
Arguments
... |
<dyn-dots> A list of formulas, where each side
of the formula should be an |
.element |
A |
Rasterize a grob object with magick
Description
Rasterize a grob object with magick
Usage
magickGrob(
grob,
magick = NULL,
...,
res = NULL,
interpolate = FALSE,
name = NULL,
vp = NULL
)
Arguments
grob |
|
magick |
A function (purrr-style formula is accepted) that takes an
|
... |
These dots are for future extensions and must be empty. |
res |
An integer sets the desired resolution in pixels. |
interpolate |
A logical value indicating whether to linearly interpolate the image (the alternative is to use nearest-neighbour interpolation, which gives a more blocky result). |
name |
A character identifier. |
vp |
A Grid viewport object (or NULL). |
Value
A magickGrob
object.
Define the links to connect the marked observations
Description
This function allows users to define links between marked observations and plot panel (e.g., for creating visual connections for related data), which could help explain the observations.
Usage
mark_draw(.draw, ...)
Arguments
.draw |
A function used to draw the links. The function must return a
|
... |
<dyn-dots> A list of formulas, where each side
of the formula should be an |
See Also
Link the observations and the panel with a line
Description
Link the observations and the panel with a line
Usage
mark_line(..., .element = NULL)
Arguments
... |
<dyn-dots> A list of formulas, where each side
of the formula should be an |
.element |
A |
Link the observations and the panel with a quadrilateral
Description
Link the observations and the panel with a quadrilateral
Usage
mark_tetragon(..., .element = NULL)
Arguments
... |
<dyn-dots> A list of formulas, where each side
of the formula should be an |
.element |
A |
Link the observations and the panel with a triangle
Description
Link the observations and the panel with a triangle
Usage
mark_triangle(..., orientation = "plot", .element = NULL)
Arguments
... |
<dyn-dots> A list of formulas, where each side
of the formula should be an |
orientation |
A single string, either |
.element |
An
|
Sort matrix for better visualization
Description
Helper function used to order the Oncoplot samples. Typically, you would use
this in combination with align_order2()
, e.g.,
align_order2(memo_order)
.
Usage
memo_order(x)
Arguments
x |
A matrix, where |
Value
A vector of ordering weights.
Change the shape of the input object
Description
-
new_tune
: Creates a new object by wrapping it in a scalar list with the specified attributes and class. -
tune_data
: Retrieves the original input data.
Usage
new_tune(x, ..., class = character())
tune_data(x)
Arguments
x |
An R object. |
... |
Additional attributes passed to |
class |
A character vector specifying the class name to be added. |
Remove scale expansion
Description
Remove scale expansion
Usage
no_expansion(borders = "tlbr")
Arguments
borders |
Which border should be removed? A string containing
one or more of |
Value
An object which can be added to ggplot.
Ordering Permutation
Description
order2
returns a permutation which rearranges its first argument into
ascending order.
Usage
order2(x)
## S3 method for class 'hclust'
order2(x)
## S3 method for class 'dendrogram'
order2(x)
## S3 method for class 'ser_permutation_vector'
order2(x)
## S3 method for class 'ser_permutation'
order2(x)
## S3 method for class 'phylo'
order2(x)
## S3 method for class 'memo_weights'
order2(x)
Arguments
x |
Any objects can be extracting ordering. |
Value
An integer vector unless any of the inputs has 2^31
or more
elements, when it is a double vector.
Examples
order2(hclust2(matrix(rnorm(100L), nrow = 10L)))
Helper function to create pairs of observation groups
Description
ggmark()
and cross_link()
allow users to add links between
observations. These functions help define the linked observations. The
selected pairs will either be linked together, or each group in the pair will
be linked separately to the same plot area.
-
pair_links
: Helper function to create pairs of observation groups. -
range_link
: Helper function to create a range of observations.
Usage
pair_links(..., .handle_missing = "error", .reorder = NULL)
range_link(point1, point2)
Arguments
... |
<dyn-dots> A list of formulas, where each side
of the formula should be an |
.handle_missing |
A string of |
.reorder |
A string of |
point1 , point2 |
A single integer or character index, defining the lower
and higher bounds of the range. For integer indices, wrap them with |
Examples
x <- pair_links(
# group on the left hand only
c("a", "b"),
# normally, integer index will be interpreted as the index of the
# origianl data
1:2,
# wrapped with `I()` indicate` the integer index is ordering of the
# layout
I(1:2),
range_link(1, 6),
range_link("a", "b"),
# group on the right hand only
~ 1:2,
~ c("a", "b"),
~ range_link(1, 6),
# group on the both side
range_link(1, 6) ~ c("a", "b"),
# waiver() indicates the right hand is the same of the left hand
range_link(1, 6) ~ waiver(),
# the same for the left hand
waiver() ~ 1:2,
~NULL # an empty link
)
x
# we can modify it as usual list
x[[1]] <- NULL # remove the first link
x$a <- ~LETTERS
x
# modify with a list
x[1:2] <- list(~ c("a", "b"), ~ range_link("a", "b"))
x
Convert Object into a Grob
Description
The patch()
function is used by ggwrap()
and inset()
to convert
objects into a grob
.
Usage
patch(x, ...)
Arguments
x |
An object to be converted into a |
... |
Additional arguments passed to specific methods. |
Value
A grob
object.
patch
method collections
Convert Object into a Grob
Description
The patch()
function is used by ggwrap()
and inset()
to convert
objects into a grob
.
Usage
## S3 method for class 'Heatmap'
patch(x, ..., device = NULL)
## S3 method for class 'HeatmapList'
patch(x, ..., device = NULL)
## S3 method for class 'HeatmapAnnotation'
patch(x, ..., device = NULL)
Arguments
x |
An object to be converted into a |
... |
Additional arguments passed to draw(). |
device |
A function that opens a graphics device for temporary
rendering. By default this is an off-screen, in-memory device
based on the |
Value
A grob
object.
See Also
Other patch()
methods:
patch.alignpatches()
,
patch.formula()
,
patch.ggplot()
,
patch.grob()
,
patch.patch()
,
patch.patch_ggplot()
,
patch.patchwork()
,
patch.pheatmap()
,
patch.recordedplot()
,
patch.trellis()
Convert Object into a Grob
Description
The patch()
function is used by ggwrap()
and inset()
to convert
objects into a grob
.
Usage
## S3 method for class 'alignpatches'
patch(x, ...)
Arguments
x |
An object to be converted into a |
... |
Not used currently. |
Value
A grob
object.
See Also
Other patch()
methods:
patch.Heatmap()
,
patch.formula()
,
patch.ggplot()
,
patch.grob()
,
patch.patch()
,
patch.patch_ggplot()
,
patch.patchwork()
,
patch.pheatmap()
,
patch.recordedplot()
,
patch.trellis()
Convert Object into a Grob
Description
The patch()
function is used by ggwrap()
and inset()
to convert
objects into a grob
.
Usage
## S3 method for class 'formula'
patch(x, ..., device = NULL, name = NULL)
## S3 method for class ''function''
patch(x, ..., device = NULL, name = NULL)
Arguments
x |
An object to be converted into a |
... |
Graphical Parameters passed on to par(). |
device |
A function that opens a graphics device for |
name |
A character identifier. |
Value
A grob
object.
See Also
Other patch()
methods:
patch.Heatmap()
,
patch.alignpatches()
,
patch.ggplot()
,
patch.grob()
,
patch.patch()
,
patch.patch_ggplot()
,
patch.patchwork()
,
patch.pheatmap()
,
patch.recordedplot()
,
patch.trellis()
Convert Object into a Grob
Description
The patch()
function is used by ggwrap()
and inset()
to convert
objects into a grob
.
Usage
## S3 method for class 'ggplot'
patch(x, ...)
Arguments
x |
An object to be converted into a |
... |
Not used currently. |
Value
A grob
object.
See Also
Other patch()
methods:
patch.Heatmap()
,
patch.alignpatches()
,
patch.formula()
,
patch.grob()
,
patch.patch()
,
patch.patch_ggplot()
,
patch.patchwork()
,
patch.pheatmap()
,
patch.recordedplot()
,
patch.trellis()
Convert Object into a Grob
Description
The patch()
function is used by ggwrap()
and inset()
to convert
objects into a grob
.
Usage
## S3 method for class 'grob'
patch(x, ...)
## S3 method for class 'gList'
patch(x, ...)
Arguments
x |
An object to be converted into a |
... |
Not used currently. |
Value
A grob
object.
See Also
Other patch()
methods:
patch.Heatmap()
,
patch.alignpatches()
,
patch.formula()
,
patch.ggplot()
,
patch.patch()
,
patch.patch_ggplot()
,
patch.patchwork()
,
patch.pheatmap()
,
patch.recordedplot()
,
patch.trellis()
Convert Object into a Grob
Description
The patch()
function is used by ggwrap()
and inset()
to convert
objects into a grob
.
Usage
## S3 method for class 'patch'
patch(x, ...)
Arguments
x |
An object to be converted into a |
... |
Not used currently. |
Value
A grob
object.
See Also
Other patch()
methods:
patch.Heatmap()
,
patch.alignpatches()
,
patch.formula()
,
patch.ggplot()
,
patch.grob()
,
patch.patch_ggplot()
,
patch.patchwork()
,
patch.pheatmap()
,
patch.recordedplot()
,
patch.trellis()
Convert Object into a Grob
Description
The patch()
function is used by ggwrap()
and inset()
to convert
objects into a grob
.
Usage
## S3 method for class 'patch_ggplot'
patch(x, ...)
Arguments
x |
An object to be converted into a |
... |
Not used currently. |
Value
A grob
object.
See Also
Other patch()
methods:
patch.Heatmap()
,
patch.alignpatches()
,
patch.formula()
,
patch.ggplot()
,
patch.grob()
,
patch.patch()
,
patch.patchwork()
,
patch.pheatmap()
,
patch.recordedplot()
,
patch.trellis()
Convert Object into a Grob
Description
The patch()
function is used by ggwrap()
and inset()
to convert
objects into a grob
.
Usage
## S3 method for class 'patchwork'
patch(x, ...)
Arguments
x |
An object to be converted into a |
... |
Not used currently. |
Value
A grob
object.
See Also
Other patch()
methods:
patch.Heatmap()
,
patch.alignpatches()
,
patch.formula()
,
patch.ggplot()
,
patch.grob()
,
patch.patch()
,
patch.patch_ggplot()
,
patch.pheatmap()
,
patch.recordedplot()
,
patch.trellis()
Convert Object into a Grob
Description
The patch()
function is used by ggwrap()
and inset()
to convert
objects into a grob
.
Usage
## S3 method for class 'pheatmap'
patch(x, ...)
Arguments
x |
An object to be converted into a |
... |
Not used currently. |
Value
A grob
object.
See Also
Other patch()
methods:
patch.Heatmap()
,
patch.alignpatches()
,
patch.formula()
,
patch.ggplot()
,
patch.grob()
,
patch.patch()
,
patch.patch_ggplot()
,
patch.patchwork()
,
patch.recordedplot()
,
patch.trellis()
Convert Object into a Grob
Description
The patch()
function is used by ggwrap()
and inset()
to convert
objects into a grob
.
Usage
## S3 method for class 'recordedplot'
patch(x, ..., device = NULL)
Arguments
x |
An object to be converted into a |
... |
Not used currently. |
device |
A function that opens a graphics device for |
Value
A grob
object.
See Also
Other patch()
methods:
patch.Heatmap()
,
patch.alignpatches()
,
patch.formula()
,
patch.ggplot()
,
patch.grob()
,
patch.patch()
,
patch.patch_ggplot()
,
patch.patchwork()
,
patch.pheatmap()
,
patch.trellis()
Convert Object into a Grob
Description
The patch()
function is used by ggwrap()
and inset()
to convert
objects into a grob
.
Usage
## S3 method for class 'trellis'
patch(x, ..., device = NULL)
Arguments
x |
An object to be converted into a |
... |
Arguments passed on to
|
device |
A function that opens a graphics device for temporary
rendering. By default this is an off-screen, in-memory device
based on the |
Value
A grob
object.
See Also
Other patch()
methods:
patch.Heatmap()
,
patch.alignpatches()
,
patch.formula()
,
patch.ggplot()
,
patch.grob()
,
patch.patch()
,
patch.patch_ggplot()
,
patch.patchwork()
,
patch.pheatmap()
,
patch.recordedplot()
Add patch titles to plot borders
Description
This function extends ggplot2's title functionality, allowing you to add titles to each border of the plot: top, left, bottom, and right.
Usage
patch_titles(
top = waiver(),
left = waiver(),
bottom = waiver(),
right = waiver()
)
Arguments
top , left , bottom , right |
A string specifying the title to be added to the top, left, bottom, and right border of the plot. |
Details
The appearance and alignment of these patch titles can be customized using theme():
-
plot.patch_title
/plot.patch_title.*
: Controls the text appearance of patch titles. By default,plot.patch_title
inherit fromplot.title
, and settings for each border will inherit fromplot.patch_title
, with the exception of theangle
property, which is not inherited. -
plot.patch_title.position
/plot.patch_title.position.*
: Determines the alignment of the patch titles. By default,plot.patch_title.position
inherit fromplot.title.position
, and settings for each border will inherit fromplot.patch_title
. The value"panel"
aligns the patch titles with the plot panels. Setting this to"plot"
aligns the patch title with the entire plot (excluding margins and plot tags).
Value
A labels
object to be added to ggplot.
Examples
ggplot(mtcars) +
geom_point(aes(mpg, disp)) +
patch_titles(
top = "I'm top patch title",
left = "I'm left patch title",
bottom = "I'm bottom patch title",
right = "I'm right patch title"
)
Determine the Active Context of Quad-Layout
Description
-
quad_active
: Sets the active context to thequad_layout()
/ggheatmap()
itself. -
quad_anno
: Sets the active context to the specified annotation stack based on theposition
argument. -
anno_top
: A special case ofquad_anno
withposition = "top"
. -
anno_left
: A special case ofquad_anno
withposition = "left"
. -
anno_bottom
: A special case ofquad_anno
withposition = "bottom"
. -
anno_right
: A special case ofquad_anno
withposition = "right"
.
Usage
quad_active(width = NULL, height = NULL)
quad_anno(
position,
size = NULL,
free_guides = waiver(),
initialize = NULL,
what = waiver()
)
anno_top(
size = NULL,
free_guides = waiver(),
initialize = NULL,
what = waiver()
)
anno_left(
size = NULL,
free_guides = waiver(),
initialize = NULL,
what = waiver()
)
anno_bottom(
size = NULL,
free_guides = waiver(),
initialize = NULL,
what = waiver()
)
anno_right(
size = NULL,
free_guides = waiver(),
initialize = NULL,
what = waiver()
)
Arguments
width , height |
The relative width/height of the main plot, can be a
|
position |
A string of |
size |
A numeric value or an
|
free_guides |
Override the |
initialize |
A boolean indicating whether the annotation stack should be
initialized if it is not already. By default, the annotation stack layout
will attempt to initialize when the data is compatible. If set to |
what |
What should get activated in the annotation stack?
A single number or string of the plot elements in the layout. If |
Details
By default, quad_anno()
attempts to initialize the annotation stack layout
using data from quad_layout()
/ggheatmap()
. However, in situations where you want to use
different data for the annotation stack, you can set initialize = FALSE
and then provide a custom stack_layout()
.
Value
An object that can be added to quad_layout()
/ggheatmap()
.
See Also
Initialize Quad-Layout Annotation
Description
This function was deprecated, you can add stack_layout()
directly.
Usage
quad_init(position, data = waiver(), ...)
Arrange plots in the quad-side of a main plot
Description
This function arranges plots around the quad-sides of a main plot, aligning both horizontal and vertical axes, and can handle either discrete or continuous variables.
If
xlim
is provided, a continuous variable will be required and aligned in the vertical direction. Otherwise, a discrete variable will be required and aligned.If
ylim
is provided, a continuous variable will be required and aligned in the horizontal direction. Otherwise, a discrete variable will be required and aligned.
The quad_discrete
is a special case where both xlim
and ylim
are not
provided.
The quad_continuous
is a special case where both xlim
and ylim
are
provided.
For historical reasons, the following aliases are available:
-
quad_alignh
: Align discrete variables in the horizontal direction and continuous variables in vertical direction. -
quad_alignv
: Align discrete variables in the vertical direction and continuous variables in horizontal direction. -
quad_alignb
is an alias forquad_discrete
. -
quad_free
is an alias forquad_continuous
.
Usage
quad_layout(
data = waiver(),
mapping = aes(),
xlim = waiver(),
ylim = waiver(),
...,
theme = NULL,
active = NULL,
width = NA,
height = NA
)
quad_alignh(..., ylim = waiver())
quad_alignv(..., xlim = waiver())
quad_discrete(
data = waiver(),
mapping = aes(),
...,
theme = NULL,
active = NULL,
width = NA,
height = NA
)
quad_continuous(
data = waiver(),
mapping = aes(),
xlim = NULL,
ylim = NULL,
...,
theme = NULL,
active = NULL,
width = NA,
height = NA
)
Arguments
data |
Default dataset to use for the layout. If not specified, it must be supplied in each plot added to the layout. By default, this will attempt to inherit from the parent layout. If both Otherwise, a |
mapping |
Default list of aesthetic mappings to use for main plot in the layout. If not specified, must be supplied in each layer added to the main plot. |
xlim , ylim |
A |
... |
Additional arguments passed to |
theme |
A |
active |
A |
width , height |
The relative width/height of the main plot, can be a
|
Value
A QuadLayout
object.
ggplot2 specification
If either xlim
or ylim
is not provided, the data input will be converted
to a matrix using fortify_matrix()
, and the data in the underlying main
plot will contain the following columns:
-
.panel_x
and.panel_y
: the column and row panel groups. -
.x
and.y
: an integer index ofx
andy
coordinates -
.discrete_x
and.discrete_y
: a factor of the data labels (only applicable when.row_names
and.column_names
exists). -
.row_names
and.column_names
: A character of the row and column names of the original matrix (only applicable when names exist). -
.row_index
and.column_index
: the row and column index of the original matrix. -
value
: the actual matrix value.
Otherwise, the data input will be used for the main plot.
Determine the Active Context of Quad-Layout
Description
quad_switch()
integrates quad_active()
and quad_anno()
into one
function for ease of use. This function allows you to quickly change the
active context of the quad_layout()
and its annotations.
hmanno
is an alias for quad_switch
, with additional arguments for
backward compatibility
Usage
quad_switch(
position = NULL,
size = NULL,
width = NULL,
height = NULL,
free_guides = waiver(),
initialize = NULL,
what = waiver()
)
hmanno(
position = NULL,
size = NULL,
width = NULL,
height = NULL,
free_guides = waiver(),
initialize = NULL,
what = waiver()
)
Arguments
position |
A string of |
size |
A numeric value or an
|
width , height |
The relative width/height of the main plot, can be a
|
free_guides |
Override the |
initialize |
A boolean indicating whether the annotation stack should be
initialized if it is not already. By default, the annotation stack layout
will attempt to initialize when the data is compatible. If set to |
what |
What should get activated in the annotation stack?
A single number or string of the plot elements in the layout. If |
Value
An object that can be added to quad_layout()
/ggheatmap()
.
See Also
Examples
ggheatmap(matrix(rnorm(81), nrow = 9)) +
anno_top() +
align_dendro()
Rasterize the ggplot layers
Description
The function rasterizes input graphical objects (e.g., grob, layer, ggplot) and optionally processes the resulting raster using magick, a powerful image manipulation library. This allows for advanced graphical transformations directly within the plotting pipeline.
Usage
raster_magick(
x,
magick = NULL,
...,
res = NULL,
interpolate = FALSE,
vp = NULL
)
Arguments
x |
An object to rasterize, can be a |
magick |
A function (purrr-style formula is accepted) that takes an
|
... |
These dots are for future extensions and must be empty. |
res |
An integer sets the desired resolution in pixels. |
interpolate |
A logical value indicating whether to linearly interpolate the image (the alternative is to use nearest-neighbour interpolation, which gives a more blocky result). |
vp |
A Grid viewport object (or NULL). |
Value
An object with the same class of the input.
See Also
Examples
# Currently, `magick` package require R >= 4.1.0
if (requireNamespace("magick")) {
# data generated code was copied from `ComplexHeatmap`
set.seed(123)
small_mat <- matrix(rnorm(56), nrow = 7)
rownames(small_mat) <- paste0("row", seq_len(nrow(small_mat)))
colnames(small_mat) <- paste0("column", seq_len(ncol(small_mat)))
ggheatmap(small_mat, aes(.x, .y), filling = NULL) +
raster_magick(geom_tile(aes(fill = value)), res = 20)
ggheatmap(small_mat, aes(.x, .y), filling = NULL) +
# Use `magick::filter_types()` to check available `filter` arguments
raster_magick(
geom_tile(aes(fill = value)),
magick = function(image) {
magick::image_resize(image,
geometry = "50%x", filter = "Lanczos"
)
}
)
}
Read Example Data
Description
This function reads example data from the file. If no file is specified, it returns a list of available example files.
Usage
read_example(file = NULL)
Arguments
file |
A string representing the name of the example file to be read. If
|
Value
If file
is NULL
, returns a character vector of available example
file names. Otherwise, returns the contents of the specified example file,
read as an R object.
Examples
read_example()
Objects exported from other packages
Description
These objects are imported from other packages. Follow the links below to see their documentation.
Scale for gshape
aesthetic
Description
geom_gshape
depends on the new aesthetics gshape
(shape with grid
functions), which should always be provided with scale_gshape_manual()
,
in which, we can provide a list of grobs or functions that define how each
value should be drawn. Any ggplot2 aesthetics can be used as the arguments.
Usage
scale_gshape_manual(..., values, breaks = waiver(), na.value = NA)
Arguments
... |
Arguments passed on to
|
values |
A list of grobs or functions (including purrr-like lambda syntax) that define how each cell's grob (graphical object) should be drawn. |
breaks |
One of:
|
na.value |
The aesthetic value to use for missing ( |
Life cycle
We're unsure whether this function is truly necessary, which is why it is
marked as questioning. So far, we've found that geom_subrect()
and
geom_subtile()
handle most use cases effectively.
Aesthetics
geom_gshape()
understands the following aesthetics (required aesthetics are in bold):
Learn more about setting these aesthetics in vignette("ggplot2-specs", package = "ggplot2")
.
Examples
library(grid)
ggplot(data.frame(value = letters[seq_len(5)], y = seq_len(5))) +
geom_gshape(aes(x = 1, y = y, gshape = value, fill = value)) +
scale_gshape_manual(values = list(
a = function(x, y, width, height, fill) {
rectGrob(x, y,
width = width, height = height,
gp = gpar(fill = fill),
default.units = "native"
)
},
b = function(x, y, width, height, fill) {
rectGrob(x, y,
width = width, height = height,
gp = gpar(fill = fill),
default.units = "native"
)
},
c = function(x, y, width, height, fill) {
rectGrob(x, y,
width = width, height = height,
gp = gpar(fill = fill),
default.units = "native"
)
},
d = function(x, y, width, height, shape) {
gList(
pointsGrob(x, y, pch = shape),
# To ensure the rectangle color is shown in the legends, you
# must explicitly provide a color argument and include it in
# the `gpar()` of the graphical object
rectGrob(x, y, width, height,
gp = gpar(col = "black", fill = NA)
)
)
},
e = function(xmin, xmax, ymin, ymax) {
segmentsGrob(
xmin, ymin,
xmax, ymax,
gp = gpar(lwd = 2)
)
}
)) +
scale_fill_brewer(palette = "Dark2") +
theme_void()
z scales
Description
z scales
Usage
scale_z_continuous(name = waiver(), ..., range = c(0.1, 1), guide = "none")
scale_z_binned(name = waiver(), ..., range = c(0.1, 1), guide = "none")
scale_z_discrete(...)
scale_z_ordinal(name = waiver(), ..., range = c(0.1, 1), guide = "none")
Arguments
name |
The name of the scale. Used as the axis or legend title. If
|
... |
Other arguments passed on to
|
range |
Output range of z values. Must larger than 0. |
guide |
A function used to create a guide or its name. See
|
See Also
Examples
set.seed(7)
mat <- matrix(runif(100), 10)
rownames(mat) <- LETTERS[1:10]
colnames(mat) <- letters[1:10]
ggheatmap(mat,
filling = FALSE,
theme = theme(
legend.box.spacing = unit(10, "mm"),
plot.margin = margin(t = 15, unit = "mm")
)
) +
geom_tile3d(aes(fill = value, z = value, width = 0.8, height = 0.8)) +
scale_z_continuous(range = c(0.2, 1)) +
coord_cartesian(clip = "off")
Align Specifications in the Layout
Description
The scheme_align()
function defines the align Specifications for plots.
Usage
scheme_align(guides = NA, free_spaces = NA, free_labs = NA)
Arguments
guides |
A string with one or more of |
free_spaces |
A string with one or more of Usually you want to apply this with the whole layout, instead of individual plots. |
free_labs |
A string with one or more of |
Value
A scheme_align
object.
Examples
set.seed(123)
mat <- matrix(rnorm(72), nrow = 8)
# used in the layout, define the default action for all plots in the layout
ggheatmap(mat) -
scheme_align(guides = NULL) +
anno_right() +
align_dendro(aes(color = branch), k = 3)
# You can also add it for a single plot
ggheatmap(mat) -
# for all plots in the layout, we default won't collect any guide legends
scheme_align(guides = NULL) +
# for the heatmap body, we collect guide legends in the right
# note, the guide legends will be collected to the right side of the
# layout which will overlap the legends in the right annotation
scheme_align(guides = "r") +
anno_right() +
align_dendro(aes(color = branch), k = 3)
# to avoid overlapping, we can also collect the guide legends in the
# right annotation
ggheatmap(mat) -
scheme_align(guides = NULL) +
scheme_align(guides = "r") +
anno_right() +
align_dendro(aes(color = branch), k = 3) +
scheme_align(guides = "r")
Plot data Specifications
Description
Transforms the plot data. Many functions in this package require a specific
data format to align observations, scheme_data()
helps reformat data frames
as needed.
Usage
scheme_data(data, inherit = FALSE)
Arguments
data |
A function to transform the plot data before rendering. Acceptable values include:
Use this hook to modify the data for all |
inherit |
A single boolean value indicates whether to apply the parent
|
Details
Defaults will attempt to inherit from the parent layout if the actual data is
inherited from the parent layout, with one exception: align_dendro()
, which
will not inherit the scheme_data
by default.
Plot default theme
Description
scheme_theme()
serves as the default theme and will always be overridden by
any theme()
settings applied directly to the plot. The default theme
(scheme_theme()
) is applied first, followed by any specific theme()
settings, even if theme()
is added before scheme_theme()
.
Usage
scheme_theme(
...,
line,
rect,
text,
title,
aspect.ratio,
axis.title,
axis.title.x,
axis.title.x.top,
axis.title.x.bottom,
axis.title.y,
axis.title.y.left,
axis.title.y.right,
axis.text,
axis.text.x,
axis.text.x.top,
axis.text.x.bottom,
axis.text.y,
axis.text.y.left,
axis.text.y.right,
axis.text.theta,
axis.text.r,
axis.ticks,
axis.ticks.x,
axis.ticks.x.top,
axis.ticks.x.bottom,
axis.ticks.y,
axis.ticks.y.left,
axis.ticks.y.right,
axis.ticks.theta,
axis.ticks.r,
axis.minor.ticks.x.top,
axis.minor.ticks.x.bottom,
axis.minor.ticks.y.left,
axis.minor.ticks.y.right,
axis.minor.ticks.theta,
axis.minor.ticks.r,
axis.ticks.length,
axis.ticks.length.x,
axis.ticks.length.x.top,
axis.ticks.length.x.bottom,
axis.ticks.length.y,
axis.ticks.length.y.left,
axis.ticks.length.y.right,
axis.ticks.length.theta,
axis.ticks.length.r,
axis.minor.ticks.length,
axis.minor.ticks.length.x,
axis.minor.ticks.length.x.top,
axis.minor.ticks.length.x.bottom,
axis.minor.ticks.length.y,
axis.minor.ticks.length.y.left,
axis.minor.ticks.length.y.right,
axis.minor.ticks.length.theta,
axis.minor.ticks.length.r,
axis.line,
axis.line.x,
axis.line.x.top,
axis.line.x.bottom,
axis.line.y,
axis.line.y.left,
axis.line.y.right,
axis.line.theta,
axis.line.r,
legend.background,
legend.margin,
legend.spacing,
legend.spacing.x,
legend.spacing.y,
legend.key,
legend.key.size,
legend.key.height,
legend.key.width,
legend.key.spacing,
legend.key.spacing.x,
legend.key.spacing.y,
legend.frame,
legend.ticks,
legend.ticks.length,
legend.axis.line,
legend.text,
legend.text.position,
legend.title,
legend.title.position,
legend.position,
legend.position.inside,
legend.direction,
legend.byrow,
legend.justification,
legend.justification.top,
legend.justification.bottom,
legend.justification.left,
legend.justification.right,
legend.justification.inside,
legend.location,
legend.box,
legend.box.just,
legend.box.margin,
legend.box.background,
legend.box.spacing,
panel.background,
panel.border,
panel.spacing,
panel.spacing.x,
panel.spacing.y,
panel.grid,
panel.grid.major,
panel.grid.minor,
panel.grid.major.x,
panel.grid.major.y,
panel.grid.minor.x,
panel.grid.minor.y,
panel.ontop,
plot.background,
plot.title,
plot.title.position,
plot.subtitle,
plot.caption,
plot.caption.position,
plot.tag,
plot.tag.position,
plot.tag.location,
plot.margin,
strip.background,
strip.background.x,
strip.background.y,
strip.clip,
strip.placement,
strip.text,
strip.text.x,
strip.text.x.bottom,
strip.text.x.top,
strip.text.y,
strip.text.y.left,
strip.text.y.right,
strip.switch.pad.grid,
strip.switch.pad.wrap,
complete = FALSE,
validate = TRUE
)
Arguments
... |
A |
line |
all line elements ( |
rect |
all rectangular elements ( |
text |
all text elements ( |
title |
all title elements: plot, axes, legends ( |
aspect.ratio |
aspect ratio of the panel |
axis.title , axis.title.x , axis.title.y , axis.title.x.top , axis.title.x.bottom , axis.title.y.left , axis.title.y.right |
labels of axes ( |
axis.text , axis.text.x , axis.text.y , axis.text.x.top , axis.text.x.bottom , axis.text.y.left , axis.text.y.right , axis.text.theta , axis.text.r |
tick labels along axes ( |
axis.ticks , axis.ticks.x , axis.ticks.x.top , axis.ticks.x.bottom , axis.ticks.y , axis.ticks.y.left , axis.ticks.y.right , axis.ticks.theta , axis.ticks.r |
tick marks along axes ( |
axis.minor.ticks.x.top , axis.minor.ticks.x.bottom , axis.minor.ticks.y.left , axis.minor.ticks.y.right , axis.minor.ticks.theta , axis.minor.ticks.r |
minor tick marks along axes ( |
axis.ticks.length , axis.ticks.length.x , axis.ticks.length.x.top , axis.ticks.length.x.bottom , axis.ticks.length.y , axis.ticks.length.y.left , axis.ticks.length.y.right , axis.ticks.length.theta , axis.ticks.length.r |
length of tick marks ( |
axis.minor.ticks.length , axis.minor.ticks.length.x , axis.minor.ticks.length.x.top , axis.minor.ticks.length.x.bottom , axis.minor.ticks.length.y , axis.minor.ticks.length.y.left , axis.minor.ticks.length.y.right , axis.minor.ticks.length.theta , axis.minor.ticks.length.r |
length of minor tick marks ( |
axis.line , axis.line.x , axis.line.x.top , axis.line.x.bottom , axis.line.y , axis.line.y.left , axis.line.y.right , axis.line.theta , axis.line.r |
lines along axes ( |
legend.background |
background of legend ( |
legend.margin |
the margin around each legend ( |
legend.spacing , legend.spacing.x , legend.spacing.y |
the spacing between legends ( |
legend.key |
background underneath legend keys ( |
legend.key.size , legend.key.height , legend.key.width |
size of legend keys ( |
legend.key.spacing , legend.key.spacing.x , legend.key.spacing.y |
spacing
between legend keys given as a |
legend.frame |
frame drawn around the bar ( |
legend.ticks |
tick marks shown along bars or axes ( |
legend.ticks.length |
length of tick marks in legend ( |
legend.axis.line |
lines along axes in legends ( |
legend.text |
legend item labels ( |
legend.text.position |
placement of legend text relative to legend keys or bars ("top", "right", "bottom" or "left"). The legend text placement might be incompatible with the legend's direction for some guides. |
legend.title |
title of legend ( |
legend.title.position |
placement of legend title relative to the main legend ("top", "right", "bottom" or "left"). |
legend.position |
the default position of legends ("none", "left", "right", "bottom", "top", "inside") |
legend.position.inside |
A numeric vector of length two setting the
placement of legends that have the |
legend.direction |
layout of items in legends ("horizontal" or "vertical") |
legend.byrow |
whether the legend-matrix is filled by columns
( |
legend.justification |
anchor point for positioning legend inside plot ("center" or two-element numeric vector) or the justification according to the plot area when positioned outside the plot |
legend.justification.top , legend.justification.bottom , legend.justification.left , legend.justification.right , legend.justification.inside |
Same as |
legend.location |
Relative placement of legends outside the plot as a
string. Can be |
legend.box |
arrangement of multiple legends ("horizontal" or "vertical") |
legend.box.just |
justification of each legend within the overall bounding box, when there are multiple legends ("top", "bottom", "left", or "right") |
legend.box.margin |
margins around the full legend area, as specified
using |
legend.box.background |
background of legend area ( |
legend.box.spacing |
The spacing between the plotting area and the
legend box ( |
panel.background |
background of plotting area, drawn underneath plot
( |
panel.border |
border around plotting area, drawn on top of plot so that
it covers tick marks and grid lines. This should be used with
|
panel.spacing , panel.spacing.x , panel.spacing.y |
spacing between facet
panels ( |
panel.grid , panel.grid.major , panel.grid.minor , panel.grid.major.x , panel.grid.major.y , panel.grid.minor.x , panel.grid.minor.y |
grid lines ( |
panel.ontop |
option to place the panel (background, gridlines) over
the data layers ( |
plot.background |
background of the entire plot ( |
plot.title |
plot title (text appearance) ( |
plot.title.position , plot.caption.position |
Alignment of the plot title/subtitle
and caption. The setting for |
plot.subtitle |
plot subtitle (text appearance) ( |
plot.caption |
caption below the plot (text appearance)
( |
plot.tag |
upper-left label to identify a plot (text appearance)
( |
plot.tag.position |
The position of the tag as a string ("topleft",
"top", "topright", "left", "right", "bottomleft", "bottom", "bottomright")
or a coordinate. If a coordinate, can be a numeric vector of length 2 to
set the x,y-coordinate relative to the whole plot. The coordinate option
is unavailable for |
plot.tag.location |
The placement of the tag as a string, one of
|
plot.margin |
margin around entire plot ( |
strip.background , strip.background.x , strip.background.y |
background of facet labels ( |
strip.clip |
should strip background edges and strip labels be clipped
to the extend of the strip background? Options are |
strip.placement |
placement of strip with respect to axes, either "inside" or "outside". Only important when axes and strips are on the same side of the plot. |
strip.text , strip.text.x , strip.text.y , strip.text.x.top , strip.text.x.bottom , strip.text.y.left , strip.text.y.right |
facet labels ( |
strip.switch.pad.grid |
space between strips and axes when strips are
switched ( |
strip.switch.pad.wrap |
space between strips and axes when strips are
switched ( |
complete |
set this to |
validate |
|
Theme inheritance
Theme elements inherit properties from other theme elements hierarchically.
For example, axis.title.x.bottom
inherits from axis.title.x
which inherits
from axis.title
, which in turn inherits from text
. All text elements inherit
directly or indirectly from text
; all lines inherit from
line
, and all rectangular objects inherit from rect
.
This means that you can modify the appearance of multiple elements by
setting a single high-level component.
Learn more about setting these aesthetics in vignette("ggplot2-specs")
.
See Also
+.gg()
and %+replace%,
element_blank()
, element_line()
,
element_rect()
, and element_text()
for
details of the specific theme elements.
The modifying theme components and theme elements sections of the online ggplot2 book.
Examples
set.seed(123)
small_mat <- matrix(rnorm(56), nrow = 8)
ggheatmap(small_mat) +
scheme_theme(plot.background = element_rect(fill = "red"))
# `scheme_theme()` serves as the default theme and will always be
# overridden by any `theme()` settings applied directly to the plot
ggheatmap(small_mat) +
theme(plot.background = element_rect(fill = "blue")) +
scheme_theme(plot.background = element_rect(fill = "red"))
Show CraftBox
information
Description
Show CraftBox
information
Usage
## S4 method for signature 'CraftBox'
show(object)
Arguments
object |
A |
Value
The input invisiblely.
Print Layout object
Description
Print Layout object
Usage
## S4 method for signature 'LayoutProto'
show(object)
Arguments
object |
A |
Value
The input invisiblely.
Arrange plots crosswise horizontally or vertically
Description
The stack_cross
function is derived from stack_discrete()
and allows
for different layout ordering indices within a single layout.
Two aliases are provided for convenience:
-
stack_crossv
: A special case ofstack_cross
that setsdirection = "v"
for vertical alignment. -
stack_crossh
: A special case ofstack_cross
that setsdirection = "h"
for horizontal alignment.
Usage
stack_cross(direction, data = NULL, ..., theme = NULL, sizes = NA)
stack_crossv(data = NULL, ...)
stack_crossh(data = NULL, ...)
Arguments
direction |
A string indicating the direction of the stack layout,
either |
data |
Default dataset to use for the layout. If not specified, it must be supplied in each plot added to the layout, |
... |
Additional arguments passed to |
theme |
A |
sizes |
A numeric value or a |
See Also
Arrange plots horizontally or vertically
Description
If limits
is provided, a continuous variable will be required and aligned
in the direction specified (stack_continuous
). Otherwise, a discrete
variable will be required and aligned (stack_discrete
).
Several aliases are provided for convenience:
-
stack_vertical
: A special case ofstack_layout
that setsdirection = "v"
. -
stack_horizontal
: A special case ofstack_layout
that setsdirection = "h"
. -
stack_discretev
: A special case ofstack_discrete
that setsdirection = "v"
. -
stack_discreteh
: A special case ofstack_discrete
that setsdirection = "h"
. -
stack_continuousv()
: A special case ofstack_free
that setsdirection = "v"
. -
stack_continuoush()
: A special case ofstack_free
that setsdirection = "h"
.
For historical reasons, the following aliases are available:
-
stack_align
is an alias forstack_discrete
. -
stack_alignv
is an alias forstack_discretev
. -
stack_alignh
is an alias forstack_discreteh
. -
stack_free
is an alias forstack_continuous
. -
stack_freev
is an alias forstack_continuousv
. -
stack_freeh
is an alias forstack_continuoush
.
Usage
stack_layout(
direction,
data = NULL,
...,
theme = NULL,
sizes = NA,
limits = waiver()
)
stack_horizontal(data = NULL, ..., limits = waiver())
stack_vertical(data = NULL, ..., limits = waiver())
stack_discrete(direction, data = NULL, ..., theme = NULL, sizes = NA)
stack_discretev(data = NULL, ...)
stack_discreteh(data = NULL, ...)
stack_continuous(
direction,
data = NULL,
...,
limits = NULL,
theme = NULL,
sizes = NA
)
stack_continuousv(data = NULL, ...)
stack_continuoush(data = NULL, ...)
Arguments
direction |
A string indicating the direction of the stack layout,
either |
data |
Default dataset to use for the layout. If not specified, it must be supplied in each plot added to the layout:
|
... |
Additional arguments passed to |
theme |
A |
sizes |
A numeric value or a |
limits |
A |
Value
A StackLayout
object.
Examples
set.seed(123)
small_mat <- matrix(rnorm(56), nrow = 7L)
stack_horizontal(small_mat) + align_dendro()
# this is the same with:
stack_discrete("h", small_mat) + align_dendro()
stack_discreteh(small_mat) + align_dendro()
# For vertical layout:
stack_vertical(small_mat) + align_dendro()
Determine the active context of stack layout
Description
stack_active
is an alias for stack_switch()
, which sets what = NULL
by
default.
Usage
stack_switch(sizes = NULL, what = waiver(), ...)
stack_active(sizes = NULL, ...)
Arguments
sizes |
A numeric value or a |
what |
What should get activated for the stack layout?
A single number or string of the plot elements in the layout. If |
... |
These dots are for future extensions and must be empty. |
Value
A stack_switch
object which can be added to stack_layout()
.
Examples
stack_discrete("h", matrix(1:9, nrow = 3L)) +
ggheatmap() +
# ggheamtap will set the active context, directing following addition
# into the heatmap plot area. To remove the heatmap active context,
# we can use `stack_active()` which will direct subsequent addition into
# the stack
stack_active() +
# here we add a dendrogram to the stack.
align_dendro()
Remove axis elements
Description
Remove axis elements
Usage
theme_no_axes(
axes = "xy",
text = TRUE,
ticks = TRUE,
title = TRUE,
line = FALSE
)
Arguments
axes |
Which axes elements should be removed? A string containing
one or more of |
text |
If |
ticks |
If |
title |
If |
line |
If |
Value
A theme()
object.
Examples
p <- ggplot() +
geom_point(aes(x = wt, y = qsec), data = mtcars)
p + theme_no_axes()
p + theme_no_axes("b")
p + theme_no_axes("l")
Change the shape of the input object
Description
Change the shape of the input object
Usage
tune(data, shape = NULL)
Arguments
data |
An R object. |
shape |
Usually |
Details
In most cases, fortify_matrix()
or fortify_data_frame()
provide full
support for transforming objects. However, some objects may require two
completely different approaches to be fortified. The tune
function acts as
a helper to create a new class tailored for these objects.
tune
method collections
Convert the shape of a MAF for fortify method
Description
Convert the shape of a MAF for fortify method
Usage
## S3 method for class 'MAF'
tune(data, shape = NULL)
Arguments
data |
A |
shape |
Not used currently. |
See Also
Other tune:
tune.list()
,
tune.matrix()
Convert the shape of a list for fortify method
Description
Convert the shape of a list for fortify method
Usage
## S3 method for class 'list'
tune(data, shape = NULL)
Arguments
data |
A list |
shape |
Not used currently. |
See Also
Other tune:
tune.MAF()
,
tune.matrix()
Convert the shape of a matrix for fortify method
Description
Convert the shape of a matrix for fortify method
Usage
## S3 method for class 'matrix'
tune(data, shape)
Arguments
data |
A matrix. |
shape |
A string of |
See Also
Other tune:
tune.MAF()
,
tune.list()
Modify operated Context in quad_layout()
Description
The with_quad()
function modifies the application context of elements in
ggheatmap()
/quad_layout()
. It controls how objects like themes, scales,
or other plot modifications apply to specific annotation stacks or the main
plot without altering the currently active layout or plot.
Usage
with_quad(x, position = waiver(), main = NULL)
Arguments
x |
An object which can be added to the ggplot, including
schemes. See |
position |
A string specifying one or more positions-
|
main |
A single boolean value indicating whether |
Details
Default Behavior when adding object wrapped with with_quad()
:
For quad_layout()
object:
When
ggheatmap()
/quad_layout()
has no active annotation stack, objects added via+
or-
operate normally withoutwith_quad()
.When the active annotation stack is set,
with_quad()
ensures the applied object also modifies:The main plot (by default).
Opposite annotation stacks when using
-
.
For stack_layout()
object:
When the active layout is the
stack_layout()
itself:-
-
operator will apply changes to all plots along thestack_layout()
, which means if the stack layout is inhorizontal
,-
operator will also add the element to theleft
andright
annotation, if the stack layout is invertical
,-
operator will also add element to thetop
andbottom
annotation. -
+
operator won't do anything special.
-
When the active layout is the nested
ggheatmap()
/quad_layout()
, the+
/-
operator applies the elements to this nested layout, following the same principles as forggheatmap()
/quad_layout()
.
Value
The original object with an added attribute that sets the specified context.
Examples
set.seed(123)
small_mat <- matrix(rnorm(56), nrow = 7)
# By wrapping object with `with_quad()`, the `+` operator will apply the
# object not only to the active plot in the annotation stack, but also to
# the main plot unless specified by `main` argument otherwise.
ggheatmap(small_mat) +
# initialize the left annotation
anno_left(size = 0.2) +
align_dendro() +
# apply the object not only to the active plot in the annotation stack,
# but also to the main plot
with_quad(theme(plot.background = element_rect(fill = "red")))
# the `-` operator will apply changes not only to the active annotation
# stack but also to the opposite one (i.e., bottom if top is active, and
# vice versa). The same principle applies to the left and right annotation.
ggheatmap(small_mat) +
anno_left(size = 0.2) +
align_dendro(aes(color = branch), k = 3L) +
# Change the active layout to the left annotation
anno_top(size = 0.2) +
align_dendro(aes(color = branch), k = 3L) +
anno_bottom(size = 0.2) +
align_dendro(aes(color = branch), k = 3L) -
# Modify the color scale of all plots in the bottom and the opposite
# annotation, in this way, the `main` argument by default would be `TRUE`
with_quad(scale_color_brewer(palette = "Dark2", name = "Top and bottom"))
# When the `position` argument is manually set, the
# default value of the `main` argument will be `FALSE`.
ggheatmap(small_mat) +
anno_left(size = 0.2) +
align_dendro(aes(color = branch), k = 3L) +
anno_top(size = 0.2) +
align_dendro(aes(color = branch), k = 3L) +
anno_bottom(size = 0.2) +
align_dendro(aes(color = branch), k = 3L) -
# Modify the background of all plots in the left and top annotation
with_quad(theme(plot.background = element_rect(fill = "red")), "tl")