@@ -1,8 +1,8 @@

 Package: ComplexHeatmap

 Type: Package

 Title: Make Complex Heatmaps

-Version: 2.7.1.1010

-Date: 2020-12-8

+Version: 2.7.1.1011

+Date: 2020-12-13

 Author: Zuguang Gu

 Maintainer: Zuguang Gu <z.gu@dkfz.de>

 Depends: R (>= 3.1.2), methods, grid, graphics, stats, grDevices

@@ -13,7 +13,7 @@ Suggests: testthat (>= 1.0.0), knitr, markdown, dendsort,

     jpeg, tiff, fastcluster, EnrichedHeatmap,

     dendextend (>= 1.0.1), grImport, grImport2, glue,

     GenomicRanges, gridtext, pheatmap (>= 1.0.12),

-    shiny, S4Vectors (>= 0.26.1)

+    shiny, S4Vectors (>= 0.26.1), gridGraphics, gplots

 VignetteBuilder: knitr

 Description: Complex heatmaps are efficient to visualize associations 

     between different sources of data sets and reveal potential patterns. 

@@ -21,4 +21,4 @@ Description: Complex heatmaps are efficient to visualize associations

     multiple heatmaps and supports various annotation graphics.

 biocViews: Software, Visualization, Sequencing

 URL: https://github.com/jokergoo/ComplexHeatmap, https://jokergoo.github.io/ComplexHeatmap-reference/book/

-License: MIT + file LICENSE

\ No newline at end of file

+License: MIT + file LICENSE

@@ -154,6 +154,8 @@ export("columnAnnotation")

 export("comb_degree")

 export("comb_name")

 export("comb_size")

+export("compare_heatmap")

+export("compare_heatmap.2")

 export("compare_pheatmap")

 export("complement_size")

 export("decorate_annotation")

@@ -181,6 +183,8 @@ export("grid.annotation_axis")

 export("grid.boxplot")

 export("grid.dendrogram")

 export("gt_render")

+export("heatmap")

+export("heatmap.2")

 export("ht_global_opt")

 export("ht_opt")

 export("ht_pos_on_device")

@@ -12,6 +12,7 @@ CHANGES in VERSION 2.7.1

 * add `bin_genome()` and `normalize_genomic_signals_to_bins()`

 * print messages if directly sending `anno_*()` functions to `top_annotation` or similar arguments.

 * `pheatmap()`: set heatmap name to " " so that there is no legend title by default.

+* also translate `stats::heatmap()` and `gplots::heatmap.2()`.

 ========================

@@ -243,12 +243,17 @@ AnnotationFunction = function(fun, fun_name = "", which = c("column", "row"),

 			stop_wrap("This object is not subsetable.")

 		}

 		x = copy_all(x)

+		if(x@fun_name == "anno_mark") {

+			ind_at = which(x@var_env[["at"]] %in% i)

+		}

 		for(var in names(x@subset_rule)) {

+			

 			oe = try(x@var_env[[var]] <- x@subset_rule[[var]](x@var_env[[var]], i), silent = TRUE)

 			if(inherits(oe, "try-error")) {

 				message(paste0("An error when subsetting ", var))

 				stop_wrap(oe)

 			}

+			

 		}

 		if(is.logical(i)) {

 			x@n = sum(i)

new file mode 100644

@@ -0,0 +1,855 @@

+# == title

+# Translate stats::heatmap to ComplexHeatmap::Heatmap

+#

+# == alias

+# stats_heatmap

+#

+# == param

+# -x The input matrix.

+# -col A vector of colors.

+# -Rowv The same as in `stats::heatmap`.

+# -Colv The same as in `stats::heatmap`.

+# -distfun The same as in `stats::heatmap`.

+# -hclustfun The same as in `stats::heatmap`.

+# -reorderfun The same as in `stats::heatmap`.

+# -add.expr Ignored.

+# -symm Ignored.

+# -revC Ignored.

+# -scale The same as in `stats::heatmap`.

+# -na.rm Ignored.

+# -margins Ignored.

+# -ColSideColors The same as in `stats::heatmap`.

+# -RowSideColors The same as in `stats::heatmap`.

+# -cexRow The same as in `stats::heatmap`.

+# -cexCol The same as in `stats::heatmap`.

+# -labRow The same as in `stats::heatmap`.

+# -labCol The same as in `stats::heatmap`.

+# -main The same as in `stats::heatmap`.

+# -xlab The same as in `stats::heatmap`.

+# -ylab The same as in `stats::heatmap`.

+# -keep.dendro Ignored.

+# -verbose Ignored.

+# -... Other arguments passed to `Heatmap`.

+#

+# == value

+# A `Heatmap-class` object.

+#

+# == seealso

+# `compare_heatmap` that compares heatmaps between ``stats::heatmap()`` and ``ComplexHeatmap::heatmap()``.

+heatmap = function(x, 

+	col = hcl.colors(12, "YlOrRd", rev = TRUE),

+	Rowv = NULL, 

+	Colv = NULL,

+    distfun = dist, 

+    hclustfun = hclust,

+    reorderfun = function(d, w) reorder(d, w),

+    add.expr, 

+    symm = FALSE, 

+    revC = identical(Colv, "Rowv"),

+    scale = c("row", "column", "none"), 

+    na.rm = TRUE,

+    margins = c(5, 5), 

+    ColSideColors, 

+    RowSideColors,

+    cexRow = 0.2 + 1/log10(nr), 

+    cexCol = 0.2 + 1/log10(nc),

+    labRow = NULL, 

+    labCol = NULL, 

+    main = NULL,

+    xlab = NULL, 

+    ylab = NULL,

+    keep.dendro = FALSE, 

+    verbose = getOption("verbose"), 

+    ...) {

+

+	if(is.data.frame(x)) {

+        warning_wrap("The input is a data frame, convert it to the matrix.")

+        mat = as.matrix(x)

+    } else {

+    	mat = x

+    }

+

+    nr = nrow(mat)

+    nc = ncol(mat)

+

+    ht_param = list()

+

+    # Rowv can be 1. NA, 2. a dendrogram object, 3. a vector, 4. a logical value, 5. NULL

+    if(identical(Rowv, NA)) {

+    	ht_param$cluster_rows = FALSE

+

+    	mat = mat[nr:1, , drop = FALSE]

+    	if(!missing(RowSideColors)) {

+    		RowSideColors = rev(RowSideColors)

+    	}

+        if(is.null(rownames(mat))) labRow = seq_len(nr)

+        if(!is.null(labRow)) {

+            labRow = rev(labRow)

+        }

+    } else {

+    	if(is.null(Rowv)) {

+    		row_dend = as.dendrogram(hclustfun(distfun(mat)))

+    		row_dend = reorderfun(row_dend, -rowMeans(mat))

+    	} else if(inherits(Rowv, c("dendrogram", "hclust"))) {

+    		row_dend = as.dendrogram(Rowv)

+    	} else if(is.vector(Rowv)) {

+    		if(length(Rowv) == nr) {

+    			row_dend = as.dendrogram(hclustfun(distfun(mat)))

+    			row_dend = reorderfun(row_dend, Rowv)

+    		} else if(length(Rowv) == 1 && is.logical(Rowv)) {

+    			if(Rowv) {

+    				row_dend = as.dendrogram(hclustfun(distfun(mat)))

+    				row_dend = reorderfun(row_dend, -rowMeans(mat))

+    			} else {

+    				row_dend = as.dendrogram(hclustfun(distfun(mat)))

+    				row_dend = rev(row_dend)

+    			}

+    		} else {

+    			stop_wrap("Wrong value for 'Rowv'.")

+    		}

+    	}

+

+    	ht_param$cluster_rows = row_dend

+    }

+

+    if(identical(Colv, NA)) {

+    	ht_param$cluster_columns = FALSE

+    } else {

+    	if(is.null(Colv)) {

+    		column_dend = as.dendrogram(hclustfun(distfun(t(mat))))

+    		column_dend = reorderfun(column_dend, colMeans(mat))

+    	} else if(inherits(Colv, c("dendrogram", "hclust"))) {

+    		column_dend = as.dendrogram(Colv)

+    	} else if(is.vector(Colv)) {

+    		if(length(Colv) == nc) {

+    			column_dend = as.dendrogram(hclustfun(distfun(t(mat))))

+    			column_dend = reorderfun(column_dend, Colv)

+    		} else if(length(Colv) == 1 && is.logical(Colv)) {

+    			if(Colv) {

+    				column_dend = as.dendrogram(hclustfun(distfun(t(mat))))

+    				column_dend = reorderfun(column_dend, -colMeans(mat))

+    			} else {

+    				column_dend = as.dendrogram(hclustfun(distfun(t(mat))))

+    			}

+    		} else {

+    			stop_wrap("Wrong value for 'Colv'.")

+    		}

+    	}

+

+    	ht_param$cluster_columns = column_dend

+    }

+

+    ht_param$row_dend_width = unit(2, "cm")

+    ht_param$column_dend_height = unit(2, "cm")

+

+    scale = match.arg(scale)[1]

+    if("row" %in% scale) {

+

+        if(any(is.na(mat))) {

+            mat = (mat - rowMeans(mat, na.rm = TRUE))/rowSds(mat, na.rm = TRUE)

+        } else {

+            mat = t(scale(t(mat)))

+        }

+        message_wrap("Note, in 'heatmap()', when rows are scaled, the row dendrogram is still calculated from the original matrix (not from the scaled matrix).")

+    } else if("column" %in% scale) {

+        if(any(is.na(mat))) {

+            mat = t((t(mat) - colMeans(mat, na.rm = TRUE))/colSds(mat, na.rm = TRUE))

+        } else {

+            mat = scale(mat)

+        }

+        message_wrap("Note, in 'heatmap()', when columns are scaled, the column dendrogram is still calculated from the original matrix (not from the scaled matrix).")

+    }

+

+    ht_param$matrix = mat

+

+    # if color is a color mapping function

+    if(is.function(col)) {

+        ht_param$col = col

+    } else {

+        n_col = length(col)

+        if(identical(scale, "row") || identical(scale, "column")) {

+            lim = max(abs(mat), na.rm = TRUE)

+            ht_param$col = colorRamp2(seq(-lim, lim, length = n_col), col)

+        } else {

+            ht_param$col = colorRamp2(seq(min(mat, na.rm = TRUE), max(mat, na.rm = TRUE), length = n_col), col)

+        } 

+    }

+    

+    if(!missing(ColSideColors)) {

+    	ht_param$top_annotation = HeatmapAnnotation(column = ColSideColors,

+    		col = list(column = structure(unique(ColSideColors), names = unique(ColSideColors))),

+    		show_legend = FALSE, show_annotation_name = FALSE)

+    }

+    if(!missing(RowSideColors)) {

+    	ht_param$left_annotation = rowAnnotation(row = RowSideColors,

+    		col = list(row = structure(unique(RowSideColors), names = unique(RowSideColors))),

+    		show_legend = FALSE, show_annotation_name = FALSE)

+    }

+

+    if(!is.null(labRow)) {

+    	ht_param$row_labels = labRow

+    } else if(is.null(rownames(mat))) {

+    	ht_param$row_labels = seq_len(nr)

+    } else {

+    	ht_param$row_labels = rownames(mat)

+    }

+

+    if(!is.null(labCol)) {

+    	ht_param$column_labels = labCol

+    } else if(is.null(colnames(mat))) {

+    	ht_param$column_labels = seq_len(nc)

+    } else {

+    	ht_param$column_labels = colnames(mat)

+    }

+

+    ht_param$row_names_gp = gpar(cex = cexRow)

+    ht_param$column_names_gp = gpar(cex = cexCol)

+

+    if(!is.null(main)) {

+    	ht_param$column_title = main

+    }

+    if(!is.null(xlab)) {

+    	if(is.null(ht_param$column_labels)) {

+    		ht_param$bottom_annotation = HeatmapAnnotation(xlab = anno_block(labels = xlab, gp = gpar(col = NA)))

+    	} else {

+    		ht_param$bottom_annotation = HeatmapAnnotation(

+    			colnames = anno_text(ht_param$column_labels, gp = ht_param$column_names_gp),

+    			xlab = anno_block(labels = xlab, gp = gpar(col = NA))

+    		)

+    		ht_param$show_column_names = FALSE

+    	}

+    }

+    if(!is.null(ylab)) {

+    	if(is.null(ht_param$row_labels)) {

+    		ht_param$right_annotation = rowAnnotation(ylab = anno_block(labels = ylab, gp = gpar(col = NA)))

+    	} else {

+    		ht_param$right_annotation = rowAnnotation(

+    			rownames = anno_text(ht_param$row_labels, gp = ht_param$row_names_gp),

+    			ylab = anno_block(labels = ylab, gp = gpar(col = NA))

+    		)

+    		ht_param$show_row_names = FALSE

+    	}

+    }

+

+    heatmap_legend_param = list(title = "")

+    ht_param$heatmap_legend_param = heatmap_legend_param

+

+    if(!missing(add.expr)) {

+    	warning_wrap("argument `add.expr` is not supported in heatmap -> Heatmap translation, skip it.")

+    }

+

+    ht_param = c(ht_param, list(...))

+    ht = do.call(Heatmap, ht_param)

+    attr(ht, "translate_from") = "heatmap"

+    ht

+}

+

+# == title

+# Compare heatmaps between stats::heatmap() and ComplexHeatmap::heatmap()

+#

+# == param

+# -... The same set of arguments passed to ``stats::heatmap`` and ``ComplexHeatmap::heatmap``.

+#

+# == details

+# The function plots two heatmaps, one by ``stats::heatmap`` and one by ``ComplexHeatmap::heatmap``.

+# Users can see the difference between the two implementations.

+#

+# == example

+# mat = matrix(rnorm(100), 10)

+# compare_heatmap(mat)

+compare_heatmap = function(...) {

+    p1 = gridGraphics::echoGrob(function() stats::heatmap(...))

+    p2 = grid.grabExpr(draw(heatmap(...)))

+    grid.newpage()

+    pushViewport(viewport(x = 0, width = 0.5, y = 0, height = unit(1, "npc") - unit(1, "cm"), just = c("left", "bottom")))

+    grid.draw(p1)

+    popViewport()

+    pushViewport(viewport(x = 0, width = 0.5, y = 1, height = unit(1, "cm"), just = c("left", "top")))

+    grid.text("stats::heatmap()")

+    popViewport()

+    pushViewport(viewport(x = 0.5, width = 0.5, y = 0, height = unit(1, "npc") - unit(1, "cm"), just = c("left", "bottom")))

+    grid.draw(p2)

+    popViewport()

+    pushViewport(viewport(x = 0.5, width = 0.5, y = 1, height = unit(1, "cm"), just = c("left", "top")))

+    grid.text("ComplexHeatmap::heatmap()")

+    popViewport()

+}

+

+

+# == title

+# Translate gplots::heatmap.2 to ComplexHeatmap::Heatmap

+#

+# == param

+# -x The input matrix.

+# -Rowv The same as in `gplots::heatmap.2`.

+# -Colv The same as in `gplots::heatmap.2`.

+# -distfun The same as in `gplots::heatmap.2`.

+# -hclustfun The same as in `gplots::heatmap.2`.

+# -dendrogram The same as in `gplots::heatmap.2`.

+# -reorderfun The same as in `gplots::heatmap.2`.

+# -symm Ignored.

+# -scale The same as in `gplots::heatmap.2`.

+# -na.rm Ignored.

+# -revC Ignored.

+# -add.expr Ignored.

+# -breaks The same as in `gplots::heatmap.2`.

+# -symbreaks Ignored.

+# -col The same as in `gplots::heatmap.2`.

+# -colsep Ignored.

+# -rowsep Ignored.

+# -sepcolor Ignored.

+# -sepwidth Ignored.

+# -cellnote The same as in `gplots::heatmap.2`.

+# -notecex The same as in `gplots::heatmap.2`.

+# -notecol The same as in `gplots::heatmap.2`.

+# -na.color The same as in `gplots::heatmap.2`.

+# -trace 'both' is reset to 'column', others are the same as in `gplots::heatmap.2`.

+# -tracecol The same as in `gplots::heatmap.2`.

+# -hline The same as in `gplots::heatmap.2`.

+# -vline The same as in `gplots::heatmap.2`.

+# -linecol The same as in `gplots::heatmap.2`.

+# -margins Ignored.

+# -ColSideColors The same as in `gplots::heatmap.2`.

+# -RowSideColors The same as in `gplots::heatmap.2`.

+# -cexRow The same as in `gplots::heatmap.2`.

+# -cexCol The same as in `gplots::heatmap.2`.

+# -labRow The same as in `gplots::heatmap.2`.

+# -labCol The same as in `gplots::heatmap.2`.

+# -srtRow Ignored.

+# -srtCol Ignored.

+# -adjRow Ignored.

+# -adjCol Ignored.

+# -offsetRow Ignored.

+# -offsetCol Ignored.

+# -colRow The same as in `gplots::heatmap.2`.

+# -colCol The same as in `gplots::heatmap.2`.

+# -key Always TRUE.

+# -keysize Ignored.

+# -density.info The same as in `gplots::heatmap.2`.

+# -denscol The same as in `gplots::heatmap.2`.

+# -symkey Ignored.

+# -densadj The same as in `gplots::heatmap.2`.

+# -key.title Always "Color Key".

+# -key.xlab Always "Value".

+# -key.ylab "Count" or "Density", depends on the value of ``density.info``.

+# -key.xtickfun Ignored.

+# -key.ytickfun Ignored.

+# -key.par Ignored.

+# -main The same as in `gplots::heatmap.2`.

+# -xlab The same as in `gplots::heatmap.2`.

+# -ylab The same as in `gplots::heatmap.2`.

+# -lmat Ignored.

+# -lhei Ignored.

+# -lwid Ignored.

+# -extrafun Ignored.

+# -... Other arguments passed to `Heatmap`.

+#

+# == value

+# A `Heatmap-class` object.

+#

+# == seealso

+# `compare_heatmap.2` that compares heatmaps between ``gplots::heatmap.2()`` and ``ComplexHeatmap::heatmap.2()``.

+heatmap.2 = function(x,

+

+    # dendrogram control

+    Rowv = TRUE,

+    Colv = TRUE,

+    distfun = dist,

+    hclustfun = hclust,

+    dendrogram = c("both","row","column","none"),

+    reorderfun = function(d, w) reorder(d, w),

+    symm = FALSE,

+

+    # data scaling

+    scale = c("none","row", "column"),

+    na.rm=TRUE,

+

+    # image plot

+    revC = identical(Colv, "Rowv"),

+    add.expr,

+

+    # mapping data to colors

+    breaks,

+    symbreaks=any(x < 0, na.rm=TRUE) || scale!="none",

+

+    # colors

+    col="heat.colors",

+

+    # block sepration

+    colsep,

+    rowsep,

+    sepcolor="white",

+    sepwidth=c(0.05,0.05),

+

+    # cell labeling

+    cellnote,

+    notecex=1.0,

+    notecol="cyan",

+    na.color=par("bg"),

+

+    # level trace

+    trace=c("column","row","both","none"),

+    tracecol="cyan",

+    hline=median(breaks),

+    vline=median(breaks),

+    linecol=tracecol,

+

+    # Row/Column Labeling

+    margins = c(5, 5),

+    ColSideColors,

+    RowSideColors,

+    cexRow = 0.2 + 1/log10(nr),

+    cexCol = 0.2 + 1/log10(nc),

+    labRow = NULL,

+    labCol = NULL,

+    srtRow = NULL,

+    srtCol = NULL,

+    adjRow = c(0,NA),

+    adjCol = c(NA,0),

+    offsetRow = 0.5,

+    offsetCol = 0.5,

+    colRow = NULL,

+    colCol = NULL,

+

+    # color key + density info

+    key = TRUE,

+    keysize = 1.5,

+    density.info=c("histogram","density","none"),

+    denscol=tracecol,

+    symkey = any(x < 0, na.rm=TRUE) || symbreaks,

+    densadj = 0.25,

+    key.title = NULL,

+    key.xlab = NULL,

+    key.ylab = NULL,

+    key.xtickfun = NULL,

+    key.ytickfun = NULL,

+    key.par=list(),

+

+    # plot labels

+    main = NULL,

+    xlab = NULL,

+    ylab = NULL,

+

+    # plot layout

+    lmat = NULL,

+    lhei = NULL,

+    lwid = NULL,

+

+    # extras

+    extrafun=NULL,

+    ...

+    ) {

+

+    if(is.data.frame(x)) {

+        warning_wrap("The input is a data frame, convert it to the matrix.")

+        mat = as.matrix(x)

+    } else {

+        mat = x

+    }

+

+    nr = nrow(mat)

+    nc = ncol(mat)

+

+    ht_param = list()

+

+    # Rowv can be 1. NA, 2. a dendrogram object, 3. a vector, 4. a logical value, 5. NULL

+    if(identical(Rowv, NA) || identical(Rowv, NULL) || identical(Rowv, FALSE)) {

+        ht_param$cluster_rows = FALSE

+    } else {

+        if(inherits(Rowv, c("dendrogram", "hclust"))) {

+            row_dend = as.dendrogram(Rowv)

+        } else if(is.vector(Rowv)) {

+            if(length(Rowv) == nr) {

+                row_dend = as.dendrogram(hclustfun(distfun(mat)))

+                row_dend = reorderfun(row_dend, Rowv)

+            } else if(length(Rowv) == 1 && is.logical(Rowv)) {

+                if(Rowv) {

+                    row_dend = as.dendrogram(hclustfun(distfun(mat)))

+                    row_dend = reorderfun(row_dend, -rowMeans(mat))

+                }

+            } else {

+                stop_wrap("Wrong value for 'Rowv'.")

+            }

+        }

+

+        ht_param$cluster_rows = row_dend

+    }

+

+    if(identical(Colv, NA) || identical(Colv, NULL) || identical(Colv, FALSE)) {

+        ht_param$cluster_columns = FALSE

+    } else {

+        if(inherits(Colv, c("dendrogram", "hclust"))) {

+            column_dend = as.dendrogram(Colv)

+        } else if(is.vector(Colv)) {

+            if(length(Colv) == nc) {

+                column_dend = as.dendrogram(hclustfun(distfun(t(mat))))

+                column_dend = reorderfun(column_dend, Colv)

+            } else if(length(Colv) == 1 && is.logical(Colv)) {

+                if(Colv) {

+                    column_dend = as.dendrogram(hclustfun(distfun(t(mat))))

+                    column_dend = reorderfun(column_dend, colMeans(mat))

+                }

+            } else {

+                stop_wrap("Wrong value for 'Colv'.")

+            }

+        }

+

+        ht_param$cluster_columns = column_dend

+    }

+

+    dendrogram = match.arg(dendrogram)[1]

+    if("both" %in% dendrogram) {

+        ht_param$show_row_dend = TRUE

+        ht_param$show_column_dend = TRUE

+    } else if("row" %in% dendrogram) {

+        ht_param$show_row_dend = TRUE

+        ht_param$show_column_dend = FALSE

+    } else if("column" %in% dendrogram) {

+        ht_param$show_row_dend = FALSE

+        ht_param$show_column_dend = TRUE

+    } else if("none" %in% dendrogram) {

+        ht_param$show_row_dend = FALSE

+        ht_param$show_column_dend = FALSE

+    }

+

+    ht_param$row_dend_width = unit(4, "cm")

+    ht_param$column_dend_height = unit(3, "cm")

+

+    

+    scale = match.arg(scale)[1]

+    if("row" %in% scale) {

+        if(any(is.na(mat))) {

+            mat = (mat - rowMeans(mat, na.rm = TRUE))/rowSds(mat, na.rm = TRUE)

+        } else {

+            mat = t(scale(t(mat)))

+        }

+        message_wrap("Note, in 'heatmap.2()', when rows are scaled, the row dendrogram is still calculated from the original matrix (not from the scaled matrix).")

+    } else if("column" %in% scale) {

+        if(any(is.na(mat))) {

+            mat = t((t(mat) - colMeans(mat, na.rm = TRUE))/colSds(mat, na.rm = TRUE))

+        } else {

+            mat = scale(mat)

+        }

+        message_wrap("Note, in 'heatmap.2()', when columns are scaled, the column dendrogram is still calculated from the original matrix (not from the scaled matrix).")

+    }

+

+    ht_param$matrix = mat

+

+    ##### how to process `col` is directly from gplots::heatmap.2 ####

+    if(is.character(col) && length(col) == 1) {

+        col <- get(col, mode="function")

+    }

+    if(missing(breaks) || is.null(breaks) || length(breaks)<1 ) {

+      if( missing(col) ||  is.function(col) )

+        breaks <- 16

+      else

+        breaks <- length(col)+1

+    }

+

+    if(length(breaks)==1)

+    {

+      if(!symbreaks)

+        breaks <- seq( min(mat, na.rm=na.rm), max(mat,na.rm=na.rm), length=breaks)

+      else

+        {

+          extreme <- max(abs(mat), na.rm=TRUE)

+          breaks <- seq( -extreme, extreme, length=breaks )

+        }

+    }

+

+    nbr <- length(breaks)

+    ncol <- length(breaks)-1

+

+    if(class(col)=="function") col <- col(ncol)

+    #### until here ###

+    

+    n_col = ncol

+

+    if(identical(scale, "row") || identical(scale, "column")) {

+        lim = max(abs(mat), na.rm = TRUE)

+        ht_param$col = colorRamp2(seq(-lim, lim, length = n_col), col)

+    } else {

+        ht_param$col = colorRamp2(seq(min(mat, na.rm = TRUE), max(mat, na.rm = TRUE), length = n_col), col)

+    } 

+    

+

+    if(!missing(colsep)) {

+        warning_wrap("argument `colsep` is not supported in heatmap.2 -> Heatmap translation, skip it. Suggest to use `column_split` argument in Heatmap() which can be directly used here.")

+    }

+    if(!missing(rowsep)) {

+        warning_wrap("argument `rowsep` is not supported in heatmap.2 -> Heatmap translation, skip it. Suggest to use `row_split` argument in Heatmap() which can be directly used here.")

+    }

+

+    if(!missing(cellnote)) {

+        ht_param$layer_fun = function(j, i, x, y, w, h, fill) {

+            grid.text(pindex(cellnote, i, j), x, y, gp = gpar(cex = notecex, col = notecol))

+        }

+    }

+    ht_param$na_col = na.color

+    

+    if(!missing(ColSideColors)) {

+        ht_param$top_annotation = HeatmapAnnotation(column = ColSideColors,

+            col = list(column = structure(unique(ColSideColors), names = unique(ColSideColors))),

+            show_legend = FALSE, show_annotation_name = FALSE)

+    }

+    if(!missing(RowSideColors)) {

+        ht_param$left_annotation = rowAnnotation(row = RowSideColors,

+            col = list(row = structure(unique(RowSideColors), names = unique(RowSideColors))),

+            show_legend = FALSE, show_annotation_name = FALSE)

+    }

+

+    if(identical(ht_param$cluster_rows, FALSE)) {

+        if(is.null(ht_param$left_annotation)) {

+            ht_param$left_annotation = rowAnnotation(foo1 = anno_empty(width = unit(4, "cm"), border = FALSE))

+        } else {

+            ht_param$left_annotation = c(ht_param$left_annotation, rowAnnotation(foo1 = anno_empty(width = unit(3.5, "cm"))))

+        }

+    }

+

+    if(identical(ht_param$cluster_columns, FALSE)) {

+        if(is.null(ht_param$top_annotation)) {

+            ht_param$top_annotation = HeatmapAnnotation(foo2 = anno_empty(height = unit(3, "cm"), border = FALSE))

+        } else {

+            ht_param$top_annotation = c(ht_param$top_annotation, HeatmapAnnotation(foo2 = anno_empty(height = unit(3.5, "cm"))))

+        }

+    }

+

+    if(!is.null(labRow)) {

+        ht_param$row_labels = labRow

+    } else if(is.null(rownames(mat))) {

+        ht_param$row_labels = seq_len(nr)

+    } else {

+        ht_param$row_labels = rownames(mat)

+    }

+

+    if(!is.null(labCol)) {

+        ht_param$column_labels = labCol

+    } else if(is.null(colnames(mat))) {

+        ht_param$column_labels = seq_len(nc)

+    } else {

+        ht_param$column_labels = colnames(mat)

+    }

+

+    if(is.null(colRow)) colRow = "black"

+    ht_param$row_names_gp = gpar(cex = cexRow, col = colRow)

+    if(is.null(colCol)) colCol = "black"

+    ht_param$column_names_gp = gpar(cex = cexCol, col = colCol)

+

+    if(!is.null(srtRow)) {

+        ht_param$row_names_rot = srtRow

+    }

+    if(!is.null(srtCol)) {

+        ht_param$column_names_rot = srtCol

+    }

+

+    if(!is.null(main)) {

+        ht_param$column_title = main

+    }

+    if(!is.null(xlab)) {

+        if(is.null(ht_param$column_labels)) {

+            ht_param$bottom_annotation = HeatmapAnnotation(xlab = anno_block(labels = xlab, gp = gpar(col = NA)))

+        } else {

+            ht_param$bottom_annotation = HeatmapAnnotation(

+                colnames = anno_text(ht_param$column_labels, gp = ht_param$column_names_gp),

+                xlab = anno_block(labels = xlab, gp = gpar(col = NA))

+            )

+            ht_param$show_column_names = FALSE

+        }

+    }

+    if(!is.null(ylab)) {

+        if(is.null(ht_param$row_labels)) {

+            ht_param$right_annotation = rowAnnotation(ylab = anno_block(labels = ylab, gp = gpar(col = NA)))

+        } else {

+            ht_param$right_annotation = rowAnnotation(

+                rownames = anno_text(ht_param$row_labels, gp = ht_param$row_names_gp),

+                ylab = anno_block(labels = ylab, gp = gpar(col = NA))

+            )

+            ht_param$show_row_names = FALSE

+        }

+    }

+

+    ht_param$show_heatmap_legend = FALSE

+

+    trace = match.arg(trace)[1]

+    min = breaks[1]

+    max = breaks[length(breaks)]

+    rg = max - min

+

+    layer_fun = NULL

+    if(trace == "both") {

+        warning_wrap("trace = 'both' is not supported, change to trace = 'column'.")

+        trace = "column"

+    }

+    if(trace == "column") {

+        layer_fun = function(j, i, x, y, w, h, fill) {

+            ind_mat = restore_matrix(j, i, x, y)

+

+            ind = ind_mat[1, ]

+            grid.segments(x[ind], unit(0, "npc"), x[ind], unit(1, "npc"), gp = gpar(col = linecol, lty = 2))

+            for(ki in seq_len(ncol(ind_mat))) {

+                ind = ind_mat[, ki]

+                offset = (mat[i[ind], j[ind[1]]] - min)/(max - min)*w[ind]

+                pos_x = rep(x[ind] - w[ind]*0.5 + offset, each = 2)

+                pos_y = rep(y[ind] + h[ind]*0.5, each = 2)

+                pos_y[seq_along(ind) %% 2 == 0] = y[ind] - h[ind]*0.5

+                grid.lines(pos_x, pos_y, gp = gpar(col = tracecol))

+            }

+        }

+    } else if(trace == "row") {

+        layer_fun = function(j, i, x, y, w, h, fill) {

+            ind_mat = restore_matrix(j, i, x, y)

+

+            ind = ind_mat[, 1]

+            grid.segments(unit(0, "npc"), y[ind], unit(1, "npc"), y[ind], gp = gpar(col = linecol, lty = 2))

+            for(ki in seq_len(nrow(ind_mat))) {

+                ind = ind_mat[ki, ]

+                offset = (mat[i[ind[1]], j[ind]] - min)/(max - min)*h[ind]

+                pos_x = rep(x[ind] - w[ind]*0.5, each = 2)

+                pos_x[seq_along(ind) %% 2 == 0] = x[ind] + w[ind]*0.5

+                pos_y = rep(y[ind] - h[ind]*0.5 + offset, each = 2)

+                grid.lines(pos_x, pos_y, gp = gpar(col = tracecol))

+            }

+        }

+    }

+    if(!is.null(ht_param$layer_fun)) {

+        fun1 = ht_param$layer_fun

+        fun2 = layer_fun

+        fun3 = function(j, i, x, y, w, h, fill) {

+            fun1(j, i, x, y, w, h, fill)

+            fun2(j, i, x, y, w, h, fill)

+        }

+        layer_fun = fun3

+    }

+    ht_param$layer_fun = layer_fun

+

+

+    random_str = paste(sample(c(letters, LETTERS, 0:9), 8), collapse = "")

+    ht_param$name = paste0("heatmap.2_", random_str)

+

+    density.info = match.arg(density.info)[1]

+    if(is.null(key.xlab)) key.xlab = "Value"

+    if(is.null(key.ylab)) {

+        if(density.info == "histogram") key.ylab = "Count"

+        if(density.info == "density") key.ylab = "Density"

+    }

+

+    if(density.info == "none") {

+        post_fun = NULL

+    } else {

+        post_fun = function(ht) {

+            decorate_heatmap_body(paste0("heatmap.2_", random_str), {

+                pushViewport(viewport(unit(0, "npc"), unit(1, "npc"), width = unit(4, "cm"), height = unit(3, "cm"), just = c("right", "bottom")))

+

+                left_width = unit(1, "cm")

+                bottom_height = unit(1, "cm")

+                top_height = unit(0.5, "cm")