| Title: | Interactive Differential Expresion Analysis Browser |
|---|---|
| Description: | Bioinformatics platform containing interactive plots and tables for differential gene and region expression studies. Allows visualizing expression data much more deeply in an interactive and faster way. By changing the parameters, users can easily discover different parts of the data that like never have been done before. Manually creating and looking these plots takes time. With DEBrowser users can prepare plots without writing any code. Differential expression, PCA and clustering analysis are made on site and the results are shown in various plots such as scatter, bar, box, volcano, ma plots and Heatmaps. |
| Authors: | Alper Kucukural [aut, cre], Onur Yukselen [aut], Manuel Garber [aut] |
| Maintainer: | Alper Kucukural <[email protected]> |
| License: | GPL-3 + file LICENSE |
| Version: | 1.41.2 |
| Built: | 2026-07-25 09:26:26 UTC |
| Source: | https://github.com/bioc/debrowser |
Server: wires the dropdown to current_user, signup modal, signout.
accountDropdownServer(id)accountDropdownServer(id)
id |
Shiny module namespace id. |
invisible(NULL); called for its observers and outputs side effects (login/logout label, signup modal, sign-out flow).
UI: navbar account dropdown.
accountDropdownUI(id)accountDropdownUI(id)
id |
Shiny module namespace id. |
A 'bslib::nav_menu' element with a server-side-rendered label and a per-state menu (Sign up / Sign out).
Creates an action button whose value is initially zero, and increments by one each time it is pressed.
actionButtonDE( inputId, label, styleclass = "", size = "", block = FALSE, icon = NULL, css.class = "", ... )actionButtonDE( inputId, label, styleclass = "", size = "", block = FALSE, icon = NULL, css.class = "", ... )
inputId |
Specifies the input slot that will be used to access the value. |
label |
The contents of the button–usually a text label, but you could also use any other HTML, like an image. |
styleclass |
The Bootstrap styling class of the button–options are primary, info, success, warning, danger, inverse, link or blank |
size |
The size of the button–options are large, small, mini |
block |
Whehter the button should fill the block |
icon |
Display an icon for the button |
css.class |
Any additional CSS class one wishes to add to the action button |
... |
Other argument to feed into shiny::actionButton |
A 'shiny::tags$button' element wired as a click-counting action button, suitable for embedding in any Shiny UI.
actionButtonDE("goDE", "Go to DE Analysis")actionButtonDE("goDE", "Go to DE Analysis")
add aditional data columns to de results
addDataCols(data = NULL, de_res = NULL, cols = NULL, conds = NULL)addDataCols(data = NULL, de_res = NULL, cols = NULL, conds = NULL)
data |
loaded dataset |
de_res |
de results |
cols |
columns |
conds |
inputconds |
data
x <- addDataCols()x <- addDataCols()
Adds an id to the data frame being used.
addID(data = NULL)addID(data = NULL)
data |
loaded dataset |
data
x <- addID()x <- addID()
Build an ellmer chat object for the configured provider/model.
ai_chat(provider, model, api_key = NULL)ai_chat(provider, model, api_key = NULL)
provider |
chr(1). |
model |
chr(1). |
api_key |
chr(1) or NULL. |
An ellmer Chat object. Caller invokes '$chat(prompt)' on it.
Pure orchestrator over: payload redaction (per 'privacy_mode'), prompt template rendering (whisker), and dispatch to the provided ellmer chat object. Returns the model's response as 'chr(1)'. Errors are surfaced as classed conditions of class 'ai_error' so callers (the Shiny module) can pattern-match for friendly messages.
ai_interpret( question, payload, privacy_mode, provider_chat, top_n = 50L, template_dir = system.file("templates", package = "debrowser") )ai_interpret( question, payload, privacy_mode, provider_chat, top_n = 50L, template_dir = system.file("templates", package = "debrowser") )
question |
chr(1). Preset key. v1 supports "summarize_geneset". |
payload |
list. Pre-built payload. Shape: 'list(genes = chr, stats = data.frame|NULL, enrichment = list|NULL)'. |
privacy_mode |
chr(1). One of "symbols", "stats", "stats_enrichment". |
provider_chat |
An ellmer chat object (output of 'ai_chat()'). The chat object must have a '$chat(text)' method that returns chr(1) on success or raises an error on failure. |
top_n |
integer(1). Cap on genes-list length. Default 50. |
template_dir |
Directory containing 'ai_*.md' templates. Default 'system.file("templates", package = "debrowser")'. |
character(1). Model's response text.
AI interpretation panel server.
aiInterpretServer( id, payload_react, settings_react, payload_shape = "geneset", deterministic_methods_react = NULL )aiInterpretServer( id, payload_react, settings_react, payload_shape = "geneset", deterministic_methods_react = NULL )
id |
Module ID (matches [aiInterpretUI()]). |
payload_react |
Reactive expression returning the payload list per shape: * 'geneset' shape: 'list(genes, stats, enrichment, context_mode)' * 'de_table' shape: 'list(comparison_label, genes, stats, n_total_de, cutoffs)' * 'concordance' shape: 'list(comparison_labels, concordance_table, per_comparison_top, cutoffs)' May return NULL; Ask is disabled in that case. |
settings_react |
Reactive expression yielding the current AI settings list (from 'aiSettingsServer'). |
payload_shape |
One of '"geneset"', '"de_table"', '"concordance"'. Must match the shape passed to 'aiInterpretUI(id, ..., payload_shape)'. Default '"geneset"'. |
deterministic_methods_react |
Optional reactive expression yielding a chr(1) Methods paragraph (e.g. from 'methods_paragraph()'). Required for the 'draft_methods' preset; ignored otherwise. |
invisible(NULL).
Renders a card with: question dropdown, privacy radio (hidden for 'draft_methods'), Top-N input, "What will be sent?" disclosure, Ask button, and a sanitized-markdown response area. The card is meant to be wrapped in a parent's conditionalPanel so it only renders when settings are valid and analytical results exist.
aiInterpretUI(id, questions = "summarize_geneset", payload_shape = "geneset")aiInterpretUI(id, questions = "summarize_geneset", payload_shape = "geneset")
id |
Module ID. |
questions |
Character vector of preset keys offered in the dropdown. Default '"summarize_geneset"' (E12.A behavior). Supported keys: 'summarize_geneset', 'reconcile_enrichments', 'suggest_followup', 'draft_methods'. |
payload_shape |
One of '"geneset"', '"de_table"', '"concordance"'. Drives slot building and per-shape privacy defaults. Default '"geneset"' (E12.A behavior). |
tagList.
aiInterpretUI("ai_enrichment") aiInterpretUI("ai_de", questions = c("summarize_geneset", "suggest_followup", "draft_methods"), payload_shape = "de_table")aiInterpretUI("ai_enrichment") aiInterpretUI("ai_de", questions = c("summarize_geneset", "suggest_followup", "draft_methods"), payload_shape = "de_table")
Settings server – opens the AI configuration modal on click.
aiSettingsServer(id)aiSettingsServer(id)
id |
Module ID (matches [aiSettingsUI()]). |
shiny::reactive yielding the current settings list. Parent modules should consume this to gate the AI panel mount.
Returns a 'bslib::nav_menu' titled "Settings" with one item: "AI Assistant". Clicking the item opens a modal handled by [aiSettingsServer()].
aiSettingsUI(id)aiSettingsUI(id)
id |
Module ID. |
bslib::nav_menu element.
aiSettingsUI("ai")aiSettingsUI("ai")
Prepares all2all scatter plots for given datasets.
all2all(data, cex = 2)all2all(data, cex = 2)
data |
data that have the sample names in the header. |
cex |
text size |
all2all scatter plots
plot <- all2all(mtcars)plot <- all2all(mtcars)
Generates the controls in the left menu for an all2all plot
all2allControlsUI(id)all2allControlsUI(id)
id |
namespace id |
returns the controls for left menu
all2allControlsUI
x <- all2allControlsUI("bar")x <- all2allControlsUI("bar")
Pure function – no Shiny dependency. Accepts batch / treatment column names directly instead of pulling from a reactive 'input' object.
apply_batch_correction( counts, metadata, method = "none", batch_col = NULL, treatment_col = NULL )apply_batch_correction( counts, metadata, method = "none", batch_col = NULL, treatment_col = NULL )
counts |
Numeric matrix (genes x samples). |
metadata |
data.frame; first column is sample id. |
method |
One of "none", "Combat", "CombatSeq", "Harman". |
batch_col |
Name of the batch column in 'metadata'. |
treatment_col |
Name of the treatment column in 'metadata'. May be NULL or "None" – only required for Harman. |
Corrected count matrix.
m <- matrix(as.integer(c(100, 200, 150, 80, 250, 130, 40, 60, 55, 30, 70, 45)), nrow = 2, byrow = TRUE) colnames(m) <- paste0("S", 1:6) rownames(m) <- c("Gene1", "Gene2") # method = "none" returns the matrix unchanged apply_batch_correction(m, metadata = NULL, method = "none")m <- matrix(as.integer(c(100, 200, 150, 80, 250, 130, 40, 60, 55, 30, 70, 45)), nrow = 2, byrow = TRUE) colnames(m) <- paste0("S", 1:6) rownames(m) <- c("Gene1", "Gene2") # method = "none" returns the matrix unchanged apply_batch_correction(m, metadata = NULL, method = "none")
Pure function – no Shiny dependency. Re-normalizes the count columns, computes per-condition x/y log10 means, and labels each row by cutoff.
apply_de_filters(filt_data, cols, conds, params = list())apply_de_filters(filt_data, cols, conds, params = list())
filt_data |
data.frame with columns including 'foldChange', 'padj', plus all 'cols'. |
cols |
Character vector of sample column names. |
conds |
Character vector of per-column condition labels (length == length(cols)). Values look like "Cond1"/"Cond2"/... |
params |
Named list with components: - 'padj_cutoff' (numeric or numeric-string) - 'fold_cutoff' (numeric or numeric-string) - 'dataset' ("up"/"down"/"up+down"/"alldetected"/"selected"/ "most-varied"/"comparisons"/"searched") - 'compselect' (integer; default 1) - 'norm_method' (forwarded to [normalize_counts()]) - 'geneset_area' (string of search terms; "" = none) - 'method_tab' (UI tab id; geneset overlay only applies on "panel1") - 'top_n', 'min_count' (only for 'dataset == "most-varied"') |
data.frame with added 'x', 'y', 'Legend', 'Size' columns; or NULL.
cols <- c("S1", "S2", "S3", "S4") conds <- c("Cond1", "Cond1", "Cond2", "Cond2") fd <- data.frame( S1 = c(100L, 5L), S2 = c(120L, 8L), S3 = c(10L, 200L), S4 = c(12L, 220L), foldChange = c(10, 0.05), padj = c(0.001, 0.001), row.names = c("GeneA", "GeneB") ) params <- list(padj_cutoff = 0.05, fold_cutoff = 2, dataset = "up+down", compselect = 1, norm_method = "none") apply_de_filters(fd, cols, conds, params)cols <- c("S1", "S2", "S3", "S4") conds <- c("Cond1", "Cond1", "Cond2", "Cond2") fd <- data.frame( S1 = c(100L, 5L), S2 = c(120L, 8L), S3 = c(10L, 200L), S4 = c(12L, 220L), foldChange = c(10, 0.05), padj = c(0.001, 0.001), row.names = c("GeneA", "GeneB") ) params <- list(padj_cutoff = 0.05, fold_cutoff = 2, dataset = "up+down", compselect = 1, norm_method = "none") apply_de_filters(fd, cols, conds, params)
Pure version of 'applyFiltersToMergedComparison()'.
apply_merged_filters(dc, nc, params = list())apply_merged_filters(dc, nc, params = list())
dc |
List of per-comparison containers (each has 'init_data', 'cols', 'cond_names'). |
nc |
Number of comparisons. |
params |
Named list with 'norm_method'. |
Merged data.frame with a 'Legend' column ('"Sig"' / '"NS"').
init1 <- data.frame( S1 = c(100L, 40L), S2 = c(200L, 60L), S3 = c(10L, 150L), S4 = c(12L, 160L), foldChange = c(10, 0.25), padj = c(0.01, 0.01), row.names = c("GeneA", "GeneB") ) dc <- list(list( init_data = init1, cols = c("S1", "S2", "S3", "S4"), cond_names = c("Treat", "Ctrl") )) params <- list(norm_method = "none", padj_cutoff = 0.05, fold_cutoff = 2) apply_merged_filters(dc, nc = 1, params = params)init1 <- data.frame( S1 = c(100L, 40L), S2 = c(200L, 60L), S3 = c(10L, 150L), S4 = c(12L, 160L), foldChange = c(10, 0.25), padj = c(0.01, 0.01), row.names = c("GeneA", "GeneB") ) dc <- list(list( init_data = init1, cols = c("S1", "S2", "S3", "S4"), cond_names = c("Treat", "Ctrl") )) params <- list(norm_method = "none", padj_cutoff = 0.05, fold_cutoff = 2) apply_merged_filters(dc, nc = 1, params = params)
Applies filters based on user selected parameters to be displayed within the DEBrowser.
applyFilters(filt_data = NULL, cols = NULL, conds = NULL, input = NULL)applyFilters(filt_data = NULL, cols = NULL, conds = NULL, input = NULL)
filt_data |
loaded dataset |
cols |
selected samples |
conds |
seleced conditions |
input |
input parameters |
data
x <- applyFilters()x <- applyFilters()
Apply filters based on foldChange cutoff and padj value. This function adds a "Legend" column with "Up", "Down" or "NS" values for visualization.
applyFiltersNew(data = NULL, input = NULL)applyFiltersNew(data = NULL, input = NULL)
data |
loaded dataset |
input |
input parameters |
data
x <- applyFiltersNew()x <- applyFiltersNew()
Gathers the merged comparison data to be used within the DEBrowser.
applyFiltersToMergedComparison(dc = NULL, nc = NULL, input = NULL)applyFiltersToMergedComparison(dc = NULL, nc = NULL, input = NULL)
dc |
all data |
nc |
the number of comparisons |
input |
input params |
data
x <- applyFiltersToMergedComparison()x <- applyFiltersToMergedComparison()
Generates the controls in the left menu for a bar main plot
barMainPlotControlsUI(id)barMainPlotControlsUI(id)
id |
namespace id |
returns the controls for left menu
barMainPlotControlsUI
x <- barMainPlotControlsUI("bar")x <- barMainPlotControlsUI("bar")
batchEffectUI Creates a panel to coorect batch effect
batchEffectUI(id)batchEffectUI(id)
id |
namespace id |
panel
x <- batchEffectUI("batcheffect")x <- batchEffectUI("batcheffect")
select batch effect method
batchMethod(id)batchMethod(id)
id |
namespace id |
radio control
batchMethod
x <- batchMethod("batch")x <- batchMethod("batch")
Generates the controls in the left menu for a Box main plot
BoxMainPlotControlsUI(id)BoxMainPlotControlsUI(id)
id |
namespace id |
returns the controls for left menu
BoxMainPlotControlsUI
x <- BoxMainPlotControlsUI("box")x <- BoxMainPlotControlsUI("box")
change order of K-means clusters
changeClusterOrder(order = NULL, cld = NULL)changeClusterOrder(order = NULL, cld = NULL)
order |
order |
cld |
data |
heatmap plot area
changeClusterOrder
x <- changeClusterOrder()x <- changeClusterOrder()
Returns if there is a problem in the count data.
checkCountData(input = NULL, sep = NULL)checkCountData(input = NULL, sep = NULL)
input |
inputs |
sep |
optional override for the field separator; defaults to 'input$countdataSep' when NULL |
error if there is a problem about the loaded data
checkCountData
x <- checkCountData()x <- checkCountData()
Returns if there is a problem in the count data.
checkMetaData(input = NULL, counttable = NULL, sep = NULL)checkMetaData(input = NULL, counttable = NULL, sep = NULL)
input |
input |
counttable |
counttable |
sep |
optional override for the field separator; defaults to 'input$metadataSep' when NULL |
error if there is a problem about the loaded data
checkMetaData
x <- checkMetaData()x <- checkMetaData()
Gathers the Cluster analysis data to be used within the GO Term plots.
clusterData(dat = NULL)clusterData(dat = NULL)
dat |
the data to cluster |
clustered data
clusterData
mycluster <- clusterData()mycluster <- clusterData()
get cluster function parameter control
clustFunParamsUI()clustFunParamsUI()
cluster params
clustFunParamsUI
x <- clustFunParamsUI()x <- clustFunParamsUI()
Compares the clustered data to be displayed within the GO Term plots.
compareClust( dat = NULL, ont = "CC", org = "org.Hs.eg.db", fun = "enrichGO", title = "Ontology Distribution Comparison", pvalueCutoff = 0.01 )compareClust( dat = NULL, ont = "CC", org = "org.Hs.eg.db", fun = "enrichGO", title = "Ontology Distribution Comparison", pvalueCutoff = 0.01 )
dat |
data to compare clusters |
ont |
the ontology to use |
org |
the organism used |
fun |
fun |
title |
title of the comparison |
pvalueCutoff |
pvalueCutoff |
compared cluster
compareClust
x <- compareClust()x <- compareClust()
Each comparison contributes a label "<treatment> vs <control>" derived from its 'cond_names' field. When two comparisons collide on the same label, suffixes " (1)", " (2)", ... are appended in input order so 'names()' of the final list stays unique. Comparisons missing 'cond_names' fall back to "comparison_<index>".
comparison_labels(comparisons)comparison_labels(comparisons)
comparisons |
List of per-comparison entries (typically 'dc()' from server.R or 'comparisons_spec()'); each entry should have a 'cond_names' character vector of length >= 2 (treatment first). |
Character vector of length 'length(comparisons)'. Empty character vector when input is empty.
comparisons <- list( list(cond_names = c("Treat", "Ctrl")), list(cond_names = c("Drug", "Vehicle")) ) comparison_labels(comparisons)comparisons <- list( list(cond_names = c("Treat", "Ctrl")), list(cond_names = c("Drug", "Vehicle")) ) comparison_labels(comparisons)
Server for the Comparison Concordance tab.
comparisonConcordanceServer( id, de_results_react, comparisons_react = NULL, ai_settings_react = NULL, fgsea_pathways_react = NULL, deterministic_methods_react = NULL )comparisonConcordanceServer( id, de_results_react, comparisons_react = NULL, ai_settings_react = NULL, fgsea_pathways_react = NULL, deterministic_methods_react = NULL )
id |
Module ID. |
de_results_react |
Reactive yielding the named list of per-comparison DE result data.frames (typically 'de_results_list' from 'R/server.R'). Each element must contain 'ID', 'log2FoldChange', and 'padj' columns; entries are keyed by 'comparison_labels()' so colliding labels stay unique. |
comparisons_react |
Reactive yielding the full comparison list (typically 'dc()' from 'R/server.R'); each entry should have 'cond_names' so the pairwise DEG heatmap can label group axes. When NULL or missing cond_names, the heatmap card shows an empty-state. |
ai_settings_react |
Optional reactive yielding AI settings list (from 'aiSettingsServer'). When NULL, no AI panel is mounted. |
fgsea_pathways_react |
Optional reactive yielding the active fgsea pathway set ('names()' over the gene-set lookup). Drives the in-card pathway picker for 'reconcile_enrichments'. |
deterministic_methods_react |
Optional reactive yielding a chr(1) Methods paragraph (e.g. from 'methods_paragraph()'). Consumed by the 'draft_methods' preset. |
invisible(NULL).
de <- list( "Treat vs Ctrl" = data.frame(ID = paste0("G", 1:5), log2FoldChange = c(2, -1, 0, 3, -2), padj = c(0.01, 0.04, 0.5, 0.02, 0.03)), "Drug vs Vehicle" = data.frame(ID = paste0("G", 1:5), log2FoldChange = c(1.5, -0.8, 0.2, 2.1, -1.5), padj = c(0.02, 0.03, 0.6, 0.01, 0.04)) ) shiny::shinyApp( ui = comparisonConcordanceUI("cc"), server = function(input, output, session) { comparisonConcordanceServer("cc", shiny::reactive(de)) } )de <- list( "Treat vs Ctrl" = data.frame(ID = paste0("G", 1:5), log2FoldChange = c(2, -1, 0, 3, -2), padj = c(0.01, 0.04, 0.5, 0.02, 0.03)), "Drug vs Vehicle" = data.frame(ID = paste0("G", 1:5), log2FoldChange = c(1.5, -0.8, 0.2, 2.1, -1.5), padj = c(0.02, 0.03, 0.6, 0.01, 0.04)) ) shiny::shinyApp( ui = comparisonConcordanceUI("cc"), server = function(input, output, session) { comparisonConcordanceServer("cc", shiny::reactive(de)) } )
UI for the Comparison Concordance top-level tab.
comparisonConcordanceUI(id)comparisonConcordanceUI(id)
id |
Module ID. |
A 'shiny::tagList' with a control card (padj / |log2FC|), an UpSet card, a pairwise scatter card with x/y comparison selectizes, and a concordance summary table card.
comparisonConcordanceUI("demo")comparisonConcordanceUI("demo")
Used by the JS handler in 'getTabUpdateJS()' (R/funcs.R) and as a direct render path for static initial state.
compute_pill_class(state)compute_pill_class(state)
state |
character, progress state. |
character, CSS class name or empty string.
compute_pill_class("done")compute_pill_class("done")
Build per-method significant-gene sets.
concordance_sets(de_list, padj_cutoff = 0.05, lfc_cutoff = 0)concordance_sets(de_list, padj_cutoff = 0.05, lfc_cutoff = 0)
de_list |
Output of [run_de_methods()]. |
padj_cutoff |
Maximum padj for "significant" (default 0.05). |
lfc_cutoff |
Minimum |log2FoldChange| for "significant" (default 0; pass 0.585 for |fold|>=1.5, 1 for |fold|>=2). |
Named list of character vectors of significant gene IDs. Names match 'names(de_list)'.
de_list <- list( EdgeR = data.frame(ID = paste0("G", 1:5), log2FoldChange = c(2, -1, 0, 3, -2), padj = c(0.01, 0.04, 0.5, 0.02, 0.03)), Limma = data.frame(ID = paste0("G", 1:5), log2FoldChange = c(1.8, -0.9, 0.1, 2.5, -1.8), padj = c(0.02, 0.03, 0.6, 0.01, 0.04)) ) concordance_sets(de_list, padj_cutoff = 0.05)de_list <- list( EdgeR = data.frame(ID = paste0("G", 1:5), log2FoldChange = c(2, -1, 0, 3, -2), padj = c(0.01, 0.04, 0.5, 0.02, 0.03)), Limma = data.frame(ID = paste0("G", 1:5), log2FoldChange = c(1.8, -0.9, 0.1, 2.5, -1.8), padj = c(0.02, 0.03, 0.6, 0.01, 0.04)) ) concordance_sets(de_list, padj_cutoff = 0.05)
For each unordered pair of methods, computes set sizes, intersection size, Jaccard index, and Spearman correlation of log2FoldChange over the set of genes present in both per-method tables (excluding NAs).
concordance_summary(de_list, padj_cutoff = 0.05, lfc_cutoff = 0)concordance_summary(de_list, padj_cutoff = 0.05, lfc_cutoff = 0)
de_list |
Output of [run_de_methods()]. |
padj_cutoff |
Maximum padj for "significant" (default 0.05). |
lfc_cutoff |
Minimum |log2FoldChange| for "significant" (default 0; pass 0.585 for |fold|>=1.5, 1 for |fold|>=2). |
data.frame with one row per pair, columns: 'method1', 'method2', 'n_method1', 'n_method2', 'n_overlap', 'jaccard', 'spearman_lfc', 'n_genes_compared'. Empty data.frame (zero rows) when fewer than 2 methods are present.
de_list <- list( EdgeR = data.frame(ID = paste0("G", 1:5), log2FoldChange = c(2, -1, 0, 3, -2), padj = c(0.01, 0.04, 0.5, 0.02, 0.03)), Limma = data.frame(ID = paste0("G", 1:5), log2FoldChange = c(1.8, -0.9, 0.1, 2.5, -1.8), padj = c(0.02, 0.03, 0.6, 0.01, 0.04)) ) concordance_summary(de_list, padj_cutoff = 0.05)de_list <- list( EdgeR = data.frame(ID = paste0("G", 1:5), log2FoldChange = c(2, -1, 0, 3, -2), padj = c(0.01, 0.04, 0.5, 0.02, 0.03)), Limma = data.frame(ID = paste0("G", 1:5), log2FoldChange = c(1.8, -0.9, 0.1, 2.5, -1.8), padj = c(0.02, 0.03, 0.6, 0.01, 0.04)) ) concordance_summary(de_list, padj_cutoff = 0.05)
Comparison-Selection wizard server.
condSelectServer(id, data = NULL, metadata = NULL, initial_spec = NULL)condSelectServer(id, data = NULL, metadata = NULL, initial_spec = NULL)
id |
module namespace id (must match the id passed to 'condSelectUI'). |
data |
count matrix. |
metadata |
sample-metadata data.frame; first column is the sample id. |
initial_spec |
Optional saved comparisons_spec to populate the wizard with on mount. When the module is created during an active bookmark restore, the module's own 'onRestore' hook handles this; when the module is created LATER (e.g. by the D2.5 DE auto-replay state machine in deServer, after the active-restore window has closed), pass the captured spec here so the per-comparison reactiveValues and UI cards reflect the restored state. |
list with 'n_comparisons', 'start_de', 'is_ready', 'comparisons_spec'.
counts <- matrix(as.integer(c(100, 200, 10, 12, 40, 60)), nrow = 2, dimnames = list(c("G1", "G2"), paste0("S", 1:3))) meta <- data.frame(Sample = paste0("S", 1:3), Condition = c("Ctrl", "Ctrl", "Treat")) shiny::shinyApp( ui = condSelectUI("cs"), server = function(input, output, session) { condSelectServer("cs", data = counts, metadata = meta) } )counts <- matrix(as.integer(c(100, 200, 10, 12, 40, 60)), nrow = 2, dimnames = list(c("G1", "G2"), paste0("S", 1:3))) meta <- data.frame(Sample = paste0("S", 1:3), Condition = c("Ctrl", "Ctrl", "Treat")) shiny::shinyApp( ui = condSelectUI("cs"), server = function(input, output, session) { condSelectServer("cs", data = counts, metadata = meta) } )
Comparison-Selection wizard UI.
condSelectUI(id)condSelectUI(id)
id |
module namespace id. |
a ‘de_card' containing the wizard’s static skeleton; comparison panels are rendered dynamically by 'condSelectServer' via 'uiOutput("comparison_panels")'.
condSelectUI("demo")condSelectUI("demo")
Counts how many genes in each sample have a Cook's distance above a threshold; samples with disproportionately many high-Cook genes drove DE calls more than their share and may warrant a downstream re-check. Default threshold is the canonical DESeq2 vignette cut, '4 / (n_samples - n_params)', where 'n_params' is the column count of 'model.matrix(design(dds), colData(dds))'. The chosen threshold is attached as 'attr(out, "threshold")'.
cooks_outlier_summary(dds, threshold = NULL)cooks_outlier_summary(dds, threshold = NULL)
dds |
A fitted 'DESeqDataSet'. Must carry the 'cooks' assay (i.e. 'DESeq()' was run); otherwise raises 'qc_input_error'. |
threshold |
Optional numeric Cook's-distance cut. NULL (default) uses the DESeq2 vignette cut. |
data.frame with columns 'sample', 'n_high_cooks', 'total_genes', 'high_cooks_pct'. The active threshold is attached as 'attr(out, "threshold")'.
cooks_outlier_summary(dds)cooks_outlier_summary(dds)
Batch effect correction
correctCombat(input = NULL, idata = NULL, metadata = NULL, method = NULL)correctCombat(input = NULL, idata = NULL, metadata = NULL, method = NULL)
input |
input values |
idata |
data |
metadata |
metadata |
method |
method: either Combat or CombatSeq |
data
x <- correctCombat()x <- correctCombat()
Batch effect correction
correctHarman(input = NULL, idata = NULL, metadata = NULL)correctHarman(input = NULL, idata = NULL, metadata = NULL)
input |
input values |
idata |
data |
metadata |
metadata |
data
x <- correctHarman()x <- correctHarman()
Opens users.sqlite, writes a new kind = "shinymanager" row,
and closes the connection. Use this to bootstrap the first user when
running startDEBrowser(hosted = TRUE) for the first time, since
the in-app signup modal lives behind the login wall and is unreachable
until you have an account.
create_debrowser_user(user_id, password, email = NA_character_)create_debrowser_user(user_id, password, email = NA_character_)
user_id |
Username for login. |
password |
Plaintext password (will be hashed via scrypt). |
email |
Optional email. Default |
The created user_id, invisibly.
create_debrowser_user("alice", "hunter2!", "[email protected]") startDEBrowser(hosted = TRUE) # then log in as alice / hunter2!create_debrowser_user("alice", "hunter2!", "[email protected]") startDEBrowser(hosted = TRUE) # then log in as alice / hunter2!
get Custom Color controls
customColorsUI(id)customColorsUI(id)
id |
namespace ID |
color range
getColRng
x <- customColorsUI("heatmap")x <- customColorsUI("heatmap")
Each row defines a one-click preset for the Strict / Standard button bar. log2fc is shared across presets by design – only padj differs.
cutoff_presets()cutoff_presets()
data.frame with columns: name, label, padj, log2fc.
cutoff_presets()cutoff_presets()
Server-side companion for cutOffSelectionUI. Wires the preset radio-group buttons to the namespaced numeric inputs via install_cutoff_preset_observers.
cutOffSelectionServer(id)cutOffSelectionServer(id)
id |
Module id (matches cutOffSelectionUI(id)). |
Invisible NULL.
if (FALSE) cutOffSelectionServer("DEResults1")if (FALSE) cutOffSelectionServer("DEResults1")
Gathers the cut off selection for DE analysis
cutOffSelectionUI(id)cutOffSelectionUI(id)
id |
namespace id |
returns the left menu according to the selected tab;
cutOffSelectionUI
x <- cutOffSelectionUI("cutoff")x <- cutOffSelectionUI("cutoff")
dataLCFUI Creates a panel to filter low count genes and regions
dataLCFUI(id)dataLCFUI(id)
id |
namespace id |
panel
x <- dataLCFUI("lcf")x <- dataLCFUI("lcf")
Creates a panel to upload the data
dataLoadUI(id)dataLoadUI(id)
id |
namespace id |
panel
x <- dataLoadUI("load")x <- dataLoadUI("load")
Raises 'de_error()' with one of: '"null_input"', '"empty_matrix"', '"non_numeric"'. Otherwise returns 'x' invisibly.
de_assert_count_matrix(x)de_assert_count_matrix(x)
x |
Object to validate. |
'x' (invisibly) if valid.
m <- matrix(c(100L, 200L, 150L, 40L, 60L, 55L), nrow = 2) colnames(m) <- paste0("S", 1:3) rownames(m) <- c("GeneA", "GeneB") de_assert_count_matrix(m)m <- matrix(c(100L, 200L, 150L, 40L, 60L, 55L), nrow = 2) colnames(m) <- paste0("S", 1:3) rownames(m) <- c("GeneA", "GeneB") de_assert_count_matrix(m)
DEBrowser card wrapper used at every former 'shinydashboard::box()' site. Optionally renders a small primary download button on the right of the card header.
de_card(title, ..., download_id = NULL, full_screen = FALSE, class = NULL)de_card(title, ..., download_id = NULL, full_screen = FALSE, class = NULL)
title |
character – card title shown in the header |
... |
card body content |
download_id |
character or NULL – if non-NULL, render a 'downloadButton' with this id in the header |
full_screen |
logical – passed through to 'bslib::card()' |
class |
character or NULL – extra CSS class(es) forwarded to 'bslib::card()' (e.g. "de-subcard", "de-comparison") |
a 'bslib::card' tagList
x <- de_card("Heatmap", shiny::plotOutput("heat"))x <- de_card("Heatmap", shiny::plotOutput("heat"))
Counts significant genes per entry of a named DE-results list at the given padj / |log2FoldChange| cutoffs. Up = significant + log2FC > 0; Down = significant + log2FC < 0. NA padj / NA log2FoldChange are treated as not-significant.
de_direction_summary(de_list, padj_cutoff = 0.05, lfc_cutoff = 0)de_direction_summary(de_list, padj_cutoff = 0.05, lfc_cutoff = 0)
de_list |
Named list of DE result data.frames; each must contain 'padj' and 'log2FoldChange' columns. |
padj_cutoff |
Maximum padj for "significant" (default 0.05). |
lfc_cutoff |
Minimum |log2FoldChange| for "significant" (default 0). |
data.frame with columns 'comparison', 'n_up', 'n_down', 'n_sig' (= 'n_up + n_down'). One row per entry of 'de_list', in input order.
de_list <- list( comp1 = data.frame( log2FoldChange = c(2, -1, 0, 3, -2), padj = c(0.01, 0.04, 0.5, 0.02, 0.03) ), comp2 = data.frame( log2FoldChange = c(1.5, -0.8, 0.2, 2.1, -1.5), padj = c(0.02, 0.03, 0.6, 0.01, 0.04) ) ) de_direction_summary(de_list, padj_cutoff = 0.05)de_list <- list( comp1 = data.frame( log2FoldChange = c(2, -1, 0, 3, -2), padj = c(0.01, 0.04, 0.5, 0.02, 0.03) ), comp2 = data.frame( log2FoldChange = c(1.5, -0.8, 0.2, 2.1, -1.5), padj = c(0.02, 0.03, 0.6, 0.01, 0.04) ) ) de_direction_summary(de_list, padj_cutoff = 0.05)
All errors raised by the 'fct_*' pure functions go through this helper so callers (tests, scripts, Shiny modules) can dispatch on the error class rather than parsing message strings.
de_error(message, class = character(), ...)de_error(message, class = character(), ...)
message |
Human-readable error message. |
class |
Optional character vector of additional classes to prepend to the condition's class list. Always inherits from '"debrowser_error"'. |
... |
Extra named fields stored on the condition for caller use. |
Nothing – always raises.
tryCatch(de_error("bad input"), error = function(e) e$message)tryCatch(de_error("bad input"), error = function(e) e$message)
B3 helper. Renders a small numbered chip + eyebrow label above a panel headline. The CSS for '.de-eyebrow' and '.de-eyebrow-chip' lives in inst/extdata/www/debrowser.css and is dormant until the redesign layer is toggled on via 'data-debrowser-redesign="1"' on '<html>'.
de_eyebrow(num, label)de_eyebrow(num, label)
num |
character / numeric – the chip number (1..N) |
label |
character – the eyebrow text |
an 'htmltools::tag' ('<div class="de-eyebrow">').
x <- de_eyebrow(1, "Upload & configure")x <- de_eyebrow(1, "Upload & configure")
B3 helper. Page-level headline rendered just under the eyebrow.
de_headline(text)de_headline(text)
text |
character – the headline text |
an 'htmltools::tag' ('<h2 class="de-headline">').
x <- de_headline("Bring your counts & metadata in.")x <- de_headline("Bring your counts & metadata in.")
Render a label suitable for nav_panel(title=) or actionLink(label=) that includes a slot the JS handler can decorate with a progress icon.
de_progress_label(name, key)de_progress_label(name, key)
name |
character, the visible label (e.g. "Upload", "Data Prep"). |
key |
character, the progress key the JS handler listens for. |
a 'tags$span' HTML wrapper.
de_progress_label("Upload", "upload")de_progress_label("Upload", "upload")
B3 helper. Single stat inside a 'de_stat_strip()'.
de_stat(value, label, color = "var(--de-cyan)")de_stat(value, label, color = "var(--de-cyan)")
value |
character – the value (e.g. "6") |
label |
character – the trailing label (e.g. "samples") |
color |
CSS color – the dot color (default cyan) |
an 'htmltools::tag' ('<span>' with a dot + value + label).
x <- de_stat("6", "samples", color = "var(--de-cyan)")x <- de_stat("6", "samples", color = "var(--de-cyan)")
B3 helper. Renders a compact pill-shaped strip of stats (counts of samples / genes / conditions / current method) just under the headline. Each item is built with 'de_stat()'.
de_stat_strip(...)de_stat_strip(...)
... |
'de_stat()' items |
an 'htmltools::tag' ('<div class="de-stat-strip">').
x <- de_stat_strip(de_stat("6", "samples"), de_stat("30,739", "genes"))x <- de_stat_strip(de_stat("6", "samples"), de_stat("30,739", "genes"))
Opens the standalone component gallery shipped at 'inst/extdata/www/style-guide.html' in the default browser. Every component is rendered from 'debrowser.css' in both themes, so it doubles as the client handoff artifact and the visual-regression baseline for the CSS consolidation (see 'docs/design/06-handoff-plan.md' and 'DESIGN.md').
de_style_guide(theme = c("light", "dark"))de_style_guide(theme = c("light", "dark"))
theme |
one of "light" or "dark" – sets the initial 'data-bs-theme' via the page's '?theme=' query parameter. |
(invisibly) the path that was opened.
## Not run: de_style_guide("dark") ## End(Not run)## Not run: de_style_guide("dark") ## End(Not run)
DEBrowser bslib theme. Default behavior: hand-rolled Slate + OK-blue palette with Inter typography on Bootstrap 5. When 'preset' is supplied (e.g. '"zephyr"', '"lumen"', '"cosmo"'), returns a bare Bootstrap 5 theme with only Inter font applied – preset-specific colors come from the bootswatch CDN stylesheet that 'deUI()' injects separately, so each preset URL is unique and tabs don't collide on the same compiled bootstrap.min.css. Used as the 'theme' argument to 'bslib::page_navbar()' in [deUI()]. The URL-param playground ('?preset=NAME') wires this up.
de_theme(preset = NULL)de_theme(preset = NULL)
preset |
Optional bslib preset name. One of '.de_theme_presets'. 'NULL' (default) returns the standard custom theme. |
a 'bs_theme' object
x <- de_theme() y <- de_theme(preset = "zephyr")x <- de_theme() y <- de_theme(preset = "zephyr")
B3 helper. Small breadcrumb / toolbar row that sits above a tab's headline. Accepts a current-tab label and optional trailing actions.
de_workbar(crumb, ...)de_workbar(crumb, ...)
crumb |
character – current tab label, shown bold |
... |
trailing tags (e.g. 'actionButton's) |
an 'htmltools::tag' ('<div class="de-workbar">').
x <- de_workbar("Data Prep")x <- de_workbar("Data Prep")
Module for a bar plot that can be used in data prep, main plots low count removal modules or any desired module
debrowserall2all(id, data = NULL, cex = 2)debrowserall2all(id, data = NULL, cex = 2)
id |
namespace id |
data |
a matrix that includes expression values |
cex |
the size of the dots |
all2all plot
x <- debrowserall2all("all2all")x <- debrowserall2all("all2all")
Module for a bar plot that can be used in data prep, main plots low count removal modules or any desired module
debrowserbarmainplot( id, data = NULL, cols = NULL, conds = NULL, cond_names = NULL, key = NULL )debrowserbarmainplot( id, data = NULL, cols = NULL, conds = NULL, cond_names = NULL, key = NULL )
id |
namespace id |
data |
a matrix that includes expression values |
cols |
columns |
conds |
conditions |
cond_names |
condition names |
key |
the gene or region name |
density plot
x <- debrowserbarmainplot("bar")x <- debrowserbarmainplot("bar")
Module to correct batch effect
debrowserbatcheffect(id, ldata = NULL)debrowserbatcheffect(id, ldata = NULL)
id |
namespace id |
ldata |
loaded data |
main plot
panel
x <- debrowserbatcheffect("batch")x <- debrowserbatcheffect("batch")
Module for a box plot that can be used in DEanalysis main part and used heatmaps
debrowserboxmainplot( id, data = NULL, cols = NULL, conds = NULL, cond_names = NULL, key = NULL )debrowserboxmainplot( id, data = NULL, cols = NULL, conds = NULL, cond_names = NULL, key = NULL )
id |
namespace id |
data |
a matrix that includes expression values |
cols |
columns |
conds |
conditions |
cond_names |
condition names |
key |
the gene or region name |
density plot
x <- debrowserboxmainplot("box")x <- debrowserboxmainplot("box")
Module to load count data and metadata
debrowserdataload(id, nextpagebutton = NULL)debrowserdataload(id, nextpagebutton = NULL)
id |
namespace id |
nextpagebutton |
the name of the next page button after loading the data |
main plot
panel
x <- debrowserdataload("load")x <- debrowserdataload("load")
Module to perform and visualize DE results.
debrowserdeanalysis( id, data = NULL, metadata = NULL, columns = NULL, conds = NULL, params = NULL )debrowserdeanalysis( id, data = NULL, metadata = NULL, columns = NULL, conds = NULL, params = NULL )
id |
namespace id |
data |
a matrix that includes expression values |
metadata |
metadata |
columns |
columns |
conds |
conditions |
params |
de parameters |
DE panel
x <- debrowserdeanalysis("de")x <- debrowserdeanalysis("de")
Module for a density plot that can be used in data prep and low count removal modules
debrowserdensityplot(id, data = NULL)debrowserdensityplot(id, data = NULL)
id |
namespace id |
data |
a matrix that includes expression values |
density plot
x <- debrowserdensityplot("density")x <- debrowserdensityplot("density")
Heatmap module to create interactive heatmaps and get selected list from a heatmap
debrowserheatmap(id, expdata = NULL)debrowserheatmap(id, expdata = NULL)
id |
namespace id |
expdata |
a matrix that includes expression values |
heatmapply plot
x <- debrowserheatmap("heatmap")x <- debrowserheatmap("heatmap")
Module for a histogram that can be used in data prep and low count removal modules
debrowserhistogram(id, data = NULL)debrowserhistogram(id, data = NULL)
id |
namespace id |
data |
a matrix that includes expression values |
histogram
x <- debrowserhistogram("histogram")x <- debrowserhistogram("histogram")
Module for an IQR plot that can be used in data prep and low count removal modules
debrowserIQRplot(id, data = NULL)debrowserIQRplot(id, data = NULL)
id |
namespace id |
data |
a matrix that includes expression values |
IQR
x <- debrowserIQRplot("iqr")x <- debrowserIQRplot("iqr")
Module to filter low count genes/regions
debrowserlowcountfilter(id, ldata = NULL)debrowserlowcountfilter(id, ldata = NULL)
id |
namespace id |
ldata |
loaded data |
main plot
panel
x <- debrowserlowcountfilter("lcf")x <- debrowserlowcountfilter("lcf")
Module for a scatter, volcano and ma plots that are going to be used as a mainplot in debrowser
debrowsermainplot(id, data = NULL, cond_names = NULL)debrowsermainplot(id, data = NULL, cond_names = NULL)
id |
namespace id |
data |
a matrix that includes expression values |
cond_names |
condition names |
main plot
panel
x <- debrowsermainplot("main")x <- debrowsermainplot("main")
Module for a pca plot with its loadings as a mainplot in debrowser
debrowserpcaplot(id, pcadata = NULL, metadata = NULL)debrowserpcaplot(id, pcadata = NULL, metadata = NULL)
id |
namespace id |
pcadata |
a matrix that includes expression values |
metadata |
metadata to color the plots |
main plot
panel
x <- debrowserpcaplot("pca")x <- debrowserpcaplot("pca")
Server factory for the Cook's-distance outlier-count QC card. Computes
cooks_outlier_summary and renders a vertical bar of
'n_high_cooks' per sample. Subtitle reports the active threshold.
debrowserqccooks(id, dds = NULL, selected_samples = NULL)debrowserqccooks(id, dds = NULL, selected_samples = NULL)
id |
character, namespace id matching 'qcCooksUI(id)' |
dds |
A fitted 'DESeqDataSet', or NULL. |
selected_samples |
Optional character vector of sample names to show. NULL (default) shows every sample in the dds; otherwise only bars for samples whose name is in 'selected_samples' are rendered (mirrors the QC sidebar's column-selector behaviour). |
invisible(NULL); wires 'output$body', 'output$plot', and 'output$dl'.
debrowserqccooks("cooks", dds)debrowserqccooks("cooks", dds)
Server factory for the feature-detection-rate QC card. Computes
detection_rate and renders a horizontal 'plotly' bar of
'detection_pct' per sample.
debrowserqcdetectionrate(id, counts = NULL)debrowserqcdetectionrate(id, counts = NULL)
id |
character, namespace id matching 'qcDetectionRateUI(id)' |
counts |
numeric matrix or data.frame (rows = features, cols = samples); the module no-ops if NULL |
invisible(NULL); the module wires 'output$plot' and 'output$dl'
debrowserqcdetectionrate("detectionRate", counts)debrowserqcdetectionrate("detectionRate", counts)
Server factory for the dispersion-estimates QC card. Wraps
DESeq2::plotDispEsts(dds) in 'renderPlot' (base-R graphics, not
plotly). Renders an empty-state alert when 'dds' is NULL (no DE run yet,
or method was not DESeq2).
debrowserqcdispersion(id, dds = NULL)debrowserqcdispersion(id, dds = NULL)
id |
character, namespace id matching 'qcDispersionUI(id)' |
dds |
A fitted 'DESeqDataSet', or NULL. |
invisible(NULL); wires 'output$body' and 'output$plot'.
debrowserqcdispersion("dispersion", dds)debrowserqcdispersion("dispersion", dds)
Server factory for the library-depth QC card. Computes per-sample depth via
library_depth_summary and renders a horizontal 'plotly' bar
colored by the optional 'group_col'. Outliers (>2 SD from the mean depth)
are drawn with a red marker outline.
debrowserqclibrarydepth(id, counts = NULL, meta = NULL, group_col = NULL)debrowserqclibrarydepth(id, counts = NULL, meta = NULL, group_col = NULL)
id |
character, namespace id matching 'qcLibraryDepthUI(id)' |
counts |
numeric matrix or data.frame (rows = features, cols = samples); the module no-ops if NULL |
meta |
optional metadata data.frame with a 'samples' column |
group_col |
optional name of a column in 'meta' used to color bars |
invisible(NULL); the module wires 'output$plot' and 'output$dl'
debrowserqclibrarydepth("libraryDepth", counts, meta, "samples")debrowserqclibrarydepth("libraryDepth", counts, meta, "samples")
Server factory for the mitochondrial-percentage QC card. Computes
mt_pct_per_sample and either renders a 'plotly' bar with a
horizontal threshold line at 'threshold_pct', or an empty-state info alert
when no MT genes are detected.
debrowserqcmtpct(id, counts = NULL, threshold_pct = 5)debrowserqcmtpct(id, counts = NULL, threshold_pct = 5)
id |
character, namespace id matching 'qcMtPctUI(id)' |
counts |
numeric matrix or data.frame (rows = features, cols = samples); the module no-ops if NULL |
threshold_pct |
numeric, the horizontal warning threshold drawn over the bar plot (default 5) |
invisible(NULL); the module wires 'output$body', 'output$plot', and 'output$dl'
debrowserqcmtpct("mtPct", counts, threshold_pct = 5)debrowserqcmtpct("mtPct", counts, threshold_pct = 5)
Server factory for the sample-distance heatmap. Computes
sample_distance_matrix and renders it via
heatmaply::heatmaply.
debrowserqcsampledist(id, counts = NULL)debrowserqcsampledist(id, counts = NULL)
id |
character, namespace id matching 'qcSampleDistUI(id)' |
counts |
numeric matrix or data.frame (rows = features, cols = samples); the module no-ops if NULL |
invisible(NULL); the module wires 'output$plot' and 'output$dl'
debrowserqcsampledist("sampleDist", counts)debrowserqcsampledist("sampleDist", counts)
Server factory for the size-factors-vs-library-size QC card. Computes
size_factor_library_summary and renders two scaled bars per
sample plus the Spearman correlation in the subtitle.
debrowserqcsizefactors(id, dds = NULL, selected_samples = NULL)debrowserqcsizefactors(id, dds = NULL, selected_samples = NULL)
id |
character, namespace id matching 'qcSizeFactorsUI(id)' |
dds |
A fitted 'DESeqDataSet', or NULL. |
selected_samples |
Optional character vector of sample names to show. NULL (default) shows every sample in the dds; otherwise only bars for samples whose name is in 'selected_samples' are rendered (mirrors the QC sidebar's column-selector behaviour). |
invisible(NULL); wires 'output$body', 'output$plot', and 'output$dl'.
debrowserqcsizefactors("sizeFactors", dds)debrowserqcsizefactors("sizeFactors", dds)
Single source of truth for the values that populate the DE cutoff inputs and the generateTestData() fallback in R/mainScatter.R.
default_cutoffs()default_cutoffs()
Named list with components: padj, log2fc, gopvalue.
default_cutoffs()default_cutoffs()
get distance metric parameters
dendControlsUI(id, dendtype = "Row")dendControlsUI(id, dendtype = "Row")
id |
module ID |
dendtype |
Row or Col |
controls
dendControlsUI
x <- dendControlsUI("heatmap")x <- dendControlsUI("heatmap")
Generates the controls in the left menu for a densityPlot
densityPlotControlsUI(id)densityPlotControlsUI(id)
id |
namespace id |
returns the left menu
densityPlotControlsUI
x <- densityPlotControlsUI("density")x <- densityPlotControlsUI("density")
Sets up shinyServer to be able to run DEBrowser interactively.
deServer(input, output, session)deServer(input, output, session)
input |
input params from UI |
output |
output params to UI |
session |
session variable |
the panel for main plots;
deServer
deServerdeServer
Tries tab, comma, semicolon. Returns the highest-scoring delimiter with score >= 'min_score', with the tie-break order tab > comma > semicolon. Returns NA when no candidate clears the threshold.
detect_separator(path, sample_lines = 50L, min_score = 3L)detect_separator(path, sample_lines = 50L, min_score = 3L)
path |
character, path to the file (may end in '.gz'). |
sample_lines |
integer, number of lines to read for scoring. |
min_score |
integer, minimum numeric-column count required to accept a candidate delimiter. |
Decompresses '.gz' files and strips a leading UTF-8 BOM before scoring. Excel files are not handled here – callers should branch on extension before calling this.
Counts files default to 'min_score = 3' (3+ numeric columns is a strong signal). Metadata files have only 1-2 numeric columns typically; pass 'min_score = 1' to keep the helper useful for them.
one of tab, comma, semicolon, or 'NA_character_'.
tmp <- tempfile(fileext = ".txt") writeLines(c("Gene\tS1\tS2\tS3", "GeneA\t100\t200\t150", "GeneB\t40\t60\t55"), tmp) detect_separator(tmp) unlink(tmp)tmp <- tempfile(fileext = ".txt") writeLines(c("Gene\tS1\tS2\tS3", "GeneA\t100\t200\t150", "GeneB\t40\t60\t55"), tmp) detect_separator(tmp) unlink(tmp)
Counts the number of features with values strictly greater than 'threshold' per sample and reports detection percentage.
detection_rate(counts, threshold = 0)detection_rate(counts, threshold = 0)
counts |
Numeric matrix or data.frame (rows = features, cols = samples). |
threshold |
Detection threshold (default 0). A feature is "detected" in a sample iff its value is strictly greater than 'threshold'. |
data.frame with columns 'sample', 'n_detected', 'total_features', 'detection_pct' (one row per sample).
m <- matrix(c(0, 0, 5, 5, 0, 5), nrow = 3, dimnames = list(NULL, c("a", "b"))) detection_rate(m)m <- matrix(c(0, 0, 5, 5, 0, 5), nrow = 3, dimnames = list(NULL, c("a", "b"))) detection_rate(m)
Creates a shinyUI to be able to run DEBrowser interactively. B1 shell: bslib::page_navbar with 5 nav panels (Data Prep / Main Plots / QC Plots / GO Term / Tables), Slate + OK-blue theme, light/dark toggle.
deUI(req = NULL)deUI(req = NULL)
req |
Shiny request object (auto-supplied by Shiny when 'deUI' is used as the 'ui' argument to 'shinyApp()'). |
Accepts a Shiny 'request' argument so that the theme can be swapped at runtime via the '?preset=NAME' query parameter (e.g. '?preset=zephyr'). Unknown or missing 'preset' keeps the default theme.
the page tagList for DEBrowser
deUI
shiny::shinyApp(ui = deUI, server = deServer)shiny::shinyApp(ui = deUI, server = deServer)
get distance metric parameters
distFunParamsUI()distFunParamsUI()
funParams
distFunParamsUI
x <- distFunParamsUI()x <- distFunParamsUI()
draw KEGG patwhay with expression values
drawKEGG(input = NULL, dat = NULL, pid = NULL)drawKEGG(input = NULL, dat = NULL, pid = NULL)
input |
input |
dat |
expression matrix |
pid |
pathway id |
enriched DO
drawKEGG
x <- drawKEGG()x <- drawKEGG()
Creates a more detailed plot using the PCA results from the selected dataset.
drawPCAExplained(explainedData = NULL)drawPCAExplained(explainedData = NULL)
explainedData |
selected data |
explained plot
x <- drawPCAExplained()x <- drawPCAExplained()
Returns a reactive that yields a named list of gene-symbol vectors -
the same shape gmt_to_pathways produces - or NULL until
the user has loaded a source.
enrichmentGmtServer(id)enrichmentGmtServer(id)
id |
Module ID. |
Both branches populate an internal reactiveVal so the load step is observable independently of any downstream consumer (the previous eventReactive design was lazy and didn't fire until Submit). A small status output reports load success / failure / set count next to the picker.
Reactive expression yielding the parsed pathways list.
shiny::shinyApp( ui = enrichmentGmtUI("gmt"), server = function(input, output, session) { enrichmentGmtServer("gmt") } )shiny::shinyApp( ui = enrichmentGmtUI("gmt"), server = function(input, output, session) { enrichmentGmtServer("gmt") } )
Two sources: manual '.gmt' upload (auto-loads on file pick) and MSigDB (loads on explicit "Load gene sets" click). A status line below the picker reports how many gene sets are currently loaded so the user has immediate feedback before pressing Submit.
enrichmentGmtUI(id)enrichmentGmtUI(id)
id |
Module ID. |
Shiny tagList for inclusion in a 'bslib::accordion_panel'.
enrichmentGmtUI("demo")enrichmentGmtUI("demo")
Server for the NES heatmap card.
enrichmentNesHeatmapServer(id, results_by_comparison)enrichmentNesHeatmapServer(id, results_by_comparison)
id |
Module ID. |
results_by_comparison |
Reactive yielding a named list of
|
invisible(NULL).
shiny::shinyApp( ui = enrichmentNesHeatmapUI("nes"), server = function(input, output, session) { enrichmentNesHeatmapServer("nes", shiny::reactive(list())) } )shiny::shinyApp( ui = enrichmentNesHeatmapUI("nes"), server = function(input, output, session) { enrichmentNesHeatmapServer("nes", shiny::reactive(list())) } )
Renders only when [enrichmentServer] passes more than one comparison's GSEA results.
enrichmentNesHeatmapUI(id)enrichmentNesHeatmapUI(id)
id |
Module ID. |
A 'bslib::card'.
enrichmentNesHeatmapUI("demo")enrichmentNesHeatmapUI("demo")
Server for the Enrichment tab.
enrichmentServer(id, de_results)enrichmentServer(id, de_results)
id |
Module ID. |
de_results |
Reactive yielding either: - a single data.frame with columns 'ID' (or 'gene'), 'log2FoldChange', 'padj' (one comparison), or - a named list of such data.frames (multi-comparison; enables the NES heatmap). |
invisible(NULL).
de <- data.frame(ID = paste0("G", 1:5), log2FoldChange = c(2, -1, 0, 3, -2), padj = c(0.01, 0.04, 0.5, 0.02, 0.03)) shiny::shinyApp( ui = enrichmentUI("e1"), server = function(input, output, session) { enrichmentServer("e1", shiny::reactive(de)) } )de <- data.frame(ID = paste0("G", 1:5), log2FoldChange = c(2, -1, 0, 3, -2), padj = c(0.01, 0.04, 0.5, 0.02, 0.03)) shiny::shinyApp( ui = enrichmentUI("e1"), server = function(input, output, session) { enrichmentServer("e1", shiny::reactive(de)) } )
Lives next to the existing GO Term tab. E2 will fold GO Term into here as the ORA mode; E11 adds the "Compare methods" mode.
enrichmentUI(id)enrichmentUI(id)
id |
Module ID. |
A 'bslib::layout_sidebar' tagList.
enrichmentUI("demo")enrichmentUI("demo")
Export menu items (without nav_menu wrapper) for embedding in the account dropdown. Returns a list of '<li>'s, each carrying either a shiny-download-link (downloads) or a 'data-debrowser-input' action link (modal opens). IDs are namespaced under 'id' so the existing 'exportMenuServer(id, ...)' observers/handlers wire up unchanged.
exportMenuItems(id)exportMenuItems(id)
id |
Module ID (matches the one passed to 'exportMenuServer()'). |
list of 'shiny::tags$li' elements.
Export menu server – wires download handlers from a state reactive.
exportMenuServer(id, state_react)exportMenuServer(id, state_react)
id |
Module ID (matches [exportMenuUI()]). |
state_react |
reactive expression returning the plain-list state snapshot consumed by [build_session_blocks()]. May return NULL when no DE has run yet; both download handlers no-op (showNotification) in that case. |
Invisibly NULL.
shiny::shinyApp( ui = bslib::page_navbar(exportMenuUI("exp")), server = function(input, output, session) { exportMenuServer("exp", shiny::reactive(NULL)) } )shiny::shinyApp( ui = bslib::page_navbar(exportMenuUI("exp")), server = function(input, output, session) { exportMenuServer("exp", shiny::reactive(NULL)) } )
Mounted in the page_navbar after 'nav_spacer()'. Six items: - "R script" downloads a runnable .R reproducibility script - "Rmd source" (E3.B) downloads the raw .Rmd body, no render - "HTML" renders an .Rmd to HTML (gated on rmarkdown) - "View HTML in tab" (E3.B) renders + opens in a new browser tab - "Jupyter notebook" (E3.B) downloads the same content as .ipynb with R-kernel code cells - "Copy methods text" opens a modal with a manuscript-ready paragraph (E9) plus a "Download as .txt" button
exportMenuUI(id)exportMenuUI(id)
id |
Module ID. |
Items are disabled at the server level when DE has not yet been run; the UI emits the disabled-attribute via output bindings.
bslib::nav_menu element.
exportMenuUI("demo")exportMenuUI("demo")
Returns fileTypes that are going to be used in creating fileUpload UI
fileTypes()fileTypes()
file types
fileTypes
x <- fileTypes()x <- fileTypes()
File upload module
fileUploadBox(id = NULL, inputId = NULL, label = NULL, helper = NULL)fileUploadBox(id = NULL, inputId = NULL, label = NULL, helper = NULL)
id |
namespace id |
inputId |
input file ID |
label |
label |
helper |
optional help-text string shown beneath the card title |
radio control
fileUploadBox
x <- fileUploadBox("meta", "metadata", "Metadata")x <- fileUploadBox("meta", "metadata", "Metadata")
Filter low-count rows from a count matrix.
filter_low_counts(counts, method = "max", cutoff = 10, min_samples = NULL)filter_low_counts(counts, method = "max", cutoff = 10, min_samples = NULL)
counts |
Numeric matrix (genes x samples). |
method |
One of "max", "mean", "cpm". |
cutoff |
Numeric threshold; meaning depends on 'method'. |
min_samples |
For method="cpm": the row is kept if CPM > cutoff in at least 'min_samples' samples. Defaults to 'ncol(counts) - 1'. |
Filtered count matrix (rows preserved by row order).
m <- matrix(c(1, 50, 100, 5, 80, 120, 1, 2, 3, 1, 2, 3), nrow = 2, byrow = TRUE) colnames(m) <- paste0("S", 1:6) rownames(m) <- c("GeneA", "GeneB") filter_low_counts(m, method = "max", cutoff = 10)m <- matrix(c(1, 50, 100, 5, 80, 120, 1, 2, 3, 1, 2, 3), nrow = 2, byrow = TRUE) colnames(m) <- paste0("S", 1:6) rownames(m) <- c("GeneA", "GeneB") filter_low_counts(m, method = "max", cutoff = 10)
All A3b pure functions accept a named list of filter parameters. This helper bridges Shiny modules to those functions in a single place so the field-name mapping is documented and centralised.
filter_params_from_input(input)filter_params_from_input(input)
input |
A Shiny input reactive (or a plain list with the same fields). |
Named list with components: padj_cutoff, fold_cutoff, dataset, compselect, norm_method, geneset_area, method_tab, min_count, top_n, selected_plot.
fake_input <- list( padj = 0.05, log2fc_cutoff = 1, dataset = "up+down", compselect = 1, norm_method = "TMM", genesetarea = "", methodtabs = "panel1", mincount = 10, topn = 500, selectedplot = NULL ) filter_params_from_input(fake_input)fake_input <- list( padj = 0.05, log2fc_cutoff = 1, dataset = "up+down", compselect = 1, norm_method = "TMM", genesetarea = "", methodtabs = "panel1", mincount = 10, topn = 500, selectedplot = NULL ) filter_params_from_input(fake_input)
Pure helper used by library_depth_summary. NA values map
to FALSE in the output. Returns all FALSE if 'length(x) < 2' or if the
standard deviation is zero.
flag_outliers_2sd(x)flag_outliers_2sd(x)
x |
Numeric vector. |
Logical vector the same length as 'x'. TRUE iff 'abs(x - mean(x, na.rm = TRUE)) > 2 * sd(x, na.rm = TRUE)'.
flag_outliers_2sd(c(1, 1, 1, 1, 1, 10)) flag_outliers_2sd(c(1, 1, 1, 1)) # zero variance -> all FALSE flag_outliers_2sd(c(NA, 1, 1, 1, 10)) # NA position -> FALSEflag_outliers_2sd(c(1, 1, 1, 1, 1, 10)) flag_outliers_2sd(c(1, 1, 1, 1)) # zero variance -> all FALSE flag_outliers_2sd(c(NA, 1, 1, 1, 10)) # NA position -> FALSE
Convert fold-change cutoff to |log2FC|.
fold_to_log2fc(x)fold_to_log2fc(x)
x |
Numeric fold-change cutoff. |
|log2FC| cutoff (log2(x)).
fold_to_log2fc(2) # 1 fold_to_log2fc(4) # 2fold_to_log2fc(2) # 1 fold_to_log2fc(4) # 2
This generates a test data that is suitable to main plots in debrowser
generateTestData(dat = NULL)generateTestData(dat = NULL)
dat |
DESeq results will be generated for loaded data |
testData
x <- generateTestData()x <- generateTestData()
Compute the most-varied genes by coefficient of variation.
get_most_varied(datavar, cols, params = list())get_most_varied(datavar, cols, params = list())
datavar |
data.frame with sample columns. |
cols |
Character vector of sample column names. |
params |
Named list with 'top_n' (int) and 'min_count' (int). |
data.frame of the top-N most-varied rows.
cols <- paste0("S", 1:6) df <- as.data.frame(matrix( c(100, 200, 150, 80, 250, 130, 40, 60, 55, 30, 70, 45, 10, 10, 10, 10, 10, 10), nrow = 3, byrow = TRUE, dimnames = list(paste0("Gene", 1:3), cols) )) get_most_varied(df, cols, list(top_n = 2, min_count = 0))cols <- paste0("S", 1:6) df <- as.data.frame(matrix( c(100, 200, 150, 80, 250, 130, 40, 60, 55, 30, 70, 45, 10, 10, 10, 10, 10, 10), nrow = 3, byrow = TRUE, dimnames = list(paste0("Gene", 1:3), cols) )) get_most_varied(df, cols, list(top_n = 2, min_count = 0))
Pure version of 'getDataForTables()'.
get_table_data( init_data = NULL, filt_data = NULL, selected = NULL, get_most_varied_data = NULL, merged_comp = NULL, explained_data = NULL, params = list() )get_table_data( init_data = NULL, filt_data = NULL, selected = NULL, get_most_varied_data = NULL, merged_comp = NULL, explained_data = NULL, params = list() )
init_data |
Initial DE result. |
filt_data |
Filtered DE result; defaults to 'init_data' if NULL. |
selected |
Genes the user lasso-selected (used when 'dataset == "selected"'). |
get_most_varied_data |
Most-varied subset (used when 'dataset == "most-varied"'). |
merged_comp |
Merged comparisons table. |
explained_data |
Unused; preserved for legacy signature parity. |
params |
Named list with 'dataset', 'geneset_area'. |
list(data, padj_colname, fold_colname).
init_data <- data.frame( foldChange = c(5, 0.1, 1.0), padj = c(0.01, 0.01, 0.5), Legend = c("Up", "Down", "NS"), row.names = c("GeneA", "GeneB", "GeneC") ) result <- get_table_data( init_data = init_data, params = list(dataset = "alldetected", geneset_area = "") ) result[[1]] # the data.frameinit_data <- data.frame( foldChange = c(5, 0.1, 1.0), padj = c(0.01, 0.01, 0.5), Legend = c("Up", "Down", "NS"), row.names = c("GeneA", "GeneB", "GeneC") ) result <- get_table_data( init_data = init_data, params = list(dataset = "alldetected", geneset_area = "") ) result[[1]] # the data.frame
Generates and displays the message to be shown after loading data within the DEBrowser.
getAfterLoadMsg()getAfterLoadMsg()
return After Load Msg
getAfterLoadMsg
x <- getAfterLoadMsg()x <- getAfterLoadMsg()
all2all plots UI.
getAll2AllPlotUI(id)getAll2AllPlotUI(id)
id |
namespace id |
A 'shiny::uiOutput' placeholder under namespace 'id' that the all2all module's server fills with the all-pairs scatter matrix plot.
getAll2AllPlotUI
x <- getAll2AllPlotUI("bar")x <- getAll2AllPlotUI("bar")
Makes Density plots
getBarMainPlot( data = NULL, cols = NULL, conds = NULL, cond_names = NULL, key = NULL, title = "", input = NULL )getBarMainPlot( data = NULL, cols = NULL, conds = NULL, cond_names = NULL, key = NULL, title = "", input = NULL )
data |
count or normalized data |
cols |
cols |
conds |
conds |
cond_names |
condition names |
key |
key |
title |
title |
input |
input |
A 'plotly' bar plot for the selected gene/region across samples.
getBarMainPlot()getBarMainPlot()
main bar plots UI.
getBarMainPlotUI(id)getBarMainPlotUI(id)
id |
namespace id |
the panel for Density plots;
getBarMainPlotUI
x <- getBarMainPlotUI("bar")x <- getBarMainPlotUI("bar")
Makes Density plots
getBoxMainPlot( data = NULL, cols = NULL, conds = NULL, cond_names = NULL, key = NULL, title = "", input = NULL )getBoxMainPlot( data = NULL, cols = NULL, conds = NULL, cond_names = NULL, key = NULL, title = "", input = NULL )
data |
count or normalized data |
cols |
cols |
conds |
conds |
cond_names |
condition names |
key |
key |
title |
title |
input |
input |
A 'plotly' box plot for the selected gene/region across samples.
getBoxMainPlot()getBoxMainPlot()
main Box plots UI.
getBoxMainPlotUI(id)getBoxMainPlotUI(id)
id |
namespace id |
the panel for Density plots;
getBoxMainPlotUI
x <- getBoxMainPlotUI("box")x <- getBoxMainPlotUI("box")
getBSTableUI prepares a Modal to put a table
getBSTableUI( name = NULL, label = NULL, trigger = NULL, size = "large", modal = NULL )getBSTableUI( name = NULL, label = NULL, trigger = NULL, size = "large", modal = NULL )
name |
name |
label |
label |
trigger |
trigger button for the modal |
size |
size of the modal |
modal |
modal yes/no |
the modal
x <- getBSTableUI()x <- getBSTableUI()
get colors for the domains
getColors(domains = NULL)getColors(domains = NULL)
domains |
domains to be colored |
colors
x <- getColors()x <- getColors()
Generates the fill and shape selection boxes for PCA plots. metadata file has to be loaded in this case
getColorShapeSelection(metadata = NULL, input = NULL, session = NULL)getColorShapeSelection(metadata = NULL, input = NULL, session = NULL)
metadata |
metadata table |
input |
input |
session |
session |
Color and shape selection boxes
x <- getColorShapeSelection()x <- getColorShapeSelection()
Gathers the user selected comparison set to be used within the DEBrowser.
getCompSelection(name = NULL, count = NULL)getCompSelection(name = NULL, count = NULL)
name |
the name of the selectInput |
count |
comparison count |
A 'shiny::selectInput' (or NULL when only one comparison exists) listing the available comparison indices.
getCompSelection
x <- getCompSelection(name = "comp", count = 2)x <- getCompSelection(name = "comp", count = 2)
Generates and displays the current conditions and their samples within the DEBrowser.
getCondMsg(dc = NULL, input = NULL, cols = NULL, conds = NULL)getCondMsg(dc = NULL, input = NULL, cols = NULL, conds = NULL)
dc |
columns |
input |
selected comparison |
cols |
columns |
conds |
selected conditions |
return conditions
getCondMsg
x <- getCondMsg()x <- getCondMsg()
Gathers the cut off selection for DE analysis
getCutOffSelection(nc = 1)getCutOffSelection(nc = 1)
nc |
total number of comparisons |
returns the left menu according to the selected tab;
getCutOffSelection
x <- getCutOffSelection()x <- getCutOffSelection()
getDataAssesmentText DataAssesment text
getDataAssesmentText()getDataAssesmentText()
help text for data assesment
x <- getDataAssesmentText()x <- getDataAssesmentText()
getDataForTables get data to fill up tables tab
getDataForTables( input = NULL, init_data = NULL, filt_data = NULL, selected = NULL, getMostVaried = NULL, mergedComp = NULL, explainedData = NULL )getDataForTables( input = NULL, init_data = NULL, filt_data = NULL, selected = NULL, getMostVaried = NULL, mergedComp = NULL, explainedData = NULL )
input |
input parameters |
init_data |
initial dataset |
filt_data |
filt_data |
selected |
selected genes |
getMostVaried |
most varied genes |
mergedComp |
merged comparison set |
explainedData |
pca gene set |
data
x <- getDataForTables()x <- getDataForTables()
getDataPreparationText DataPreparation text
getDataPreparationText()getDataPreparationText()
help text for data preparation
x <- getDataPreparationText()x <- getDataPreparationText()
getDEAnalysisText DEAnalysis text
getDEAnalysisText()getDEAnalysisText()
help text for DE Analysis
x <- getDEAnalysisText()x <- getDEAnalysisText()
Makes Density plots
getDensityPlot(data = NULL, input = NULL, title = "")getDensityPlot(data = NULL, input = NULL, title = "")
data |
count or normalized data |
input |
input |
title |
title |
A 'plotly' density plot showing the per-sample distributions of the input count matrix (one density curve per sample).
getDensityPlot()getDensityPlot()
Density plot UI.
getDensityPlotUI(id)getDensityPlotUI(id)
id |
namespace id |
the panel for Density plots;
getDensityPlotUI
x <- getDensityPlotUI("density")x <- getDensityPlotUI("density")
getDEResultsUI Creates a panel to visualize DE results
getDEResultsUI(id)getDEResultsUI(id)
id |
namespace id |
panel
x <- getDEResultsUI("batcheffect")x <- getDEResultsUI("batcheffect")
Get domains for the main plots.
getDomains(filt_data = NULL)getDomains(filt_data = NULL)
filt_data |
data to get the domains |
domains
x <- getDomains()x <- getDomains()
getDown get down regulated data
getDown(filt_data = NULL)getDown(filt_data = NULL)
filt_data |
filt_data |
data
x <- getDown()x <- getDown()
download section button and dataset selection box in the menu for user to download selected data.
getDownloadSection(choices = NULL)getDownloadSection(choices = NULL)
choices |
main vs. QC section |
the panel for download section in the menu;
getDownloadSection
x <- getDownloadSection()x <- getDownloadSection()
Gathers the Enriched DO Term analysis data to be used within the GO Term plots.
getEnrichDO(genelist = NULL, pvalueCutoff = 0.01)getEnrichDO(genelist = NULL, pvalueCutoff = 0.01)
genelist |
gene list |
pvalueCutoff |
the p value cutoff |
enriched DO
getEnrichDO
x <- getEnrichDO()x <- getEnrichDO()
Gathers the Enriched GO Term analysis data to be used within the GO Term plots.
getEnrichGO( genelist = NULL, pvalueCutoff = 0.01, org = "org.Hs.eg.db", ont = "CC" )getEnrichGO( genelist = NULL, pvalueCutoff = 0.01, org = "org.Hs.eg.db", ont = "CC" )
genelist |
gene list |
pvalueCutoff |
p value cutoff |
org |
the organism used |
ont |
the ontology used |
Enriched GO
getEnrichGO
x <- getEnrichGO()x <- getEnrichGO()
Gathers the Enriched KEGG analysis data to be used within the GO Term plots.
getEnrichKEGG(genelist = NULL, pvalueCutoff = 0.01, org = "org.Hs.eg.db")getEnrichKEGG(genelist = NULL, pvalueCutoff = 0.01, org = "org.Hs.eg.db")
genelist |
gene list |
pvalueCutoff |
the p value cutoff |
org |
the organism used |
Enriched KEGG
getEnrichKEGG
x <- getEnrichKEGG()x <- getEnrichKEGG()
Gathers the gene list to use for GOTerm analysis.
getEntrezIds(genes = NULL, org = "org.Hs.eg.db")getEntrezIds(genes = NULL, org = "org.Hs.eg.db")
genes |
gene list with fold changes |
org |
orgranism for gene symbol entrez ID conversion |
ENTREZ ID list
GOTerm
getEntrezIds
symobol to ENTREZ ID conversion
x <- getEntrezIds()x <- getEntrezIds()
Gathers the entrezIds of the genes in given list and their data
getEntrezTable(genes = NULL, dat = NULL, org = "org.Hs.eg.db")getEntrezTable(genes = NULL, dat = NULL, org = "org.Hs.eg.db")
genes |
gene list |
dat |
data matrix |
org |
orgranism for gene symbol entrez ID conversion |
table with the entrez IDs in the rownames
GOTerm
getEntrezTable
symobol to ENTREZ ID conversion
x <- getEntrezTable()x <- getEntrezTable()
Gathers the gene list to use for GOTerm analysis.
getGeneList( genes = NULL, org = "org.Hs.eg.db", fromType = "SYMBOL", toType = c("ENTREZID") )getGeneList( genes = NULL, org = "org.Hs.eg.db", fromType = "SYMBOL", toType = c("ENTREZID") )
genes |
gene list |
org |
orgranism for gene symbol entrez ID conversion |
fromType |
from Type |
toType |
to Type |
ENTREZ ID list
GOTerm
getGeneList
symobol to ENTREZ ID conversion
x <- getGeneList(c("OCLN", "ABCC2"))x <- getGeneList(c("OCLN", "ABCC2"))
Gathers the specified gene set list to be used within the DEBrowser.
getGeneSetData(data = NULL, geneset = NULL)getGeneSetData(data = NULL, geneset = NULL)
data |
loaded dataset |
geneset |
given gene set |
data
x <- getGeneSetData()x <- getGeneSetData()
Generates the GO Left menu to be displayed within the DEBrowser.
getGOLeftMenu()getGOLeftMenu()
returns the left menu according to the selected tab;
getGOLeftMenu
x <- getGOLeftMenu()x <- getGOLeftMenu()
Creates go term analysis panel within the shiny display.
getGoPanel()getGoPanel()
the panel for go term analysis;
getGoPanel
x <- getGoPanel()x <- getGoPanel()
Go term analysis panel. Generates appropriate GO plot based on user selection.
getGOPlots(dataset = NULL, GSEARes = NULL, input = NULL)getGOPlots(dataset = NULL, GSEARes = NULL, input = NULL)
dataset |
the dataset used |
GSEARes |
GSEA results |
input |
input params |
the panel for go plots;
getGOPlots
x <- getGOPlots()x <- getGOPlots()
Gathers the Enriched KEGG analysis data to be used within the GO Term plots.
getGSEA( dataset = NULL, pvalueCutoff = 0.01, org = "org.Hs.eg.db", sortfield = "log2FoldChange" )getGSEA( dataset = NULL, pvalueCutoff = 0.01, org = "org.Hs.eg.db", sortfield = "log2FoldChange" )
dataset |
dataset |
pvalueCutoff |
the p value cutoff |
org |
the organism used |
sortfield |
sort field for GSEA |
GSEA
getGSEA
x <- getGSEA()x <- getGSEA()
Generates the left menu to be used for heatmap plots
getHeatmapUI(id)getHeatmapUI(id)
id |
module ID |
heatmap plot area
getHeatmapUI
x <- getHeatmapUI("heatmap")x <- getHeatmapUI("heatmap")
getHelpButton prepares a helpbutton for to go to a specific site in the documentation
getHelpButton(name = NULL, link = NULL)getHelpButton(name = NULL, link = NULL)
name |
name that are going to come after info |
link |
link of the help |
the info button
x <- getHelpButton()x <- getHelpButton()
hide legend
getHideLegendOnOff(id = "pca")getHideLegendOnOff(id = "pca")
id |
namespace id |
A 'shiny::radioButtons' toggling whether the PCA plot legend is rendered or hidden.
x <- getHideLegendOnOff("pca")x <- getHideLegendOnOff("pca")
Histogram plots UI.
getHistogramUI(id)getHistogramUI(id)
id |
namespace id |
the panel for PCA plots;
getHistogramUI
x <- getHistogramUI("histogram")x <- getHistogramUI("histogram")
getIntroText Intro text
getIntroText()getIntroText()
the JS for tab updates
x <- getIntroText()x <- getIntroText()
Makes IQR boxplot plot
getIQRPlot(data = NULL, input = NULL, title = "")getIQRPlot(data = NULL, input = NULL, title = "")
data |
count or normalized data |
input |
input |
title |
title |
A 'plotly' IQR boxplot showing the per-sample inter-quartile spread of the input data.
getIQRPlot()getIQRPlot()
IQR plot UI.
getIQRPlotUI(id)getIQRPlotUI(id)
id |
namespace id |
the panel for IQR plots;
getIQRPlotUI
x <- getIQRPlotUI("IQR")x <- getIQRPlotUI("IQR")
heatmap JS code for selection functionality
getJSLine()getJSLine()
JS Code
x <- getJSLine()x <- getJSLine()
getKEGGModal prepares a modal for KEGG plots
getKEGGModal()getKEGGModal()
the info button
x <- getKEGGModal()x <- getKEGGModal()
Generates the left menu for for plots within the DEBrowser.
getLeftMenu(input = NULL)getLeftMenu(input = NULL)
input |
input values |
returns the left menu according to the selected tab;
getLeftMenu
x <- getLeftMenu()x <- getLeftMenu()
Generates colors according to the data
getLegendColors(Legend = c("up", "down", "NS"))getLegendColors(Legend = c("up", "down", "NS"))
Legend |
unique Legends |
mainPlotControls
getLegendColors
x <- getLegendColors(c("up", "down", "GS", "NS"))x <- getLegendColors(c("up", "down", "GS", "NS"))
Radio buttons for the types in the legend
getLegendRadio(id)getLegendRadio(id)
id |
namespace id |
radio control
getLegendRadio
x <- getLegendRadio("deprog")x <- getLegendRadio("deprog")
select legend
getLegendSelect(id = "pca")getLegendSelect(id = "pca")
id |
namespace id |
A 'shiny::selectInput' letting the user pick whether the PCA plot's legend tracks the color or shape mapping.
getLegendSelect
x <- getLegendSelect("pca")x <- getLegendSelect("pca")
Generates the order of the overlapping points
getLevelOrder(Level = c("up", "down", "NS"))getLevelOrder(Level = c("up", "down", "NS"))
Level |
factor levels shown in the legend |
order
getLevelOrder
x <- getLevelOrder(c("up", "down", "GS", "NS"))x <- getLevelOrder(c("up", "down", "GS", "NS"))
Generates and displays the logo to be shown within DEBrowser.
getLogo()getLogo()
return logo
getLogo
x <- getLogo()x <- getLogo()
main panel for volcano, scatter and maplot. Barplot and box plots are in this page as well.
getMainPanel()getMainPanel()
the panel for main plots;
getMainPanel
x <- getMainPanel()x <- getMainPanel()
Generates the Main PLots Left menu to be displayed within the DEBrowser.
getMainPlotsLeftMenu()getMainPlotsLeftMenu()
returns the left menu according to the selected tab;
getMainPlotsLeftMenu
x <- getMainPlotsLeftMenu()x <- getMainPlotsLeftMenu()
main plot for volcano, scatter and maplot.
getMainPlotUI(id)getMainPlotUI(id)
id |
namespace id |
the panel for main plots;
getMainPlotUI
x <- getMainPlotUI("main")x <- getMainPlotUI("main")
Gathers the mean for selected condition.
getMean(data = NULL, selcols = NULL)getMean(data = NULL, selcols = NULL)
data |
dataset |
selcols |
input cols |
data
x <- getMean()x <- getMean()
Gathers the merged comparison data to be used within the DEBrowser.
getMergedComparison(dc = NULL, nc = NULL, input = NULL)getMergedComparison(dc = NULL, nc = NULL, input = NULL)
dc |
data container |
nc |
the number of comparisons |
input |
input params |
data
x <- getMergedComparison()x <- getMergedComparison()
Calculates the most varied genes to be used for specific plots within the DEBrowser.
getMostVariedList(datavar = NULL, cols = NULL, input = NULL)getMostVariedList(datavar = NULL, cols = NULL, input = NULL)
datavar |
loaded dataset |
cols |
selected columns |
input |
input |
data
x <- getMostVariedList()x <- getMostVariedList()
Normalizes the matrix passed to be used within various methods within DEBrowser. Requires edgeR package
getNormalizedMatrix(M = NULL, method = "TMM")getNormalizedMatrix(M = NULL, method = "TMM")
M |
numeric matrix |
method |
normalization method for edgeR. default is TMM |
normalized matrix
getNormalizedMatrix
x <- getNormalizedMatrix(mtcars)x <- getNormalizedMatrix(mtcars)
getOrganism
getOrganism(org)getOrganism(org)
org |
organism |
organism name for keg
getOrganism
x <- getOrganism()x <- getOrganism()
Get the organism Box.
getOrganismBox()getOrganismBox()
selectInput
getOrganismBox
getOrganismBox
makes the organism box
x <- getOrganismBox()x <- getOrganismBox()
getOrganismPathway
getOrganismPathway(org)getOrganismPathway(org)
org |
organism |
organism name for pathway
getOrganismPathway
x <- getOrganismPathway()x <- getOrganismPathway()
getPCAcontolUpdatesJS in the prep menu we have two PCA plots to show how batch effect correction worked. One set of PCA input controls updates two PCA plots with this JS.
getPCAcontolUpdatesJS()getPCAcontolUpdatesJS()
the JS for tab updates
x <- getTabUpdateJS()x <- getTabUpdateJS()
Creates a more detailed plot using the PCA results from the selected dataset.
getPCAexplained(datasetInput = NULL, pca_data = NULL, input = NULL)getPCAexplained(datasetInput = NULL, pca_data = NULL, input = NULL)
datasetInput |
selected data |
pca_data |
from user |
input |
input params |
explained plot
load(system.file("extdata", "demo", "demodata.Rda", package = "debrowser")) input <- c() input$qcplot <- "pca" input$col_list <- colnames(demodata[, seq_len(6L)]) dat <- getNormalizedMatrix(demodata[, seq_len(6L)]) pca_data <- run_pca(dat) x <- getPCAexplained(dat, pca_data, input)load(system.file("extdata", "demo", "demodata.Rda", package = "debrowser")) input <- c() input$qcplot <- "pca" input$col_list <- colnames(demodata[, seq_len(6L)]) dat <- getNormalizedMatrix(demodata[, seq_len(6L)]) pca_data <- run_pca(dat) x <- getPCAexplained(dat, pca_data, input)
PCA plots UI.
getPCAPlotUI(id)getPCAPlotUI(id)
id |
namespace id |
the panel for PCA plots;
getPCAPlotUI
x <- getPCAPlotUI("pca")x <- getPCAPlotUI("pca")
Generates the PC selection number to be used within DEBrowser.
getPCselection(id, num = 1, xy = "x")getPCselection(id, num = 1, xy = "x")
id |
namespace id |
num |
PC selection number |
xy |
x or y coordinate |
PC selection for PCA analysis
getPCselection
x <- getPCselection("pca")x <- getPCselection("pca")
returns plot area either for heatmaply or heatmap.2
getPlotArea(input = NULL, session = NULL)getPlotArea(input = NULL, session = NULL)
input |
input variables |
session |
session |
heatmapply/heatmap.2 plot area
x <- getPlotArea()x <- getPlotArea()
Generates the title of the program to be displayed within DEBrowser. If it is called in a program, the program title will be hidden
getProgramTitle(session = NULL)getProgramTitle(session = NULL)
session |
session var |
program title
getProgramTitle
title <- getProgramTitle()title <- getProgramTitle()
getQAText Some questions and answers
getQAText()getQAText()
help text for QA
x <- getQAText()x <- getQAText()
Generates the left menu to be used for QC plots within the DEBrowser.
getQCLeftMenu(input = NULL)getQCLeftMenu(input = NULL)
input |
input values |
QC left menu
getQCLeftMenu
x <- getQCLeftMenu()x <- getQCLeftMenu()
Gathers the conditional panel for QC plots
getQCPanel(input = NULL)getQCPanel(input = NULL)
input |
user input |
the panel for QC plots
getQCSection
x <- getQCPanel()x <- getQCPanel()
get sample details
getSampleDetails(output = NULL, summary = NULL, details = NULL, data = NULL)getSampleDetails(output = NULL, summary = NULL, details = NULL, data = NULL)
output |
output |
summary |
summary output name |
details |
details ouput name |
data |
data |
panel
x <- getSampleDetails()x <- getSampleDetails()
search the geneset in the tables and return it
getSearchData(dat = NULL, input = NULL)getSearchData(dat = NULL, input = NULL)
dat |
table data |
input |
input params |
data
x <- getSearchData()x <- getSearchData()
gets selected columns
getSelectedCols(data = NULL, datasetInput = NULL, input = NULL)getSelectedCols(data = NULL, datasetInput = NULL, input = NULL)
data |
all loaded data |
datasetInput |
selected dataset |
input |
user input params |
A subset of 'data' (rows of 'datasetInput', columns selected in 'input$col_list'), or NULL when neither input is provided.
getSelectedCols()getSelectedCols()
Gathers the user selected dataset output to be displayed.
getSelectedDatasetInput( rdata = NULL, getSelected = NULL, getMostVaried = NULL, mergedComparison = NULL, input = NULL )getSelectedDatasetInput( rdata = NULL, getSelected = NULL, getMostVaried = NULL, mergedComparison = NULL, input = NULL )
rdata |
filtered dataset |
getSelected |
selected data |
getMostVaried |
most varied data |
mergedComparison |
merged comparison data |
input |
input parameters |
data
x <- getSelectedDatasetInput()x <- getSelectedDatasetInput()
heatmap selection functionality
getSelHeat(expdata = NULL, input = NULL)getSelHeat(expdata = NULL, input = NULL)
expdata |
selected genes |
input |
input params |
plot
x <- getSelHeat()x <- getSelHeat()
Generates the fill and shape selection boxes for PCA plots. metadata file has to be loaded in this case
getShapeColor(input = NULL)getShapeColor(input = NULL)
input |
input values |
Color and shape from selection boxes or defaults
x <- getShapeColor()x <- getShapeColor()
Generates and displays the starting messgae to be shown once the user has first seen the main plots page within DEBrowser.
getStartPlotsMsg()getStartPlotsMsg()
return start plot msg
getStartPlotsMsg
x <- getStartPlotsMsg()x <- getStartPlotsMsg()
Generates and displays the starting message within DEBrowser.
getStartupMsg()getStartupMsg()
return startup msg
getStartupMsg
x <- getStartupMsg()x <- getStartupMsg()
get table details To be able to put a table into two lines are necessary; into the server part; getTableDetails(output, session, "dataname", data, modal=TRUE) into the ui part; uiOutput(ns("dataname"))
getTableDetails( output = NULL, session = NULL, tablename = NULL, data = NULL, modal = NULL )getTableDetails( output = NULL, session = NULL, tablename = NULL, data = NULL, modal = NULL )
output |
output |
session |
session |
tablename |
table name |
data |
matrix data |
modal |
if it is true, the matrix is going to be in a modal |
panel
x <- getTableDetails()x <- getTableDetails()
getTableModal prepares table modal for KEGG
getTableModal()getTableModal()
the info button
x <- getTableModal()x <- getTableModal()
User defined selection that selects the style of table to display within the DEBrowser.
getTableStyle( dat = NULL, input = NULL, padj = c("padj"), foldChange = c("foldChange"), DEsection = TRUE )getTableStyle( dat = NULL, input = NULL, padj = c("padj"), foldChange = c("foldChange"), DEsection = TRUE )
dat |
dataset |
input |
input params |
padj |
the name of the padj value column in the dataset |
foldChange |
the name of the foldChange column in the dataset |
DEsection |
if it is in DESection or not |
A 'DT::datatable' HTML widget with row colouring driven by the supplied padj / log2FoldChange thresholds.
getTableStyle
x <- getTableStyle()x <- getTableStyle()
Returns a '<script>' tag that installs a Shiny custom-message handler for type "debrowser-progress". The handler decorates wizard progress icons ('.de-progress-icon[data-progress-key=...]') and parent pills ('a[data-progress-pill=...]') with done/locked/skipped CSS classes. Producer side: 'update_progress(session, key, state)' in R/de_progress.R.
getTabUpdateJS()getTabUpdateJS()
Name retained for export-compatibility; historically this tag drove wizard tab updates, but progressive reveal moved to server-side observers in B1 and progress decoration is the current responsibility.
a '<script>' tag with the custom-message handler installed.
x <- getTabUpdateJS()x <- getTabUpdateJS()
getUp get up regulated data
getUp(filt_data = NULL)getUp(filt_data = NULL)
filt_data |
filt_data |
data
x <- getUp()x <- getUp()
getUpDown get up+down regulated data
getUpDown(filt_data = NULL)getUpDown(filt_data = NULL)
filt_data |
filt_data |
data
x <- getUpDown()x <- getUpDown()
Adds an id to the data frame being used.
getVariationData(inputdata = NULL, cols = NULL, conds = NULL, key = NULL)getVariationData(inputdata = NULL, cols = NULL, conds = NULL, key = NULL)
inputdata |
dataset |
cols |
columns |
conds |
conditions |
key |
gene or region name |
plotdata
x <- getVariationData()x <- getVariationData()
Thin wrapper around fgsea::gmtPathways() that adds an explicit
file-existence check (raising classed de_error) and a
require_pkg("fgsea") gate so callers without 'fgsea' installed
see a friendly install message rather than a stack trace.
gmt_to_pathways(path)gmt_to_pathways(path)
path |
Path to a '.gmt' file (tab-separated, columns: name, url, gene1, gene2, ...). |
Named list, names = pathway names, elements = character vectors of gene symbols (or whatever ID the GMT uses).
p <- system.file("extdata", "test-gmt", "hallmark-mini.gmt", package = "debrowser") gmt_to_pathways(p)p <- system.file("extdata", "test-gmt", "hallmark-mini.gmt", package = "debrowser") gmt_to_pathways(p)
Generates the left menu to be used for heatmap plots
heatmapControlsUI(id)heatmapControlsUI(id)
id |
module ID |
HeatmapControls
heatmapControlsUI
x <- heatmapControlsUI("heatmap")x <- heatmapControlsUI("heatmap")
heatmap JS code for selection functionality
heatmapJScode()heatmapJScode()
JS Code
x <- heatmapJScode()x <- heatmapJScode()
Sets up shinyServer to be able to run heatmapServer interactively.
heatmapServer(input, output, session)heatmapServer(input, output, session)
input |
input params from UI |
output |
output params to UI |
session |
session variable |
the panel for main plots;
heatmapServer
heatmapServerheatmapServer
Creates a shinyUI to be able to run DEBrowser interactively.
heatmapUI(input, output, session)heatmapUI(input, output, session)
input |
input variables |
output |
output objects |
session |
session |
the panel for heatmapUI;
heatmapUI
shiny::shinyApp(ui = heatmapUI, server = function(input, output) {})shiny::shinyApp(ui = heatmapUI, server = function(input, output) {})
Hides a shiny object.
hideObj(btns = NULL)hideObj(btns = NULL)
btns |
hide group of objects with shinyjs |
invisible(NULL); called for the side effect of calling 'shinyjs::hide()' on each supplied id.
x <- hideObj()x <- hideObj()
Generates the controls in the left menu for a histogram
histogramControlsUI(id)histogramControlsUI(id)
id |
namespace id |
returns the left menu
histogramControlsUI
x <- histogramControlsUI("histogram")x <- histogramControlsUI("histogram")
Two observers are installed on the supplied session: (1) a click on the 'cutoff_preset' radio group fills the two numeric inputs with that preset's values; (2) a manual edit on either numeric input clears the preset highlight if the resulting (padj, log2fc) pair no longer matches any preset (or selects the matching preset if it happens to match one exactly).
install_cutoff_preset_observers(input, session)install_cutoff_preset_observers(input, session)
input, session
|
A Shiny input/session pair (either the top-level session for the global widget, or a moduleServer session for the namespaced widget). |
The observers guard against echoing each other via an 'isolate()' + '!identical()' check on the current radio-group selection. Both use 'ignoreInit = TRUE' to avoid the page-load click cascade.
Invisible NULL; observers are installed as a side effect.
# Inside a Shiny server function: # install_cutoff_preset_observers(input, session) # The call has side effects (observers) and requires a live # reactive context, so the body is wrapped to skip at example # time but still satisfies BiocCheck's runnable-example rule. if (interactive()) { message("install_cutoff_preset_observers requires a Shiny session") }# Inside a Shiny server function: # install_cutoff_preset_observers(input, session) # The call has side effects (observers) and requires a live # reactive context, so the body is wrapped to skip at example # time but still satisfies BiocCheck's runnable-example rule. if (interactive()) { message("install_cutoff_preset_observers requires a Shiny session") }
Generates the controls in the left menu for an IQR plot#'
IQRPlotControlsUI(id)IQRPlotControlsUI(id)
id |
namespace id |
returns the left menu
IQRPlotControlsUI
x <- IQRPlotControlsUI("IQR")x <- IQRPlotControlsUI("IQR")
get kmeans controls
kmeansControlsUI(id)kmeansControlsUI(id)
id |
module ID |
controls
kmeansControlsUI
x <- kmeansControlsUI("heatmap")x <- kmeansControlsUI("heatmap")
Radio buttons for low count removal methods
lcfMetRadio(id)lcfMetRadio(id)
id |
namespace id |
radio control
lcfMetRadio
x <- lcfMetRadio("lcf")x <- lcfMetRadio("lcf")
Computes column sums (sequencing depth) for a count matrix, optionally annotates each sample with a group label from a metadata data.frame, and flags outliers using a 2-sigma rule on the depth values.
library_depth_summary(counts, meta = NULL, group_col = NULL)library_depth_summary(counts, meta = NULL, group_col = NULL)
counts |
Numeric matrix or data.frame (rows = features, cols = samples). |
meta |
Optional data.frame with at least a 'samples' column matching 'colnames(counts)' plus the column named in 'group_col'. If NULL, 'group' is 'NA_character_' for every sample. |
group_col |
Name of the column in 'meta' to use as the group label. Ignored if 'meta' is NULL. |
data.frame with columns 'sample', 'depth', 'group', 'is_outlier_2sd' (one row per sample, ordered as 'colnames(counts)').
m <- matrix(rpois(60, lambda = 10), nrow = 10, dimnames = list(NULL, paste0("s", 1:6))) library_depth_summary(m)m <- matrix(rpois(60, lambda = 10), nrow = 10, dimnames = list(NULL, paste0("s", 1:6))) library_depth_summary(m)
Calls the provider's models endpoint via ellmer. Returns the user's available model ids on success, or a hardcoded fallback list on failure. Always returns a non-empty character vector.
list_models(provider, api_key = NULL)list_models(provider, api_key = NULL)
provider |
chr(1). "anthropic" | "openai" | "ollama". |
api_key |
chr(1) or NULL. Required for anthropic/openai; NULL for ollama. |
character vector of model ids.
Convert |log2FC| cutoff to fold-change cutoff.
log2fc_to_fold(x)log2fc_to_fold(x)
x |
Numeric |log2FC| cutoff. |
Fold-change cutoff (2^x).
log2fc_to_fold(1) # 2 log2fc_to_fold(2) # 4log2fc_to_fold(1) # 2 log2fc_to_fold(2) # 4
Generates the left menu to be used for main plots
mainPlotControlsUI(id)mainPlotControlsUI(id)
id |
module ID |
mainPlotControls
mainPlotControlsUI
x <- mainPlotControlsUI("main")x <- mainPlotControlsUI("main")
Creates the main scatter, volcano or MA plot to be displayed within the main panel.
mainScatterNew(input = NULL, data = NULL, cond_names = NULL, source = NULL)mainScatterNew(input = NULL, data = NULL, cond_names = NULL, source = NULL)
input |
input params |
data |
dataframe that has log2FoldChange and log10padj values |
cond_names |
condition names |
source |
for event triggering to select genes |
scatter, volcano or MA plot
x <- mainScatterNew()x <- mainScatterNew()
Used as a fallback when the user uploads counts without metadata. Downstream condSelect's existing "need >=2 conditions" validation will surface the requirement when the user proceeds – no new validation is added here.
make_default_metadata(counts)make_default_metadata(counts)
counts |
data frame whose column names are the sample IDs. |
data frame with columns 'Sample', 'Condition', 'Batch'.
counts <- data.frame(S1 = c(100, 40), S2 = c(200, 60), S3 = c(150, 55)) rownames(counts) <- c("GeneA", "GeneB") make_default_metadata(counts)counts <- data.frame(S1 = c(100, 40), S2 = c(200, 60), S3 = c(150, 55)) rownames(counts) <- c("GeneA", "GeneB") make_default_metadata(counts)
Uses a small numeric tolerance because numericInput round-trips floats via JSON and exact equality occasionally fails.
match_preset(padj, log2fc, tol = 1e-09)match_preset(padj, log2fc, tol = 1e-09)
padj, log2fc
|
Numeric scalars from the cutoff inputs. |
tol |
Match tolerance. |
Character scalar ("strict" | "standard") or NA_character_ if either input is invalid or no preset matches.
match_preset(0.01, 1) # "strict" match_preset(0.05, 1) # "standard" match_preset(0.10, 1) # NA_character_match_preset(0.01, 1) # "strict" match_preset(0.05, 1) # "standard" match_preset(0.10, 1) # NA_character_
Pure version of 'getMergedComparison()'. The legacy version reads 'input$norm_method'; this takes the same value off 'params'.
merge_comparisons(dc, nc, params = list())merge_comparisons(dc, nc, params = list())
dc |
List of per-comparison containers (each has 'init_data', 'cols', 'cond_names'). |
nc |
Number of comparisons. |
params |
Named list with 'norm_method'. |
Merged data.frame (samples + per-comparison foldChange/padj cols).
init1 <- data.frame( S1 = c(100L, 40L), S2 = c(200L, 60L), S3 = c(10L, 150L), S4 = c(12L, 160L), foldChange = c(10, 0.25), padj = c(0.01, 0.01), row.names = c("GeneA", "GeneB") ) dc <- list(list( init_data = init1, cols = c("S1", "S2", "S3", "S4"), cond_names = c("Treat", "Ctrl") )) merge_comparisons(dc, nc = 1, params = list(norm_method = "none"))init1 <- data.frame( S1 = c(100L, 40L), S2 = c(200L, 60L), S3 = c(10L, 150L), S4 = c(12L, 160L), foldChange = c(10, 0.25), padj = c(0.01, 0.01), row.names = c("GeneA", "GeneB") ) dc <- list(list( init_data = init1, cols = c("S1", "S2", "S3", "S4"), cond_names = c("Treat", "Ctrl") )) merge_comparisons(dc, nc = 1, params = list(norm_method = "none"))
Joins the non-NA per-step sentences from [methods_sentences()] into a single paragraph (~150-250 words for typical sessions). Embeds inline citations from '.method_refs' and version stamps via [.pkg_version_or_unknown()]. Used by 'emit_r_script()' (header comment), ‘emit_rmd()' (Methods section), and the Export menu’s "Copy methods text" modal.
methods_paragraph(blocks)methods_paragraph(blocks)
blocks |
Output of [build_session_blocks()]. |
character(1). A single paragraph; no embedded newlines.
Wraps msigdbr::msigdbr() and reshapes the long-format result
into the same named-list-of-character-vectors shape that
gmt_to_pathways returns, so the rest of the Enrichment
tab is source-agnostic. msigdbr is in Suggests; the
require_pkg("msigdbr") gate produces a friendly install prompt
for users without it.
msigdb_pathways( species = "Homo sapiens", collection = "H", subcollection = NULL )msigdb_pathways( species = "Homo sapiens", collection = "H", subcollection = NULL )
species |
Character; an MSigDB-supported species name (see
|
collection |
Character; the top-level MSigDB collection code
(e.g. |
subcollection |
Optional character; the subcollection code (e.g.
|
Pathway names use the canonical gs_name (e.g.
HALLMARK_HYPOXIA). Genes use the human-readable
gene_symbol column.
Named list – names are pathway names, elements are character
vectors of gene symbols. Empty list with a classed
empty_input error if msigdbr returns no rows for the given
species/collection/subcollection combination.
p <- msigdb_pathways("Homo sapiens", "H") length(p) # 50 (Hallmark) head(p[["HALLMARK_HYPOXIA"]])p <- msigdb_pathways("Homo sapiens", "H") length(p) # 50 (Hallmark) head(p[["HALLMARK_HYPOXIA"]])
Identifies mitochondrial-genome rows by matching 'rownames(counts)' against a curated list of MT gene symbols across the common naming conventions: human HGNC ('MT-ND1', 'MT-CO1'), mouse MGI ('mt-Nd1', 'mt-Co1'), the dash-stripped Ensembl-style variants ('MTND1', 'mtNd1'), and the prefix-stripped suffixes ('ND1', 'Nd1'). Avoids false positives like 'Mtor', 'Mthfr', 'Atp6v0a1' by anchoring to the exact suffix set.
mt_pct_per_sample(counts, pattern = NULL)mt_pct_per_sample(counts, pattern = NULL)
counts |
Numeric matrix or data.frame (rows = features, cols = samples). |
pattern |
Optional regex to override the default matcher. If NULL (the default), the curated MT symbol list is used. |
Returns each sample's mitochondrial count, total count, and MT percentage.
data.frame with columns 'sample', 'mt_count', 'total', 'mt_pct'. Zero rows if no rownames match.
m <- matrix(c(1, 2, 0, 4, 5, 0), nrow = 3, dimnames = list(c("MT-ND1", "ACTB", "GAPDH"), c("a", "b"))) mt_pct_per_sample(m) # mouse MGI (with or without the dash) also matches: m2 <- matrix(c(3, 0, 7, 0), nrow = 2, dimnames = list(c("mt-Nd1", "Actb"), c("a", "b"))) mt_pct_per_sample(m2)m <- matrix(c(1, 2, 0, 4, 5, 0), nrow = 3, dimnames = list(c("MT-ND1", "ACTB", "GAPDH"), c("a", "b"))) mt_pct_per_sample(m) # mouse MGI (with or without the dash) also matches: m2 <- matrix(c(3, 0, 7, 0), nrow = 2, dimnames = list(c("mt-Nd1", "Actb"), c("a", "b"))) mt_pct_per_sample(m2)
Used by enrichmentNesHeatmapServer to render a tile plot
of NES across pathways (rows) by comparisons (columns).
nes_heatmap_data(results_by_comparison, sig_only = FALSE, sig_threshold = 0.05)nes_heatmap_data(results_by_comparison, sig_only = FALSE, sig_threshold = 0.05)
results_by_comparison |
Named list of |
sig_only |
Logical; if TRUE, retain only pathways significant in at least one comparison. |
sig_threshold |
padj cutoff used when 'sig_only = TRUE'. |
data.frame with columns 'pathway', 'comparison', 'NES', 'padj'.
nes_heatmap_data(list(c1 = run_gsea(de1, paths), c2 = run_gsea(de2, paths)))nes_heatmap_data(list(c1 = run_gsea(de1, paths), c2 = run_gsea(de2, paths)))
Generates hierarchially clustered K-means clusters
niceKmeans(df = NULL, input = NULL, iter.max = 1000, nstart = 100)niceKmeans(df = NULL, input = NULL, iter.max = 1000, nstart = 100)
df |
data |
input |
user inputs |
iter.max |
max iteration for kmeans clustering |
nstart |
n for kmeans clustering |
heatmap plot area
niceKmeans
x <- niceKmeans()x <- niceKmeans()
Select box to select normalization method prior to batch effect correction
normalizationMethods(id)normalizationMethods(id)
id |
namespace id |
radio control
normalizationMethods
x <- normalizationMethods("batch")x <- normalizationMethods("batch")
Pure function: takes a numeric matrix, returns a normalized numeric matrix. Wraps 'edgeR::calcNormFactors' + 'edgeR::equalizeLibSizes' for TMM/RLE/upper-quartile, DESeq2's median-of-ratios for '"MRN"', identity for '"none"'.
normalize_counts(counts, method = "TMM")normalize_counts(counts, method = "TMM")
counts |
Numeric matrix or data.frame (genes x samples). |
method |
One of "TMM", "RLE", "upperquartile", "MRN", "none". |
Normalized numeric matrix with the same shape and dimnames.
m <- matrix(as.integer(c(100, 200, 150, 80, 250, 130, 40, 60, 55, 30, 70, 45)), nrow = 2, byrow = TRUE) colnames(m) <- paste0("S", 1:6) rownames(m) <- c("Gene1", "Gene2") normalize_counts(m, method = "TMM")m <- matrix(as.integer(c(100, 200, 150, 80, 250, 130, 40, 60, 55, 30, 70, 45)), nrow = 2, byrow = TRUE) colnames(m) <- paste0("S", 1:6) rownames(m) <- c("Gene1", "Gene2") normalize_counts(m, method = "TMM")
get pallete
palUI(id)palUI(id)
id |
namespace ID |
pals
palUI
x <- palUI("heatmap")x <- palUI("heatmap")
Prepares the correlations for the all2all plot.
panel.cor(x, y, prefix = "rho=", cex.cor = 2, ...)panel.cor(x, y, prefix = "rho=", cex.cor = 2, ...)
x |
numeric vector x |
y |
numeric vector y |
prefix |
prefix for the text |
cex.cor |
correlation font size |
... |
additional parameters |
all2all correlation plots
panel.cor(c(1, 2, 3), c(4, 5, 6))panel.cor(c(1, 2, 3), c(4, 5, 6))
Prepares the historgram for the all2all plot.
panel.hist(x, ...)panel.hist(x, ...)
x |
a vector of values for which the histogram is desired |
... |
any additional params |
all2all histogram plots
panel.hist(1)panel.hist(1)
Generates the PCA PLots Left menu to be displayed within the DEBrowser.
pcaPlotControlsUI(id = "pca")pcaPlotControlsUI(id = "pca")
id |
namespace id |
returns the left menu according to the selected tab;
pcaPlotControlsUI
x <- pcaPlotControlsUI("pca")x <- pcaPlotControlsUI("pca")
Up bars (red) extend right; down bars (blue) extend left from the zero line. Comparisons are ordered top-to-bottom by total DEG count.
plot_de_direction_bar(summary, subtitle = NULL)plot_de_direction_bar(summary, subtitle = NULL)
summary |
data.frame as returned by [de_direction_summary()]; must contain 'comparison', 'n_up', 'n_down', 'n_sig'. |
subtitle |
Optional subtitle (typically a cutoff label like "Threshold: padj <= 0.05"). |
ggplot object.
summary <- data.frame( comparison = c("Treat vs Ctrl", "Drug vs Vehicle"), n_up = c(120L, 45L), n_down = c(80L, 30L), n_sig = c(200L, 75L), stringsAsFactors = FALSE ) plot_de_direction_bar(summary, subtitle = "padj <= 0.05")summary <- data.frame( comparison = c("Treat vs Ctrl", "Drug vs Vehicle"), n_up = c(120L, 45L), n_down = c(80L, 30L), n_sig = c(200L, 75L), stringsAsFactors = FALSE ) plot_de_direction_bar(summary, subtitle = "padj <= 0.05")
Builds a 'groups x groups' symmetric matrix (diagonal NA) where each off-diagonal cell shows the number of significant DEGs in the comparison between those two groups. Group identities come from 'cond_names' of 'comparisons'; sig counts come from 'summary', matched on 'comparison_labels(comparisons)'. When the same group pair appears in multiple comparisons, the last seen wins.
plot_de_pairwise_heatmap(summary, comparisons, subtitle = NULL)plot_de_pairwise_heatmap(summary, comparisons, subtitle = NULL)
summary |
data.frame as returned by [de_direction_summary()]. |
comparisons |
List of comparison spec/dc-style entries with 'cond_names' (treatment, control) used as group labels. Length and order should mirror the 'de_list' that produced 'summary'. |
subtitle |
Optional subtitle (typically a cutoff label). |
ggplot object.
summary_df <- data.frame( comparison = c("Treat vs Ctrl", "Drug vs Vehicle"), n_up = c(120L, 45L), n_down = c(80L, 30L), n_sig = c(200L, 75L), stringsAsFactors = FALSE ) comparisons <- list( list(cond_names = c("Treat", "Ctrl")), list(cond_names = c("Drug", "Vehicle")) ) plot_de_pairwise_heatmap(summary_df, comparisons)summary_df <- data.frame( comparison = c("Treat vs Ctrl", "Drug vs Vehicle"), n_up = c(120L, 45L), n_down = c(80L, 30L), n_sig = c(200L, 75L), stringsAsFactors = FALSE ) comparisons <- list( list(cond_names = c("Treat", "Ctrl")), list(cond_names = c("Drug", "Vehicle")) ) plot_de_pairwise_heatmap(summary_df, comparisons)
Joins the two per-entry tables on gene ID and renders a scatter of log2FoldChange (id1 on x, id2 on y). Spearman rho appears in the subtitle. The y=x reference line is drawn dashed.
plot_method_scatter(de_list, id1, id2)plot_method_scatter(de_list, id1, id2)
de_list |
Named list of DE result data.frames (each with at minimum 'ID' and 'log2FoldChange' columns). |
id1, id2
|
Names present in 'names(de_list)' to put on x and y. |
Generic across "DE list dimensions": entries can be DE methods on the same comparison, OR comparisons on the same method, OR any other axis as long as each named entry contains a 'data.frame(ID, log2FoldChange, ...)'.
ggplot object.
de_list <- list( EdgeR = data.frame(ID = paste0("G", 1:5), log2FoldChange = c(2, -1, 0, 3, -2), padj = c(0.01, 0.04, 0.5, 0.02, 0.03)), Limma = data.frame(ID = paste0("G", 1:5), log2FoldChange = c(1.8, -0.9, 0.1, 2.5, -1.8), padj = c(0.02, 0.03, 0.6, 0.01, 0.04)) ) plot_method_scatter(de_list, id1 = "EdgeR", id2 = "Limma")de_list <- list( EdgeR = data.frame(ID = paste0("G", 1:5), log2FoldChange = c(2, -1, 0, 3, -2), padj = c(0.01, 0.04, 0.5, 0.02, 0.03)), Limma = data.frame(ID = paste0("G", 1:5), log2FoldChange = c(1.8, -0.9, 0.1, 2.5, -1.8), padj = c(0.02, 0.03, 0.6, 0.01, 0.04)) ) plot_method_scatter(de_list, id1 = "EdgeR", id2 = "Limma")
Gated by 'require_pkg("UpSetR")'. Returns the 'UpSetR::upset()' object – caller (renderPlot) is responsible for printing.
plot_method_upset(de_list, padj_cutoff = 0.05, lfc_cutoff = 0)plot_method_upset(de_list, padj_cutoff = 0.05, lfc_cutoff = 0)
de_list |
Output of [run_de_methods()]. |
padj_cutoff |
Maximum padj for "significant" (default 0.05). |
lfc_cutoff |
Minimum |log2FoldChange| for "significant" (default 0; pass 0.585 for |fold|>=1.5, 1 for |fold|>=2). |
Result of 'UpSetR::upset()' (a list with class '"upset"'). When fewer than 2 methods produce non-empty sets, returns NULL (caller should render an empty-state instead).
if (requireNamespace("UpSetR", quietly = TRUE)) { de_list <- list( EdgeR = data.frame(ID = paste0("G", 1:5), log2FoldChange = c(2, -1, 0, 3, -2), padj = c(0.01, 0.04, 0.5, 0.02, 0.03)), Limma = data.frame(ID = paste0("G", 1:5), log2FoldChange = c(1.8, -0.9, 0.1, 2.5, -1.8), padj = c(0.02, 0.03, 0.6, 0.01, 0.04)) ) plot_method_upset(de_list) }if (requireNamespace("UpSetR", quietly = TRUE)) { de_list <- list( EdgeR = data.frame(ID = paste0("G", 1:5), log2FoldChange = c(2, -1, 0, 3, -2), padj = c(0.01, 0.04, 0.5, 0.02, 0.03)), Limma = data.frame(ID = paste0("G", 1:5), log2FoldChange = c(1.8, -0.9, 0.1, 2.5, -1.8), padj = c(0.02, 0.03, 0.6, 0.01, 0.04)) ) plot_method_upset(de_list) }
Plots the PCA results for the selected dataset.
plot_pca( dat = NULL, pcx = 1, pcy = 2, metadata = NULL, color = NULL, shape = NULL, size = NULL, textonoff = "On", legendSelect = "samples", input = NULL )plot_pca( dat = NULL, pcx = 1, pcy = 2, metadata = NULL, color = NULL, shape = NULL, size = NULL, textonoff = "On", legendSelect = "samples", input = NULL )
dat |
data |
pcx |
x axis label |
pcy |
y axis label |
metadata |
additional data |
color |
color for plot |
shape |
shape for plot |
size |
size of the plot |
textonoff |
text on off |
legendSelect |
select legend |
input |
input param |
pca list
load(system.file("extdata", "demo", "demodata.Rda", package = "debrowser" )) metadata <- cbind( colnames(demodata[, seq_len(6L)]), colnames(demodata[, seq_len(6L)]), c(rep("Cond1", 3), rep("Cond2", 3)) ) colnames(metadata) <- c("samples", "color", "shape") a <- plot_pca( getNormalizedMatrix( demodata[rowSums(demodata[, seq_len(6L)]) > 10, seq_len(6L)] ), metadata = metadata, color = "samples", size = 5, shape = "shape" )load(system.file("extdata", "demo", "demodata.Rda", package = "debrowser" )) metadata <- cbind( colnames(demodata[, seq_len(6L)]), colnames(demodata[, seq_len(6L)]), c(rep("Cond1", 3), rep("Cond2", 3)) ) colnames(metadata) <- c("samples", "color", "shape") a <- plot_pca( getNormalizedMatrix( demodata[rowSums(demodata[, seq_len(6L)]) > 10, seq_len(6L)] ), metadata = metadata, color = "samples", size = 5, shape = "shape" )
prepare plot data for mainplots
plotData(pdata = NULL, input = NULL)plotData(pdata = NULL, input = NULL)
pdata |
data |
input |
input |
prepdata
plotData
x <- plotData()x <- plotData()
Margins module for plotly plots
plotMarginsUI(id, t = 20, b = 100, l = 100, r = 20)plotMarginsUI(id, t = 20, b = 100, l = 100, r = 20)
id |
id |
t |
top margin |
b |
bottom margin |
l |
left margin |
r |
right margin |
size and margins controls
plotMarginsUI
x <- plotMarginsUI("heatmap")x <- plotMarginsUI("heatmap")
Size and margins module for plotly plots
plotSizeMarginsUI(id, w = 800, h = 640, t = 20, b = 100, l = 100, r = 20)plotSizeMarginsUI(id, w = 800, h = 640, t = 20, b = 100, l = 100, r = 20)
id |
id |
w |
width |
h |
height |
t |
top margin |
b |
bottom margin |
l |
left margin |
r |
right margin |
size and margins controls
plotSizeMarginsUI
x <- plotSizeMarginsUI("heatmap")x <- plotSizeMarginsUI("heatmap")
Size module for plotly plots
plotSizeUI(id, w = 800, h = 600)plotSizeUI(id, w = 800, h = 600)
id |
id |
w |
width |
h |
height |
size and margins controls
plotSizeUI
x <- plotSizeUI("heatmap")x <- plotSizeUI("heatmap")
Plot download type
plotTypeUI(id)plotTypeUI(id)
id |
id |
size and margins controls
plotTypeUI
x <- plotTypeUI("heatmap")x <- plotTypeUI("heatmap")
Run DE per comparison and return the downstream 'dclist' payload.
prepDataContainer(data, metadata, comparisons_spec)prepDataContainer(data, metadata, comparisons_spec)
data |
count matrix (rows = features, cols = samples). |
metadata |
sample-metadata data.frame; first column is the sample id. |
comparisons_spec |
list of per-comparison spec lists with components 'treatment_samples', 'control_samples', 'treatment_label', 'control_label', 'de_method', 'method_params', 'covariates', 'meta_column' (NA_character_ when manual mode). |
list of length 'length(comparisons_spec)' with components 'conds', 'cols', 'cond_names', 'init_data', 'demethod_params', 'dds' per comparison. 'dds' is the fitted 'DESeqDataSet' for DESeq2 runs and NULL for edgeR/limma. Returns NULL if no comparison produced usable results.
set.seed(42) counts <- matrix( as.integer(abs(rnorm(60, mean = 100, sd = 30))), nrow = 10, ncol = 6, dimnames = list(paste0("G", 1:10), paste0("S", 1:6)) ) meta <- data.frame( Sample = paste0("S", 1:6), Condition = c(rep("Ctrl", 3), rep("Treat", 3)), stringsAsFactors = FALSE ) spec <- list(list( treatment_samples = paste0("S", 4:6), control_samples = paste0("S", 1:3), treatment_label = "Treat", control_label = "Ctrl", de_method = "EdgeR", method_params = list( edgeR_normfact = "TMM", dispersion = "0", edgeR_testType = "exactTest" ), covariates = character(0), meta_column = NA_character_ )) ## prepDataContainer must run inside a Shiny session ## (delegates to a moduleServer-based DE analysis module). prepDataContainer(counts, meta, spec)set.seed(42) counts <- matrix( as.integer(abs(rnorm(60, mean = 100, sd = 30))), nrow = 10, ncol = 6, dimnames = list(paste0("G", 1:10), paste0("S", 1:6)) ) meta <- data.frame( Sample = paste0("S", 1:6), Condition = c(rep("Ctrl", 3), rep("Treat", 3)), stringsAsFactors = FALSE ) spec <- list(list( treatment_samples = paste0("S", 4:6), control_samples = paste0("S", 1:3), treatment_label = "Treat", control_label = "Ctrl", de_method = "EdgeR", method_params = list( edgeR_normfact = "TMM", dispersion = "0", edgeR_testType = "exactTest" ), covariates = character(0), meta_column = NA_character_ )) ## prepDataContainer must run inside a Shiny session ## (delegates to a moduleServer-based DE analysis module). prepDataContainer(counts, meta, spec)
prepare group table
prepGroup(conds = NULL, cols = NULL, metadata = NULL, covariates = NULL)prepGroup(conds = NULL, cols = NULL, metadata = NULL, covariates = NULL)
conds |
inputconds |
cols |
columns |
metadata |
metadata |
covariates |
covariates |
data
x <- prepGroup()x <- prepGroup()
scales the data
prepHeatData(expdata = NULL, input = NULL)prepHeatData(expdata = NULL, input = NULL)
expdata |
a matrixthat includes expression values |
input |
input variables |
heatdata
x <- prepHeatData()x <- prepHeatData()
prepares pca data with metadata. If metadata doesn't exists it puts all the sampels into a signlge group; "Conds".
prepPCADat(pca_data = NULL, metadata = NULL, input = NULL, pcx = 1, pcy = 2)prepPCADat(pca_data = NULL, metadata = NULL, input = NULL, pcx = 1, pcy = 2)
pca_data |
pca run results |
metadata |
additional meta data |
input |
input |
pcx |
x axis label |
pcy |
y axis label |
Color and shape from selection boxes or defaults
x <- prepPCADat()x <- prepPCADat()
Build a named list payload for the "debrowser-progress" custom message.
progress_message(key, state)progress_message(key, state)
key |
character, progress key (e.g. "upload", "filter", "data_prep"). |
state |
character, one of "pending", "done", "locked", "skipped", or "" (empty clears the icon). |
named list with elements 'key' and 'state'.
progress_message("upload", "done")progress_message("upload", "done")
Push an object to the list.
push(l, ...)push(l, ...)
l |
that are going to push to the list |
... |
list object |
combined list
mylist <- list() newlist <- push(1, mylist)mylist <- list() newlist <- push(1, mylist)
Mirrors the QC sidebar's column-selector contract: NULL 'selected'
(the pre-render state) returns 'counts' unchanged; otherwise keeps
only the columns whose name is in 'selected'. Empty intersection
returns a zero-column matrix (matches getSelectedCols on an
empty selection).
qc_keep_cols(counts, selected = NULL)qc_keep_cols(counts, selected = NULL)
counts |
Numeric matrix or data.frame, or NULL. |
selected |
Character vector of sample names to keep, or NULL. |
The subset matrix (or 'counts' unchanged if 'selected' is NULL); NULL passes through.
m <- matrix(1:6, nrow = 2, dimnames = list(NULL, c("a", "b", "c"))) qc_keep_cols(m, c("a", "c")) qc_keep_cols(m, NULL) # unchangedm <- matrix(1:6, nrow = 2, dimnames = list(NULL, c("a", "b", "c"))) qc_keep_cols(m, c("a", "c")) qc_keep_cols(m, NULL) # unchanged
Companion to qc_keep_cols: keeps the rows of 'meta'
whose 'samples' column matches 'selected'. NULL 'selected' returns
'meta' unchanged. NULL 'meta' passes through. If 'meta' has no
'samples' column, returns it unchanged.
qc_keep_meta_rows(meta, selected = NULL)qc_keep_meta_rows(meta, selected = NULL)
meta |
data.frame with a 'samples' column, or NULL. |
selected |
Character vector of sample names to keep, or NULL. |
The subset data.frame, or 'meta' unchanged when there is nothing to do; NULL passes through.
m <- data.frame(samples = c("a", "b", "c"), x = 1:3) qc_keep_meta_rows(m, c("a", "c"))m <- data.frame(samples = c("a", "b", "c"), x = 1:3) qc_keep_meta_rows(m, c("a", "c"))
UI factory for the Cook's-distance outlier-count QC card. The body is a 'uiOutput' so the server can switch between the bar plot and an empty-state alert when no fitted 'DESeqDataSet' is available.
qcCooksUI(id)qcCooksUI(id)
id |
character, namespace id |
a 'bslib::card' tagList
qcCooksUI("cooks")qcCooksUI("cooks")
UI factory for the feature-detection-rate QC card. Renders a 'de_card' containing a 'plotly' bar of detection percentage per sample plus a one-line caption.
qcDetectionRateUI(id)qcDetectionRateUI(id)
id |
character, namespace id |
a 'bslib::card' tagList
qcDetectionRateUI("detectionRate")qcDetectionRateUI("detectionRate")
UI factory for the DESeq2 dispersion-estimates QC card. The body is a 'uiOutput' so the server can switch between the base-R dispersion plot and an empty-state alert when no fitted 'DESeqDataSet' is available.
qcDispersionUI(id)qcDispersionUI(id)
id |
character, namespace id |
a 'bslib::card' tagList
qcDispersionUI("dispersion")qcDispersionUI("dispersion")
UI factory for the library-depth QC card. Renders a 'de_card' containing a 'plotly' bar of total counts per sample (with a CSV download button) and a one-line caption explaining the 2-SD outlier flag.
qcLibraryDepthUI(id)qcLibraryDepthUI(id)
id |
character, namespace id |
a 'bslib::card' tagList
qcLibraryDepthUI("libraryDepth")qcLibraryDepthUI("libraryDepth")
UI factory for the mitochondrial-percentage QC card. The body is a 'uiOutput' so the server can switch between a plot and an empty-state alert when no MT genes are detected.
qcMtPctUI(id)qcMtPctUI(id)
id |
character, namespace id |
a 'bslib::card' tagList
qcMtPctUI("mtPct")qcMtPctUI("mtPct")
UI factory for the sample-distance QC card. Renders a 'de_card' containing a 'heatmaply' heatmap and a caption explaining the distance metric.
qcSampleDistUI(id)qcSampleDistUI(id)
id |
character, namespace id |
a 'bslib::card' tagList
qcSampleDistUI("sampleDist")qcSampleDistUI("sampleDist")
UI factory for the size-factors-vs-library-size QC card. The body is a 'uiOutput' so the server can render the comparison plot or an empty-state alert when no fitted 'DESeqDataSet' is available.
qcSizeFactorsUI(id)qcSizeFactorsUI(id)
id |
character, namespace id |
a 'bslib::card' tagList
qcSizeFactorsUI("sizeFactors")qcSizeFactorsUI("sizeFactors")
remove unnecessary columns
removeCols(cols = NULL, dat = NULL)removeCols(cols = NULL, dat = NULL)
cols |
columns that are going to be removed from data frame |
dat |
data |
data
x <- removeCols()x <- removeCols()
remove extra columns for QC plots
removeExtraCols(dat = NULL)removeExtraCols(dat = NULL)
dat |
selected data |
'dat' with QC-extraneous columns (padj/foldChange/Legend/etc.) stripped, leaving only sample columns suitable for plotting.
removeExtraCols()removeExtraCols()
Used to gate features that depend on packages declared in 'Suggests:' rather than 'Imports:'. Raises a 'de_error()' with class '"missing_suggested_pkg"' that names the package and the feature that needs it, plus the install command.
require_pkg(pkg, feature = pkg)require_pkg(pkg, feature = pkg)
pkg |
Package name (single string). |
feature |
Short human description of the feature that requires it (e.g. '"Harman batch correction"'). |
'TRUE' invisibly if available; otherwise raises.
# Returns TRUE invisibly when the package is present: require_pkg("stats", feature = "basic statistics")# Returns TRUE invisibly when the package is present: require_pkg("stats", feature = "basic statistics")
Generates a fresh token + 24h expiry and pushes a new send. Safe to call repeatedly – each call invalidates any previous link.
resend_verification_email(user_id, base_url = NULL)resend_verification_email(user_id, base_url = NULL)
user_id |
Username. |
base_url |
Optional app base URL (used to build the verify link). |
TRUE on success; errors if user is unknown or already verified.
Updates the hashed_pw column for an existing user. Useful when
the password is forgotten and there is no admin UI yet.
reset_debrowser_password(user_id, new_password)reset_debrowser_password(user_id, new_password)
user_id |
Username. |
new_password |
New plaintext password (hashed before storage). |
TRUE on success; errors if the user does not exist.
reset_debrowser_password("alice", "newhunter2!")reset_debrowser_password("alice", "newhunter2!")
Plot PCA results.
round_vals(l)round_vals(l)
l |
the value |
round value
x <- round_vals(5.1323223)x <- round_vals(5.1323223)
Dispatch a DE run by method name.
run_de( method, counts, metadata = NULL, columns = NULL, conds = NULL, params = list(), return_dds = FALSE )run_de( method, counts, metadata = NULL, columns = NULL, conds = NULL, params = list(), return_dds = FALSE )
method |
One of "DESeq2", "EdgeR", "Limma". |
counts |
A numeric count matrix or data.frame (genes x samples). |
metadata |
Sample metadata; first column is sample id. |
columns |
Character vector of sample column names to use. |
conds |
Factor of conditions, length == length(columns). |
params |
Named list with components: covariates (character "|"-joined or "NoCovariate"), fit_type ("parametric"/"local"/"mean"), beta_prior (logical), test_type ("Wald"/"LRT"), shrinkage ("None"/"apeglm"/"ashr"/"normal"). |
return_dds |
Logical. Forwarded to [run_deseq2()] for the DESeq2 branch; ignored for edgeR/limma. When TRUE for DESeq2 the function returns 'list(res, dds)'; for non-DESeq2 methods the standard per-method result object is wrapped to 'list(res = <obj>, dds = NULL)' so downstream code can pattern-match a single shape. |
Method-specific result object.
set.seed(42) counts <- matrix( as.integer(abs(rnorm(60, mean = 100, sd = 30))), nrow = 10, ncol = 6, dimnames = list(paste0("G", 1:10), paste0("S", 1:6)) ) conds <- c("Cond1", "Cond1", "Cond1", "Cond2", "Cond2", "Cond2") run_de("EdgeR", counts, columns = colnames(counts), conds = conds)set.seed(42) counts <- matrix( as.integer(abs(rnorm(60, mean = 100, sd = 30))), nrow = 10, ncol = 6, dimnames = list(paste0("G", 1:10), paste0("S", 1:6)) ) conds <- c("Cond1", "Cond1", "Cond1", "Cond2", "Cond2", "Cond2") run_de("EdgeR", counts, columns = colnames(counts), conds = conds)
Wraps [run_de()] for each requested method and returns a named list of per-method result data.frames keyed by 'methods'. The returned frames are normalized to a common shape: 'data.frame(ID, log2FoldChange, padj, pvalue, stat)' so downstream helpers can join by 'ID' without per-method special-casing.
run_de_methods( counts, metadata = NULL, columns = NULL, conds = NULL, methods = c("DESeq2", "EdgeR", "Limma"), params_per_method = list() )run_de_methods( counts, metadata = NULL, columns = NULL, conds = NULL, methods = c("DESeq2", "EdgeR", "Limma"), params_per_method = list() )
counts |
Numeric count matrix or data.frame (genes x samples). |
metadata |
Sample metadata data.frame. |
columns |
Character vector of sample column names to use. |
conds |
Factor of conditions, length == length(columns). |
methods |
Character vector of method names; subset of 'c("DESeq2", "EdgeR", "Limma")'. Default all three. |
params_per_method |
Optional named list keyed by method name whose values are the per-method 'params' list passed to [run_de()]. Missing methods get an empty list (defaults take over inside the per-method runner). |
DESeq2's native return is a 'DESeqResults' object – coerced via 'as.data.frame()'. edgeR / limma already return data.frames.
Named list of per-method data.frames with columns ID, log2FoldChange, padj, pvalue, stat. 'length()' equals 'length(methods)'. Methods that error out are dropped from the returned list and a warning is signalled (not an error) so partial results remain usable.
set.seed(42) counts <- matrix( as.integer(abs(rnorm(60, mean = 100, sd = 30))), nrow = 10, ncol = 6, dimnames = list(paste0("G", 1:10), paste0("S", 1:6)) ) conds <- c("Cond1", "Cond1", "Cond1", "Cond2", "Cond2", "Cond2") run_de_methods(counts, columns = colnames(counts), conds = conds, methods = c("EdgeR", "Limma"))set.seed(42) counts <- matrix( as.integer(abs(rnorm(60, mean = 100, sd = 30))), nrow = 10, ncol = 6, dimnames = list(paste0("G", 1:10), paste0("S", 1:6)) ) conds <- c("Cond1", "Cond1", "Cond1", "Cond2", "Cond2", "Cond2") run_de_methods(counts, columns = colnames(counts), conds = conds, methods = c("EdgeR", "Limma"))
Pure function: takes plain R objects, returns a 'DESeqResults' object. No Shiny dependency. Errors are raised via [de_error()] with classes: - 'too_few_columns' - 'null_input'
run_deseq2( counts, metadata = NULL, columns = NULL, conds = NULL, params = list(), return_dds = FALSE )run_deseq2( counts, metadata = NULL, columns = NULL, conds = NULL, params = list(), return_dds = FALSE )
counts |
A numeric count matrix or data.frame (genes x samples). |
metadata |
Sample metadata; first column is sample id. |
columns |
Character vector of sample column names to use. |
conds |
Factor of conditions, length == length(columns). |
params |
Named list with components: covariates (character "|"-joined or "NoCovariate"), fit_type ("parametric"/"local"/"mean"), beta_prior (logical), test_type ("Wald"/"LRT"), shrinkage ("None"/"apeglm"/"ashr"/"normal"). |
return_dds |
Logical. If TRUE, return a list with components 'res' (DESeqResults) and 'dds' (the fitted DESeqDataSet), so downstream QC cards (Dispersion / SizeFactors / Cook's) can introspect the fit. Default FALSE preserves the legacy data.frame-shaped contract. |
DESeqResults if 'return_dds = FALSE'; otherwise 'list(res = DESeqResults, dds = DESeqDataSet)'.
set.seed(42) counts <- matrix( as.integer(abs(rnorm(60, mean = 100, sd = 30))), nrow = 10, ncol = 6, dimnames = list(paste0("G", 1:10), paste0("S", 1:6)) ) conds <- c("Cond1", "Cond1", "Cond1", "Cond2", "Cond2", "Cond2") run_deseq2(counts, columns = colnames(counts), conds = conds, params = list(test_type = "Wald", shrinkage = "None"))set.seed(42) counts <- matrix( as.integer(abs(rnorm(60, mean = 100, sd = 30))), nrow = 10, ncol = 6, dimnames = list(paste0("G", 1:10), paste0("S", 1:6)) ) conds <- c("Cond1", "Cond1", "Cond1", "Cond2", "Cond2", "Cond2") run_deseq2(counts, columns = colnames(counts), conds = conds, params = list(test_type = "Wald", shrinkage = "None"))
Run edgeR on a count matrix.
run_edger( counts, metadata = NULL, columns = NULL, conds = NULL, params = list() )run_edger( counts, metadata = NULL, columns = NULL, conds = NULL, params = list() )
counts |
A numeric count matrix or data.frame (genes x samples). |
metadata |
Sample metadata; first column is sample id. |
columns |
Character vector of sample column names to use. |
conds |
Factor of conditions, length == length(columns). |
params |
Named list with components: covariates, norm_fact ("TMM"/"RLE"/"upperquartile"/"none"), dispersion (numeric or character "common"/"trended"/"tagwise"/"auto"), test_type ("exactTest"/"glmLRT"). |
data.frame with columns log2FoldChange, pvalue, padj, stat.
set.seed(42) counts <- matrix( as.integer(abs(rnorm(60, mean = 100, sd = 30))), nrow = 10, ncol = 6, dimnames = list(paste0("G", 1:10), paste0("S", 1:6)) ) conds <- c("Cond1", "Cond1", "Cond1", "Cond2", "Cond2", "Cond2") run_edger(counts, columns = colnames(counts), conds = conds)set.seed(42) counts <- matrix( as.integer(abs(rnorm(60, mean = 100, sd = 30))), nrow = 10, ncol = 6, dimnames = list(paste0("G", 1:10), paste0("S", 1:6)) ) conds <- c("Cond1", "Cond1", "Cond1", "Cond2", "Cond2", "Cond2") run_edger(counts, columns = colnames(counts), conds = conds)
Pure function: takes a DE table (one row per gene with an effect-size column) and a named list of pathways, returns a tidy data.frame of enrichment scores ordered by descending |NES|. No Shiny calls.
run_gsea( de_table, pathways, min_size = 15L, max_size = 500L, n_perm = 1000L, seed = 1L, stat_col = "log2FoldChange", id_col = "gene" )run_gsea( de_table, pathways, min_size = 15L, max_size = 500L, n_perm = 1000L, seed = 1L, stat_col = "log2FoldChange", id_col = "gene" )
de_table |
data.frame with at minimum 'id_col' (gene ID) and 'stat_col' (numeric effect size, e.g. log2 fold change). |
pathways |
Named list, output of |
min_size, max_size
|
Pathway-size filter passed to 'fgsea::fgsea'. |
n_perm |
Permutations for 'fgsea::fgsea' 'nPermSimple' arg. |
seed |
RNG seed for reproducibility. |
stat_col |
Column in 'de_table' providing the ranking statistic. |
id_col |
Column in 'de_table' providing the gene ID matching 'pathways'. |
Symbols in 'de_table[[id_col]]' are matched against the gene IDs in 'pathways' directly – caller is responsible for ID-space consistency (typically both SYMBOL or both ENTREZID).
data.frame with columns 'pathway', 'size', 'NES', 'padj', 'pval', 'leading_edge' (last is a list-column of character vectors), ordered by descending '|NES|'.
p <- gmt_to_pathways(system.file("extdata", "test-gmt", "hallmark-mini.gmt", package = "debrowser")) de <- data.frame(gene = c("PGK1", "PDK1"), log2FoldChange = c(3, 2.5)) run_gsea(de, p)p <- gmt_to_pathways(system.file("extdata", "test-gmt", "hallmark-mini.gmt", package = "debrowser")) de <- data.frame(gene = c("PGK1", "PDK1"), log2FoldChange = c(3, 2.5)) run_gsea(de, p)
Run limma-voom on a count matrix.
run_limma( counts, metadata = NULL, columns = NULL, conds = NULL, params = list() )run_limma( counts, metadata = NULL, columns = NULL, conds = NULL, params = list() )
counts |
A numeric count matrix or data.frame (genes x samples). |
metadata |
Sample metadata; first column is sample id. |
columns |
Character vector of sample column names to use. |
conds |
Factor of conditions, length == length(columns). |
params |
Named list: covariates, norm_fact, fit_type ("ls"/"robust"), norm_bet ("none"/"scale"/"quantile"/...). |
data.frame with columns log2FoldChange, pvalue, padj, stat.
set.seed(42) counts <- matrix( as.integer(abs(rnorm(60, mean = 100, sd = 30))), nrow = 10, ncol = 6, dimnames = list(paste0("G", 1:10), paste0("S", 1:6)) ) conds <- c("Cond1", "Cond1", "Cond1", "Cond2", "Cond2", "Cond2") run_limma(counts, columns = colnames(counts), conds = conds)set.seed(42) counts <- matrix( as.integer(abs(rnorm(60, mean = 100, sd = 30))), nrow = 10, ncol = 6, dimnames = list(paste0("G", 1:10), paste0("S", 1:6)) ) conds <- c("Cond1", "Cond1", "Cond1", "Cond2", "Cond2", "Cond2") run_limma(counts, columns = colnames(counts), conds = conds)
Runs PCA on the selected dataset.
run_pca(x = NULL, retx = TRUE, center = TRUE, scale = TRUE)run_pca(x = NULL, retx = TRUE, center = TRUE, scale = TRUE)
x |
dataframe with experiment data |
retx |
specifies if the data should be returned |
center |
center the PCA (Boolean) |
scale |
scale the PCA (Boolean) |
pca list
load(system.file("extdata", "demo", "demodata.Rda", package = "debrowser" )) pca_data <- run_pca(getNormalizedMatrix( demodata[rowSums(demodata[, seq_len(6L)]) > 10, seq_len(6L)] ))load(system.file("extdata", "demo", "demodata.Rda", package = "debrowser" )) pca_data <- run_pca(getNormalizedMatrix( demodata[rowSums(demodata[, seq_len(6L)]) > 10, seq_len(6L)] ))
Run DE algorithms on the selected parameters. Output is to be used for the interactive display.
runDE( data = NULL, metadata = NULL, columns = NULL, conds = NULL, params = NULL, return_dds = FALSE )runDE( data = NULL, metadata = NULL, columns = NULL, conds = NULL, params = NULL, return_dds = FALSE )
data |
A matrix that includes all the expression raw counts, rownames has to be the gene, isoform or region names/IDs |
metadata |
metadata of the matrix of expression raw counts |
columns |
is a vector that includes the columns that are going to be analyzed. These columns has to match with the given data. |
conds |
experimental conditions. The order has to match with the column order |
params |
all params for the DE methods |
return_dds |
Logical. When TRUE the function returns a list 'list(res, dds)' for DESeq2 (so QC cards can introspect the fit) and 'list(res, dds = NULL)' for edgeR / limma. Default FALSE returns the per-method data.frame as before. |
de results
x <- runDE()x <- runDE()
Run DESeq2 algorithm on the selected conditions. Output is to be used for the interactive display.
runDESeq2( data = NULL, metadata = NULL, columns = NULL, conds = NULL, params = NULL, return_dds = FALSE )runDESeq2( data = NULL, metadata = NULL, columns = NULL, conds = NULL, params = NULL, return_dds = FALSE )
data |
A matrix that includes all the expression raw counts, rownames has to be the gene, isoform or region names/IDs |
metadata |
metadata of the matrix of expression raw counts |
columns |
is a vector that includes the columns that are going to be analyzed. These columns has to match with the given data. |
conds |
experimental conditions. The order has to match with the column order |
params |
fitType: either "parametric", "local", or "mean" for the type of fitting of dispersions to the mean intensity. See estimateDispersions for description. betaPrior: whether or not to put a zero-mean normal prior on the non-intercept coefficients See nbinomWaldTest for description of the calculation of the beta prior. By default, the beta prior is used only for the Wald test, but can also be specified for the likelihood ratio test. testType: either "Wald" or "LRT", which will then use either Wald significance tests (defined by nbinomWaldTest), or the likelihood ratio test on the difference in deviance between a full and reduced model formula (defined by nbinomLRT) shrinkage: Adds shrunken log2 fold changes (LFC) and SE to a results table from DESeq run without LFC shrinkage. For consistency with results, the column name lfcSE is used here although what is returned is a posterior SD. Three shrinkage estimators for LFC are available via type (see the vignette for more details on the estimators). The apeglm publication demonstrates that 'apeglm' and 'ashr' outperform the original 'normal' shrinkage estimator. |
return_dds |
Logical. When TRUE the function returns 'list(res, dds)' so QC cards can introspect the fitted DESeqDataSet. Default FALSE preserves the legacy data.frame return shape. |
deseq2 results
x <- runDESeq2()x <- runDESeq2()
Run EdgeR algorithm on the selected conditions. Output is to be used for the interactive display.
runEdgeR( data = NULL, metadata = NULL, columns = NULL, conds = NULL, params = NULL )runEdgeR( data = NULL, metadata = NULL, columns = NULL, conds = NULL, params = NULL )
data |
A matrix that includes all the expression raw counts, rownames has to be the gene, isoform or region names/IDs |
metadata |
metadata of the matrix of expression raw counts |
columns |
is a vector that includes the columns that are going to be analyzed. These columns has to match with the given data. |
conds |
experimental conditions. The order has to match with the column order |
params |
normfact: Calculate normalization factors to scale the raw library sizes. Values can be "TMM","RLE","upperquartile","none". dispersion: either a numeric vector of dispersions or a character string indicating that dispersions should be taken from the data object. If a numeric vector, then can be either of length one or of length equal to the number of genes. Allowable character values are "common", "trended", "tagwise" or "auto". Default behavior ("auto" is to use most complex dispersions found in data object. testType: exactTest or glmLRT. exactTest: Computes p-values for differential abundance for each gene between two digital libraries, conditioning on the total count for each gene. The counts in each group as a proportion of the whole are assumed to follow a binomial distribution. glmLRT: Fit a negative binomial generalized log-linear model to the read counts for each gene. Conduct genewise statistical tests for a given coefficient or coefficient contrast. |
edgeR results
x <- runEdgeR()x <- runEdgeR()
Creates a heatmap based on the user selected parameters within shiny
runHeatmap(input = NULL, session = NULL, expdata = NULL)runHeatmap(input = NULL, session = NULL, expdata = NULL)
input |
input variables |
session |
session |
expdata |
a matrix that includes expression values |
heatmapply plot
x <- runHeatmap()x <- runHeatmap()
Creates a heatmap based on the user selected parameters within shiny
runHeatmap2(input = NULL, session = NULL, expdata = NULL)runHeatmap2(input = NULL, session = NULL, expdata = NULL)
input |
input variables |
session |
session |
expdata |
a matrix that includes expression values |
heatmap.2
x <- runHeatmap2()x <- runHeatmap2()
Run Limma algorithm on the selected conditions. Output is to be used for the interactive display.
runLimma( data = NULL, metadata = NULL, columns = NULL, conds = NULL, params = NULL )runLimma( data = NULL, metadata = NULL, columns = NULL, conds = NULL, params = NULL )
data |
A matrix that includes all the expression raw counts, rownames has to be the gene, isoform or region names/IDs |
metadata |
metadata of the matrix of expression raw counts |
columns |
is a vector that includes the columns that are going to be analyzed. These columns has to match with the given data. |
conds |
experimental conditions. The order has to match with the column order |
params |
normfact: Calculate normalization factors to scale the raw library sizes. Values can be "TMM","RLE","upperquartile","none". fitType, fitting method; "ls" for least squares or "robust" for robust regression normBet: Normalizes expression intensities so that the intensities or log-ratios have similar distributions across a set of arrays. |
Limma results
x <- runLimma()x <- runLimma()
Applies DESeq2's variance-stabilizing transformation
(vst when 'nrow(counts) >= 30', otherwise
varianceStabilizingTransformation) and computes
euclidean distances between samples on the transformed scale. Falls back
to 'log2(counts + 1)' if vst fails (e.g., all-zero rows).
sample_distance_matrix(counts)sample_distance_matrix(counts)
counts |
Numeric matrix or data.frame (rows = features, cols = samples). |
Symmetric numeric matrix of size 'ncol(counts) x ncol(counts)', diagonal = 0, dimnames = 'colnames(counts)' on both axes.
m <- matrix(rpois(600, lambda = 10), nrow = 100, dimnames = list(NULL, paste0("s", 1:6))) d <- sample_distance_matrix(m) isSymmetric(d)m <- matrix(rpois(600, lambda = 10), nrow = 100, dimnames = list(NULL, paste0("s", 1:6))) d <- sample_distance_matrix(m) isSymmetric(d)
Search a data.frame's 'ID' column for a gene-set list.
search_geneset(dat, params = list())search_geneset(dat, params = list())
dat |
data.frame with an 'ID' column (or first column treated as ID). |
params |
Named list with 'geneset_area' (string of search terms). |
Filtered data.frame; or 'dat' unchanged if 'geneset_area' is empty.
dat <- data.frame( ID = c("BRCA1", "TP53", "MYC"), padj = c(0.01, 0.02, 0.5), stringsAsFactors = FALSE ) # Empty search returns all rows: search_geneset(dat, params = list(geneset_area = ""))dat <- data.frame( ID = c("BRCA1", "TP53", "MYC"), padj = c(0.01, 0.02, 0.5), stringsAsFactors = FALSE ) # Empty search returns all rows: search_geneset(dat, params = list(geneset_area = ""))
Pick a subset of 'rdata' based on the 'dataset' filter param.
select_dataset( rdata, get_selected = NULL, get_most_varied_data = NULL, merged_comparison = NULL, params = list() )select_dataset( rdata, get_selected = NULL, get_most_varied_data = NULL, merged_comparison = NULL, params = list() )
rdata |
Filtered data.frame (typically the output of [apply_de_filters()]). |
get_selected |
Optional; the user's lasso/click selection. |
get_most_varied_data |
Optional; the most-varied subset to use when 'dataset == "most-varied"'. |
merged_comparison |
Optional; merged comparisons table. |
params |
Named list with 'dataset' and (optionally) 'selected_plot', 'geneset_area'. |
Subset data.frame.
rdata <- data.frame( foldChange = c(5, 0.1, 1.0), padj = c(0.01, 0.01, 0.5), Legend = c("Up", "Down", "NS"), row.names = c("GeneA", "GeneB", "GeneC") ) select_dataset(rdata, params = list(dataset = "alldetected"))rdata <- data.frame( foldChange = c(5, 0.1, 1.0), padj = c(0.01, 0.01, 0.5), Legend = c("Up", "Down", "NS"), row.names = c("GeneA", "GeneB", "GeneC") ) select_dataset(rdata, params = list(dataset = "alldetected"))
Group info column selection. This can be used in batch effect or coloring the groups in the plots.
selectGroupInfo( metadata = NULL, input = NULL, selectname = "groupselect", label = "Group info" )selectGroupInfo( metadata = NULL, input = NULL, selectname = "groupselect", label = "Group info" )
metadata |
metadata |
input |
input values |
selectname |
name of the select box |
label |
label of the select box |
A 'shiny::selectInput' listing metadata-column choices (with "None" prepended), or NULL when no metadata is supplied.
selectGroupInfo
x <- selectGroupInfo()x <- selectGroupInfo()
Radio button for separators
sepRadio(id, name)sepRadio(id, name)
id |
module id |
name |
name |
radio control
sepRadio
x <- sepRadio("meta", "metadata")x <- sepRadio("meta", "metadata")
setBatch to skip batch effect correction batch variable set with the filter results
setBatch(fd = NULL)setBatch(fd = NULL)
fd |
filtered data |
fd data
x <- setBatch()x <- setBatch()
Displays a shiny object.
showObj(btns = NULL)showObj(btns = NULL)
btns |
show group of objects with shinyjs |
invisible(NULL); called for the side effect of calling 'shinyjs::show()' on each supplied id.
x <- showObj()x <- showObj()
Pulls the size factors that DESeq2 estimated for the comparison and the raw library sizes from the same 'DESeqDataSet', returned in a tidy data.frame plus 'sf_scaled'/'lib_scaled' columns rescaled to [0,1] for a side-by-side bar comparison. Spearman's rho between size factor and library size is attached as 'attr(out, "spearman_rho")'; values close to 1 confirm DESeq2 picked up depth differences without unexpected per-sample composition shifts.
size_factor_library_summary(dds)size_factor_library_summary(dds)
dds |
A fitted 'DESeqDataSet'. |
data.frame with columns 'sample', 'size_factor', 'library_size', 'sf_scaled', 'lib_scaled'. Attribute 'spearman_rho' holds the rank correlation between size factor and library size (NA for n < 2).
size_factor_library_summary(dds)size_factor_library_summary(dds)
Starts the DEBrowser to be able to run interactively.
startDEBrowser(hosted = FALSE, trusted_proxies = character(0), port = 3838)startDEBrowser(hosted = FALSE, trusted_proxies = character(0), port = 3838)
hosted |
Logical. When TRUE, enables hosted-mode behaviors: auth-provider chain, per-user AI settings (D2.6), bookmark ownership enforcement (D2.3+). Default FALSE preserves the single-user desktop launch experience. May also be set via the 'DEBROWSER_HOSTED' env var. |
trusted_proxies |
Character vector of proxy IPs and CIDR networks (e.g. 'c("127.0.0.1", "10.0.0.0/8")') whose 'X-Forwarded-User' header is trusted as the authenticated user. Only used when 'hosted = TRUE'. Empty by default. |
port |
Integer TCP port to bind. Default '3838' matches the shiny-server convention so bookmark URLs stay stable across restarts (essential for '?_state_id_=...' links the user copies from the share modal). Pass 'NULL' to let Shiny pick a random free port (legacy behavior). |
the app
startDEBrowser
startDEBrowser() startDEBrowser(hosted = TRUE, trusted_proxies = c("127.0.0.1", "10.0.0.0/8"))startDEBrowser() startDEBrowser(hosted = TRUE, trusted_proxies = c("127.0.0.1", "10.0.0.0/8"))
Starts the DEBrowser heatmap
startHeatmap()startHeatmap()
the app
startHeatmap
startHeatmap()startHeatmap()
Generates a text area input to be used for gene selection within the DEBrowser.
textareaInput(id, label, value, rows = 20, cols = 35, class = "form-control")textareaInput(id, label, value, rows = 20, cols = 35, class = "form-control")
id |
id of the control |
label |
label of the control |
value |
initial value |
rows |
the # of rows |
cols |
the # of cols |
class |
css class |
A 'shiny::tags$div' containing a '<label>' and a '<textarea>' Shiny-bound input.
x <- textareaInput("genesetarea", "Gene Set", "Fgf21", rows = 5, cols = 35 )x <- textareaInput("genesetarea", "Gene Set", "Fgf21", rows = 5, cols = 35 )
User defined toggle to display which panels are to be shown within DEBrowser.
togglePanels(num = NULL, nums = NULL, session = NULL)togglePanels(num = NULL, nums = NULL, session = NULL)
num |
selected panel |
nums |
all panels |
session |
session info |
invisible(NULL); called for the navbar nav_show / nav_hide / nav_select side effects on the methodtabs nav.
togglePanels
x <- togglePanels()x <- togglePanels()
Sends a Shiny custom message of type "debrowser-progress" with a payload built by 'progress_message(key, state)'. The handler installed by 'getTabUpdateJS()' (R/funcs.R) reads the message and toggles CSS classes on the matching icon span and parent pill.
update_progress(session, key, state)update_progress(session, key, state)
session |
Shiny session object. |
key |
character, progress key. |
state |
character, progress state. |
Invisibly NULL.
if (interactive()) { update_progress(session, "upload", "done") }if (interactive()) { update_progress(session, "upload", "done") }