Skip to main content
Log in
F

FloWuenne

@FloWuenne·38 public vizzes

Loading thumbnail…

Method description for the structure track for OpenADMET Blind Challenge: Predicting PXR Induction

This visualization maps the optimization workflow for the PXR ligand-pose prediction challenge, showing how automated method variants are iteratively tested against a leakage-controlled LDDT-PLI benchmark. It charts performance scores for co-folding models, diffusion guidance, docking hybrids, and fine-tuning strategies, with each bar or point colored by method family. The code uses `d3.forceSimulation` for node layout and `d3.scaleLinear` for axis mapping, drawing from the gist’s computational framework description and benchmark results. The chart highlights that IntelliFold-2 and physics-guided steering outperform the Boltz-2 baseline, while most sampling and refinement approaches yield flat or negative gains.

Jul 1, 2026
Loading thumbnail…

Perform sliding window analysis on count data in a 2d array

This example visualizes the spatial distribution of spot counts and total intensity in a 2D array using sliding-window binning. It shows two heatmaps side-by-side, one for spot count and one for total intensity, with the y-axis inverted to match image orientation, plus a joint regression plot revealing the correlation between the two metrics. The code uses pandas for data loading and quantile-based thresholding, then bins the filtered data into 10x10 pixel windows. Seaborn’s `heatmap` and `jointplot` render the visualizations, while `matplotlib.pyplot` handles the subplot layout and axis inversion.

Jul 10, 2023
Loading thumbnail…

Build kb-python reference for GENCODE release M26 GRCm39

This visualization demonstrates the command-line workflow for building a kallisto\|bustools reference index for the GENCODE mouse annotation release M26, specifically for the GRCm39 genome assembly. It shows the sequence of shell commands required to set up a Python virtual environment, install the kb-python package via pip, download the primary assembly genome FASTA and annotation GTF files from the EBI FTP server, and then run `kb ref` to generate the index, transcript-to-gene mapping, and cDNA files. The code relies on the `kb-python` API and standard Unix tools like `wget` and `module load`, with the process occurring on a compute cluster.

Feb 25, 2021
Loading thumbnail…

Building a custom reference for kb-python in a virtual environment

This example demonstrates a shell script that builds a custom kb-python reference index for single-cell RNA-seq analysis. It shows the step-by-step process of creating a Python virtual environment, installing kb-python, and downloading Gencode mouse reference files. The script then appends custom FASTA and GTF sequences to the standard reference using `cat`, and constructs the index via the `kb ref` command with the `--workflow standard` flag. The code relies on the `venv` module, `pip3`, `wget`, and `gunzip` to prepare files, and explicitly requires properly formatted FASTA headers and GTF entries for successful integration.

Feb 25, 2021
Loading thumbnail…

Make a Featureplot style plot using schex from a Seurat object

This example demonstrates how to create a series of feature plots from a Seurat object using the schex package, with each plot visualizing the expression of a specified gene across a hexagonal binning of cells. The visualization shows gene expression levels as color gradients over a UMAP reduction, with each hexagon representing an aggregated summary of nearby cells. The code first calls `make_hexbin` to bin the cells, then iterates through gene IDs, generating plots with `plot_hexbin_feature` and applying `theme_cowplot` for styling. It relies on Seurat for data handling and schex for the hexagonal binning approach, using the specified assay, slot, and aggregation action (e.g., mean).

Jun 30, 2020
Loading thumbnail…

Get list of installed R packages

This example shows a plain-text list of installed R packages, displaying the package name and version, with the priority column filtered out. The code retrieves the data using `installed.packages()`, selecting the first, third, and fourth columns, then removes rows where the priority is not missing. It prints the resulting two-column data frame without row names using `print(ip, row.names=FALSE)`. The rendering is purely textual, relying on R’s base printing, with no external graphics or visualization libraries involved.

Feb 13, 2020
Loading thumbnail…

Setup Gist for new Rshiny server VMs.

This example shows a setup script for provisioning a new R Shiny server virtual machine, listing the essential R packages and GitHub-hosted tools required for a typical bioinformatics workflow. It demonstrates how to automate dependency installation using base R functions like `install.packages()` and `install_github()` from the `devtools` package, alongside `install_bitbucket()` for MAGeCKFlute. The code explicitly names libraries such as `tidyverse`, `plotly`, `shinydashboard`, and `manhattanly`, and includes custom forks like `manhattanlyCRISPR`. The rendering approach is a plain-text R script, not a visualization, but the list clarifies the environment’s package landscape for reproducibility.

Aug 22, 2019
Loading thumbnail…

Quick testing of the Jensen-Shannon implementation in the philentropy package

This example tests the Jensen-Shannon divergence (JSD) and distance calculations in the `philentropy` R package, using toy distributions to validate the expected behavior for positive and negative controls. It shows that perfectly overlapping distributions yield a distance of 1, while fully independent distributions yield a distance of 0. The code manually normalizes two input vectors (regulon activity scores and cell identity indicators) and passes them as a matrix to `philentropy::JSD`, then applies the formula `1 - sqrt(JSD)` to derive the distance. The source is a public gist by FloWuenne, demonstrating a quick sanity check for the package's implementation.

Nov 9, 2018
Loading thumbnail…

Analyze and fix .gtf file for Drop-seq pipeline to remove warnings and skipping for genes with issues

This R script demonstrates a bioinformatics workflow for cleaning a modified GTF genome annotation file by identifying and filtering problematic gene entries before running a Drop-seq pipeline. It shows how duplicated gene names and multiple gene IDs cause warnings and skips during processing. The code uses the `refGenome` package to parse the GTF and extract gene positions, then leverages `dplyr` and `tidyr` for data manipulation to categorize issues. It cross-references gene expression data from two DGE files and queries the Ensembl database via `biomaRt` to retrieve current gene IDs. The visualization ultimately classifies problematic genes by duplication, chromosomal disagreement, or strand disagreement, filtering them out to create a clean annotation set.

Jul 20, 2018
Loading thumbnail…

Check correlation between number of genic reads and genes and transcripts detected per cell

This example uses scatter plots to examine the correlation between the number of genic reads and the number of genes or transcripts detected per cell. Two separate plots are generated, each coloring points by the third variable—either transcript count or gene count—to reveal potential relationships. The code relies on the ggplot2 library in R, using `ggplot()` with `geom_point()` and an `aes()` mapping for the x-axis, y-axis, and color. The data is read from a tab-separated table via `read.table()`, and the visualizations are based on the summary statistics in the `DGE_info` data frame.

Jun 14, 2018
Loading thumbnail…

Extract shiny clustering data for full dataset

This example prepares a clustered single-cell dataset for interactive visualization by extracting tSNE coordinates, cluster identities, normalized expression, and marker genes from a Seurat object. It shows how the full dataset’s clustering structure is assembled into a custom S4 object for downstream use. The code uses R with `dplyr` and `tidyr` to filter the top 50 markers per cluster by `avg_logFC`, and merges tSNE embeddings with cell identities. It saves the processed data as an RDS file for a Shiny app, relying on Seurat’s data structures and base R matrix operations.

May 2, 2018
Loading thumbnail…

Save raw UMI counts and metadata for each object

This example saves raw UMI counts and metadata for each timepoint in a single-cell heart maturation dataset. It iterates over six developmental stages, reading a Seurat object for each and extracting the raw UMI matrix and metadata. The code uses base R functions `as.matrix()` and `readRDS()`, then writes tab-separated files with `write.table()`. The visualization shows how raw count matrices are paired with their corresponding cell annotations, facilitating downstream differential expression analysis. The approach relies on Seurat’s stored raw data and metadata slots, producing separate DGE and metadata files per timepoint.

May 1, 2018
Loading thumbnail…

Run certain gists in R from GithubGist

This example shows how to run a series of R scripts hosted as GitHub Gists, each generating a clustering module for a Shiny application. It demonstrates the use of the `devtools` package’s `source_gist` function to fetch and execute code directly from specific gist URLs, with filenames specified for each dataset. The code processes specific time-point Rds files, all time points, and full datasets, including renamed and merged clustering variants. The visualization highlights a reproducible workflow for sourcing remote R code, relying on the gist API and local file handling rather than any graphical or interactive rendering.

Apr 27, 2018
Loading thumbnail…

Create an Rds file for the full heart maturation dataset

This example demonstrates how to convert a Seurat single-cell RNA sequencing object into a compact RDS file for a Shiny visualization app. It shows the creation of a custom S4 class that bundles tSNE coordinates, normalized expression data, cell metadata, and the top 50 differentially expressed markers per cluster. Using the dplyr and tidyr libraries for data manipulation, the script extracts the tSNE embeddings and cluster identities from the Seurat object, then merges them with metadata. The resulting clustering_module object is saved via saveRDS, enabling efficient downstream interactive exploration of heart maturation data.

Apr 26, 2018
Loading thumbnail…

Create shiny cluster modules for renamed datasets

This example demonstrates how to process and store single-cell RNA sequencing data across multiple developmental time points, creating Shiny-ready cluster modules for each stage. The code defines an S4 class, `clustering_module`, that bundles t-SNE embeddings, normalized expression data, metadata, and a marker list for each time point from E14.5 to P7. It loads Seurat objects, extracts the t-SNE coordinates and cell identities, filters markers by expression difference using `dplyr`’s `top_n`, and saves each time point as a compressed RDS file. The workflow uses `Seurat` for data handling and `tidyr` for reshaping, preparing interactive visualizations for the Shiny server.

Apr 24, 2018
Loading thumbnail…

Create clustering module for shiny server for all timepoints

This example builds a clustering module for a Shiny server across multiple developmental time points. It processes Seurat objects to extract t-SNE embeddings, cluster identities, normalized expression data, and metadata, then combines them into a custom S4 object via the `setClass` function. The code filters marker lists by the top 50 markers per cluster using `dplyr`’s `top_n` on pct difference. Using base R matrix conversions and `merge`, it consolidates cell embeddings with identities, saving each time point as an RDS file for later visualization.

Apr 20, 2018
Loading thumbnail…

Takes as input an Rds file for clustering module (.Rmd code)

This example compares the read performance of RDS and Feather file formats for a single-cell clustering module object. It benchmarks loading the entire RDS object versus reading its four components (tsne, normalized expression, metadata, and marker list) as separate Feather files. The code uses the `feather`, `microbenchmark`, and `tibble` libraries, along with `readRDS()` and `write_feather()` functions, to measure mean execution times. The visualization shows autoplots of benchmark results, highlighting the time differences between the two storage approaches.

Apr 20, 2018
Loading thumbnail…

Make a nice ClusterTree from the initial ClusterTree plot from Seurat

This example shows a cluster tree visualization derived from a Seurat single-cell analysis, displaying the hierarchical relationships between cell clusters as a phylogenetic-style tree. The plot renders a ladderized dendrogram where nodes are labeled with grey circles, making the branching structure easier to interpret than the default Seurat output. The code uses Seurat’s `BuildClusterTree` function to compute the tree, then plots it with base R’s `plot` and `nodelabels` functions. The visualization applies `ladderize` to reorder branches for clarity and sets custom graphical parameters like `edge.width` and `label.offset` to improve readability. The data source is the Seurat object’s cluster tree, saved as a PNG file.

Apr 18, 2018
Loading thumbnail…

Create .Rds object with components needed for clustering module of heartmat shiny server (for .Rds)

This R script builds a clustering module object for the Shiny server by processing a Seurat object, creating a data frame that combines tSNE coordinates with cluster identities. It demonstrates data preparation for interactive visualization by extracting normalized expression data, metadata, and a marker list filtered to the top 20 markers per cluster by average log fold change. The code uses the dplyr and tidyr libraries for data manipulation, and relies on Seurat’s slots for tSNE embeddings, expression matrices, and metadata, ultimately saving the assembled S4 object as an .Rds file for downstream Shiny app use.

Apr 17, 2018
Loading thumbnail…

Extract data for clustering module from all time points (For .Rdata)

This example demonstrates a data-extraction workflow that prepares Seurat clustering results from multiple developmental time points for a Shiny server application. It loads seven Seurat objects (E14.5 through P6) and, for each, extracts normalized expression matrices, t-SNE embeddings, cluster identities, and metadata. The script explicitly uses the `dplyr` and `tidyr` packages for data manipulation, converting sparse expression matrices to dense data frames and merging cell embeddings with identity assignments. The resulting data frames are saved as `.RData` files per time point, preserving the structure needed for interactive clustering visualization. The code relies on Seurat’s slot accessors (`@data`, `@dr$tsne`, `@ident`, `@meta.data`) to gather all relevant components.

Apr 17, 2018
Loading thumbnail…

Create .Rdata file from Seurat object for clustering module of shiny server (for .Rdata)

This example demonstrates how to convert a Seurat object into an .Rdata file for use in a clustering module of a Shiny server. The script extracts normalized expression data as a dense matrix, along with t-SNE embeddings and cell cluster identities, and merges them into a single data frame. It also includes the full metadata associated with each cell. The code uses the Seurat and dplyr APIs, specifically accessing the `@data`, `@dr$tsne@cell.embeddings`, and `@ident` slots, and saves the resulting objects with the base R `save` function.

Apr 17, 2018
Loading thumbnail…

Quick testing of CIDR implementation

This example tests a CIDR implementation for single-cell RNA sequencing data, specifically using colorectal cancer cells from a 2017 Li et al. study. It first reads in the data and applies the CIDR clustering workflow, with most steps commented out. The visualization shows a two-dimensional principal component analysis (PCA) plot, coloring points by cell type and using plotting symbols to denote CIDR clusters. The code uses the `scDataConstructor`, `determineDropoutCandidates`, and `plot` functions from the CIDR package, alongside `ggplot2` for an alternative scatterplot of the same PC axes.

Mar 17, 2018
Loading thumbnail…

Make a table of the number of cells for each group in the seurat object

The example builds a data frame of cell counts for each cluster in a Seurat object, broken down by treatment group. It first shows raw cell numbers per group per cluster, then adds normalized proportions relative to each group’s total cell count, making group compositions comparable despite unequal sample sizes. The code uses `Seurat` functions like `SubsetData` and the `@ident` and `@meta.data` slots, alongside `dplyr`’s `select` and `nrow` to count group memberships. It iterates over clusters, appending rows via `rbind`, and finally writes the result to a tab-separated file with `write.table`. The output table directly reveals per-cluster group distributions and their normalized percentages, aiding differential abundance analysis.

Mar 8, 2018
Loading thumbnail…

In Scenic analysis, identify all regulons that contain a gene of interest

This example demonstrates how to identify all regulons containing a specific gene of interest within a single-cell analysis pipeline. The visualization shows the R code iterating through each regulon in the `regulons` object and printing the name of any regulon that includes the target gene. The code uses a `for` loop with a conditional `if` statement and the `%in%` operator to check membership. The regulons themselves are loaded from a saved RData file, and the script outputs the matching regulon names to the console.

Jan 9, 2018
Loading thumbnail…

Plot PCA for ethnicity from any given VCF file combined with 1000 genomes data

This visualization plots principal component analysis (PCA) results from a user-provided VCF file, combined with 1000 Genomes reference data, to infer ethnic ancestry. It shows a scatterplot of PC1 versus PC2, where each point represents a sample, colored by population assignment. The code uses the `SNPRelate` package to convert the VCF to GDS format, perform LD-based SNP pruning, and run PCA, while `ggplot2` renders the final plot. Ethnicity labels are merged from an external population table, and a custom publication theme colors the points.

Nov 22, 2017
Loading thumbnail…

Use Seurat to find specific markers of each cell type (modified from Dan Skelly)

This example shows a dot plot of the top five specific marker genes for each cell type in a single-cell RNA-sequencing dataset, with dot size and color encoding expression level and percentage of cells expressing each gene. The visualization relies on Seurat’s `FindMarkers` function with a ROC test to perform all pairwise comparisons between cell types, filtering for markers expressed in fewer than 50% of cells in other clusters and retaining those with a mean AUC above 0.65. The code uses tidyverse functions like `mutate`, `filter`, `summarize`, and `group_by` to process the marker data, and Seurat’s `DotPlot` to render the final figure. Marker lists are written to TSV files, and the plot is saved as a PNG.

Nov 17, 2017
Loading thumbnail…

Theme for publication quality graphs. Modified from https://rpubs.com/Koundy/71792!

This example demonstrates a publication-quality ggplot2 theme with custom fill and color palettes. It shows how to apply a consistent, clean aesthetic—featuring bold axis titles, light gray gridlines, and a horizontal legend—to any plot. The code defines a `theme_Publication_custom` function using `theme_foundation` from `ggthemes` and custom `scale_fill_Publication` and `scale_colour_Publication` functions built on `discrete_scale` and `manual_pal` from `scales`. The theme and palettes are intended for reproducible, polished figures from data frames.

Nov 16, 2017
Loading thumbnail…

Translate human to mouse gene symbols for cell cycling genes using biomart and save results for faster reading next time

This example demonstrates a workflow for converting human gene symbols to mouse orthologs for cell cycle genes, saving the results for faster future access. It shows the conversion of two gene lists—S-phase and G2/M-phase markers—from the Seurat `cc.genes` dataset into mouse equivalents. The code uses the `biomaRt` package to query Ensembl databases, specifically calling `useMart` for human and mouse datasets and `getLDS` to map HGNC symbols to MGI symbols. After conversion, the results are written to tab-separated text files for reuse, avoiding repeated live queries.

Nov 14, 2017
Loading thumbnail…

Use Seurat to find specific markers of each cell type

This example demonstrates how to identify specific marker genes for each cell type in a Seurat single-cell RNA-seq analysis. It shows a workflow that compares every cell type against all others using the `FindMarkers` function with a ROC test, then filters the results to retain only markers expressed in fewer than 50% of cells in all other populations. The code uses the `tidyverse` and `Seurat` libraries to perform pairwise comparisons, calculate the difference in expression percentages, and summarize the average AUC values. The final output is a curated list of the top 10 markers per cell type, emphasizing those with high discriminatory power.

Oct 30, 2017
Loading thumbnail…

Translate Human gene symbols into Mouse symbols using bioMart

This example demonstrates a utility for translating human gene symbols into their mouse equivalents using the biomaRt package. It shows the conversion process, highlighting which genes fail to map and reporting the total count of untranslated genes. The function `convertHumanGeneList` queries Ensembl databases for human and mouse through `useMart` and `getLDS`, matching HGNC symbols to MGI symbols. It relies on the biomaRt API to retrieve cross-species annotations and prints diagnostic messages about translation success or failure.

Sep 24, 2017
Loading thumbnail…

Create a cellview Rds object from a seurat expression object (updated for Seurat version 2) [MOUSE]

This example demonstrates how to prepare a Seurat single-cell expression object for use with the CellView visualization tool, specifically for mouse data. It shows the workflow of rerunning t-SNE with three dimensions, converting gene symbols to Ensembl IDs using `bitr` from clusterProfiler, and constructing the necessary `log2cpm`, `featuredata`, and `tsne.data` matrices. The code uses Seurat’s `RunTSNE`, the `Matrix` and `dplyr` packages for data manipulation, and ultimately saves the combined object as an Rds file for downstream visualization.

Aug 10, 2017
Loading thumbnail…

Plot VlnPlot for markers with minimum axis for joined marker plot as in (Macosko et al for retina)

This example uses Seurat’s `VlnPlot` to draw violin plots for a set of candidate marker genes (GAPDH, NANOG, ACTB) across cell populations, with a fixed y-max of 6 and no axis labels or ticks to focus on expression distributions. The code loops through each gene, builds a violin plot, and then removes all axis lines and text while flipping coordinates so the plots are horizontal. It demonstrates how to customize Seurat’s plotting defaults—using `point.size.use = -1` to suppress points, `remove.legend = TRUE`, and theme elements to create a minimal, clean visualization for comparing marker expression across clusters. The data source is an updated Seurat object (`expression_seurat.updated`).

Aug 9, 2017
Loading thumbnail…

Visualize the output from GatherMolecularBarcodeDistributionByGene to assess UMI duplication rates

This example visualizes the relationship between duplicated and unique UMI counts, split by cell and by gene, to assess UMI duplication rates. Scatter plots show each cell or gene as a point, with axes for duplicated versus unique UMIs, while histograms display the distribution of mean duplication events per cell. The code uses R’s ggplot2 and plotly to build interactive scatter plots with tooltips, and dplyr for data wrangling. It calculates per-cell and per-gene duplication percentages from a table of UMI observations, highlighting overall duplication patterns.

Aug 2, 2017
Loading thumbnail…

Creating quick SCE object from Seurat expression data

This example demonstrates how to convert a Seurat expression dataset into a SingleCellExperiment (SCE) object for use with scater’s analytical and plotting functions. It shows the creation of an `AnnotatedDataFrame` from Seurat’s metadata, followed by constructing a new SCE object via `newSCESet()` with expression data from `expression_seurat@data` and quality-control metrics calculated using `calculateQCMetrics()`. The code relies on the scater and Seurat libraries, along with the `AnnotatedDataFrame` class from Bioconductor, to bridge the two single-cell analysis frameworks.

Jul 31, 2017
Loading thumbnail…

Cell cycle assignment for single cell data using scran and cyclone with gene symbols instead of ensembl IDs

This example demonstrates how to assign cell cycle phases to single-cell RNA sequencing data by converting the pretrained marker gene pairs in the scran package from Ensembl IDs to gene symbols. It shows the resulting phase assignments being added as metadata to a Seurat object for downstream analysis. The code uses the scran cyclone function, the org.Hs.eg.db database for ID conversion via bitr, and dplyr for data manipulation. The visualization implicitly relies on the Seurat object’s structure to store the new cell cycle labels, though no plot is generated in the provided script.

Jul 26, 2017
Loading thumbnail…

Plot mean expression of a gene vs other parameters and highlight specific genes using ggrepel

This example uses the scater package to calculate quality metrics for single-cell RNA-seq data, then plots mean gene expression against percent dropout and percent total expression. The ggplot2 code highlights a user-defined set of genes of interest in red, while ggrepel’s `geom_text_repel` labels those genes to avoid overlapping points. Two separate scatterplots are generated from the same `gene_info` data frame, each saved as an SVG, showing how specific genes relate to global expression distributions. The analysis relies on the `newSCESet` and `calculateQCMetrics` functions from scater to derive the plotted metrics.

Jul 26, 2017
Loading thumbnail…

Cell cycle assignment for single cells (using Dropbead), starting from a Seurat object and adding cell cycle to Metadata of Seurat object

This example assigns cell cycle phases to single cells and adds the result as metadata to a Seurat object. It shows each cell’s dominant cell cycle phase (e.g., G1, S, G2/M) based on per-cell scores, with the phase label stored as new metadata. The code uses the Dropbead package’s `assignCellCyclesPhases` function, which processes an expression matrix within a `SingleSpeciesSample` object. It then selects the highest-scoring phase per cell via `max.col` and attaches the resulting data frame to the Seurat object using `AddMetaData`. The pipeline relies on a supplied Excel file of cell cycle genes.

Jun 27, 2017
Loading thumbnail…

Unload R packages that override certain tidyverse functions (scran, scater) if they appear in search()

This example demonstrates how to resolve function conflicts when loading single-cell R packages alongside the tidyverse. It shows a defensive code snippet that checks whether the `scran` or `scater` packages are present in the search path using `search()`, and if so, forcibly unloads them with `detach(..., unload=TRUE)` to prevent their functions from overriding tidyverse verbs like `mutate` or `arrange`. The approach relies on base R functions, specifically `search()`, `%in%`, and `detach()`, to conditionally remove packages at runtime. The visualization highlights a practical workflow safeguard, using the `gistfile1.txt` source as the basis for the code logic.

Jun 7, 2017