@@ -597,6 +597,9 @@ Heatmap = function(matrix, col, name,

             if(is.null(names(col))) {

                 if(length(col) == length(unique(as.vector(matrix)))) {

+                    if(length(col) >= 50) {

+                        message_wrap(qq("There are @{length(col)} unique colors in the vector `col` and @{length(col)} unique values in `matrix`. `Heatmap()` will treat it as an exact discrete one-to-one mapping. If this is not what you want, slightly change the number of colors, e.g. by adding one more color or removing a color."))

+                    }

                     if(is.null(fa_level)) {

                         if(is.numeric(matrix)) {

                             names(col) = sort(unique(as.vector(matrix)))

@@ -626,14 +626,14 @@ Heatmap = function(matrix, col, name,

                     col = col[intersect(c(fa_level, "_NA_"), names(col))]

                 }

                 if(!is.null(heatmap_legend_param) && !identical(.Object@matrix_param$gp$type, "none")) {

-                    if(!is.null(heatmap_legend_param$at) && !is.null(heatmap_legend_param$labels)) {

+                    if(!is.null(heatmap_legend_param$at) && !is.null(heatmap_legend_param[["labels"]])) {

                         l = heatmap_legend_param$at %in% names(col)

                         heatmap_legend_param$at = heatmap_legend_param$at[l]

-                        heatmap_legend_param$labels = heatmap_legend_param$labels[l]

+                        heatmap_legend_param[["labels"]] = heatmap_legend_param[["labels"]][l]

                     } else if(is.null(heatmap_legend_param$at) && !is.null(heatmap_legend_param$labels)) {

-                        l = heatmap_legend_param$labels %in% names(col)

-                        heatmap_legend_param$labels = heatmap_legend_param$labels[l]

-                    } else if(!is.null(heatmap_legend_param$at) && is.null(heatmap_legend_param$labels)) {

+                        l = heatmap_legend_param[["labels"]] %in% names(col)

+                        heatmap_legend_param[["labels"]] = heatmap_legend_param[["labels"]][l]

+                    } else if(!is.null(heatmap_legend_param$at) && is.null(heatmap_legend_param[["labels"]])) {

                         l = heatmap_legend_param$at %in% names(col)

                         heatmap_legend_param$at = heatmap_legend_param$at[l]

                     }

@@ -644,7 +644,7 @@ Heatmap = function(matrix, col, name,

         }

         .Object@matrix_legend_param = heatmap_legend_param

     }

-    

+

     ##### titles, should also consider titles after row splitting #####

     if(identical(row_title, NA) || identical(row_title, "")) {

         row_title = character(0)

@@ -102,11 +102,11 @@ Heatmap = setClass("Heatmap",

 # -row_title Title on the row.

 # -row_title_side Will the title be put on the left or right of the heatmap?

 # -row_title_gp Graphic parameters for row title.

-# -row_title_rot Rotation of row title. Only 0, 90, 270 are allowed to set.

+# -row_title_rot Rotation of row title.

 # -column_title Title on the column.

 # -column_title_side Will the title be put on the top or bottom of the heatmap?

 # -column_title_gp Graphic parameters for column title.

-# -column_title_rot Rotation of column titles. Only 0, 90, 270 are allowed to set.

+# -column_title_rot Rotation of column titles.

 # -cluster_rows If the value is a logical, it controls whether to make cluster on rows. The value can also

 #               be a `stats::hclust` or a `stats::dendrogram` which already contains clustering.

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

@@ -559,7 +559,7 @@ Heatmap = function(matrix, col, name,

             warning_wrap("You defined `cell_fun` for a heatmap with more than 100 rows or columns, which might be very slow to draw. Consider to use the vectorized version `layer_fun`.")

         }

     }

-    

+

     ### color for main matrix #########

     if(ncol(matrix) > 0 && nrow(matrix) > 0) {

         if(missing(col)) {

@@ -625,7 +625,7 @@ Heatmap = function(matrix, col, name,

                 } else {

                     col = col[intersect(c(fa_level, "_NA_"), names(col))]

                 }

-                if(!is.null(heatmap_legend_param)) {

+                if(!is.null(heatmap_legend_param) && !identical(.Object@matrix_param$gp$type, "none")) {

                     if(!is.null(heatmap_legend_param$at) && !is.null(heatmap_legend_param$labels)) {

                         l = heatmap_legend_param$at %in% names(col)

                         heatmap_legend_param$at = heatmap_legend_param$at[l]

@@ -619,11 +619,25 @@ Heatmap = function(matrix, col, name,

                 }

             } else {

                 full_col = col

+                # note here col can be reduced

                 if(is.null(fa_level)) {

                     col = col[intersect(c(names(col), "_NA_"), as.character(matrix))]

                 } else {

                     col = col[intersect(c(fa_level, "_NA_"), names(col))]

                 }

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

+                    if(!is.null(heatmap_legend_param$at) && !is.null(heatmap_legend_param$labels)) {

+                        l = heatmap_legend_param$at %in% names(col)

+                        heatmap_legend_param$at = heatmap_legend_param$at[l]

+                        heatmap_legend_param$labels = heatmap_legend_param$labels[l]

+                    } else if(is.null(heatmap_legend_param$at) && !is.null(heatmap_legend_param$labels)) {

+                        l = heatmap_legend_param$labels %in% names(col)

+                        heatmap_legend_param$labels = heatmap_legend_param$labels[l]

+                    } else if(!is.null(heatmap_legend_param$at) && is.null(heatmap_legend_param$labels)) {

+                        l = heatmap_legend_param$at %in% names(col)

+                        heatmap_legend_param$at = heatmap_legend_param$at[l]

+                    }

+                }

                 .Object@matrix_color_mapping = ColorMapping(colors = col, name = name, na_col = na_col, full_col = full_col)

                 if(verbose) qqcat("input color is a named vector\n")

             }

@@ -531,6 +531,26 @@ Heatmap = function(matrix, col, name,

     if(!missing(border_gp) && missing(border)) border = TRUE

     .Object@matrix_param$border = border

     .Object@matrix_param$border_gp = border_gp

+

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

+        global_vars = codetools::findGlobals(cell_fun, merge = FALSE)$variables

+

+        ee = new.env(parent = environment(cell_fun))

+        for(v in global_vars) {

+            assign(v, value = get(v, envir = environment(cell_fun)), envir = ee)

+        }

+        environment(cell_fun) = ee

+    }

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

+        global_vars = codetools::findGlobals(layer_fun, merge = FALSE)$variables

+

+        ee = new.env(parent = environment(layer_fun))

+        for(v in global_vars) {

+            assign(v, value = get(v, envir = environment(layer_fun)), envir = ee)

+        }

+        environment(layer_fun) = ee

+    }

+

     .Object@matrix_param$cell_fun = cell_fun

     .Object@matrix_param$layer_fun = layer_fun

@@ -557,12 +557,24 @@ Heatmap = function(matrix, col, name,

             if(verbose) qqcat("color is not specified, use randomly generated colors\n")

         }

         if(is.function(col)) {

-            .Object@matrix_color_mapping = ColorMapping(col_fun = col, name = name, na_col = na_col)

+            if(is.null(attr(col, "breaks"))) {

+                breaks = seq(min(matrix, na.rm = TRUE), max(matrix, na.rm = TRUE), length.out = 5)

+                rg = range(breaks)

+                diff = rg[2] - rg[1]

+                rg[1] = rg[1] + diff*0.05

+                rg[2] = rg[2] - diff*0.05

+

+                le = pretty(rg, n = 3)

+                .Object@matrix_color_mapping = ColorMapping(col_fun = col, name = name, breaks = le, na_col = na_col)

+            } else {

+                .Object@matrix_color_mapping = ColorMapping(col_fun = col, name = name, na_col = na_col)

+            }

             if(verbose) qqcat("input color is a color mapping function\n")

         } else if(inherits(col, "ColorMapping")){

             .Object@matrix_color_mapping = col

             if(verbose) qqcat("input color is a ColorMapping object\n")

         } else {

+

             if(is.null(names(col))) {

                 if(length(col) == length(unique(as.vector(matrix)))) {

                     if(is.null(fa_level)) {

@@ -974,7 +974,17 @@ Heatmap = function(matrix, col, name,

     .Object@heatmap_param$height = heatmap_height

     .Object@heatmap_param$show_heatmap_legend = show_heatmap_legend

     .Object@heatmap_param$use_raster = use_raster

-    .Object@heatmap_param$raster_device = match.arg(raster_device)[1]

+

+    if(missing(raster_device)) {

+        if(requireNamespace("Cairo", quietly = TRUE)) {

+            raster_device = "CairoPNG"

+        } else {

+            raster_device = "png"

+        }

+    } else {

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

+    }

+    .Object@heatmap_param$raster_device = raster_device

     .Object@heatmap_param$raster_quality = raster_quality

     .Object@heatmap_param$raster_device_param = raster_device_param

     .Object@heatmap_param$raster_resize_mat = raster_resize_mat

@@ -578,7 +578,7 @@ Heatmap = function(matrix, col, name,

                     .Object@matrix_color_mapping = ColorMapping(colors = col, name = name, na_col = na_col)

                     if(verbose) qqcat("input color is a vector with no names, treat it as discrete color mapping\n")

                 } else if(is.numeric(matrix)) {

-                    col = colorRamp2(seq(min(matrix, na.rm = TRUE), max(matrix, na.rm = TRUE), length = length(col)),

+                    col = colorRamp2(seq(min(matrix, na.rm = TRUE), max(matrix, na.rm = TRUE), length.out = length(col)),

                                      col, space = color_space)

                     .Object@matrix_color_mapping = ColorMapping(col_fun = col, name = name, na_col = na_col)

                     if(verbose) qqcat("input color is a vector with no names, treat it as continuous color mapping\n")

@@ -360,7 +360,7 @@ Heatmap = function(matrix, col, name,

     if(is.data.frame(matrix)) {

         if(verbose) qqcat("convert data frame to matrix\n")

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

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

         if(!all(sapply(matrix, is.numeric))) {

             warning_wrap("Note: not all columns in the data frame are numeric. The data frame will be converted into a character matrix.")

         }

@@ -360,7 +360,10 @@ Heatmap = function(matrix, col, name,

     if(is.data.frame(matrix)) {

         if(verbose) qqcat("convert data frame to matrix\n")

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

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

+        if(!all(sapply(matrix, is.numeric))) {

+            warning_wrap("Note: not all columns in the data frame are numeric. The data frame will be converted into a character matrix.")

+        }

         matrix = as.matrix(matrix)

     }

     fa_level = NULL

@@ -293,7 +293,7 @@ Heatmap = function(matrix, col, name,

     heatmap_legend_param = list(title = name),

     use_raster = NULL, 

-    raster_device = c("CairoPNG", "CairoJPEG", "CairoTIFF", "png", "jpeg", "tiff", "agg_png"),

+    raster_device = c("png", "jpeg", "tiff", "CairoPNG", "CairoJPEG", "CairoTIFF", "agg_png"),

     raster_quality = 1,

     raster_device_param = list(),

     raster_resize_mat = FALSE,

@@ -803,6 +803,9 @@ Heatmap = function(matrix, col, name,

             }

         }

     }

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

+        validate_anno_names_with_matrix(matrix, top_annotation, "column")

+    }

     .Object@bottom_annotation = bottom_annotation # a `HeatmapAnnotation` object

     if(is.null(bottom_annotation)) {

@@ -826,6 +829,9 @@ Heatmap = function(matrix, col, name,

             }

         }

     }

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

+        validate_anno_names_with_matrix(matrix, bottom_annotation, "column")

+    }

     .Object@left_annotation = left_annotation # a `rowAnnotation` object

     if(is.null(left_annotation)) {

@@ -849,6 +855,9 @@ Heatmap = function(matrix, col, name,

             }

         }

     }

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

+        validate_anno_names_with_matrix(matrix, left_annotation, "row")

+    }

     .Object@right_annotation = right_annotation # a `rowAnnotation` object

     if(is.null(right_annotation)) {

@@ -872,6 +881,9 @@ Heatmap = function(matrix, col, name,

             }

         }

     }

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

+        validate_anno_names_with_matrix(matrix, right_annotation, "row")

+    }

     .Object@layout = list(

         layout_size = list(

@@ -530,6 +530,12 @@ Heatmap = function(matrix, col, name,

     .Object@matrix_param$border_gp = border_gp

     .Object@matrix_param$cell_fun = cell_fun

     .Object@matrix_param$layer_fun = layer_fun

+

+    if(nrow(matrix) > 100 || ncol(matrix) > 100) {

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

+            warning_wrap("You defined `cell_fun` for a heatmap with more than 100 rows or columns, which might be very slow to draw. Consider to use the vectorized version `layer_fun`.")

+        }

+    }

     ### color for main matrix #########

     if(ncol(matrix) > 0 && nrow(matrix) > 0) {

@@ -467,6 +467,7 @@ Heatmap = function(matrix, col, name,

         column_km = 1

         if(verbose) qqcat("matrix is character. Do not cluster unless distance method is provided.\n")

     }

+    class(matrix) = "matrix"

     .Object@matrix = matrix

     .Object@matrix_param$row_km = row_km

@@ -179,7 +179,7 @@ Heatmap = setClass("Heatmap",

 # -use_raster Whether render the heatmap body as a raster image. It helps to reduce file size when the matrix is huge. If number of rows or columns is more than 2000, it is by default turned on. Note if ``cell_fun``

 #       is set, ``use_raster`` is enforced to be ``FALSE``.

 # -raster_device Graphic device which is used to generate the raster image.

-# -raster_quality Ignored now.

+# -raster_quality A value larger than 1.

 # -raster_device_param A list of further parameters for the selected graphic device. For raster image support, please check https://jokergoo.github.io/ComplexHeatmap-reference/book/a-single-heatmap.html#heatmap-as-raster-image .

 # -raster_resize_mat Whether resize the matrix to let the dimension of the matrix the same as the dimension of the raster image?

 #          The value can be logical. If it is ``TRUE``, `base::mean` is used to summarize the sub matrix which corresponds to a single pixel.

@@ -294,7 +294,7 @@ Heatmap = function(matrix, col, name,

     use_raster = NULL, 

     raster_device = c("CairoPNG", "CairoJPEG", "CairoTIFF", "png", "jpeg", "tiff", "agg_png"),

-    raster_quality = 2,

+    raster_quality = 1,

     raster_device_param = list(),

     raster_resize_mat = FALSE,

     raster_by_magick = requireNamespace("magick", quietly = TRUE),

@@ -1204,7 +1204,11 @@ make_cluster = function(object, which = c("row", "column")) {

             slot(object, paste0(which, "_dend_slice")) = dend_slice

             if(!is.null(split)) {

-                split = data.frame(rep(seq_along(order_list), times = sapply(order_list, length)))

+                if(is.null(attr(dend_list[[1]], ".class_label"))) {

+                    split = data.frame(rep(seq_along(order_list), times = sapply(order_list, length)))

+                } else {

+                    split = data.frame(rep(sapply(dend_list, function(x) attr(x, ".class_label")), times = sapply(order_list, length)))

+                }

                 object@matrix_param[[ paste0(which, "_split") ]] = split

                 # adjust row_names_param$gp if the length of some elements is the same as row slices

@@ -1231,7 +1235,7 @@ make_cluster = function(object, which = c("row", "column")) {

                     stop_wrap(qq("Length of `gap` should be 1 or number of @{which} slices."))

                 }

                 object@matrix_param[[ paste0(which, "_gap") ]] = gap # adjust title

-                

+

                 title = slot(object, paste0(which, "_title"))

                 if(!is.null(split)) {

                     if(length(title) == 0 && !is.null(title)) { ## default title

@@ -1145,7 +1145,7 @@ make_cluster = function(object, which = c("row", "column")) {

                 dend_slice = ct$upper

                 sth = tapply(order.dendrogram(dend_param$obj), 

                     rep(seq_along(dend_list), times = sapply(dend_list, nobs)), 

-                    function(x) x)

+                    function(x) x, simplify = FALSE)

                 attributes(sth) = NULL

                 order_list = sth

                 if(verbose) qqcat("cut @{which} dendrogram into @{split} slices.\n")

@@ -1579,9 +1579,9 @@ make_cluster = function(object, which = c("row", "column")) {

     }

     slot(object, paste0(which, "_title")) = title

     # check whether height of the dendrogram is zero

-    if(all(sapply(dend_list, dend_heights) == 0)) {

-        slot(object, paste0(which, "_dend_param"))$show = FALSE

-    }

+    # if(all(sapply(dend_list, dend_heights) == 0)) {

+    #     slot(object, paste0(which, "_dend_param"))$show = FALSE

+    # }

     return(object)

 }

@@ -556,7 +556,12 @@ Heatmap = function(matrix, col, name,

             if(is.null(names(col))) {

                 if(length(col) == length(unique(as.vector(matrix)))) {

                     if(is.null(fa_level)) {

-                        names(col) = sort(unique(as.vector(matrix)))

+                        if(is.numeric(matrix)) {

+                            names(col) = sort(unique(as.vector(matrix)))

+                            col = rev(col)

+                        } else {

+                            names(col) = sort(unique(as.vector(matrix)))

+                        }

                     } else {

                         names(col) = fa_level

                     }

@@ -539,6 +539,13 @@ Heatmap = function(matrix, col, name,

             }

             if(verbose) qqcat("color is not specified, use randomly generated colors\n")

         }

+        if(is.null(col)) {

+            col = default_col(matrix, main_matrix = TRUE)

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

+                col = col[fa_level]

+            }

+            if(verbose) qqcat("color is not specified, use randomly generated colors\n")

+        }

         if(is.function(col)) {

             .Object@matrix_color_mapping = ColorMapping(col_fun = col, name = name, na_col = na_col)

             if(verbose) qqcat("input color is a color mapping function\n")

@@ -766,6 +766,9 @@ Heatmap = function(matrix, col, name,

     if(is.null(top_annotation)) {

         .Object@top_annotation_param$height = unit(0, "mm")    

     } else {

+        if(inherits(top_annotation, "AnnotationFunction")) {

+            stop_wrap("The annotation function `anno_*()` should be put inside `HeatmapAnnotation()`.")

+        }

         .Object@top_annotation_param$height = height(top_annotation) + ht_opt$COLUMN_ANNO_PADDING  # append the gap

     }

     if(!is.null(top_annotation)) {

@@ -786,6 +789,9 @@ Heatmap = function(matrix, col, name,

     if(is.null(bottom_annotation)) {

         .Object@bottom_annotation_param$height = unit(0, "mm")

     } else {

+        if(inherits(bottom_annotation, "AnnotationFunction")) {

+            stop_wrap("The annotation function `anno_*()` should be put inside `HeatmapAnnotation()`.")

+        }

         .Object@bottom_annotation_param$height = height(bottom_annotation) + ht_opt$COLUMN_ANNO_PADDING  # append the gap

     }

     if(!is.null(bottom_annotation)) {

@@ -806,6 +812,9 @@ Heatmap = function(matrix, col, name,

     if(is.null(left_annotation)) {

         .Object@left_annotation_param$width = unit(0, "mm")

     } else {

+        if(inherits(left_annotation, "AnnotationFunction")) {

+            stop_wrap("The annotation function `anno_*()` should be put inside `rowAnnotation()`.")

+        }

         .Object@left_annotation_param$width = width(left_annotation) + ht_opt$ROW_ANNO_PADDING  # append the gap

     }

     if(!is.null(left_annotation)) {

@@ -826,6 +835,9 @@ Heatmap = function(matrix, col, name,

     if(is.null(right_annotation)) {

         .Object@right_annotation_param$width = unit(0, "mm")

     } else {

+        if(inherits(right_annotation, "AnnotationFunction")) {

+            stop_wrap("The annotation function `anno_*()` should be put inside `rowAnnotation()`.")

+        }

         .Object@right_annotation_param$width = width(right_annotation) + ht_opt$ROW_ANNO_PADDING  # append the gap

     }

     if(!is.null(right_annotation)) {

@@ -1,4 +1,3 @@

-

 ###############################

 # class for single heatmap

 #

@@ -1275,14 +1274,14 @@ make_cluster = function(object, which = c("row", "column")) {

             # cl = km.fit$cluster

             cl = consensus_kmeans(mat, km, km_repeats)

             meanmat = lapply(sort(unique(cl)), function(i) {

-                colMeans(mat[cl == i, , drop = FALSE])

+                colMeans(mat[cl == i, , drop = FALSE], na.rm = TRUE)

             })

         } else {

             # km.fit = kmeans(t(mat), centers = km)

             # cl = km.fit$cluster

             cl = consensus_kmeans(t(mat), km, km_repeats)

             meanmat = lapply(sort(unique(cl)), function(i) {

-                rowMeans(mat[, cl == i, drop = FALSE])

+                rowMeans(mat[, cl == i, drop = FALSE], na.rm = TRUE)

             })

         }

@@ -1451,9 +1450,9 @@ make_cluster = function(object, which = c("row", "column")) {

         if(length(order_list) > 1 && cluster_slices) {

             if(which == "row") {

-                slice_mean = sapply(order_list, function(ind) colMeans(mat[ind, , drop = FALSE]))

+                slice_mean = sapply(order_list, function(ind) colMeans(mat[ind, , drop = FALSE], na.rm = TRUE))

             } else {

-                slice_mean = sapply(order_list, function(ind) rowMeans(mat[, ind, drop = FALSE]))

+                slice_mean = sapply(order_list, function(ind) rowMeans(mat[, ind, drop = FALSE], na.rm = TRUE))

             }

             if(!is.matrix(slice_mean)) {

                 slice_mean = matrix(slice_mean, nrow = 1)

@@ -1680,4 +1679,3 @@ setMethod(f = "prepare",

     return(object)

 })

-

@@ -223,11 +223,11 @@ Heatmap = function(matrix, col, name,

     row_title = character(0), 

     row_title_side = c("left", "right"), 

-    row_title_gp = gpar(fontsize = 13), 

+    row_title_gp = gpar(fontsize = 13.2), 

     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 = 13), 

+    column_title_gp = gpar(fontsize = 13.2), 

     column_title_rot = 0,

     cluster_rows = TRUE, 

@@ -223,11 +223,11 @@ Heatmap = function(matrix, col, name,

     row_title = character(0), 

     row_title_side = c("left", "right"), 

-    row_title_gp = gpar(fontsize = 14), 

+    row_title_gp = gpar(fontsize = 13), 

     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_gp = gpar(fontsize = 13), 

     column_title_rot = 0,

     cluster_rows = TRUE, 

@@ -565,12 +565,13 @@ Heatmap = function(matrix, col, name,

                     stop_wrap("`col` should have names to map to values in `mat`.")

                 }

             } else {

+                full_col = col

                 if(is.null(fa_level)) {

                     col = col[intersect(c(names(col), "_NA_"), as.character(matrix))]

                 } else {

                     col = col[intersect(c(fa_level, "_NA_"), names(col))]

                 }

-                .Object@matrix_color_mapping = ColorMapping(colors = col, name = name, na_col = na_col)

+                .Object@matrix_color_mapping = ColorMapping(colors = col, name = name, na_col = na_col, full_col = full_col)

                 if(verbose) qqcat("input color is a named vector\n")

             }

         }

@@ -294,7 +294,7 @@ Heatmap = function(matrix, col, name,

     heatmap_legend_param = list(title = name),

     use_raster = NULL, 

-    raster_device = c("png", "jpeg", "tiff", "CairoPNG", "CairoJPEG", "CairoTIFF", "agg_png"),

+    raster_device = c("CairoPNG", "CairoJPEG", "CairoTIFF", "png", "jpeg", "tiff", "agg_png"),

     raster_quality = 2,

     raster_device_param = list(),

     raster_resize_mat = FALSE,

@@ -1352,6 +1352,7 @@ make_cluster = function(object, which = c("row", "column")) {

         names(order_list) = level

     }

+    slice_od = seq_along(order_list)

     # make dend in each slice

     if(cluster) {

         if(verbose) qqcat("apply clustering on each slice (@{length(order_list)} slices)\n")

@@ -98,7 +98,8 @@ Heatmap = setClass("Heatmap",

 # -jitter Random shifts added to the matrix. The value can be logical or a single numeric value. It it is ``TRUE``, random 

 #      values from uniform distribution between 0 and 1e-10 are generated. If it is a numeric value,

 #      the range for the uniform distribution is (0, ``jitter``). It is mainly to solve the problem of "Error: node stack overflow"

-#      when there are too many identical rows/columns for plotting the dendrograms.

+#      when there are too many identical rows/columns for plotting the dendrograms. ADD: From version 2.5.6, the error of node stack overflow

+#      has been fixed, now this argument is ignored.

 # -row_title Title on the row.

 # -row_title_side Will the title be put on the left or right of the heatmap?

 # -row_title_gp Graphic parameters for row title.

@@ -293,7 +293,7 @@ Heatmap = function(matrix, col, name,

     heatmap_legend_param = list(title = name),

     use_raster = NULL, 

-    raster_device = c("png", "jpeg", "tiff", "CairoPNG", "CairoJPEG", "CairoTIFF"),

+    raster_device = c("png", "jpeg", "tiff", "CairoPNG", "CairoJPEG", "CairoTIFF", "agg_png"),

     raster_quality = 2,

     raster_device_param = list(),

     raster_resize_mat = FALSE,

@@ -909,6 +909,16 @@ Heatmap = function(matrix, col, name,

             use_raster = FALSE

         }

     }

+

+    if(use_raster) {

+        if(missing(raster_by_magick)) {

+            if(!raster_by_magick) {

+                if(ht_opt$message) {

+                    message_wrap("'magick' package is suggested to install to give better rasterization.\n\nSet `ht_opt$message = FALSE` to turn off this message.")

+                }

+            }

+        }

+    }

     .Object@matrix_param$width = width

     .Object@matrix_param$height = height

@@ -294,7 +294,7 @@ Heatmap = function(matrix, col, name,

     use_raster = NULL, 

     raster_device = c("png", "jpeg", "tiff", "CairoPNG", "CairoJPEG", "CairoTIFF"),

-    raster_quality = 1,

+    raster_quality = 2,

     raster_device_param = list(),

     raster_resize_mat = FALSE,

     raster_by_magick = requireNamespace("magick", quietly = TRUE),

@@ -215,7 +215,7 @@ Heatmap = function(matrix, col, name,

     color_space = "LAB",

     rect_gp = gpar(col = NA), 

     border = NA,

-    border_gp = gpar(fill = NA, col = "black"),

+    border_gp = gpar(col = "black"),

     cell_fun = NULL,

     layer_fun = NULL,

     jitter = FALSE,

@@ -524,7 +524,7 @@ Heatmap = function(matrix, col, name,

     if(missing(border)) {

         if(!is.null(ht_opt$heatmap_border)) border = ht_opt$heatmap_border

     }

-    if(identical(border, TRUE)) border = "black"

+    if(!missing(border_gp) && missing(border)) border = TRUE

     .Object@matrix_param$border = border

     .Object@matrix_param$border_gp = border_gp

     .Object@matrix_param$cell_fun = cell_fun

@@ -179,9 +179,14 @@ Heatmap = setClass("Heatmap",

 # -use_raster Whether render the heatmap body as a raster image. It helps to reduce file size when the matrix is huge. If number of rows or columns is more than 2000, it is by default turned on. Note if ``cell_fun``

 #       is set, ``use_raster`` is enforced to be ``FALSE``.

 # -raster_device Graphic device which is used to generate the raster image.

-# -raster_quality A value set to larger than 1 will improve the quality of the raster image.

+# -raster_quality Ignored now.

 # -raster_device_param A list of further parameters for the selected graphic device. For raster image support, please check https://jokergoo.github.io/ComplexHeatmap-reference/book/a-single-heatmap.html#heatmap-as-raster-image .

-# -raster_resize Whether resize the matrix to let the dimension of the matrix the same as the dimension of the raster image?

+# -raster_resize_mat Whether resize the matrix to let the dimension of the matrix the same as the dimension of the raster image?

+#          The value can be logical. If it is ``TRUE``, `base::mean` is used to summarize the sub matrix which corresponds to a single pixel.

+#          The value can also be a summary function, e.g. `base::max`.

+# -raster_by_magick Whether to use `magick::image_resize` to scale the image.

+# -raster_magick_filter Pass to ``filter`` argument of `magick::image_resize`. A character scalar and all possible values

+#          are in `magick::filter_types`. The default is ``"Lanczos"``.

 # -post_fun A function which will be executed after the heatmap list is drawn.

 #

 # == details

@@ -289,9 +294,11 @@ Heatmap = function(matrix, col, name,

     use_raster = NULL, 

     raster_device = c("png", "jpeg", "tiff", "CairoPNG", "CairoJPEG", "CairoTIFF"),

-    raster_quality = 2,

+    raster_quality = 1,

     raster_device_param = list(),

-    raster_resize = FALSE,

+    raster_resize_mat = FALSE,

+    raster_by_magick = requireNamespace("magick", quietly = TRUE),

+    raster_magick_filter = NULL,

     post_fun = NULL) {

@@ -891,12 +898,12 @@ Heatmap = function(matrix, col, name,

         if(nrow(matrix) > 2000 && ncol(matrix) > 10) {

             use_raster = TRUE

             if(ht_opt$message) {

-                message_wrap("`use_raster` is automatically set to TRUE for a matrix with more than 2000 rows. You can control `use_raster` arugment by explicitly setting TRUE/FALSE to it. Set `ht_opt$message = FALSE` to turn off this message.")

+                message_wrap("`use_raster` is automatically set to TRUE for a matrix with more than 2000 rows. You can control `use_raster` argument by explicitly setting TRUE/FALSE to it.\n\nSet `ht_opt$message = FALSE` to turn off this message.")

             }

         } else if(ncol(matrix) > 2000 && nrow(matrix) > 10) {

             use_raster = TRUE

             if(ht_opt$message) {

-                message_wrap("`use_raster` is automatically set to TRUE for a matrix with more than 2000 columns You can control `use_raster` arugment by explicitly setting TRUE/FALSE to it. Set `ht_opt$message = FALSE` to turn off this message.")

+                message_wrap("`use_raster` is automatically set to TRUE for a matrix with more than 2000 columns You can control `use_raster` argument by explicitly setting TRUE/FALSE to it.\n\nSet `ht_opt$message = FALSE` to turn off this message.")

             }

         } else {

             use_raster = FALSE

@@ -913,7 +920,9 @@ Heatmap = function(matrix, col, name,

     .Object@heatmap_param$raster_device = match.arg(raster_device)[1]

     .Object@heatmap_param$raster_quality = raster_quality

     .Object@heatmap_param$raster_device_param = raster_device_param

-    .Object@heatmap_param$raster_resize = raster_resize

+    .Object@heatmap_param$raster_resize_mat = raster_resize_mat

+    .Object@heatmap_param$raster_by_magick = raster_by_magick

+    .Object@heatmap_param$raster_magick_filter = raster_magick_filter

     .Object@heatmap_param$verbose = verbose

     .Object@heatmap_param$post_fun = post_fun

     .Object@heatmap_param$calling_env = parent.frame()

@@ -88,6 +88,8 @@ Heatmap = setClass("Heatmap",

 # -color_space The color space in which colors are interpolated. Only used if ``matrix`` is numeric and 

 #            ``col`` is a vector of colors. Pass to `circlize::colorRamp2`.

 # -border Whether draw border. The value can be logical or a string of color.

+# -border_gp Graphic parameters for the borders. If you want to set different parameters for different heatmap slices,

+#           please consider to use `decorate_heatmap_body`.

 # -cell_fun Self-defined function to add graphics on each cell. Seven parameters will be passed into 

 #           this function: ``j``, ``i``, ``x``, ``y``, ``width``, ``height``, ``fill`` which are column index,

 #           row index in ``matrix``, coordinate of the cell,

@@ -174,7 +176,7 @@ Heatmap = setClass("Heatmap",

 # -heatmap_height Height of the whole heatmap (including heatmap components). Check https://jokergoo.github.io/ComplexHeatmap-reference/book/a-single-heatmap.html#size-of-the-heatmap .

 # -show_heatmap_legend Whether show heatmap legend?

 # -heatmap_legend_param A list contains parameters for the heatmap legends. See `color_mapping_legend,ColorMapping-method` for all available parameters.

-# -use_raster Whether render the heatmap body as a raster image. It helps to reduce file size when the matrix is huge. Note if ``cell_fun``

+# -use_raster Whether render the heatmap body as a raster image. It helps to reduce file size when the matrix is huge. If number of rows or columns is more than 2000, it is by default turned on. Note if ``cell_fun``

 #       is set, ``use_raster`` is enforced to be ``FALSE``.

 # -raster_device Graphic device which is used to generate the raster image.

 # -raster_quality A value set to larger than 1 will improve the quality of the raster image.

@@ -208,6 +210,7 @@ Heatmap = function(matrix, col, name,

     color_space = "LAB",

     rect_gp = gpar(col = NA), 

     border = NA,

+    border_gp = gpar(fill = NA, col = "black"),

     cell_fun = NULL,

     layer_fun = NULL,

     jitter = FALSE,

@@ -516,6 +519,7 @@ Heatmap = function(matrix, col, name,

     }

     if(identical(border, TRUE)) border = "black"

     .Object@matrix_param$border = border

+    .Object@matrix_param$border_gp = border_gp

     .Object@matrix_param$cell_fun = cell_fun

     .Object@matrix_param$layer_fun = layer_fun

@@ -1433,6 +1437,7 @@ make_cluster = function(object, which = c("row", "column")) {

                 slice_mean = matrix(slice_mean, nrow = 1)

             }

             dend_slice = as.dendrogram(hclust(dist(t(slice_mean))))

+            dend_slice = reorder(dend_slice, slice_mean, mean)

             if(verbose) qqcat("perform clustering on mean of @{which} slices\n")

             slice_od = order.dendrogram(dend_slice)

@@ -785,7 +785,7 @@ Heatmap = function(matrix, col, name,

         nb = nobs(bottom_annotation)

         if(!is.na(nb)) {

             if(nb != ncol(.Object@matrix)) {

-                stop_wrap("number of observations in bottom anntotion should be as same as ncol of the matrix.")

+                stop_wrap("number of observations in bottom annotation should be as same as ncol of the matrix.")

             }

         }

     }

@@ -805,7 +805,7 @@ Heatmap = function(matrix, col, name,

         nb = nobs(left_annotation)

         if(!is.na(nb)) {

             if(nb != nrow(.Object@matrix)) {

-                stop_wrap("number of observations in left anntotion should be same as nrow of the matrix.")

+                stop_wrap("number of observations in left annotation should be same as nrow of the matrix.")

             }

         }

     }

@@ -825,7 +825,7 @@ Heatmap = function(matrix, col, name,

         nb = nobs(right_annotation)

         if(!is.na(nb)) {

             if(nb != nrow(.Object@matrix)) {

-                stop_wrap("number of observations in right anntotion should be same as nrow of the matrix.")

+                stop_wrap("number of observations in right annotation should be same as nrow of the matrix.")

             }

         }

     }

@@ -531,6 +531,9 @@ Heatmap = function(matrix, col, name,

         if(is.function(col)) {

             .Object@matrix_color_mapping = ColorMapping(col_fun = col, name = name, na_col = na_col)

             if(verbose) qqcat("input color is a color mapping function\n")

+        } else if(inherits(col, "ColorMapping")){

+            .Object@matrix_color_mapping = col

+            if(verbose) qqcat("input color is a ColorMapping object\n")

         } else {

             if(is.null(names(col))) {

                 if(length(col) == length(unique(as.vector(matrix)))) {

@@ -301,6 +301,9 @@ Heatmap = function(matrix, col, name,

     if(missing(name)) {

         name = paste0("matrix_", get_heatmap_index() + 1)

         increase_heatmap_index()

+    } else if(is.null(name)) {

+        name = paste0("matrix_", get_heatmap_index() + 1)

+        increase_heatmap_index()

     }

     if(name == "") {

         stop_wrap("Heatmap name cannot be empty string.")

@@ -1112,7 +1112,6 @@ make_cluster = function(object, which = c("row", "column")) {

             }

             if(identical(reorder, TRUE)) {

                 do_reorder = TRUE

-                browser()

                 if(which == "row") {

                     reorder = -rowMeans(mat, na.rm = TRUE)

                 } else {

@@ -1112,6 +1112,7 @@ make_cluster = function(object, which = c("row", "column")) {

             }

             if(identical(reorder, TRUE)) {

                 do_reorder = TRUE

+                browser()

                 if(which == "row") {

                     reorder = -rowMeans(mat, na.rm = TRUE)

                 } else {

@@ -888,6 +888,8 @@ Heatmap = function(matrix, col, name,

             if(ht_opt$message) {

                 message_wrap("`use_raster` is automatically set to TRUE for a matrix with more than 2000 columns You can control `use_raster` arugment by explicitly setting TRUE/FALSE to it. Set `ht_opt$message = FALSE` to turn off this message.")

             }

+        } else {

+            use_raster = FALSE

         }

     }

@@ -284,7 +284,7 @@ Heatmap = function(matrix, col, name,

     show_heatmap_legend = TRUE,

     heatmap_legend_param = list(title = name),

-    use_raster = (nrow(matrix) > 2000 && ncol(matrix) > 10) || (ncol(matrix) > 2000 && nrow(matrix) > 10), 

+    use_raster = NULL, 

     raster_device = c("png", "jpeg", "tiff", "CairoPNG", "CairoJPEG", "CairoTIFF"),

     raster_quality = 2,

     raster_device_param = list(),

@@ -876,6 +876,20 @@ Heatmap = function(matrix, col, name,

             stop_wrap("`heatmap_height` and `height` should not all be the absolute units.")

         }

     }

+

+    if(is.null(use_raster)) {

+        if(nrow(matrix) > 2000 && ncol(matrix) > 10) {

+            use_raster = TRUE

+            if(ht_opt$message) {

+                message_wrap("`use_raster` is automatically set to TRUE for a matrix with more than 2000 rows. You can control `use_raster` arugment by explicitly setting TRUE/FALSE to it. Set `ht_opt$message = FALSE` to turn off this message.")

+            }

+        } else if(ncol(matrix) > 2000 && nrow(matrix) > 10) {

+            use_raster = TRUE

+            if(ht_opt$message) {

+                message_wrap("`use_raster` is automatically set to TRUE for a matrix with more than 2000 columns You can control `use_raster` arugment by explicitly setting TRUE/FALSE to it. Set `ht_opt$message = FALSE` to turn off this message.")

+            }

+        }

+    }

     .Object@matrix_param$width = width

     .Object@matrix_param$height = height

@@ -1462,7 +1462,7 @@ make_cluster = function(object, which = c("row", "column")) {

         stop_wrap(qq("Length of `gap` should be 1 or number of @{which} slices."))

     }

     object@matrix_param[[ paste0(which, "_gap") ]] = gap

-    

+

     # adjust title

     title = slot(object, paste0(which, "_title"))

     if(!is.null(split)) {

@@ -1474,9 +1474,9 @@ make_cluster = function(object, which = c("row", "column")) {

                     lt = lapply(x, function(x) x)

                     lt$fmt = title

                     do.call(sprintf, lt)

-                })

+                })[slice_od]

             } else if(grepl("@\\{.+\\}", title)) {

-                title = apply(unique(split), 1, function(x) {

+                title = apply(unique(split[order2, , drop = FALSE]), 1, function(x) {

                     x = x

                     envir = environment()

                     title = get("title")

@@ -1486,12 +1486,12 @@ make_cluster = function(object, which = c("row", "column")) {

                     title = GetoptLong::qq(title, envir = envir)

                     parent.env(envir) = op

                     return(title)

-                })

+                })[slice_od]

             } else if(grepl("\\{.+\\}", title)) {

                 if(!requireNamespace("glue")) {

                     stop_wrap("You need to install glue package.")

                 }

-                title = apply(unique(split), 1, function(x) {

+                title = apply(unique(split[order2, , drop = FALSE]), 1, function(x) {

                     x = x

                     envir = environment()

                     title = get("title")

@@ -1501,7 +1501,7 @@ make_cluster = function(object, which = c("row", "column")) {