Skip to main content
SimilarExport ZIP
100%

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

✓ Published0🌍 Public
FFloWuenne
Last edited Aug 10, 2017
Created on Jul 31, 2017

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.

AI-generated description

Similar vizzes

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.

FFloWuenne
74% match
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.

FFloWuenne
71% match
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.

FFloWuenne
70% match
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.

FFloWuenne
67% match
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.

FFloWuenne
65% match
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.

FFloWuenne
64% match
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.

FFloWuenne
64% match
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.

FFloWuenne
64% match