Constructor Method for AdditiveUnit Class

Description

Constructor Method for AdditiveUnit Class

Usage

AdditiveUnit(...)

Arguments

Details

This method is not used in the package.

Value

No value is returned.

Author

Zuguang Gu z.gu@dkfz.de

Examples

# There is no example
NULL

Class for Concatenating Heatmaps and Annotations

Description

Class for Concatenating Heatmaps and Annotations

Details

This class is a super class for Heatmap-class , HeatmapList-class and HeatmapAnnotation-class classes. It is only designed for + generic method and the %v%v method so that above three classes can be appended to each other.

Examples

# There is no example
NULL

Constructor of AnnotationFunction Class

Description

Constructor of AnnotationFunction Class

Usage

AnnotationFunction(fun, fun_name = "", which = c("column", "row"),
    var_import = list(), n = NA, data_scale = c(0, 1), subset_rule = list(),
    subsetable = length(subset_rule) > 0, show_name = TRUE, width = NULL, height = NULL)

Arguments

Details

In the package, we have implemted quite a lot annotation functions by AnnotationFunction constructor: anno_empty , anno_image , anno_points , anno_lines , anno_barplot , anno_boxplot , anno_histogram , anno_density , anno_joyplot , anno_horizon , anno_text and anno_mark . These built-in annotation functions support as both row annotations and column annotations and they are are all subsettable.

The build-in annotation functions are already enough for most of the analysis, nevertheless, if users want to know more about how to construct the AnnotationFunction class manually, they can refer to https://jokergoo.github.io/ComplexHeatmap-reference/book/heatmap-annotations.html#implement-new-annotation-functions.

Value

A AnnotationFunction-class object which can be used in HeatmapAnnotation .

Examples

x = 1:10
anno1 = AnnotationFunction(
fun = function(index, k, n) {
n = length(index)
pushViewport(viewport(xscale = c(0.5, n + 0.5), yscale = c(0, 10)))
grid.rect()
grid.points(1:n, x[index], default.units = "native")
if(k == 1) grid.yaxis()
popViewport()
},
var_import = list(x = x),
n = 10,
subsetable = TRUE,
height = unit(2, "cm")
)
m = rbind(1:10, 11:20)
Heatmap(m, top_annotation = HeatmapAnnotation(foo = anno1))
Heatmap(m, top_annotation = HeatmapAnnotation(foo = anno1), column_km = 2)

The AnnotationFunction Class

Description

The AnnotationFunction Class

Details

The heatmap annotation is basically graphics aligned to the heatmap columns or rows. There is no restriction for the graphic types, e.g. it can be heatmap-like annotation or points. Here the AnnotationFunction class is designed for creating complex and flexible annotation graphics. As the main part of the class, it uses a user-defined function to define the graphics. It also keeps information of the size of the plotting regions of the annotation. And most importantly, it allows subsetting to the annotation to draw a subset of the graphics, which is the base for the splitting of the annotations.

See AnnotationFunction constructor for details.

Examples

# There is no example
NULL

Constructor Method for ColorMapping Class

Description

Constructor Method for ColorMapping Class

Usage

ColorMapping(name, colors = NULL, levels = NULL,
    col_fun = NULL, breaks = NULL, na_col = "#FFFFFF")

Arguments

Details

colors and levels are used for discrete color mapping, col_fun and breaks are used for continuous color mapping.

Value

A ColorMapping-class object.

Author

Zuguang Gu z.gu@dkfz.de

Examples

cm = ColorMapping(colors = c("A" = "red", "B" = "black"))
cm
require(circlize)
col_fun = colorRamp2(c(0, 1), c("white", "red"))
cm = ColorMapping(col_fun = col_fun)

Class for Color Mapping

Description

Class for Color Mapping

Details

The ColorMapping-class handles color mapping for discrete values and continuous values. Discrete values are mapped by setting a vector of colors and continuous values are mapped by setting a color mapping function.

Author

Zuguang Gu z.gu@dkfz.de

Examples

# There is no example
NULL

Make complex heatmaps

Description

Make complex heatmaps

Details

This package aims to provide a simple and flexible way to arrange multiple heatmaps as well as flexible annotation graphics.

The package is implemented in an object-oriented way. The heatmap lists are abstracted into several classes.

• Heatmap-class : a single heatmap containing heatmap body, row/column names, titles, dendrograms and annotations.

• HeatmapList-class : a list of heatmaps and annotations.

• HeatmapAnnotation-class : a list of row/column annotations.

There are also several internal classes:

• SingleAnnotation-class : a single row annotation or column annotation.

• ColorMapping-class : mapping from values to colors.

• AnnotationFunction-class : construct an annotation function which allows subsetting.

Following two high-level functions take use of functionality of complex heatmaps:

• oncoPrint : oncoPrint plot which visualize genomic alterations in a set of genes.

• densityHeatmap : use heatmaps to visualize density distributions.

The complete reference of ComplexHeatmap package is available at http://jokergoo.github.io/ComplexHeatmap-reference/book.

Examples

# There is no example
NULL

Subset an AnnotationFunction Object

Description

Subset an AnnotationFunction Object

Usage

list(list("["), list("AnnotationFunction"))(x, i)

Arguments

Details

One good thing for designing the AnnotationFunction-class is it can be subsetted, and this is the base for the splitting of the annotations.

Examples

anno = anno_simple(1:10)
anno[1:5]
draw(anno[1:5], test = "subset of column annotation")

Subset a Heatmap

Description

Subset a Heatmap

Usage

list(list("["), list("Heatmap"))(x, i, j)

Arguments

Details

This functionality is quite experimental. It should be applied before the layout is initialized.

Examples

m = matrix(rnorm(100), nrow = 10)
rownames(m) = letters[1:10]
colnames(m) = LETTERS[1:10]
ht = Heatmap(m)
ht[1:5, ]
ht[1:5]
ht[, 1:5]
ht[1:5, 1:5]

Subset the HeatmapAnnotation object

Description

Subset the HeatmapAnnotation object

Usage

list(list("["), list("HeatmapAnnotation"))(x, i, j)

Arguments

Examples

ha = HeatmapAnnotation(foo = 1:10, bar = anno_points(10:1),
sth = cbind(1:10, 10:1))
ha[1:5, ]
ha[, c("foo", "bar")]
ha[, 1:2]
ha[1:5, c("foo", "sth")]

Subset a HeatmapList object

Description

Subset a HeatmapList object

Usage

list(list("["), list("HeatmapList"))(x, i, j)

Arguments

Details

If the heatmap list is horizontal, i is the row indices and j corresponds to heatmap names and single annotation names. and if the heatlist is vertical, i corresponds to heatmap/annotation names and j is the column indices.

Examples

ht_list = Heatmap(matrix(rnorm(100), 10), name = "rnorm") +
rowAnnotation(foo = 1:10, bar = anno_points(10:1)) +
Heatmap(matrix(runif(100), 10), name = "runif")
summary(ht_list[1:5, ])
summary(ht_list[1:5, 1])
summary(ht_list[1:5, "rnorm"])
summary(ht_list[1:5, c("rnorm", "foo")])

ht_list = Heatmap(matrix(rnorm(100), 10), name = "rnorm") %v%
columnAnnotation(foo = 1:10, bar = anno_points(10:1)) %v%
Heatmap(matrix(runif(100), 10), name = "runif")
summary(ht_list[, 1:5])
summary(ht_list[1, 1:5])
summary(ht_list["rnorm", 1:5])
summary(ht_list[c("rnorm", "foo"), 1:5])

Subset an SingleAnnotation Object

Description

Subset an SingleAnnotation Object

Usage

list(list("["), list("SingleAnnotation"))(x, i)

Arguments

Details

The SingleAnnotation class object is subsetable only if the containing AnnotationFunction-class object is subsetable. All the anno_* functions are subsetable, so if the SingleAnnotation object is constructed by one of these functions, it is also subsetable.

Examples

ha = SingleAnnotation(value = 1:10)
ha[1:5]
draw(ha[1:5], test = "ha[1:5]")

Subset the Combination Matrix

Description

Subset the Combination Matrix

Usage

list(list("["), list("comb_mat"))(x, i, j, drop = FALSE)

Arguments

Details

If sets are on rows of the combination matrix, the row indices correspond to sets and column indices correspond to combination sets, and if sets are on columns of the combination matrix, rows correspond to the combination sets.

If the index is one-dimension, e.g. x[i] , the index always corresponds to the combination sets.

You should not subset by the sets. It will give you wrong combination set size. The subsetting on sets are only used internally.

This subsetting method is mainly for subsetting combination sets, i.e., users can first use comb_size to get the size of each combination set, and filter them by the size.

Examples

set.seed(123)
lt = list(a = sample(letters, 10),
b = sample(letters, 15),
c = sample(letters, 20))
m = make_comb_mat(lt)
m2 = m[, comb_size(m) >= 3]
comb_size(m2)
m[comb_size(m) >= 3]

Constructor method for Heatmap class

Description

Constructor method for Heatmap class

Usage

Heatmap(matrix, col, name,
    na_col = "grey",
    color_space = "LAB",
    rect_gp = gpar(col = NA),
    border = NA,
    cell_fun = NULL,
    layer_fun = NULL,
    
    row_title = character(0),
    row_title_side = c("left", "right"),
    row_title_gp = gpar(fontsize = 14),
    row_title_rot = switch(row_title_side[1], "left" = 90, "right" = 270),
    column_title = character(0),
    column_title_side = c("top", "bottom"),
    column_title_gp = gpar(fontsize = 14),
    column_title_rot = 0,
    
    cluster_rows = TRUE,
    cluster_row_slices = TRUE,
    clustering_distance_rows = "euclidean",
    clustering_method_rows = "complete",
    row_dend_side = c("left", "right"),
    row_dend_width = unit(10, "mm"),
    show_row_dend = TRUE,
|    row_dend_reorder = is.logical(cluster_rows) || is.function(cluster_rows),|
    row_dend_gp = gpar(),
    cluster_columns = TRUE,
    cluster_column_slices = TRUE,
    clustering_distance_columns = "euclidean",
    clustering_method_columns = "complete",
    column_dend_side = c("top", "bottom"),
    column_dend_height = unit(10, "mm"),
    show_column_dend = TRUE,
    column_dend_gp = gpar(),
|    column_dend_reorder = is.logical(cluster_columns) || is.function(cluster_columns),|
    
    row_order = NULL,
    column_order = NULL,
    
    row_labels = rownames(matrix),
    row_names_side = c("right", "left"),
    show_row_names = TRUE,
    row_names_max_width = unit(6, "cm"),
    row_names_gp = gpar(fontsize = 12),
    row_names_rot = 0,
    row_names_centered = FALSE,
    column_labels = colnames(matrix),
    column_names_side = c("bottom", "top"),
    show_column_names = TRUE,
    column_names_max_height = unit(6, "cm"),
    column_names_gp = gpar(fontsize = 12),
    column_names_rot = 90,
    column_names_centered = FALSE,
    
    top_annotation = NULL,
    bottom_annotation = NULL,
    left_annotation = NULL,
    right_annotation = NULL,
    
    km = 1,
    split = NULL,
    row_km = km,
    row_km_repeats = 1,
    row_split = split,
    column_km = 1,
    column_km_repeats = 1,
    column_split = NULL,
    gap = unit(1, "mm"),
    row_gap = unit(1, "mm"),
    column_gap = unit(1, "mm"),
    show_parent_dend_line = ht_opt$show_parent_dend_line,
    
    heatmap_width = unit(1, "npc"),
    width = NULL,
    heatmap_height = unit(1, "npc"),
    height = NULL,
    
    show_heatmap_legend = TRUE,
    heatmap_legend_param = list(title = name),
    
|    use_raster = (nrow(matrix) > 2000 && ncol(matrix) > 1) || (ncol(matrix) > 2000 && nrow(matrix) > 1),|
    raster_device = c("png", "jpeg", "tiff", "CairoPNG", "CairoJPEG", "CairoTIFF"),
    raster_quality = 2,
    raster_device_param = list(),
    raster_resize = FALSE,
    
    post_fun = NULL)

Arguments

Details

The initialization function only applies parameter checking and fill values to the slots with some validation.

Following methods can be applied to the Heatmap-class object:

• show,Heatmap-method : draw a single heatmap with default parameters

• draw,Heatmap-method : draw a single heatmap.

• + or %v% append heatmaps and annotations to a list of heatmaps.

The constructor function pretends to be a high-level graphic function because the show method of the Heatmap-class object actually plots the graphics.

Value

A Heatmap-class object.

Seealso

https://jokergoo.github.io/ComplexHeatmap-reference/book/a-single-heatmap.html

Author

Zuguang Gu z.gu@dkfz.de

Examples

# There is no example
NULL

Constructor Method for HeatmapAnnotation class

Description

Constructor Method for HeatmapAnnotation class

Usage

HeatmapAnnotation(...,
    df, name, col, na_col = "grey",
    annotation_legend_param = list(),
    show_legend = TRUE,
    which = c("column", "row"),
    gp = gpar(col = NA),
    border = FALSE,
    gap = unit(1, "points"),
    
    show_annotation_name = TRUE,
    annotation_name_gp = gpar(),
    annotation_name_offset = NULL,
    annotation_name_side = ifelse(which == "column", "right", "bottom"),
    annotation_name_rot = NULL,
    
    annotation_height = NULL,
    annotation_width = NULL,
    height = NULL,
    width = NULL,
    simple_anno_size = ht_opt$simple_anno_size,
    simple_anno_size_adjust = FALSE)

Arguments

Details

For arguments show_legend , border , annotation_name_offset , annotation_name_side , annotation_name_rot , show_annotation_name , they can be set as named vectors to modify values for some of the annotations, e.g. assuming you have an annotation with name foo , you can specify border = c(foo = TRUE) in HeatmapAnnotation .

There are three ways to specify heatmap annotations:

1. If the annotation is simply a vector or a matrix, it can be specified like HeatmapAnnotation(foo = 1:10) .
2. If the annotations are already stored as a data frame, it can be specified like HeatmapAnnotation(df = df) .
3. For complex annotations, users can use the pre-defined annotation functions such as anno_points : HeatmapAnnotation(foo = anno_points(1:10)) .

For more details and examples, please check https://jokergoo.github.io/ComplexHeatmap-reference/book/heatmap-annotations.html.

Value

A HeatmapAnnotation-class object.

Seealso

There are two helper functions: rowAnnotation and columnAnnotation .

Author

Zuguang Gu z.gu@dkfz.de

Examples

# There is no example
NULL

Class for Heatmap Annotations

Description

Class for Heatmap Annotations

Details

A complex heatmap contains a list of annotations which are represented as graphics placed on rows and columns. The HeatmapAnnotation-class contains a list of single annotations which are represented as a list of SingleAnnotation-class objects.

Author

Zuguang Gu z.gu@dkfz.de

Examples

# There is no example
NULL

Constructor method for HeatmapList class

Description

Constructor method for HeatmapList class

Usage

HeatmapList(...)

Arguments

Details

There is no public constructor method for the HeatmapList-class .

Value

No value is returned.

Author

Zuguang Gu z.gu@dkfz.de

Examples

# There is no example
NULL

Class for a list of heatmaps

Description

Class for a list of heatmaps

Details

A heatmap list is defined as a list of heatmaps and annotations.

Author

Zuguang Gu z.gu@dkfz.de

Examples

# There is no example
NULL

Class for a Single Heatmap

Description

Class for a Single Heatmap

Details

The Heatmap-class is not responsible for heatmap legend and annotation legends. The draw,Heatmap-method method constructs a HeatmapList-class object which only contains one single heatmap and call draw,HeatmapList-method to make the complete heatmap.

Author

Zuguang Gu z.gu@dkfz.de

Examples

# There is no example
NULL

Make a Single Legend

Description

Make a Single Legend

Usage

Legend(at, labels = at, col_fun, nrow = NULL, ncol = 1, by_row = FALSE,
    grid_height = unit(4, "mm"), grid_width = unit(4, "mm"), gap = unit(2, "mm"),
    labels_gp = gpar(fontsize = 10), labels_rot = 0,
    border = NULL, background = "#EEEEEE",
    type = "grid", legend_gp = gpar(),
    pch = 16, size = unit(2, "mm"),
    legend_height = NULL, legend_width = NULL,
    direction = c("vertical", "horizontal"),
    title = "", title_gp = gpar(fontsize = 10, fontface = "bold"),
    title_position = c("topleft", "topcenter", "leftcenter", "lefttop", "leftcenter-rot", "lefttop-rot"),
    title_gap = unit(1.5, "mm"))

Arguments

Details

Most of the argument can also be set in heatmap_legend_param argument in Heatmap or annotation_legend_param argument in HeatmapAnnotation to configure legend styles for heatmap and annotations.

Value

A Legends-class object.

Seealso

packLegend packs multiple legends into one Legends-class object.

See examples of configuring legends: https://jokergoo.github.io/ComplexHeatmap-reference/book/legends.html

Examples

lgd = Legend(labels = month.name[1:6], title = "foo", legend_gp = gpar(fill = 1:6))
draw(lgd, test = "add labels and title")

require(circlize)
col_fun = colorRamp2(c(0, 0.5, 1), c("blue", "white", "red"))
lgd = Legend(col_fun = col_fun, title = "foo")
draw(lgd, test = "only col_fun")

col_fun = colorRamp2(c(0, 0.5, 1), c("blue", "white", "red"))
lgd = Legend(col_fun = col_fun, title = "foo", at = c(0, 0.1, 0.15, 0.5, 0.9, 0.95, 1))
draw(lgd, test = "unequal interval breaks")

Constructor method for Legends class

Description

Constructor method for Legends class

Usage

Legends(...)

Arguments

Details

There is no public constructor method for the Legends-class .

Value

No value is returned.

Author

Zuguang Gu z.gu@dkfz.de

Examples

# There is no example
NULL

The Class for Legends

Description

The Class for Legends

Details

This is a very simple class for legends that it only has one slot which is the real grob of the legends.

Construct a single legend by Legend and a group of legends by packLegend .

Examples

lgd = Legend(at = 1:4)
lgd
lgd@grob

Constructor Method for SingleAnnotation Class

Description

Constructor Method for SingleAnnotation Class

Usage

SingleAnnotation(name, value, col, fun,
    na_col = "grey",
    which = c("column", "row"),
    show_legend = TRUE,
    gp = gpar(col = NA),
    border = FALSE,
    legend_param = list(),
    show_name = TRUE,
    name_gp = gpar(fontsize = 12),
    name_offset = NULL,
    name_side = ifelse(which == "column", "right", "bottom"),
    name_rot = NULL,
    simple_anno_size = ht_opt$simple_anno_size,
    width = NULL, height = NULL)

Arguments

Details

A single annotation is a basic unit of complex heatmap annotations where the heamtap annotations are always a list of single annotations. An annotation can be simply heatmap-like (here we call it simple annotation) or more complex like points, lines, boxes (for which we call it complex annotation).

In the SingleAnnotation constructor, value , col , na_col are used to construct a anno_simple annotation funciton which is generated internally by AnnotationFunction . The legend of the simple annotation can be automatcally generated,

For construcing a complex annotation, users need to use fun which is a user-defind function. Normally it is constucted by AnnotationFunction . One big advantage for using AnnotationFunction is the annotation function or the graphics drawn by the annotation function can be split according to row splitting or column splitting of the heatmap. Users can also provide a "pure" function which is a normal R function for the fun argument. The function only needs one argument which is a vector of index for rows or columns depending whether it is a row annotation or column annotation. The other two optional arguments are the current slice index and total number of slices. See Examples section for an example. If it is a normal R function, it will be constructed into the AnnotationFunction-class object internally.

The SingleAnnotation-class is a simple wrapper on top of AnnotationFunction-class only with annotation name added.

The class also stored the "extended area" relative to the area for the annotation graphics. The extended areas are those created by annotation names and axes.

Value

A SingleAnnotation-class object.

Seealso

There are following built-in annotation functions that can be directly used to generate complex annotations: anno_simple , anno_points , anno_lines , anno_barplot , anno_histogram , anno_boxplot , anno_density , anno_text , anno_joyplot , anno_horizon , anno_image , anno_block , anno_summary and anno_mark .

Author

Zuguang Gu z.gu@dkfz.de

Examples

ha = SingleAnnotation(value = 1:10)
draw(ha, test = "single column annotation")

m = cbind(1:10, 10:1)
colnames(m) = c("a", "b")
ha = SingleAnnotation(value = m)
draw(ha, test = "matrix as column annotation")

anno = anno_barplot(matrix(nc = 2, c(1:10, 10:1)))
ha = SingleAnnotation(fun = anno)
draw(ha, test = "anno_barplot as input")

fun = local({
# because there variables outside the function for use, we put it a local environment
value = 1:10
function(index, k = 1, n = 1) {
pushViewport(viewport(xscale = c(0.5, length(index) + 0.5), yscale = range(value)))
grid.points(seq_along(index), value[index])
grid.rect()
if(k == 1) grid.yaxis()
popViewport()
}
})
ha = SingleAnnotation(fun = fun, height = unit(4, "cm"))
draw(ha, index = 1:10, test = "self-defined function")

Class for a Single Annotation

Description

Class for a Single Annotation

Details

The SingleAnnotation-class is used for storing data for a single annotation and provides methods for drawing annotation graphics.

Seealso

The SingleAnnotation-class is always used internally. The public HeatmapAnnotation-class contains a list of SingleAnnotation-class objects and is used to add annotation graphics on heatmaps.

Author

Zuguang Gu z.gu@dkfz.de

Examples

# There is no example
NULL

Make the UpSet plot

Description

Make the UpSet plot

Usage

UpSet(m,
    comb_col = "black",
    pt_size = unit(3, "mm"), lwd = 2,
    bg_col = "#F0F0F0", bg_pt_col = "#CCCCCC",
    set_order = order(set_size(m), decreasing = TRUE),
    comb_order = if(attr(m, "set_on_rows")) {
    order.comb_mat(m[set_order, ], decreasing = TRUE)
    } else {
    order.comb_mat(m[, set_order], decreasing = TRUE)
    },
    top_annotation = upset_top_annotation(m),
    right_annotation = upset_right_annotation(m),
    row_names_side = "left",
    ...)

Arguments

Details

By default, the sets are on rows and combination sets are on columns. The positions of the two types of sets can be switched by transposing the matrix.

When sets are on rows, the default top annotation is the barplot showing the size of each combination sets and the default right annotation is the barplot showing the size of the sets. The annotations are simply constructed by HeatmapAnnotation and anno_barplot with some parameters pre-set. Users can check the source code of upset_top_annotation and upset_right_annotation to find out how the annotations are defined.

To change or to add annotations, users just need to define a new HeatmapAnnotation object. E.g. if we want to change the side of the axis and name on top annotation:

list(" ", " Upset(..., top_annotation = ", " HeatmapAnnotation( ", " "Intersection size" = anno_barplot( ", " comb_size(m), ", " border = FALSE, ", " gp = gpar(fill = "black"), ", " height = unit(2, "cm"), ", " axis_param = list(side = "right") ", " ), ", " annotation_name_side = "right", ", " annotation_name_rot = 0) ", " ) ")

To add more annotations on top, users just add it in HeatmapAnnotation :

list(" ", " Upset(..., top_annotation = ", " HeatmapAnnotation( ", " "Intersection size" = anno_barplot( ", " comb_size(m), ", " border = FALSE, ", " gp = gpar(fill = "black"), ", " height = unit(2, "cm"), ", " axis_param = list(side = "right") ", " ), ", " "anno1" = anno_points(...), ", " "anno2" = some_vector, ", " annotation_name_side = "right", ",

"           annotation_name_rot = 0)

", " ) ")

And so is for the right annotations.

UpSet returns a Heatmap-class object, which means, you can add it with other heatmaps and annotations by + or %v% .

Examples

set.seed(123)
lt = list(a = sample(letters, 10),
b = sample(letters, 15),
c = sample(letters, 20))
m = make_comb_mat(lt)
UpSet(m)
UpSet(t(m))

m = make_comb_mat(lt, mode = "union")
UpSet(m)
UpSet(m, comb_col = c(rep(2, 3), rep(3, 3), 1))

# compare two UpSet plots
set.seed(123)
lt1 = list(a = sample(letters, 10),
b = sample(letters, 15),
c = sample(letters, 20))
m1 = make_comb_mat(lt1)
set.seed(456)
lt2 = list(a = sample(letters, 10),
b = sample(letters, 15),
c = sample(letters, 20))
m2 = make_comb_mat(lt2)

max1 = max(c(set_size(m1), set_size(m2)))
max2 = max(c(comb_size(m1), comb_size(m2)))

UpSet(m1, top_annotation = upset_top_annotation(m1, ylim = c(0, max2)),
right_annotation = upset_right_annotation(m1, ylim = c(0, max1)),
column_title = "UpSet1") +
UpSet(m2, top_annotation = upset_top_annotation(m2, ylim = c(0, max2)),
right_annotation = upset_right_annotation(m2, ylim = c(0, max1)),
column_title = "UpSet2")

Horizontally Add Heatmaps or Annotations to a Heatmap List

Description

Horizontally Add Heatmaps or Annotations to a Heatmap List

Usage

list(list("+"), list("AdditiveUnit"))(x, y)

Arguments

Details

It is only a helper function. It actually calls add_heatmap,Heatmap-method , add_heatmap,HeatmapList-method or add_heatmap,HeatmapAnnotation-method depending on the class of the input objects.

The HeatmapAnnotation-class object to be added should only be row annotations. Column annotations should be added to the heatmap list by %v% .

x and y can also be NULL .

Value

A HeatmapList-class object.

Seealso

%v% operator is used for vertical heatmap list.

Author

Zuguang Gu z.gu@dkfz.de

Examples

# There is no example
NULL

Add Annotations or Heatmaps as a Heatmap List

Description

Add Annotations or Heatmaps as a Heatmap List

Usage

list(list("add_heatmap"), list("HeatmapAnnotation"))(object, x, direction = c("horizontal", "vertical"))

Arguments

Details

Normally we directly use + for horizontal concatenation and %v% for vertical concatenation.

Value

A HeatmapList-class object.

Author

Zuguang Gu z.gu@dkfz.de

Examples

# There is no example
NULL

Add heatmaps and row annotations to the heatmap list

Description

Add heatmaps and row annotations to the heatmap list

Usage

list(list("add_heatmap"), list("HeatmapList"))(object, x, direction = c("horizontal", "vertical"))

Arguments

Details

There is a shortcut function +.AdditiveUnit .

Value

A HeatmapList-class object.

Author

Zuguang Gu z.gu@dkfz.de

Examples

# There is no example
NULL

Add Heatmap to the Heatmap List

Description

Add Heatmap to the Heatmap List

Usage

list(list("add_heatmap"), list("Heatmap"))(object, x, direction = c("horizontal", "vertical"))

Arguments

Details

Normally we directly use + for horizontal concatenation and %v% for vertical concatenation.

Value

A HeatmapList-class object.

Author

Zuguang Gu z.gu@dkfz.de

Examples

# There is no example
NULL

Method dispatch page for add_heatmap

Description

Method dispatch page for add_heatmap .

Examples

# no example
NULL

Adjust the Positions of nodes/leaves in the Dendrogram

Description

Adjust the Positions of nodes/leaves in the Dendrogram

Usage

adjust_dend_by_x(dend, leaf_pos = 1:nobs(dend)-0.5)

Arguments

Details

The positions of nodes stored as x attribute are recalculated based on the new positions of leaves.

By default, the position of leaves are at 0.5, 1.5, ..., n-0.5.

Examples

m = matrix(rnorm(100), 10)
dend = as.dendrogram(hclust(dist(m)))
dend = adjust_dend_by_x(dend, sort(runif(10)))
str(dend)
dend = adjust_dend_by_x(dend, unit(1:10, "cm"))
str(dend)

Adjust Heatmap List

Description

Adjust Heatmap List

Usage

list(list("adjust_heatmap_list"), list("HeatmapList"))(object)

Arguments

Details

This function adjusts settings in all other heatmaps according to the main heatmap. It also adjust the size of heatmap annotations to make them aligned nicely.

This function is only for internal use.

Author

Zuguang Gu z.gu@dkfz.de

Examples

# There is no example
NULL

Barplot Annotation

Description

Barplot Annotation

Usage

anno_barplot(x, baseline = 0, which = c("column", "row"), border = TRUE, bar_width = 0.6,
    gp = gpar(fill = "#CCCCCC"), ylim = NULL, extend = 0.05, axis = TRUE,
    axis_param = default_axis_param(which),
    width = NULL, height = NULL, ...)

Arguments

Value

An annotation function which can be used in HeatmapAnnotation .

Seealso

https://jokergoo.github.io/ComplexHeatmap-reference/book/heatmap-annotations.html#barplot_annotation

Examples

anno = anno_barplot(1:10)
draw(anno, test = "a vector")

m = matrix(runif(4*10), nc = 4)
m = t(apply(m, 1, function(x) x/sum(x)))
anno = anno_barplot(m, gp = gpar(fill = 2:5), bar_width = 1, height = unit(6, "cm"))
draw(anno, test = "proportion matrix")

Block annotation

Description

Block annotation

Usage

anno_block(gp = gpar(), labels = NULL, labels_gp = gpar(), labels_rot = ifelse(which == "row", 90, 0),
    which = c("column", "row"), width = NULL, height = NULL)

Arguments

Details

The block annotation is used for representing slices. The length of all arguments should be 1 or the number of slices.

Value

An annotation function which can be used in HeatmapAnnotation .

Seealso

https://jokergoo.github.io/ComplexHeatmap-reference/book/heatmap-annotations.html#block-annotation

Examples

Heatmap(matrix(rnorm(100), 10),
top_annotation = HeatmapAnnotation(foo = anno_block(gp = gpar(fill = 2:4),
labels = c("group1", "group2", "group3"), labels_gp = gpar(col = "white"))),
column_km = 3,
left_annotation = rowAnnotation(foo = anno_block(gp = gpar(fill = 2:4),
labels = c("group1", "group2", "group3"), labels_gp = gpar(col = "white"))),
row_km = 3)

Boxplot Annotation

Description

Boxplot Annotation

Usage

anno_boxplot(x, which = c("column", "row"), border = TRUE,
    gp = gpar(fill = "#CCCCCC"), ylim = NULL, extend = 0.05, outline = TRUE, box_width = 0.6,
    pch = 1, size = unit(2, "mm"), axis = TRUE, axis_param = default_axis_param(which),
    width = NULL, height = NULL, ...)

Arguments

Value

An annotation function which can be used in HeatmapAnnotation .

Seealso

https://jokergoo.github.io/ComplexHeatmap-reference/book/heatmap-annotations.html#box-annotation

Examples

set.seed(123)
m = matrix(rnorm(100), 10)
anno = anno_boxplot(m, height = unit(4, "cm"))
draw(anno, test = "anno_boxplot")
anno = anno_boxplot(m, height = unit(4, "cm"), gp = gpar(fill = 1:10))
draw(anno, test = "anno_boxplot with gp")

Density Annotation

Description

Density Annotation

Usage

anno_density(x, which = c("column", "row"),
    type = c("lines", "violin", "heatmap"),
    heatmap_colors = rev(brewer.pal(name = "RdYlBu", n = 11)),
    joyplot_scale = 1, border = TRUE, gp = gpar(fill = "#CCCCCC"),
    axis = TRUE, axis_param = default_axis_param(which),
    width = NULL, height = NULL)

Arguments

Value

An annotation function which can be used in HeatmapAnnotation .

Seealso

https://jokergoo.github.io/ComplexHeatmap-reference/book/heatmap-annotations.html#density-annotation

Examples

m = matrix(rnorm(100), 10)
anno = anno_density(m, which = "row")
draw(anno, test = "normal density")
anno = anno_density(m, which = "row", type = "violin")
draw(anno, test = "violin")
anno = anno_density(m, which = "row", type = "heatmap")
draw(anno, test = "heatmap")
anno = anno_density(m, which = "row", type = "heatmap",
heatmap_colors = c("white", "orange"))
draw(anno, test = "heatmap, colors")

Empty Annotation

Description

Empty Annotation

Usage

anno_empty(which = c("column", "row"), border = TRUE, zoom = FALSE,
    width = NULL, height = NULL)

Arguments

Details

It creates an empty annotation and holds space, later users can add graphics by decorate_annotation . This function is useful when users have difficulty to implement AnnotationFunction object.

In following example, an empty annotation is first created and later points are added:

list(" ", " m = matrix(rnorm(100), 10) ", " ht = Heatmap(m, top_annotation = HeatmapAnnotation(pt = anno_empty())) ", " ht = draw(ht) ", " co = column_order(ht)[[1]] ", " pt_value = 1:10 ", " decorate_annotation("pt", { ", " pushViewport(viewport(xscale = c(0.5, ncol(mat)+0.5), yscale = range(pt_value))) ", " grid.points(seq_len(ncol(mat)), pt_value[co], pch = 16, default.units = "native") ", " grid.yaxis() ", " popViewport() ", " }) ")

And it is similar as using anno_points :

list(" ", " Heatmap(m, top_annotation = HeatmapAnnotation(pt = anno_points(pt_value))) ")

Value

An annotation function which can be used in HeatmapAnnotation .

Seealso

https://jokergoo.github.io/ComplexHeatmap-reference/book/heatmap-annotations.html#empty-annotation

Examples

anno = anno_empty()
draw(anno, test = "anno_empty")
anno = anno_empty(border = FALSE)
draw(anno, test = "anno_empty without border")

Histogram Annotation

Description

Histogram Annotation

Usage

anno_histogram(x, which = c("column", "row"), n_breaks = 11,
    border = FALSE, gp = gpar(fill = "#CCCCCC"),
    axis = TRUE, axis_param = default_axis_param(which),
    width = NULL, height = NULL)

Arguments

Value

An annotation function which can be used in HeatmapAnnotation .

Seealso

https://jokergoo.github.io/ComplexHeatmap-reference/book/heatmap-annotations.html#histogram-annotation

Examples

m = matrix(rnorm(1000), nc = 10)
anno = anno_histogram(t(m), which = "row")
draw(anno, test = "row histogram")
anno = anno_histogram(t(m), which = "row", gp = gpar(fill = 1:10))
draw(anno, test = "row histogram with color")
anno = anno_histogram(t(m), which = "row", n_breaks = 20)
draw(anno, test = "row histogram with color")

Horizon chart Annotation

Description

Horizon chart Annotation

Usage

anno_horizon(x, which = c("column", "row"),
    gp = gpar(pos_fill = "#D73027", neg_fill = "#313695"),
    n_slice = 4, slice_size = NULL, negative_from_top = FALSE,
    normalize = TRUE, gap = unit(0, "mm"),
    axis = TRUE, axis_param = default_axis_param(which),
    width = NULL, height = NULL)

Arguments

Details

Horizon chart as row annotation is only supported.

Value

An annotation function which can be used in HeatmapAnnotation .

Seealso

https://jokergoo.github.io/ComplexHeatmap-reference/book/heatmap-annotations.html#horizon-chart-annotation

Examples

lt = lapply(1:20, function(x) cumprod(1 + runif(1000, -x/100, x/100)) - 1)
anno = anno_horizon(lt, which = "row")
draw(anno, test = "horizon chart")
anno = anno_horizon(lt, which = "row",
gp = gpar(pos_fill = "orange", neg_fill = "darkgreen"))
draw(anno, test = "horizon chart, col")
anno = anno_horizon(lt, which = "row", negative_from_top = TRUE)
draw(anno, test = "horizon chart + negative_from_top")
anno = anno_horizon(lt, which = "row", gap = unit(1, "mm"))
draw(anno, test = "horizon chart + gap")
anno = anno_horizon(lt, which = "row",
gp = gpar(pos_fill = rep(c("orange", "red"), each = 10),
neg_fill = rep(c("darkgreen", "blue"), each = 10)))
draw(anno, test = "horizon chart, col")

Image Annotation

Description

Image Annotation

Usage

anno_image(image, which = c("column", "row"), border = TRUE,
    gp = gpar(fill = NA, col = NA), space = unit(1, "mm"),
    width = NULL, height = NULL)

Arguments

Details

This function supports image formats in png , svg , pdf , eps , jpeg/jpg , tiff . png , jpeg/jpg and tiff images are imported by readPNG , readJPEG and readTIFF , and drawn by grid.raster . svg images are firstly reformatted by rsvg::rsvg_svg and then imported by readPicture and drawn by grid.picture . pdf and eps images are imported by PostScriptTrace and readPicture , later drawn by grid.picture .

Different image formats can be mixed in the image vector.

Value

An annotation function which can be used in HeatmapAnnotation .

Seealso

https://jokergoo.github.io/ComplexHeatmap-reference/book/heatmap-annotations.html#image-annotation

Examples

# download the free icons from https://github.com/Keyamoon/IcoMoon-Free
image = sample(dir("~/Downloads/IcoMoon-Free-master/PNG/64px", full.names = TRUE), 10)
anno = anno_image(image)
draw(anno, test = "png")
image[1:5] = ""
anno = anno_image(image)
draw(anno, test = "some of png")

Joyplot Annotation

Description

Joyplot Annotation

Usage

anno_joyplot(x, which = c("column", "row"), gp = gpar(fill = "#000000"),
    scale = 2, transparency = 0.6,
    axis = TRUE, axis_param = default_axis_param(which),
    width = NULL, height = NULL)

Arguments

Value

An annotation function which can be used in HeatmapAnnotation .

Seealso

https://jokergoo.github.io/ComplexHeatmap-reference/book/heatmap-annotations.html#joyplot-annotation

Examples

m = matrix(rnorm(1000), nc = 10)
lt = apply(m, 2, function(x) data.frame(density(x)[c("x", "y")]))
anno = anno_joyplot(lt, width = unit(4, "cm"), which = "row")
draw(anno, test = "joyplot")
anno = anno_joyplot(lt, width = unit(4, "cm"), which = "row", gp = gpar(fill = 1:10))
draw(anno, test = "joyplot + col")
anno = anno_joyplot(lt, width = unit(4, "cm"), which = "row", scale = 1)
draw(anno, test = "joyplot + scale")

m = matrix(rnorm(5000), nc = 50)
lt = apply(m, 2, function(x) data.frame(density(x)[c("x", "y")]))
anno = anno_joyplot(lt, width = unit(4, "cm"), which = "row", gp = gpar(fill = NA), scale = 4)
draw(anno, test = "joyplot")

Lines Annotation

Description

Lines Annotation

Usage

anno_lines(x, which = c("column", "row"), border = TRUE, gp = gpar(),
    add_points = smooth, smooth = FALSE, pch = 16, size = unit(2, "mm"), pt_gp = gpar(), ylim = NULL,
    extend = 0.05, axis = TRUE, axis_param = default_axis_param(which),
    width = NULL, height = NULL)

Arguments

Value

An annotation function which can be used in HeatmapAnnotation .

Seealso

https://jokergoo.github.io/ComplexHeatmap-reference/book/heatmap-annotations.html#lines-annotation

Examples

anno = anno_lines(runif(10))
draw(anno, test = "anno_lines")
anno = anno_lines(cbind(c(1:5, 1:5), c(5:1, 5:1)), gp = gpar(col = 2:3))
draw(anno, test = "matrix")
anno = anno_lines(cbind(c(1:5, 1:5), c(5:1, 5:1)), gp = gpar(col = 2:3),
add_points = TRUE, pt_gp = gpar(col = 5:6), pch = c(1, 16))
draw(anno, test = "matrix")

Label Markers Annotation

Description

Label Markers Annotation

Usage

anno_link(...)

Arguments

Details

anno_link is deprecated, please use anno_mark instead.

Examples

# There is no example
NULL

Link annotation with labels

Description

Link annotation with labels

Usage

anno_mark(at, labels, which = c("column", "row"),
    side = ifelse(which == "column", "top", "right"),
    lines_gp = gpar(), labels_gp = gpar(), padding = 0.5,
    link_width = unit(5, "mm"), link_height = link_width,
    link_gp = lines_gp,
    extend = unit(0, "mm"))

Arguments

Details

Sometimes there are many rows or columns in the heatmap and we want to mark some of the rows. This annotation function is used to mark these rows and connect labels and corresponding rows with links.

Value

An annotation function which can be used in HeatmapAnnotation .

Seealso

https://jokergoo.github.io/ComplexHeatmap-reference/book/heatmap-annotations.html#mark-annotation

Examples

anno = anno_mark(at = c(1:4, 20, 60, 97:100), labels = month.name[1:10], which = "row")
draw(anno, index = 1:100, test = "anno_mark")

m = matrix(1:1000, byrow = TRUE, nr = 100)
anno = anno_mark(at = c(1:4, 20, 60, 97:100), labels = month.name[1:10], which = "row")
Heatmap(m, cluster_rows = FALSE, cluster_columns = FALSE) + rowAnnotation(mark = anno)
Heatmap(m) + rowAnnotation(mark = anno)

Barplot Annotation for oncoPrint

Description

Barplot Annotation for oncoPrint

Usage

anno_oncoprint_barplot(type = NULL, which = c("column", "row"),
    bar_width = 0.6, axis = TRUE,
    axis_param = if(which == "column") default_axis_param("column") else list(side = "top", labels_rot = 0),
    width = NULL, height = NULL, border = FALSE)

Arguments

Details

This annotation function should always be used with oncoPrint .

Author

Zuguang Gu z.gu@dkfz.de

Examples

# There is no example
NULL

Points Annotation

Description

Points Annotation

Usage

anno_points(x, which = c("column", "row"), border = TRUE, gp = gpar(), pch = 16,
    size = unit(2, "mm"), ylim = NULL, extend = 0.05, axis = TRUE,
    axis_param = default_axis_param(which), width = NULL, height = NULL, ...)

Arguments

Value

An annotation function which can be used in HeatmapAnnotation .

Seealso

https://jokergoo.github.io/ComplexHeatmap-reference/book/heatmap-annotations.html#points-annotation

Examples

anno = anno_points(runif(10))
draw(anno, test = "anno_points")
anno = anno_points(matrix(runif(20), nc = 2), pch = 1:2)
draw(anno, test = "matrix")

Simple Annotation

Description

Simple Annotation

Usage

anno_simple(x, col, na_col = "grey",
    which = c("column", "row"), border = FALSE, gp = gpar(col = NA),
    pch = NULL, pt_size = unit(1, "snpc")*0.8, pt_gp = gpar(),
    simple_anno_size = ht_opt$simple_anno_size,
    width = NULL, height = NULL)

Arguments

Details

The "simple annotation" is the most widely used annotation type which is heatmap-like, where the grid colors correspond to the values. anno_simple also supports to add points/symbols on top of the grids where the it can be normal point (when pch is set as numbers) or letters (when pch is set as single letters).

Value

An annotation function which can be used in HeatmapAnnotation .

Seealso

https://jokergoo.github.io/ComplexHeatmap-reference/book/heatmap-annotations.html#simple-annotation-as-an-annotation-function

Examples

anno = anno_simple(1:10)
draw(anno, test = "a numeric vector")

anno = anno_simple(cbind(1:10, 10:1))
draw(anno, test = "a matrix")

anno = anno_simple(1:10, pch = c(1:4, NA, 6:8, NA, 10))
draw(anno, test = "pch has NA values")

anno = anno_simple(1:10, pch = c(rep("A", 5), rep(NA, 5)))
draw(anno, test = "pch has NA values")

pch = matrix(1:20, nc = 2)
pch[sample(length(pch), 10)] = NA
anno = anno_simple(cbind(1:10, 10:1), pch = pch)
draw(anno, test = "matrix, pch is a matrix with NA values")

Summary Annotation

Description

Summary Annotation

Usage

anno_summary(which = c("column", "row"), border = TRUE, bar_width = 0.8,
    axis = TRUE, axis_param = default_axis_param(which),
    ylim = NULL, extend = 0.05, outline = TRUE, box_width = 0.6,
    pch = 1, size = unit(2, "mm"), gp = gpar(),
    width = NULL, height = NULL)

Arguments

Details

anno_summary is a special annotation function that it only works for one-column or one-row heatmap. It shows the summary of the values in the heatmap. If the values in the heatmap is discrete, the proportion of each level (the sum is normalized to 1) is visualized as stacked barplot. If the heatmap is split into multiple slices, multiple bars are put in the annotation. If the value is continuous, boxplot is used.

In the barplot, the color schema is used as the same as the heatmap, while for the boxplot, the color needs to be controlled by gp .

Value

An annotation function which can be used in HeatmapAnnotation .

Seealso

https://jokergoo.github.io/ComplexHeatmap-reference/book/heatmap-annotations.html#summary-annotation

Examples

ha = HeatmapAnnotation(summary = anno_summary(height = unit(4, "cm")))
v = sample(letters[1:2], 50, replace = TRUE)
split = sample(letters[1:2], 50, replace = TRUE)
Heatmap(v, top_annotation = ha, width = unit(1, "cm"), split = split)

ha = HeatmapAnnotation(summary = anno_summary(gp = gpar(fill = 2:3), height = unit(4, "cm")))
v = rnorm(50)
Heatmap(v, top_annotation = ha, width = unit(1, "cm"), split = split)

Text Annotation

Description

Text Annotation

Usage

anno_text(x, which = c("column", "row"), gp = gpar(),
    rot = guess_rot(), just = guess_just(),
    offset = guess_location(), location = guess_location(),
    width = NULL, height = NULL)

Arguments

Value

An annotation function which can be used in HeatmapAnnotation .

Seealso

https://jokergoo.github.io/ComplexHeatmap-reference/book/heatmap-annotations.html#text-annotation

Examples

anno = anno_text(month.name)
draw(anno, test = "month names")
anno = anno_text(month.name, gp = gpar(fontsize = 16))
draw(anno, test = "month names with fontsize")
anno = anno_text(month.name, gp = gpar(fontsize = 1:12+4))
draw(anno, test = "month names with changing fontsize")
anno = anno_text(month.name, which = "row")
draw(anno, test = "month names on rows")
anno = anno_text(month.name, location = 0, rot = 45,
just = "left", gp = gpar(col = 1:12))
draw(anno, test = "with rotations")
anno = anno_text(month.name, location = 1,
rot = 45, just = "right", gp = gpar(fontsize = 1:12+4))
draw(anno, test = "with rotations")

Zoom annotation

Description

Zoom annotation

Usage

anno_zoom(align_to, panel_fun = function(index, nm = NULL) { grid.rect() },
    which = c("column", "row"), side = ifelse(which == "column", "top", "right"),
    size = NULL, gap = unit(1, "mm"),
    link_width = unit(5, "mm"), link_height = link_width, link_gp = gpar(),
    extend = unit(0, "mm"), width = NULL, height = NULL)

Arguments

Details

anno_zoom creates several plotting regions (boxes) which can be corresponded to subsets of rows/columns in the heatmap.

Value

An annotation function which can be used in HeatmapAnnotation .

Seealso

https://jokergoo.github.io/ComplexHeatmap-reference/book/heatmap-annotations.html#zoom-annotation

Examples

set.seed(123)
m = matrix(rnorm(100*10), nrow = 100)
subgroup = sample(letters[1:3], 100, replace = TRUE, prob = c(1, 5, 10))
rg = range(m)
panel_fun = function(index, nm) {
pushViewport(viewport(xscale = rg, yscale = c(0, 2)))
grid.rect()
grid.xaxis(gp = gpar(fontsize = 8))
grid.boxplot(m[index, ], pos = 1, direction = "horizontal")
grid.text(paste("distribution of group", nm), mean(rg), y = 1.9,
just = "top", default.units = "native", gp = gpar(fontsize = 10))
popViewport()
}
anno = anno_zoom(align_to = subgroup, which = "row", panel_fun = panel_fun,
size = unit(2, "cm"), gap = unit(1, "cm"), width = unit(4, "cm"))
Heatmap(m, right_annotation = rowAnnotation(foo = anno), row_split = subgroup)

Grob for Annotation Axis

Description

Grob for Annotation Axis

Usage

annotation_axis_grob(at = NULL, labels = at, labels_rot = 0, gp = gpar(),
    side = "left", facing = "outside", direction = "normal", scale = NULL)

Arguments

Value

A grob object.

Examples

gb = annotation_axis_grob(at = 1:5, labels = month.name[1:5], labels_rot = 0,
side = "left", facing = "outside")
grid.newpage()
pushViewport(viewport(xscale = c(0, 4), yscale = c(0, 6), width = 0.6, height = 0.6))
grid.rect()
grid.text('side = "left", facing = "outside"')
grid.draw(gb)
popViewport()

gb = annotation_axis_grob(at = 1:5, labels = month.name[1:5], labels_rot = 0,
side = "left", facing = "inside")
grid.newpage()
pushViewport(viewport(xscale = c(0, 4), yscale = c(0, 6), width = 0.6, height = 0.6))
grid.rect()
grid.text('side = "left", facing = "inside"')
grid.draw(gb)
popViewport()

gb = annotation_axis_grob(at = 1:5, labels = month.name[1:5], labels_rot = 0,
side = "right", facing = "outside")
grid.newpage()
pushViewport(viewport(xscale = c(0, 4), yscale = c(0, 6), width = 0.6, height = 0.6))
grid.rect()
grid.text('side = "right", facing = "outside"')
grid.draw(gb)
popViewport()

gb = annotation_axis_grob(at = 1:5, labels = month.name[1:5], labels_rot = 0,
side = "right", facing = "inside")
grid.newpage()
pushViewport(viewport(xscale = c(0, 4), yscale = c(0, 6), width = 0.6, height = 0.6))
grid.rect()
grid.text('side = "right", facing = "inside"')
grid.draw(gb)
popViewport()

gb = annotation_axis_grob(at = 1:3, labels = month.name[1:3], labels_rot = 0,
side = "top", facing = "outside")
grid.newpage()
pushViewport(viewport(xscale = c(0, 4), yscale = c(0, 6), width = 0.6, height = 0.6))
grid.rect()
grid.text('side = "top", facing = "outside"')
grid.draw(gb)
popViewport()

gb = annotation_axis_grob(at = 1:3, labels = month.name[1:3], labels_rot = 90,
side = "top", facing = "outside")
grid.newpage()
pushViewport(viewport(xscale = c(0, 4), yscale = c(0, 6), width = 0.6, height = 0.6))
grid.rect()
grid.text('side = "top", facing = "outside"')
grid.draw(gb)
popViewport()

gb = annotation_axis_grob(at = 1:3, labels = month.name[1:3], labels_rot = 45,
side = "top", facing = "outside")
grid.newpage()
pushViewport(viewport(xscale = c(0, 4), yscale = c(0, 6), width = 0.6, height = 0.6))
grid.rect()
grid.text('side = "top", facing = "outside"')
grid.draw(gb)
popViewport()

gb = annotation_axis_grob(at = 1:3, labels = month.name[1:3], labels_rot = 0,
side = "top", facing = "inside")
grid.newpage()
pushViewport(viewport(xscale = c(0, 4), yscale = c(0, 6), width = 0.6, height = 0.6))
grid.rect()
grid.text('side = "top", facing = "inside"')
grid.draw(gb)
popViewport()

gb = annotation_axis_grob(at = 1:3, labels = month.name[1:3], labels_rot = 0,
side = "bottom", facing = "outside")
grid.newpage()
pushViewport(viewport(xscale = c(0, 4), yscale = c(0, 6), width = 0.6, height = 0.6))
grid.rect()
grid.text('side = "bottom", facing = "outside"')
grid.draw(gb)
popViewport()

gb = annotation_axis_grob(at = 1:3, labels = month.name[1:3], labels_rot = 0,
side = "bottom", facing = "inside")
grid.newpage()
pushViewport(viewport(xscale = c(0, 4), yscale = c(0, 6), width = 0.6, height = 0.6))
grid.rect()
grid.text('side = "bottom", facing = "inside"')
grid.draw(gb)
popViewport()

grid.newpage()
pushViewport(viewport(xscale = c(0, 4), yscale = c(0, 6), width = 0.6, height = 0.6))
gb = annotation_axis_grob(labels_rot = 0, side = "left", facing = "outside")
grid.rect()
grid.text('side = "left", facing = "outside"')
grid.draw(gb)
popViewport()

grid.newpage()
pushViewport(viewport(xscale = c(0, 4), yscale = c(0, 6), width = 0.6, height = 0.6))
gb = annotation_axis_grob(side = "left", direction = "reverse")
grid.rect()
grid.text('side = "left", direction = "reverse')
grid.draw(gb)
popViewport()

grid.newpage()
pushViewport(viewport(xscale = c(0, 4), yscale = c(0, 6), width = 0.6, height = 0.6))
gb = annotation_axis_grob(side = "bottom", direction = "reverse")
grid.rect()
grid.text('side = "bottom", directio = "reverse"')
grid.draw(gb)
popViewport()

Size of the Annotation Legends

Description

Size of the Annotation Legends

Usage

list(list("annotation_legend_size"), list("HeatmapList"))(object, legend_list = list(), ...)

Arguments

Details

Internally, all annotation legends are packed by packLegend as a single grob object.

This function is only for internal use.

Value

A unit object.

Author

Zuguang Gu z.gu@dkfz.de

Examples

# There is no example
NULL

Concatenate Heatmap Annotations

Description

Concatenate Heatmap Annotations

Usage

list(list("c"), list("HeatmapAnnotation"))(..., gap = unit(0, "mm"))

Arguments

Details

The heatmap annotations should have same number of observations.

Examples

ha1 = HeatmapAnnotation(foo = 1:10)
ha2 = HeatmapAnnotation(bar = anno_points(10:1))
ha = c(ha1, ha2)
ha
ha3 = HeatmapAnnotation(sth = cbind(1:10, 10:1))
ha = c(ha1, ha2, ha3, gap = unit(c(1, 4), "mm"))
ha

Cluster within and between Groups

Description

Cluster within and between Groups

Usage

cluster_within_group(mat, factor)

Arguments

Details

The clustering is firstly applied in each group, then clustering is applied to group means. The within-group dendrograms and between-group dendrogram are finally connected by merge_dendrogram .

In the final dendrogram, the within group dendrograms are enforced to be flat lines to emphasize that the within group dendrograms have no sense to compare to between-group dendrogram.

Value

A dendrogram object. The order of columns can be retrieved by order.dendrogram .

Examples

m = matrix(rnorm(120), nc = 12)
colnames(m) = letters[1:12]
fa = rep(c("a", "b", "c"), times = c(2, 4, 6))
dend = cluster_within_group(m, fa)
grid.dendrogram(dend, test = TRUE)

Draw Legend Based on Color Mapping

Description

Draw Legend Based on Color Mapping

Usage

list(list("color_mapping_legend"), list("ColorMapping"))(object,
    plot = TRUE, ...,
    
    color_bar = object@type,
    
    title = object@name,
    title_gp = gpar(fontsize = 10, fontface = "bold"),
    title_position = "topleft",
    grid_height = unit(4, "mm"),
    grid_width = unit(4, "mm"),
    border = NULL,
    at = object@levels,
    labels = at,
    labels_gp = gpar(fontsize = 10),
    labels_rot = 0,
    nrow = NULL,
    ncol = 1,
    by_row = FALSE,
    legend_height = NULL,
    legend_width = NULL,
    legend_direction = c("vertical", "horizontal"),
    
    param = NULL)

Arguments

Details

The legend is constructed by Legend .

Value

A Legends-class object.

Author

Zuguang Gu z.gu@dkfz.de

Examples

# There is no example
NULL

Construct Column Annotations

Description

Construct Column Annotations

Usage

columnAnnotation(...)

Arguments

Details

The function is identical to

list(" ", " HeatmapAnnotation(..., which = "column") ")

Value

A HeatmapAnnotation-class object.

Author

Zuguang Gu z.gu@dkfz.de

Examples

# There is no example
NULL

Get Column Dendrograms from a hHeatmap List

Description

Get Column Dendrograms from a hHeatmap List

Usage

list(list("column_dend"), list("HeatmapList"))(object, name = NULL)

Arguments

Value

The format of the returned object depends on whether rows/columns of the heatmaps are split.

Author

Zuguang Gu z.gu@dkfz.de

Examples

mat = matrix(rnorm(100), 10)
ht_list = Heatmap(mat) + Heatmap(mat)
ht_list = draw(ht_list)
column_dend(ht_list)
ht_list = Heatmap(mat, column_km = 2) + Heatmap(mat, column_km = 2)
ht_list = draw(ht_list)
column_dend(ht_list)
ht_list = Heatmap(mat) %v% Heatmap(mat)
ht_list = draw(ht_list)
column_dend(ht_list)
ht_list = Heatmap(mat, column_km = 2) %v% Heatmap(mat)
ht_list = draw(ht_list)
column_dend(ht_list)

Get Column Dendrograms from a Heatmap

Description

Get Column Dendrograms from a Heatmap

Usage

list(list("column_dend"), list("Heatmap"))(object)

Arguments

Value

The format of the returned object depends on whether rows/columns of the heatmaps are split.

Author

Zuguang Gu z.gu@dkfz.de

Examples

mat = matrix(rnorm(100), 10)
ht = Heatmap(mat)
ht = draw(ht)
column_dend(ht)
ht = Heatmap(mat, column_km = 2)
ht = draw(ht)
column_dend(ht)

Method dispatch page for column_dend

Description

Method dispatch page for column_dend .

Examples

# no example
NULL

Get Column Order from a Heatmap List

Description

Get Column Order from a Heatmap List

Usage

list(list("column_order"), list("HeatmapList"))(object, name = NULL)

Arguments

Value

The format of the returned object depends on whether rows/columns of the heatmaps are split.

Author

Zuguang Gu z.gu@dkfz.de

Examples

mat = matrix(rnorm(100), 10)
ht_list = Heatmap(mat) + Heatmap(mat)
ht_list = draw(ht_list)
column_order(ht_list)
ht_list = Heatmap(mat, column_km = 2) + Heatmap(mat, column_km = 2)
ht_list = draw(ht_list)
column_order(ht_list)
ht_list = Heatmap(mat) %v% Heatmap(mat)
ht_list = draw(ht_list)
column_order(ht_list)
ht_list = Heatmap(mat, column_km = 2) %v% Heatmap(mat)
ht_list = draw(ht_list)
column_order(ht_list)

Get Column Order from a Aeatmap List

Description

Get Column Order from a Aeatmap List

Usage

list(list("column_order"), list("Heatmap"))(object)

Arguments

Value

The format of the returned object depends on whether rows/columns of the heatmaps are split.

Author

Zuguang Gu z.gu@dkfz.de

Examples

mat = matrix(rnorm(100), 10)
ht = Heatmap(mat)
ht = draw(ht)
column_order(ht)
ht = Heatmap(mat, column_km = 2)
ht = draw(ht)
column_order(ht)

Method dispatch page for column_order

Description

Method dispatch page for column_order .

Examples

# no example
NULL

Degrees of the Combination sets

Description

Degrees of the Combination sets

Usage

comb_degree(m)

Arguments

Details

The degree for a combination set is the number of sets that are selected.

Value

A vector of degrees of the combination sets.

Examples

set.seed(123)
lt = list(a = sample(letters, 10),
b = sample(letters, 15),
c = sample(letters, 20))
m = make_comb_mat(lt)
comb_degree(m)

Names of the Combination sets

Description

Names of the Combination sets

Usage

comb_name(m)

Arguments

Details

The name of the combination sets are formatted as a string of binary bits. E.g. for three sets of "a", "b", "c", the combination set with name "101" corresponds to select set a, not select set b and select set c. The definition of "select" depends on the value of mode from make_comb_mat .

Value

A vector of names of the combination sets.

Examples

set.seed(123)
lt = list(a = sample(letters, 10),
b = sample(letters, 15),
c = sample(letters, 20))
m = make_comb_mat(lt)
comb_name(m)

Sizes of the Combination sets

Description

Sizes of the Combination sets

Usage

comb_size(m, degree = NULL)

Arguments

Value

A vector of sizes of the combination sets.

Examples

set.seed(123)
lt = list(a = sample(letters, 10),
b = sample(letters, 15),
c = sample(letters, 20))
m = make_comb_mat(lt)
comb_size(m)

Height of Heatmap List Components

Description

Height of Heatmap List Components

Usage

list(list("component_height"), list("HeatmapList"))(object, k = HEATMAP_LIST_LAYOUT_COLUMN_COMPONENT)

Arguments

Value

A unit object.

Author

Zuguang Gu z.gu@dkfz.de

Examples

# There is no example
NULL

Heights of Heatmap Components

Description

Heights of Heatmap Components

Usage

list(list("component_height"), list("Heatmap"))(object, k = HEATMAP_LAYOUT_COLUMN_COMPONENT)

Arguments

Details

All column components are: column_title_top , column_dend_top , column_names_top , column_anno_top , heatmap_body , column_anno_bottom , column_names_bottom , column_dend_bottom , column_title_bottom .

This function is only for internal use.

Value

A unit object.

Author

Zuguang Gu z.gu@dkfz.de

Examples

# There is no example
NULL

Method dispatch page for component_height

Description

Method dispatch page for component_height .

Examples

# no example
NULL

Width of Heatmap List Components

Description

Width of Heatmap List Components

Usage

list(list("component_width"), list("HeatmapList"))(object, k = HEATMAP_LIST_LAYOUT_ROW_COMPONENT)

Arguments

Details

This function is only for internal use.

Value

A unit object.

Author

Zuguang Gu z.gu@dkfz.de

Examples

# There is no example
NULL

Widths of Heatmap Components

Description

Widths of Heatmap Components

Usage

list(list("component_width"), list("Heatmap"))(object, k = HEATMAP_LAYOUT_ROW_COMPONENT)

Arguments

Details

All row components are: row_title_left , row_dend_left , row_names_left , row_anno_left , heatmap_body , row_anno_right , row_names_right , row_dend_right , row_title_right .

This function is only for internal use.

Value

A unit object.

Author

Zuguang Gu z.gu@dkfz.de

Examples

# There is no example
NULL

Method dispatch page for component_width

Description

Method dispatch page for component_width .

Examples

# no example
NULL

Copy the AnnotationFunction Object

Description

Copy the AnnotationFunction Object

Usage

list(list("copy_all"), list("AnnotationFunction"))(object)

Arguments

Details

In AnnotationFunction-class , there is an environment which stores some external variables for the annotation function (specified by the var_import argument when constructing the AnnotationFunction-class object. This copy_all,AnnotationFunction-method hard copies all the variables into a new isolated environment.

The environment is at object@var_env .

Examples

# There is no example
NULL

Copy the SingleAnnotation object

Description

Copy the SingleAnnotation object

Usage

list(list("copy_all"), list("SingleAnnotation"))(object)

Arguments

Details

Since the SingleAnnotation object always contains an AnnotationFunction-class object, it calls copy_all,AnnotationFunction-method to hard copy the variable environment.

Examples

# There is no example
NULL

Method dispatch page for copy_all

Description

Method dispatch page for copy_all .

Examples

# no example
NULL

Decorate Heatmap Annotation

Description

Decorate Heatmap Annotation

Usage

decorate_annotation(annotation, code, slice = 1, envir = new.env(parent = parent.frame()))

Arguments

Details

There is a viewport for every column annotation and row annotation. This function contructs the name of the viewport, goes to the viewport by seekViewport , runs code to that viewport, and finally goes back to the original viewport.

Value

The function returns no value.

Seealso

https://jokergoo.github.io/ComplexHeatmap-reference/book/heatmap-decoration.html

Author

Zuguang Gu z.gu@dkfz.de

Examples

set.seed(123)
ha1 = HeatmapAnnotation(df = data.frame(type = rep(letters[1:2], 5)))
ha2 = rowAnnotation(point = anno_points(runif(10), which = "row"))
Heatmap(matrix(rnorm(100), 10), name = "mat", km = 2,
top_annotation = ha1) + ha2
decorate_annotation("type", {
grid.circle(x = unit(c(0.2, 0.4, 0.6, 0.8), "npc"),
gp = gpar(fill = "#FF000080"))
})
decorate_annotation("point", {
grid.rect(gp = gpar(fill = "#FF000080"))
}, slice = 2)

Decorate Heatmap Column Dendrograms

Description

Decorate Heatmap Column Dendrograms

Usage

decorate_column_dend(..., envir = new.env(parent = parent.frame()))

Arguments

Details

This is a wrapper function which pre-defined which argument in decorate_dend .

Value

The function returns no value.

Author

Zuguang Gu z.gu@dkfz.de

Examples

# There is no example
NULL

Decorate Heatmap Column Names

Description

Decorate Heatmap Column Names

Usage

decorate_column_names(..., envir = new.env(parent = parent.frame()))

Arguments

Details

This is a helper function which pre-defined which argument in decorate_dimnames .

Value

The function returns no value.

Author

Zuguang Gu z.gu@dkfz.de

Examples

# There is no example
NULL

Decorate Heatmap Column Titles

Description

Decorate Heatmap Column Titles

Usage

decorate_column_title(..., envir = new.env(parent = parent.frame()))

Arguments

Details

This is a helper function which pre-defined which argument in decorate_title .

Value

The function returns no value.

Author

Zuguang Gu z.gu@dkfz.de

Examples

# There is no example
NULL

Decorate Heatmap Dendrograms

Description

Decorate Heatmap Dendrograms

Usage

decorate_dend(heatmap, code, slice = 1, which = c("column", "row"),
    envir = new.env(parent = parent.frame()))

Arguments

Details

If you know the number of leaves in the dendrogram, it is simple to calculate the position of every leave in the dendrogram. E.g., for the column dendrogram, the i^th leave is located at:

list(" ", " # assume nc is the number of columns in the column slice ", " unit((i-0.5)/nc, "npc") ")

Value

This function returns no value.

Seealso

https://jokergoo.github.io/ComplexHeatmap-reference/book/heatmap-decoration.html

Author

Zuguang Gu z.gu@dkfz.de

Examples

set.seed(123)
Heatmap(matrix(rnorm(100), 10), name = "mat", km = 2)
decorate_dend("mat", {
grid.rect(gp = gpar(fill = "#FF000080"))
}, which = "row", slice = 2)

Decorate Heatmap Dimension Names

Description

Decorate Heatmap Dimension Names

Usage

decorate_dimnames(heatmap, code, slice = 1, which = c("column", "row"),
    envir = new.env(parent = parent.frame()))

Arguments

Details

If you know the dimensions of the matrix, it is simple to calculate the position of every row name or column name in the heatmap. E.g., for the column column, the i^th name is located at:

list(" ", " # assume nc is the number of columns in the column slice ", " unit((i-0.5)/nc, "npc") ")

Value

The function returns no value.

Author

Zuguang Gu z.gu@dkfz.de

Examples

set.seed(123)
mat = matrix(rnorm(100), 10)
rownames(mat) = letters[1:10]
colnames(mat) = LETTERS[1:10]
Heatmap(mat, name = "mat", km = 2)

decorate_dimnames("mat", {
grid.rect(gp = gpar(fill = "#FF000080"))
}, which = "row", slice = 2)

Decorate Heatmap Bodies

Description

Decorate Heatmap Bodies

Usage

decorate_heatmap_body(heatmap, code,
    slice = 1, row_slice = slice, column_slice = 1,
    envir = new.env(parent = parent.frame()))

Arguments

Details

There is a viewport for each slice in each heatmap. This function contructs the name of the viewport, goes to the viewport by seekViewport , runs the code to that viewport and finally goes back to the original viewport.

Value

This function returns no value.

Seealso

https://jokergoo.github.io/ComplexHeatmap-reference/book/heatmap-decoration.html

Author

Zuguang Gu z.gu@dkfz.de

Examples

set.seed(123)
Heatmap(matrix(rnorm(100), 10), name = "mat")
decorate_heatmap_body("mat", {
grid.circle(gp = gpar(fill = "#FF000080"))
})

Decorate Heatmap Row Dendrograms

Description

Decorate Heatmap Row Dendrograms

Usage

decorate_row_dend(..., envir = new.env(parent = parent.frame()))

Arguments

Details

This is a helper function which pre-defined which argument in decorate_dend .

Value

The function returns no value.

Author

Zuguang Gu z.gu@dkfz.de

Examples

# There is no example
NULL

Decorate Heatmap Row Names

Description

Decorate Heatmap Row Names

Usage

decorate_row_names(..., envir = new.env(parent = parent.frame()))

Arguments

Details

This is a helper function which pre-defined which argument in decorate_dimnames .

Value

The function returns no value.

Author

Zuguang Gu z.gu@dkfz.de

Examples

# There is no example
NULL

Decorate Heatmap Row Titles

Description

Decorate Heatmap Row Titles

Usage

decorate_row_title(..., envir = new.env(parent = parent.frame()))

Arguments

Details

This is a helper function which pre-defined which argument in decorate_title .

Value

The function returns no value.

Author

Zuguang Gu z.gu@dkfz.de

Examples

# There is no example
NULL

Decorate Heatmap Titles

Description

Decorate Heatmap Titles

Usage

decorate_title(heatmap, code, slice = 1, which = c("column", "row"),
    envir = new.env(parent = parent.frame()))

Arguments

Details

There is a viewport for row titles and column title in the heatmap. This function contructs the name of the viewport, goes to the viewport by seekViewport , runs code to that viewport and finally goes back to the original viewport.

Value

The function returns no value.

Seealso

https://jokergoo.github.io/ComplexHeatmap-reference/book/heatmap-decoration.html

Author

Zuguang Gu z.gu@dkfz.de

Examples

set.seed(123)
Heatmap(matrix(rnorm(100), 10), name = "mat", km = 2)
decorate_title("mat", {
grid.rect(gp = gpar(fill = "#FF000080"))
}, which = "row", slice = 2)

The Default Parameters for Annotation Axis

Description

The Default Parameters for Annotation Axis

Usage

default_axis_param(which)

Arguments

Details

There are following parameters for the annotation axis:

list(" ", " ", list(list("at"), list("The breaks of axis. By default it is automatically inferred.")), " ", " ", list(list("labels"), list("The corresponding axis labels.")), " ", " ", list(list("labels_rot"), list("The rotation of the axis labels.")), " ", " ", list(list("gp"), list("Graphc parameters of axis labels. The value should be a ", list(list("unit")), " object.")), " ", " ", list(list("side"), list("If it is for column annotation, the value should only be one of ", list("left"),

" and ", list("right"), ". If it is for row annotation, the value should only be one of ", list("top"), " and ", list("bottom"), ".")), "

", " ", list(list("facing"), list("Whether the axis faces to the outside of the annotation region or inside. Sometimes when appending more than one heatmaps, the axes of column annotations of one heatmap might overlap to the neighbouring heatmap, setting ", list("facing"), " to ", list("inside"), " may invoild it.")), " ", " ", list(list("direction"), list(

"The direction of the axis. Value should be "normal" or "reverse".")), "

")

All the parameters are passed to annotation_axis_grob to construct an axis grob.

Examples

default_axis_param("column")
default_axis_param("row")

Default get_type for oncoPrint()

Description

Default get_type for oncoPrint()

Usage

default_get_type(x)

Arguments

Details

|It recognizes following separators: ;:,| .|

Examples

# There is no example
NULL

Height of the Dendrograms

Description

Height of the Dendrograms

Usage

dend_heights(x)

Arguments

Examples

# There is no example
NULL

Coordinates of the Dendrogram

Description

Coordinates of the Dendrogram

Usage

dend_xy(dend)

Arguments

Details

dend will be processed by adjust_dend_by_x if it is processed yet.

Value

A list of leave positions ( x ) and dendrogram height ( y ).

Examples

m = matrix(rnorm(100), 10)
dend1 = as.dendrogram(hclust(dist(m)))
dend_xy(dend1)

dend1 = adjust_dend_by_x(dend1, sort(runif(10)))
dend_xy(dend1)

dend1 = adjust_dend_by_x(dend1, unit(1:10, "cm"))
dend_xy(dend1)

Grob for Dendrogram

Description

Grob for Dendrogram

Usage

dendrogramGrob(dend, facing = c("bottom", "top", "left", "right"),
    order = c("normal", "reverse"), gp = gpar())

Arguments

Details

If dend has not been processed by adjust_dend_by_x , internally adjust_dend_by_x is called to add x attributes to each node/leaf.

Value

A grob object which is contructed by segmentsGrob .

Examples

# There is no example
NULL

Visualize Density Distribution by Heatmap

Description

Visualize Density Distribution by Heatmap

Usage

densityHeatmap(data,
    density_param = list(na.rm = TRUE),
    
    col = rev(brewer.pal(11, "Spectral")),
    color_space = "LAB",
    ylab = deparse(substitute(data)),
    column_title = paste0("Density heatmap of ", deparse(substitute(data))),
    title = column_title,
    ylim = c(-Inf, Inf),
    range = ylim,
    
    title_gp = gpar(fontsize = 14),
    ylab_gp = gpar(fontsize = 12),
    tick_label_gp = gpar(fontsize = 10),
    quantile_gp = gpar(fontsize = 10),
    
    column_order = NULL,
    column_names_side = "bottom",
    show_column_names = TRUE,
    column_names_max_height = unit(6, "cm"),
    column_names_gp = gpar(fontsize = 12),
    column_names_rot = 90,
    
    cluster_columns = FALSE,
    clustering_distance_columns = "ks",
    clustering_method_columns = "complete",
    mc.cores = 1,
    
    ...)

Arguments

Details

To visualize data distribution in a matrix or in a list, we normally use boxplot or violinplot. We can also use colors to map the density values and visualize distribution of values through a heatmap. It is useful if you have huge number of columns in data to visualize.

The density matrix is generated with 500 rows ranging between the maximun and minimal values in all densities.

Value

A Heatmap-class object. It can oly add other heatmaps/annotations vertically.

Seealso

https://jokergoo.github.io/ComplexHeatmap-reference/book/other-high-level-plots.html#density-heatmap

Author

Zuguang Gu z.gu@dkfz.de