OSCR

Comparative transcriptomics reveals differences in cortical cell type organization between metatherian and eutherian mammals.

Code ↔ Paper

14 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 14 matches
  1. [1] § Methods › Analysis of single-nucleus transcriptomics data ↔ figure S1/S1B_intergenic_distance_pipeline.sh, lines 1–41 · score 0.83 · UTR annotation, nearest gene, intergenic, Samtools, stratifying, BEDtools
  2. [2] § Results › IT glutamatergic neurons have poor cross-species correspondence ↔ figure 2/2DEF_OpossumMouse_CrossSpeciesMapping.Rmd, lines 102–120 · score 0.79 · subclasses mapped, cross species, L5NP, L6CT, L5PT, L6IT
  3. [3] § Results › IT glutamatergic neurons have poor cross-species correspondence ↔ figure 3/3FGHIJ_OpossumMouse_PCGradients.Rmd, lines 644–752 · score 0.77 · Spearman correlations, PC space, mouse subclass, mouse cells, Opossum cells, opossum subclass
  4. [4] § Results › IT glutamatergic neurons have poor cross-species correspondence ↔ figure 1/1GHIJK_OpossumMouse_ClassSubclassProportions.Rmd, lines 40–102 · score 0.75 · L5NP, L6CT, L5PT, L6IT, GABAergic, CGE
  5. [5] § Methods › Analysis of single-nucleus transcriptomics data ↔ figure 2/2LMN_OpossumMouse_WGCNAModules.Rmd, lines 361–373 · score 0.70 · HubGeneNetworkPlot, preserved modules, hub genes, WGCNA, mouse, opossum
  6. [6] § Results › Gene expression continua reveal conserved and divergent features of IT neurons ↔ figure 2/2DEF_OpossumMouse_CrossSpeciesMapping.Rmd, lines 102–120 · score 0.66 · cortical layers, L6CT, L5PT, cross species, predicts, neurons
  7. [7] § Methods › Analysis of spatial transcriptomics data ↔ figure 3/3FGHIJ_OpossumMouse_PCGradients.Rmd, lines 156–200 · score 0.66 · PC space, delta, noc, L5IT, Stereo seq, PCHA
  8. [8] § Methods › Analysis of single-nucleus transcriptomics data ↔ figure 3/3FGHIJ_OpossumMouse_PCGradients.Rmd, lines 156–200 · score 0.63 · convex hull, PC spaces, PCHA, vertex, mice, subclass
  9. [9] § Methods › Analysis of single-nucleus transcriptomics data ↔ preprocessing/0_Opossum_ExtendGenomeAnnotation.Rmd, lines 70–122 · score 0.62 · gene biotype, FASTA, strand, shift, genome, GTF
  10. [10] § Results › A spatial gradient along the opossum IT_A–C transcriptomic axis ↔ figure 3/3FGHIJ_OpossumMouse_PCGradients.Rmd, lines 644–752 · score 0.55 · Spearman correlations, PC space, fitted, Ratio, distance, position
  11. [11] § Results › A spatial gradient along the opossum IT_A–C transcriptomic axis ↔ figure 3/3FGHIJ_OpossumMouse_PCGradients.Rmd, lines 238–338 · score 0.55 · triangle vertices, L5IT, Stereo seq, gradients, distance, PC
  12. [12] § Results › A single-nucleus transcriptomic atlas of the primary visual cortex in the gray short-tailed opossum ↔ figure 2/2DEF_OpossumMouse_CrossSpeciesMapping.Rmd, lines 122–135 · score 0.53 · Cross species, GABAergic, interneurons, Lamp5, Pvalb, Sst
  13. [13] § Results › A single-nucleus transcriptomic atlas of the primary visual cortex in the gray short-tailed opossum ↔ figure 1/1GHIJK_OpossumMouse_ClassSubclassProportions.Rmd, lines 40–102 · score 0.53 · GABAergic, MGE, subtypes, CGE, Lamp5, Pvalb
  14. [14] § Methods › Analysis of single-nucleus transcriptomics data ↔ figure 2/2DEF_OpossumMouse_CrossSpeciesMapping.Rmd, lines 137–150 · score 0.51 · Confusion matrices, cross species, rows, predicted, mouse, subclasses

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

R Markdown · 1,108 lines · 39 KB · MIT · 5 matches

  1. ---
  2. title: "Figure 3F-J: IT Subclass PC Gradients in Opossum and Mouse"
  3. output:
  4. ---
  6. ```{r setup, include=FALSE}
  7. # This sets the project root based on the repo structure.
  8. # If you move this file, you may to set the root manually to find config.R
  9. knitr::opts_knit$set(root.dir = dirname(dirname(rstudioapi::getSourceEditorContext()$path)))
  10. knitr::opts_chunk$set(echo = TRUE, warning = FALSE, message = FALSE)
  11. ```
  13. ```{r libraries}
  14. # Conda environment with required packages: numpy pandas scipy scikit-learn networkx py-pcha
  15. Sys.setenv(RETICULATE_PYTHON = "C:/Users/TLab/anaconda3/envs/pcha/python.exe")
  16. library(Seurat)
  17. library(ggplot2)
  18. library(dplyr)
  19. library(reticulate)
  20. library(comparatome)
  21. source("config.R")
  22. use_condaenv("pcha")
  23. ```
  25. ```{r load_integrated_data}
  26. # Load integrated objects containing both snRNA-seq and Stereo-seq data
  27. obj.i.mouse <- readRDS(paste0(dir.list$spatial$seurat$processed, "mouse_stereoseq_integrated.rds"))
  28. obj.i.opossum <- readRDS(paste0(dir.list$spatial$seurat$processed, "opossum_stereoseq_integrated.rds"))
  30. cat(sprintf("Mouse integrated: %d cells\n", ncol(obj.i.mouse)))
  31. cat(sprintf("Opossum integrated: %d cells\n", ncol(obj.i.opossum)))
  32. ```
  34. ```{r, filter_IT_subtypes_mouse}
  35. # Mouse IT cells
  36. IT.sn.names.mouse <- colnames(obj.i.mouse)[obj.i.mouse$subclass %in% c("L2/3", "L4", "L5IT")]
  37. IT.sp.names.mouse <- colnames(obj.i.mouse)[obj.i.mouse$subclass_nn %in% c("L2/3", "L4", "L5IT")]
  38. IT.cells.mouse <- unique(c(IT.sn.names.mouse, IT.sp.names.mouse))
  40. # Subset without images
  41. obj.i.mouse.noimg <- obj.i.mouse
  42. obj.i.mouse.noimg@images <- list()
  43. obj.i.mouse.IT <- obj.i.mouse.noimg[, IT.cells.mouse]
  45. # Restore images with only spatial cells present in subset
  46. spatial_cells_in_subset <- intersect(IT.sp.names.mouse, colnames(obj.i.mouse.IT))
  47. if(length(spatial_cells_in_subset) > 0) {
  48. for(img_name in c("COL")) {
  49. obj.i.mouse.IT@images[[img_name]] <- subset(obj.i.mouse@images[[img_name]],
  50. cells = spatial_cells_in_subset)
  51. }
  52. }
  54. # Opossum IT cells
  55. IT.sn.names.opossum <- colnames(obj.i.opossum)[obj.i.opossum$subclass %in% c("IT_A", "IT_B", "IT_C")]
  56. IT.sp.names.opossum <- colnames(obj.i.opossum)[obj.i.opossum$subclass_nn %in% c("IT_A", "IT_B", "IT_C")]
  57. IT.cells.opossum <- unique(c(IT.sn.names.opossum, IT.sp.names.opossum))
  59. obj.i.opossum.noimg <- obj.i.opossum
  60. obj.i.opossum.noimg@images <- list()
  61. obj.i.opossum.IT <- obj.i.opossum.noimg[, IT.cells.opossum]
  63. spatial_cells_in_subset <- intersect(IT.sp.names.opossum, colnames(obj.i.opossum.IT))
  64. if(length(spatial_cells_in_subset) > 0) {
  65. for(img_name in c("COL")) {
  66. obj.i.opossum.IT@images[[img_name]] <- subset(obj.i.opossum@images[[img_name]],
  67. cells = spatial_cells_in_subset)
  68. }
  69. }
  70. ```
  72. ```{r}
  73. cat(sprintf("Mouse IT neurons: %d cells (%d snRNA, %d spatial)\n",
  74. ncol(obj.i.mouse.IT), length(IT.sn.names.mouse), length(IT.sp.names.mouse)))
  75. obj.i.mouse.IT$method[is.na(obj.i.mouse.IT$method)] <- "Stereo-seq"
  76. cat(sprintf("Opossum IT neurons: %d cells (%d snRNA, %d spatial)\n",
  77. ncol(obj.i.opossum.IT), length(IT.sn.names.opossum), length(IT.sp.names.opossum)))
  78. obj.i.opossum.IT$method[is.na(obj.i.opossum.IT$method)] <- "Stereo-seq"
  79. ```
  81. ```{r run_pca}
  82. # Run PCA - PC2 and PC3 typically capture IT continuum better than PC1 (technical variation)
  83. obj.i.mouse.IT$method[is.na(obj.i.mouse.IT$method)] <- "Stereo-seq"
  84. obj.i.mouse.IT <- RunPCA(obj.i.mouse.IT, npcs = 30, verbose = FALSE)
  85. obj.i.opossum.IT <- RunPCA(obj.i.opossum.IT, npcs = 30, verbose = FALSE)
  87. # Get all colors
  88. colors <- get_colors()
  90. # Function to plot PCA with snRNA gray and spatial colored by subclass
  91. plot_pca_by_method <- function(obj, colors, title, dims = c(2, 3)) {
  92. pca_coords <- Embeddings(obj, "pca")[, dims]
  93. df <- data.frame(
  94. PC_x = pca_coords[, 1],
  95. PC_y = pca_coords[, 2],
  96. method = obj$method,
  97. subclass = ifelse(obj$method == "Stereo-seq",
  98. as.character(obj$subclass_nn),
  99. "snRNA-seq")
  100. )
  102. # Order so spatial cells plot on top
  103. df <- df[order(df$method == "Stereo-seq"), ]
  105. # Build color vector: gray for snRNA, subclass colors for spatial
  106. spatial_subclasses <- unique(df$subclass[df$subclass != "snRNA-seq"])
  107. color_vec <- c("snRNA-seq" = "gray70", unlist(colors[spatial_subclasses]))
  109. p <- ggplot(df, aes(x = PC_x, y = PC_y, color = subclass)) +
  110. geom_point(size = 1.5, alpha = 1) +
  111. scale_color_manual(values = color_vec) +
  112. labs(x = paste0("PC", dims[1]), y = paste0("PC", dims[2]), title = title) +
  113. coord_equal() +
  114. theme_classic() +
  115. guides(color = guide_legend(override.aes = list(size = 3)))
  116. print(p)
  117. return(p)
  118. }
  120. # Mouse plots
  121. p.m <- plot_pca_by_method(obj.i.mouse.IT, colors, "Mouse IT - PC2 vs PC3")
  122. SavePNGandSVG(p.m, dir.list$fig3$plots, "3F_Mouse-SpatialITSubclass-PCAEmbeddings")
  124. # Opossum plots
  125. p.o <- plot_pca_by_method(obj.i.opossum.IT, colors, "Opossum IT - PC2 vs PC3")
  126. SavePNGandSVG(p.o, dir.list$fig3$plots, "3F_Opossum-SpatialITSubclass-PCAEmbeddings")
  127. ```
  129. ```{r export_pc_coordinates}
  130. # Export PC coordinates for Python RGB calculation
  131. df.mouse <- data.frame(
  132. cell = colnames(obj.i.mouse.IT),
  133. method = obj.i.mouse.IT$method,
  134. subclass_nn = ifelse(obj.i.mouse.IT$method == "Stereo-seq",
  135. obj.i.mouse.IT$subclass_nn,
  136. obj.i.mouse.IT$subclass),
  137. X = obj.i.mouse.IT@reductions$[email hidden][, 2],
  138. Y = obj.i.mouse.IT@reductions$[email hidden][, 3]
  139. )
  140. write.csv(df.mouse, paste0(dir.list$fig3$data, "mouse_integrated_PC_coords.csv"), row.names = FALSE)
  142. df.opossum <- data.frame(
  143. cell = colnames(obj.i.opossum.IT),
  144. method = obj.i.opossum.IT$method,
  145. subclass_nn = ifelse(obj.i.opossum.IT$method == "Stereo-seq",
  146. obj.i.opossum.IT$subclass_nn,
  147. obj.i.opossum.IT$subclass),
  148. X = obj.i.opossum.IT@reductions$[email hidden][, 2],
  149. Y = obj.i.opossum.IT@reductions$[email hidden][, 3]
  150. )
  151. write.csv(df.opossum, paste0(dir.list$fig3$data, "opossum_integrated_PC_coords.csv"), row.names = FALSE)
  153. cat("Exported PC coordinates\n")
  154. ```
  156. ```{python find_triangle_vertices_mouse}
  157. # Find convex hull vertices in PC space using PCHA
  158. # Identifies extreme points defining the IT subtype continuum
  160. import pandas as pd
  161. import numpy as np
  162. from py_pcha import PCHA
  163. from collections import Counter
  165. # Load and filter for spatial cells (cleaner spatial distribution)
  166. df = pd.read_csv(r['dir.list']['fig3']['data'] + "mouse_integrated_PC_coords.csv")
  167. df_spatial = df.loc[df["method"] == "Stereo-seq"]
  168. X = np.array(df_spatial[["X", "Y"]])
  170. # Find 3 vertices (triangle corners)
  171. XC, S, C, SSE, varexpl = PCHA(X.T, noc=3, delta=0.1)
  173. # Identify which vertex corresponds to which subclass
  174. # For each vertex, find nearest cells and determine majority subclass
  175. vertex_subclasses = []
  176. for i in range(3):
  177. vertex = XC[:, i].reshape(1, -1)
  178. # Calculate distances to all spatial cells
  179. coords = np.array(df_spatial[["X", "Y"]])
  180. distances = np.linalg.norm(coords - vertex, axis=1)
  181. # Get 50 nearest cells
  182. nearest_idx = np.argsort(distances)[:50]
  183. # Get subclass labels for these cells from the CSV
  184. nearest_subclasses = df_spatial.iloc[nearest_idx]['subclass_nn'].values
  185. subclass_counts = Counter(nearest_subclasses)
  186. vertex_subclasses.append(subclass_counts.most_common(1)[0][0])
  188. print(f"Vertex identification: {vertex_subclasses}")
  190. # Create mapping to desired order: A (L2/3), B (L4), C (L5IT)
  191. vertex_map = {}
  192. for i, subclass in enumerate(vertex_subclasses):
  193. vertex_map[subclass] = i
  195. # Reorder vertices: [L2/3, L4, L5IT] -> [A, B, C]
  196. XC_mouse = XC[:, [vertex_map['L2/3'], vertex_map['L4'], vertex_map['L5IT']]]
  198. print("Mouse PC vertices (ordered A, B, C):")
  199. print(XC_mouse.T)
  200. ```
  202. ```{python find_triangle_vertices_opossum}
  203. # Find vertices for opossum
  205. df = pd.read_csv(r['dir.list']['fig3']['data'] + "opossum_integrated_PC_coords.csv")
  206. df_spatial = df.loc[df["method"] == "Stereo-seq"]
  207. X = np.array(df_spatial[["X", "Y"]])
  209. XC, S, C, SSE, varexpl = PCHA(X.T, noc=3, delta=0.1)
  211. # Identify which vertex corresponds to which subclass
  212. # For each vertex, find nearest cells and determine majority subclass
  213. vertex_subclasses = []
  214. for i in range(3):
  215. vertex = XC[:, i].reshape(1, -1)
  216. coords = np.array(df_spatial[["X", "Y"]])
  217. distances = np.linalg.norm(coords - vertex, axis=1)
  218. nearest_idx = np.argsort(distances)[:50]
  219. # Get subclass labels for these cells from the CSV
  220. nearest_subclasses = df_spatial.iloc[nearest_idx]['subclass_nn'].values
  221. subclass_counts = Counter(nearest_subclasses)
  222. vertex_subclasses.append(subclass_counts.most_common(1)[0][0])
  224. print(f"Vertex identification: {vertex_subclasses}")
  226. # Create mapping to desired order: A (IT_A), B (IT_B), C (IT_C)
  227. vertex_map = {}
  228. for i, subclass in enumerate(vertex_subclasses):
  229. vertex_map[subclass] = i
  231. # Reorder vertices: [IT_A, IT_B, IT_C] -> [A, B, C]
  232. XC_opossum = XC[:, [vertex_map['IT_A'], vertex_map['IT_B'], vertex_map['IT_C']]]
  234. print("Opossum PC vertices (ordered A, B, C):")
  235. print(XC_opossum.T)
  236. ```
  238. ```{python calculate_rgb_mouse}
  239. # Calculate RGB colors using barycentric coordinates
  240. # Color interpolates based on position within triangle
  242. import numpy as np
  243. from scipy.spatial.distance import cdist
  244. import pandas as pd
  245. from sklearn.neighbors import kneighbors_graph
  246. import networkx as nx
  247. from collections import Counter
  249. def barycentric_coords(triangle, points):
  250. """Calculate barycentric coordinates for RGB interpolation."""
  251. # Ensure shapes: triangle -> (3, 2), points -> (N, 2)
  252. tri = np.asarray(triangle, dtype=float).reshape(-1, 2)
  253. pts = np.asarray(points, dtype=float)
  255. A, B, C = tri[0], tri[1], tri[2]
  256. v0 = B - A
  257. v1 = C - A
  258. v2 = pts - A # (N, 2)
  260. d00 = np.dot(v0, v0)
  261. d01 = np.dot(v0, v1)
  262. d11 = np.dot(v1, v1)
  263. d20 = np.sum(v2 * v0, axis=1)
  264. d21 = np.sum(v2 * v1, axis=1)
  266. denom = d00 * d11 - d01 * d01
  267. v = (d11 * d20 - d01 * d21) / denom
  268. w = (d00 * d21 - d01 * d20) / denom
  269. u = 1.0 - v - w
  271. return np.column_stack([u, v, w])
  273. # Load full dataset
  274. df = pd.read_csv(r['dir.list']['fig3']['data'] + "mouse_integrated_PC_coords.csv")
  275. df_spatial = df.loc[df["method"] == "Stereo-seq"]
  276. cells = np.array(df_spatial[["X", "Y"]], dtype=float)
  277. cell_names = df_spatial["cell"].to_numpy()
  279. # Triangle vertices: shape (3, 2)
  280. vertices = np.asarray(XC_mouse.T, dtype=float)
  282. # Vertex colors: A=Cyan (L2/3), B=Yellow (L4), C=Purple (L5IT)
  283. colors = np.array([
  284. [0.31764706, 0.94117647, 0.89019608], # A: L2/3 (cyan)
  285. [1.0, 0.95294118, 0.18823529], # B: L4 (yellow)
  286. [0.36863, 0.23529, 0.6 ] # C: L5IT (purple)
  287. ], dtype=float)
  289. # Calculate RGB via barycentric interpolation
  290. bary_coords = barycentric_coords(vertices, cells)
  291. bary_coords = np.clip(bary_coords, 0.0, 1.0)
  293. cell_colors = np.clip(bary_coords @ colors, 0.0, 1.0)
  295. rgb_df = pd.DataFrame(
  296. cell_colors,
  297. columns=["R", "G", "B"],
  298. index=cell_names
  299. )
  301. # Euclidean distances to vertices
  302. euclidean_distances = cdist(cells, vertices, metric='euclidean')
  303. for i, vertex_label in enumerate(['Vertex_A', 'Vertex_B', 'Vertex_C']):
  304. rgb_df[f'Euclidean_to_{vertex_label}'] = euclidean_distances[:, i]
  306. # Geodesic distances via KNN graph
  307. n_neighbors = 5
  308. knn_graph = kneighbors_graph(
  309. cells, n_neighbors=n_neighbors,
  310. mode='distance', include_self=False
  311. )
  312. G = nx.from_scipy_sparse_array(knn_graph, edge_attribute='weight')
  314. vertex_indices = [
  315. np.argmin(np.linalg.norm(cells - vertex, axis=1))
  316. for vertex in vertices
  317. ]
  319. geodesic_distances = np.zeros((cells.shape[0], len(vertices)))
  320. for idx, vertex_idx in enumerate(vertex_indices):
  321. lengths = nx.single_source_dijkstra_path_length(G, vertex_idx)
  322. geodesic_distances[:, idx] = [
  323. lengths.get(i, np.inf) for i in range(cells.shape[0])
  324. ]
  326. for i, vertex_label in enumerate(['Vertex_A', 'Vertex_B', 'Vertex_C']):
  327. rgb_df[f'Geodesic_to_{vertex_label}'] = geodesic_distances[:, i]
  329. # Use r['dir.list'] again here
  330. rgb_df.to_csv(r['dir.list']['fig3']['data'] + "mouse_integrated_PC_colors.csv")
  332. print(
  333. f"Mouse: {len(rgb_df)} cells | RGB range [0-1]: "
  334. f"R[{rgb_df.R.min():.2f}-{rgb_df.R.max():.2f}] "
  335. f"G[{rgb_df.G.min():.2f}-{rgb_df.G.max():.2f}] "
  336. f"B[{rgb_df.B.min():.2f}-{rgb_df.B.max():.2f}]"
  337. )
  338. ```
  340. ```{python calculate_rgb_opossum}
  341. # Calculate RGB for opossum
  343. df = pd.read_csv(r['dir.list']['fig3']['data'] + "opossum_integrated_PC_coords.csv")
  344. df_spatial = df.loc[df["method"] == "Stereo-seq"]
  345. cells = np.array(df_spatial[["X", "Y"]])
  346. cell_names = df_spatial["cell"]
  348. # Triangle vertices: shape (3, 2)
  349. vertices = np.asarray(XC_opossum.T, dtype=float)
  351. # Vertex colors: A=Cyan (IT_A/L2/3), B=Yellow (IT_B/L4), C=Purple (IT_C/L5IT)
  352. colors = np.array([
  353. [0.31764706, 0.94117647, 0.89019608], # A: IT_A (cyan)
  354. [1.0, 0.95294118, 0.18823529], # B: IT_B (yellow)
  355. [0.36863, 0.23529, 0.6 ] # C: IT_C (purple)
  356. ], dtype=float)
  358. # Calculate RGB via barycentric interpolation
  359. bary_coords = barycentric_coords(vertices, cells)
  360. bary_coords = np.clip(bary_coords, 0.0, 1.0)
  362. cell_colors = np.clip(bary_coords @ colors, 0.0, 1.0)
  364. rgb_df = pd.DataFrame(
  365. cell_colors,
  366. columns=["R", "G", "B"],
  367. index=cell_names
  368. )
  370. # Euclidean distances to vertices
  371. euclidean_distances = cdist(cells, vertices, metric='euclidean')
  372. for i, vertex_label in enumerate(['Vertex_A', 'Vertex_B', 'Vertex_C']):
  373. rgb_df[f'Euclidean_to_{vertex_label}'] = euclidean_distances[:, i]
  375. # Geodesic distances via KNN graph
  376. n_neighbors = 5
  377. knn_graph = kneighbors_graph(
  378. cells, n_neighbors=n_neighbors,
  379. mode='distance', include_self=False
  380. )
  381. G = nx.from_scipy_sparse_array(knn_graph, edge_attribute='weight')
  383. vertex_indices = [
  384. np.argmin(np.linalg.norm(cells - vertex, axis=1))
  385. for vertex in vertices
  386. ]
  388. geodesic_distances = np.zeros((cells.shape[0], len(vertices)))
  389. for idx, vertex_idx in enumerate(vertex_indices):
  390. lengths = nx.single_source_dijkstra_path_length(G, vertex_idx)
  391. geodesic_distances[:, idx] = [
  392. lengths.get(i, np.inf) for i in range(cells.shape[0])
  393. ]
  395. for i, vertex_label in enumerate(['Vertex_A', 'Vertex_B', 'Vertex_C']):
  396. rgb_df[f'Geodesic_to_{vertex_label}'] = geodesic_distances[:, i]
  398. # Use r['dir.list'] again here
  399. rgb_df.to_csv(r['dir.list']['fig3']['data'] + "opossum_integrated_PC_colors.csv")
  401. print(
  402. f"Opossum: {len(rgb_df)} cells | RGB range [0-1]: "
  403. f"R[{rgb_df.R.min():.2f}-{rgb_df.R.max():.2f}] "
  404. f"G[{rgb_df.G.min():.2f}-{rgb_df.G.max():.2f}] "
  405. f"B[{rgb_df.B.min():.2f}-{rgb_df.B.max():.2f}]"
  406. )
  407. ```
  409. ```{r plot_pc_gradients, fig.width=6, fig.height=6}
  410. # RGB gradients in PC space - Figure 3G
  411. DimPlotGradient <- function(obj, rgb_csv, pc1 = "PC_2", pc2 = "PC_3", size = 2) {
  413. # Load RGB colors from CSV
  414. rgb_data <- read.csv(rgb_csv, row.names = 1)
  416. # Extract PC coordinates from the Seurat object
  417. pc_coords <- Embeddings(obj, reduction = "pca")[, c(pc1, pc2)]
  419. # Create dataframe
  420. df <- data.frame(PC1 = pc_coords[, 1], PC2 = pc_coords[, 2], cells = rownames(pc_coords))
  422. # Merge colors with PC coordinates
  423. df <- merge(df, rgb_data, by.x = "cells", by.y = "row.names", all.x = TRUE)
  424. df <- df[!is.na(df$R), ]
  426. # Ensure RGB values are within range [0,1]
  427. df$R <- pmax(0, pmin(1, df$R))
  428. df$G <- pmax(0, pmin(1, df$G))
  429. df$B <- pmax(0, pmin(1, df$B))
  431. # Convert RGB to hex color codes
  432. df$hex_color <- with(df, rgb(R, G, B, maxColorValue = 1))
  434. # Reorder points for proper layering
  435. df <- df[order(df$R + df$G + df$B, decreasing = FALSE), ]
  437. # Generate scatter plot
  438. p <- ggplot(df, aes(x = PC1, y = PC2, color = hex_color)) +
  439. geom_point(shape = 19, size = size, alpha = 1) +
  440. scale_color_identity() + # Directly use hex colors, no legend
  441. theme_minimal() +
  442. theme(axis.text = element_blank(), axis.ticks = element_blank()) +
  443. guides(color = "none") + # Remove color legend
  444. coord_equal()
  446. return(p)
  447. }
  449. # Mouse
  450. p <- DimPlotGradient(
  451. obj = obj.i.mouse.IT,
  452. rgb_csv = paste0(dir.list$fig3$data, "mouse_integrated_PC_colors.csv"),
  453. size = 3
  454. )
  455. print(p)
  456. SavePNGandSVG(p, dir.list$fig3$plots, "3G_Mouse-SpatialIT-PCGradient")
  458. # Opossum
  459. p <- DimPlotGradient(
  460. obj = obj.i.opossum.IT,
  461. rgb_csv = paste0(dir.list$fig3$data, "opossum_integrated_PC_colors.csv"),
  462. pc1 = "PC_2",
  463. pc2 = "PC_3",
  464. size = 3
  465. )
  466. print(p)
  467. SavePNGandSVG(p, dir.list$fig3$plots, "3G_Opossum-SpatialIT-PCGradient")
  468. ```
  470. ```{r plot_spatial_gradients_mouse, fig.width=8, fig.height=5}
  471. # RGB gradients in spatial coordinates - Mouse (Figure 3H - top)
  473. mouse.rgb <- paste0(dir.list$fig3$data, "mouse_integrated_PC_colors.csv")
  475. # All IT subtypes
  476. p <- PlotImageDimGradient(obj = obj.i.mouse.IT, rgb_csv = mouse.rgb,
  477. ratio = 1.5, size = 2, yticks = c(0, 500, 1000, 1500)) +
  478. scale_y_continuous(limits = c(0, 1500)) +
  479. coord_fixed(ratio = 1.5) + theme(axis.text.y = element_text())
  480. print(p)
  482. # L2/3
  483. p <- PlotImageDimGradient(obj = subset(obj.i.mouse.IT, subclass_nn == "L2/3"),
  484. rgb_csv = mouse.rgb, ratio = 1.5, yticks = c(0, 500, 1000, 1500)) +
  485. scale_y_continuous(limits = c(0, 1500)) +
  486. coord_fixed(ratio = 1.5) + ggtitle("Mouse L2/3")
  487. print(p)
  488. SavePNGandSVG(p, dir.list$fig3$plots, "3H_Mouse-SpatialL23-ColumnGradient")
  490. # L4
  491. p <- PlotImageDimGradient(obj = subset(obj.i.mouse.IT, subclass_nn == "L4"),
  492. rgb_csv = mouse.rgb, ratio = 1.5, yticks = c(0, 500, 1000, 1500)) +
  493. scale_y_continuous(limits = c(0, 1500)) +
  494. coord_fixed(ratio = 1.5) + ggtitle("Mouse L4")
  495. print(p)
  496. SavePNGandSVG(p, dir.list$fig3$plots, "3H_Mouse-SpatialL4-ColumnGradient")
  498. # L5IT
  499. p <- PlotImageDimGradient(obj = subset(obj.i.mouse.IT, subclass_nn == "L5IT"),
  500. rgb_csv = mouse.rgb, ratio = 1.5, yticks = c(0, 500, 1000, 1500)) +
  501. scale_y_continuous(limits = c(0, 1500)) +
  502. coord_fixed(ratio = 1.5) + ggtitle("Mouse L5IT")
  503. print(p)
  504. SavePNGandSVG(p, dir.list$fig3$plots, "3H_Mouse-SpatialL5IT-ColumnGradient")
  505. ```
  507. ```{r plot_spatial_gradients_opossum, fig.width=8, fig.height=5}
  508. # RGB gradients in spatial coordinates - Opossum (Figure 3H - bottom)
  510. opossum.rgb <- paste0(dir.list$fig3$data, "opossum_integrated_PC_colors.csv")
  512. # All IT subtypes
  513. p <- PlotImageDimGradient(obj = obj.i.opossum.IT, rgb_csv = opossum.rgb,
  514. ratio = 0.77 * 1.5, size = 2, yticks = c(0, 400, 800, 1200, 1600)) +
  515. scale_y_continuous(limits = c(0, 1600)) +
  516. coord_fixed(ratio = 0.77 * 1.5) + theme(axis.text.y = element_text())
  517. print(p)
  519. # IT_A
  520. p <- PlotImageDimGradient(obj = subset(obj.i.opossum.IT, subclass_nn == "IT_A"),
  521. rgb_csv = opossum.rgb, ratio = 0.77 * 1.5,
  522. yticks = c(0, 400, 800, 1200, 1600)) +
  523. scale_y_continuous(limits = c(0, 1600)) +
  524. coord_fixed(ratio = 0.77 * 1.5) + ggtitle("Opossum IT_A")
  525. print(p)
  526. SavePNGandSVG(p, dir.list$fig3$plots, "3H_Opossum_SpatialITA-ColumnGradient")
  528. # IT_B
  529. p <- PlotImageDimGradient(obj = subset(obj.i.opossum.IT, subclass_nn == "IT_B"),
  530. rgb_csv = opossum.rgb, ratio = 0.77 * 1.5,
  531. yticks = c(0, 400, 800, 1200, 1600)) +
  532. scale_y_continuous(limits = c(0, 1600)) +
  533. coord_fixed(ratio = 0.77 * 1.5) + ggtitle("Opossum IT_B")
  534. print(p)
  535. SavePNGandSVG(p, dir.list$fig3$plots, "3H_Opossum_SpatialITB-ColumnGradient")
  537. # IT_C
  538. p <- PlotImageDimGradient(obj = subset(obj.i.opossum.IT, subclass_nn == "IT_C"),
  539. rgb_csv = opossum.rgb, ratio = 0.77 * 1.5,
  540. yticks = c(0, 400, 800, 1200, 1600)) +
  541. scale_y_continuous(limits = c(0, 1600)) +
  542. coord_fixed(ratio = 0.77 * 1.5) + ggtitle("Opossum IT_C")
  543. print(p)
  544. SavePNGandSVG(p, dir.list$fig3$plots, "3H_Opossum_SpatialITC-ColumnGradient")
  545. ```
  547. ```{r, fig.width=2, fig.height=3}
  548. calculate_density_by_layer_sample <- function(obj, subclass_query, subclass_ref, scale_to_mm = 0.0005) {
  550. coords <- as.data.frame(obj@images[[1]]$centroids@coords)
  551. colnames(coords) <- c("depth", "tangential")
  553. spatial_cells <- Cells(obj@images[[1]])
  554. coords$subclass_nn <- obj$subclass_nn[spatial_cells]
  555. coords$sample <- obj$sample[spatial_cells]
  556. coords <- coords[!is.na(coords$subclass_nn), ]
  558. # Get mean depth of reference layer (across all samples)
  559. ref_depth <- mean(coords$depth[coords$subclass_nn == subclass_ref], na.rm = TRUE)
  561. # Calculate per sample
  562. results <- lapply(unique(coords$sample), function(s) {
  563. coords_s <- coords[coords$sample == s, ]
  564. coords_query <- coords_s[coords_s$subclass_nn == subclass_query, ]
  565. coords_query$position <- ifelse(coords_query$depth > ref_depth, "above", "below")
  567. width_mm <- diff(range(coords_s$tangential)) * scale_to_mm
  569. depth_above <- coords_query$depth[coords_query$position == "above"]
  570. depth_below <- coords_query$depth[coords_query$position == "below"]
  572. height_above_mm <- abs(max(depth_above) - ref_depth) * scale_to_mm
  573. height_below_mm <- abs(ref_depth - min(depth_below)) * scale_to_mm
  575. area_above_mm2 <- width_mm * height_above_mm
  576. area_below_mm2 <- width_mm * height_below_mm
  578. count_above <- sum(coords_query$position == "above")
  579. count_below <- sum(coords_query$position == "below")
  581. density_above <- count_above / area_above_mm2
  582. density_below <- count_below / area_below_mm2
  584. data.frame(
  585. sample = s,
  586. density_above = density_above,
  587. density_below = density_below,
  588. ratio_below_above = density_below / density_above
  589. )
  590. })
  592. do.call(rbind, results)
  593. }
  595. # Calculate per-sample densities
  596. density_mouse_samples <- calculate_density_by_layer_sample(obj.i.mouse.IT, "L2/3", "L4")
  597. density_mouse_samples$species <- "Mouse"
  599. density_opossum_samples <- calculate_density_by_layer_sample(obj.i.opossum.IT, "IT_A", "IT_B")
  600. density_opossum_samples$species <- "Opossum"
  602. density_samples <- rbind(density_mouse_samples, density_opossum_samples)
  603. print(density_samples)
  605. # Wilcoxon rank sum test on ratios
  606. wilcox_result <- wilcox.test(
  607. ratio_below_above ~ species,
  608. data = density_samples
  609. )
  610. cat("\nWilcoxon rank sum test (below/above ratio):\n")
  611. cat(" W =", wilcox_result$statistic, "\n")
  612. cat(" p =", signif(wilcox_result$p.value, 3), "\n")
  614. # Summarize for barplot
  615. ratio_summary <- density_samples %>%
  616. group_by(species) %>%
  617. summarize(
  618. mean_ratio = mean(ratio_below_above),
  619. se_ratio = sd(ratio_below_above) / sqrt(n()),
  620. .groups = "drop"
  621. )
  623. p_ratio <- ggplot(ratio_summary, aes(x = species, y = mean_ratio, fill = species)) +
  624. geom_bar(stat = "identity", width = 0.7) +
  625. geom_errorbar(aes(ymin = mean_ratio - se_ratio, ymax = mean_ratio + se_ratio),
  626. width = 0.2) +
  627. geom_jitter(data = density_samples, aes(y = ratio_below_above),
  628. width = 0.1, size = 2, shape = 21, fill = "black") +
  629. scale_fill_manual(values = c("Opossum" = colors$Opossum, "Mouse" = colors$Mouse)) +
  630. scale_y_continuous(expand = expansion(mult = c(0, 0.1)), limits = c(0, 0.35)) +
  631. labs(x = NULL, y = "Density ratio (below / above L4)") +
  632. theme_classic() +
  633. theme(
  634. axis.text = element_text(color = "black"),
  635. legend.position = "none"
  636. ) +
  637. annotate("text", x = 1.5, y = max(ratio_summary$mean_ratio + ratio_summary$se_ratio) * 1.15,
  638. label = sprintf("p = %s", signif(wilcox_result$p.value, 2)), size = 4)
  640. print(p_ratio)
  641. SavePNGandSVG(p_ratio, dir.list$fig3$plots, "3I_OpossumMouse-L23ITADensityAboveBelowRatio-Bar")
  642. ```
  644. ```{r}
  645. # Correlation between spatial Y position and PC vertex distances
  646. # Tests whether cells' positions along cortical depth correlate with their PC-space distances
  648. # Parameters
  649. mouse_subclass <- "L2/3"
  650. opossum_subclass <- "IT_A"
  651. vertices <- c("B", "C") # Test distances to vertices B and C
  653. # Separate regimes for mouse and opossum (top of L2/3 to middle of L4)
  654. regimes <- list(
  655. list(mouse = c(1000, 1550), opossum = c(800, 1550))
  656. )
  658. # Load distance data (already contains Euclidean and Geodesic distances)
  659. mouse.rgb <- read.csv(paste0(dir.list$fig3$data, "mouse_integrated_PC_colors.csv"),
  660. row.names = 1)
  661. opossum.rgb <- read.csv(paste0(dir.list$fig3$data, "opossum_integrated_PC_colors.csv"),
  662. row.names = 1)
  664. for (vertex_label in vertices) {
  665. vertex_col <- paste0("Euclidean_to_Vertex_", vertex_label)
  667. # Extract mouse spatial coordinates and distances
  668. mouse_cells <- colnames(obj.i.mouse.IT)[
  669. !is.na(obj.i.mouse.IT$subclass_nn) &
  670. obj.i.mouse.IT$subclass_nn == mouse_subclass
  671. ]
  672. mouse_coords <- obj.i.mouse.IT@images[[1]]$centroids@coords[
  673. obj.i.mouse.IT$subclass_nn[!is.na(obj.i.mouse.IT$subclass_nn)] == mouse_subclass,
  674. ]
  675. rownames(mouse_coords) <- mouse_cells
  676. mouse_y_positions <- mouse_coords[mouse_cells, "x"]
  677. mouse_distance <- mouse.rgb[mouse_cells, vertex_col]
  679. # Extract opossum spatial coordinates and distances
  680. opossum_cells <- colnames(obj.i.opossum.IT)[
  681. !is.na(obj.i.opossum.IT$subclass_nn) &
  682. obj.i.opossum.IT$subclass_nn == opossum_subclass
  683. ]
  684. opossum_coords <- obj.i.opossum.IT@images[[1]]$centroids@coords[
  685. obj.i.opossum.IT$subclass_nn[!is.na(obj.i.opossum.IT$subclass_nn)] == opossum_subclass,
  686. ]
  687. rownames(opossum_coords) <- opossum_cells
  688. opossum_y_positions <- opossum_coords[opossum_cells, "x"]
  689. opossum_distance <- opossum.rgb[opossum_cells, vertex_col]
  691. for (regime in regimes) {
  692. mouse_xmin <- regime$mouse[1]
  693. mouse_xmax <- regime$mouse[2]
  694. opossum_xmin <- regime$opossum[1]
  695. opossum_xmax <- regime$opossum[2]
  697. # Filter by species-specific cortical depth regimes
  698. mouse_idx <- mouse_y_positions >= mouse_xmin & mouse_y_positions < mouse_xmax
  699. opossum_idx <- opossum_y_positions >= opossum_xmin & opossum_y_positions < opossum_xmax
  701. # Normalize Y positions to [0, 1] within each species' regime
  702. mouse_y_norm <- 1 - (mouse_y_positions[mouse_idx] - mouse_xmin) / (mouse_xmax - mouse_xmin)
  703. opossum_y_norm <- 1 - (opossum_y_positions[opossum_idx] - opossum_xmin) / (opossum_xmax - opossum_xmin)
  705. # Create combined dataframe with normalized positions
  706. df_combined <- data.frame(
  707. Y_Position_Normalized = c(mouse_y_norm, opossum_y_norm),
  708. Distance = c(mouse_distance[mouse_idx], opossum_distance[opossum_idx]),
  709. Species = c(rep("Mouse", sum(mouse_idx)), rep("Opossum", sum(opossum_idx)))
  710. )
  712. mouse_regime <- df_combined[df_combined$Species == "Mouse", ]
  713. opossum_regime <- df_combined[df_combined$Species == "Opossum", ]
  715. # Calculate Spearman correlations
  716. mouse_cor <- cor.test(mouse_regime$Y_Position_Normalized, mouse_regime$Distance,
  717. method = "spearman")
  718. opossum_cor <- cor.test(opossum_regime$Y_Position_Normalized, opossum_regime$Distance,
  719. method = "spearman")
  721. plot_title <- sprintf(
  722. "Y Position vs. Distance (%s / %s, Vertex %s)",
  723. mouse_subclass, opossum_subclass, vertex_label
  724. )
  726. p <- ggplot(df_combined, aes(x = Y_Position_Normalized, y = Distance, color = Species)) +
  727. geom_point(alpha = 0.75, size = 1) +
  728. geom_smooth(method = "lm", se = TRUE) +
  729. labs(
  730. title = plot_title,
  731. subtitle = sprintf(
  732. "Mouse [%d-%d], Opossum [%d-%d]\nSpearman r: Mouse=%.2f (p=%.3g), Opossum=%.2f (p=%.3g)",
  733. mouse_xmin, mouse_xmax, opossum_xmin, opossum_xmax,
  734. mouse_cor$estimate, mouse_cor$p.value,
  735. opossum_cor$estimate, opossum_cor$p.value
  736. ),
  737. x = "Normalized Y Position (0=superficial, 1=deep)",
  738. y = vertex_col
  739. ) +
  740. theme_bw(base_size = 14) +
  741. ylim(15, 45) +
  742. xlim(0, 1) +
  743. coord_fixed(ratio = 1 / 15) +
  744. scale_color_manual(values = c("Opossum" = "#c692b8", "Mouse" = "#aaaaaa"))
  746. print(p)
  747. SavePNGandSVG(p, dir.list$fig3$plots,
  748. sprintf("3J_OpossumMouse-Spatial%s%s-CorrVertex%s-ScatterFit",
  749. gsub("/", "", mouse_subclass), opossum_subclass, vertex_label))
  750. }
  751. }
  752. ```
  754. ```{r shuffle_control_setup}
  755. # Shuffle control: Randomize PC distance assignments
  756. # Tests if spatial gradient pattern is significant by shuffling distance values
  758. set.seed(9999)
  760. shuffle_distance_test <- function(y, x, n_perm = 10000L) {
  761. # y = depth (Y_Position), x = distance values
  762. obs_r <- suppressWarnings(cor(y, x, method = "spearman"))
  763. r_perm <- numeric(n_perm)
  765. for (i in seq_len(n_perm)) {
  766. x_perm <- sample(x, length(x), replace = FALSE)
  767. r_perm[i] <- suppressWarnings(cor(y, x_perm, method = "spearman"))
  768. }
  770. p_emp <- mean(abs(r_perm) >= abs(obs_r))
  771. list(obs_r = obs_r, p_emp = p_emp, r_perm = r_perm)
  772. }
  774. shuffle_results_mouse <- list()
  775. shuffle_results_opossum <- list()
  776. ```
  778. ```{r shuffle_control_mouse}
  779. # Mouse shuffle control
  780. cat("=== Mouse Shuffle Control (Distance Randomization) ===\n")
  782. mouse_subclass <- "L2/3"
  783. vertices <- c("B", "C")
  784. regimes <- list(list(mouse = c(1000, 1550), opossum = c(1000, 1550)))
  786. mouse.rgb <- read.csv(paste0(dir.list$fig3$data, "mouse_integrated_PC_colors.csv"),
  787. row.names = 1)
  789. for (vertex_label in vertices) {
  790. vertex_col <- paste0("Euclidean_to_Vertex_", vertex_label)
  792. mouse_cells <- colnames(obj.i.mouse.IT)[
  793. !is.na(obj.i.mouse.IT$subclass_nn) &
  794. obj.i.mouse.IT$subclass_nn == mouse_subclass
  795. ]
  796. mouse_coords <- obj.i.mouse.IT@images[[1]]$centroids@coords[
  797. obj.i.mouse.IT$subclass_nn[!is.na(obj.i.mouse.IT$subclass_nn)] == mouse_subclass,
  798. ]
  799. rownames(mouse_coords) <- mouse_cells
  800. mouse_y_positions <- mouse_coords[mouse_cells, "x"]
  801. mouse_distance <- mouse.rgb[mouse_cells, vertex_col]
  803. for (regime in regimes) {
  804. mouse_xmin <- regime$mouse[1]
  805. mouse_xmax <- regime$mouse[2]
  807. idx <- mouse_y_positions >= mouse_xmin & mouse_y_positions < mouse_xmax
  808. y_regime <- 1 - (mouse_y_positions[idx] - mouse_xmin) / (mouse_xmax - mouse_xmin)
  809. x_regime <- mouse_distance[idx]
  811. res_shuffle <- shuffle_distance_test(
  812. y = y_regime,
  813. x = x_regime,
  814. n_perm = 10000L
  815. )
  817. key <- sprintf("Mouse_L23_Vertex_%s_%d_%d", vertex_label, mouse_xmin, mouse_xmax)
  818. shuffle_results_mouse[[key]] <- res_shuffle
  820. cat(key, " | obs r =", round(res_shuffle$obs_r, 3),
  821. " | shuffle p =", signif(res_shuffle$p_emp, 3), "\n")
  822. }
  823. }
  824. ```
  826. ```{r shuffle_control_opossum}
  827. # Opossum shuffle control
  828. cat("\n=== Opossum Shuffle Control (Distance Randomization) ===\n")
  830. opossum_subclass <- "IT_A"
  832. opossum.rgb <- read.csv(paste0(dir.list$fig3$data, "opossum_integrated_PC_colors.csv"),
  833. row.names = 1)
  835. for (vertex_label in vertices) {
  836. vertex_col <- paste0("Euclidean_to_Vertex_", vertex_label)
  838. opossum_cells <- colnames(obj.i.opossum.IT)[
  839. !is.na(obj.i.opossum.IT$subclass_nn) &
  840. obj.i.opossum.IT$subclass_nn == opossum_subclass
  841. ]
  842. opossum_coords <- obj.i.opossum.IT@images[[1]]$centroids@coords[
  843. obj.i.opossum.IT$subclass_nn[!is.na(obj.i.opossum.IT$subclass_nn)] == opossum_subclass,
  844. ]
  845. rownames(opossum_coords) <- opossum_cells
  846. opossum_y_positions <- opossum_coords[opossum_cells, "x"]
  847. opossum_distance <- opossum.rgb[opossum_cells, vertex_col]
  849. for (regime in regimes) {
  850. opossum_xmin <- regime$opossum[1]
  851. opossum_xmax <- regime$opossum[2]
  853. idx <- opossum_y_positions >= opossum_xmin & opossum_y_positions < opossum_xmax
  854. y_regime <- 1 - (opossum_y_positions[idx] - opossum_xmin) / (opossum_xmax - opossum_xmin)
  855. x_regime <- opossum_distance[idx]
  857. res_shuffle <- shuffle_distance_test(
  858. y = y_regime,
  859. x = x_regime,
  860. n_perm = 10000L
  861. )
  863. key <- sprintf("Opossum_ITA_Vertex_%s_%d_%d", vertex_label, opossum_xmin, opossum_xmax)
  864. shuffle_results_opossum[[key]] <- res_shuffle
  866. cat(key, " | obs r =", round(res_shuffle$obs_r, 3),
  867. " | shuffle p =", signif(res_shuffle$p_emp, 3), "\n")
  868. }
  869. }
  870. ```
  872. ```{r partial_correlation_setup}
  873. # Partial correlation: depth vs Vertex C controlling for Vertex B
  874. # Tests if relationship between depth and one vertex is independent of the other
  876. library(ppcor)
  878. mouse_subclass <- "L2/3"
  879. opossum_subclass <- "IT_A"
  880. regimes <- list(list(mouse = c(1000, 1550), opossum = c(1000, 1550)))
  882. mouse.rgb <- read.csv(paste0(dir.list$fig3$data, "mouse_integrated_PC_colors.csv"),
  883. row.names = 1)
  884. opossum.rgb <- read.csv(paste0(dir.list$fig3$data, "opossum_integrated_PC_colors.csv"),
  885. row.names = 1)
  886. ```
  888. ```{r partial_correlation_mouse}
  889. # Mouse partial correlations
  890. cat("=== Mouse Partial Correlations ===\n")
  892. mouse_cells <- colnames(obj.i.mouse.IT)[
  893. !is.na(obj.i.mouse.IT$subclass_nn) &
  894. obj.i.mouse.IT$subclass_nn == mouse_subclass
  895. ]
  896. mouse_coords <- obj.i.mouse.IT@images[[1]]$centroids@coords[
  897. obj.i.mouse.IT$subclass_nn[!is.na(obj.i.mouse.IT$subclass_nn)] == mouse_subclass,
  898. ]
  899. rownames(mouse_coords) <- mouse_cells
  901. mouse_y <- mouse_coords[mouse_cells, "x"]
  902. mouse_dB <- mouse.rgb[mouse_cells, "Euclidean_to_Vertex_B"]
  903. mouse_dC <- mouse.rgb[mouse_cells, "Euclidean_to_Vertex_C"]
  905. for (regime in regimes) {
  906. mouse_xmin <- regime$mouse[1]
  907. mouse_xmax <- regime$mouse[2]
  909. idx <- mouse_y >= mouse_xmin & mouse_y < mouse_xmax
  911. df_mouse <- data.frame(
  912. Y = 1 - (mouse_y[idx] - mouse_xmin) / (mouse_xmax - mouse_xmin),
  913. dB = mouse_dB[idx],
  914. dC = mouse_dC[idx]
  915. )
  917. # Ordinary Spearman correlations
  918. cor_Y_dB <- cor(df_mouse$Y, df_mouse$dB, method = "spearman")
  919. cor_Y_dC <- cor(df_mouse$Y, df_mouse$dC, method = "spearman")
  920. cor_dB_dC <- cor(df_mouse$dB, df_mouse$dC, method = "spearman")
  922. cat(sprintf("\nMouse [%d-%d]:\n", mouse_xmin, mouse_xmax))
  923. cat("Spearman correlations:\n")
  924. cat(" Y vs dB =", round(cor_Y_dB, 3), "\n")
  925. cat(" Y vs dC =", round(cor_Y_dC, 3), "\n")
  926. cat(" dB vs dC =", round(cor_dB_dC, 3), "\n")
  928. # Partial correlations
  929. pcor_C_given_B <- pcor.test(
  930. x = df_mouse$Y,
  931. y = df_mouse$dC,
  932. z = df_mouse$dB,
  933. method = "spearman"
  934. )
  936. pcor_B_given_C <- pcor.test(
  937. x = df_mouse$Y,
  938. y = df_mouse$dB,
  939. z = df_mouse$dC,
  940. method = "spearman"
  941. )
  943. cat("Partial correlations:\n")
  944. cat(" Y ~ dC | dB: r =", round(pcor_C_given_B$estimate, 3),
  945. " p =", signif(pcor_C_given_B$p.value, 3), "\n")
  946. cat(" Y ~ dB | dC: r =", round(pcor_B_given_C$estimate, 3),
  947. " p =", signif(pcor_B_given_C$p.value, 3), "\n")
  948. }
  949. ```
  951. ```{r partial_correlation_opossum}
  952. # Opossum partial correlations
  953. cat("\n=== Opossum Partial Correlations ===\n")
  955. opossum_cells <- colnames(obj.i.opossum.IT)[
  956. !is.na(obj.i.opossum.IT$subclass_nn) &
  957. obj.i.opossum.IT$subclass_nn == opossum_subclass
  958. ]
  959. opossum_coords <- obj.i.opossum.IT@images[[1]]$centroids@coords[
  960. obj.i.opossum.IT$subclass_nn[!is.na(obj.i.opossum.IT$subclass_nn)] == opossum_subclass,
  961. ]
  962. rownames(opossum_coords) <- opossum_cells
  964. opossum_y <- opossum_coords[opossum_cells, "x"]
  965. opossum_dB <- opossum.rgb[opossum_cells, "Euclidean_to_Vertex_B"]
  966. opossum_dC <- opossum.rgb[opossum_cells, "Euclidean_to_Vertex_C"]
  968. for (regime in regimes) {
  969. opossum_xmin <- regime$opossum[1]
  970. opossum_xmax <- regime$opossum[2]
  972. idx <- opossum_y >= opossum_xmin & opossum_y < opossum_xmax
  974. df_opossum <- data.frame(
  975. Y = 1 - (opossum_y[idx] - opossum_xmin) / (opossum_xmax - opossum_xmin),
  976. dB = opossum_dB[idx],
  977. dC = opossum_dC[idx]
  978. )
  980. # Ordinary Spearman correlations
  981. cor_Y_dB <- cor(df_opossum$Y, df_opossum$dB, method = "spearman")
  982. cor_Y_dC <- cor(df_opossum$Y, df_opossum$dC, method = "spearman")
  983. cor_dB_dC <- cor(df_opossum$dB, df_opossum$dC, method = "spearman")
  985. cat(sprintf("\nOpossum [%d-%d]:\n", opossum_xmin, opossum_xmax))
  986. cat("Spearman correlations:\n")
  987. cat(" Y vs dB =", round(cor_Y_dB, 3), "\n")
  988. cat(" Y vs dC =", round(cor_Y_dC, 3), "\n")
  989. cat(" dB vs dC =", round(cor_dB_dC, 3), "\n")
  991. # Partial correlations
  992. pcor_C_given_B <- pcor.test(
  993. x = df_opossum$Y,
  994. y = df_opossum$dC,
  995. z = df_opossum$dB,
  996. method = "spearman"
  997. )
  999. pcor_B_given_C <- pcor.test(
  1000. x = df_opossum$Y,
  1001. y = df_opossum$dB,
  1002. z = df_opossum$dC,
  1003. method = "spearman"
  1004. )
  1006. cat("Partial correlations:\n")
  1007. cat(" Y ~ dC | dB: r =", round(pcor_C_given_B$estimate, 3),
  1008. " p =", signif(pcor_C_given_B$p.value, 3), "\n")
  1009. cat(" Y ~ dB | dC: r =", round(pcor_B_given_C$estimate, 3),
  1010. " p =", signif(pcor_B_given_C$p.value, 3), "\n")
  1011. }
  1012. ```
  1014. ```{r partial_correlation_permutation}
  1015. partial_cor_permutation <- function(y, x, z, n_perm = 10000, method = "spearman") {
  1016. obs_pcor <- ppcor::pcor.test(y, x, z, method = method)$estimate
  1018. r_perm <- replicate(n_perm, {
  1019. y_shuf <- sample(y)
  1020. ppcor::pcor.test(y_shuf, x, z, method = method)$estimate
  1021. })
  1023. p_emp <- mean(abs(r_perm) >= abs(obs_pcor))
  1025. list(obs_r = obs_pcor, r_perm = r_perm, p_emp = p_emp)
  1026. }
  1028. mouse_subclass <- "L2/3"
  1029. opossum_subclass <- "IT_A"
  1030. regimes <- list(list(mouse = c(1000, 1550), opossum = c(1000, 1550)))
  1032. # Mouse
  1033. cat("=== Mouse Partial Correlations (Permutation) ===\n")
  1035. mouse_cells <- colnames(obj.i.mouse.IT)[
  1036. !is.na(obj.i.mouse.IT$subclass_nn) &
  1037. obj.i.mouse.IT$subclass_nn == mouse_subclass
  1038. ]
  1039. mouse_coords <- obj.i.mouse.IT@images[[1]]$centroids@coords[
  1040. obj.i.mouse.IT$subclass_nn[!is.na(obj.i.mouse.IT$subclass_nn)] == mouse_subclass,
  1041. ]
  1042. rownames(mouse_coords) <- mouse_cells
  1044. mouse_y <- mouse_coords[mouse_cells, "x"]
  1045. mouse_dB <- mouse.rgb[mouse_cells, "Euclidean_to_Vertex_B"]
  1046. mouse_dC <- mouse.rgb[mouse_cells, "Euclidean_to_Vertex_C"]
  1048. for (regime in regimes) {
  1049. idx <- mouse_y >= regime$mouse[1] & mouse_y < regime$mouse[2]
  1051. df_mouse <- data.frame(
  1052. Y = 1 - (mouse_y[idx] - regime$mouse[1]) / (regime$mouse[2] - regime$mouse[1]),
  1053. dB = mouse_dB[idx],
  1054. dC = mouse_dC[idx]
  1055. )
  1057. set.seed(42)
  1058. pcor_C_given_B <- partial_cor_permutation(df_mouse$Y, df_mouse$dC, df_mouse$dB)
  1059. pcor_B_given_C <- partial_cor_permutation(df_mouse$Y, df_mouse$dB, df_mouse$dC)
  1061. cat(sprintf("\nMouse [%d-%d] (n = %d cells):\n", regime$mouse[1], regime$mouse[2], nrow(df_mouse)))
  1062. cat(" Y ~ dC | dB: r =", round(pcor_C_given_B$obs_r, 3),
  1063. " p =", signif(pcor_C_given_B$p_emp, 3), "\n")
  1064. cat(" Y ~ dB | dC: r =", round(pcor_B_given_C$obs_r, 3),
  1065. " p =", signif(pcor_B_given_C$p_emp, 3), "\n")
  1066. }
  1068. # Opossum
  1069. cat("\n=== Opossum Partial Correlations (Permutation) ===\n")
  1071. opossum_cells <- colnames(obj.i.opossum.IT)[
  1072. !is.na(obj.i.opossum.IT$subclass_nn) &
  1073. obj.i.opossum.IT$subclass_nn == opossum_subclass
  1074. ]
  1075. opossum_coords <- obj.i.opossum.IT@images[[1]]$centroids@coords[
  1076. obj.i.opossum.IT$subclass_nn[!is.na(obj.i.opossum.IT$subclass_nn)] == opossum_subclass,
  1077. ]
  1078. rownames(opossum_coords) <- opossum_cells
  1080. opossum_y <- opossum_coords[opossum_cells, "x"]
  1081. opossum_dB <- opossum.rgb[opossum_cells, "Euclidean_to_Vertex_B"]
  1082. opossum_dC <- opossum.rgb[opossum_cells, "Euclidean_to_Vertex_C"]
  1084. for (regime in regimes) {
  1085. idx <- opossum_y >= regime$opossum[1] & opossum_y < regime$opossum[2]
  1087. df_opossum <- data.frame(
  1088. Y = 1 - (opossum_y[idx] - regime$opossum[1]) / (regime$opossum[2] - regime$opossum[1]),
  1089. dB = opossum_dB[idx],
  1090. dC = opossum_dC[idx]
  1091. )
  1093. set.seed(42)
  1094. pcor_C_given_B <- partial_cor_permutation(df_opossum$Y, df_opossum$dC, df_opossum$dB)
  1095. pcor_B_given_C <- partial_cor_permutation(df_opossum$Y, df_opossum$dB, df_opossum$dC)
  1097. cat(sprintf("\nOpossum [%d-%d] (n = %d cells):\n", regime$opossum[1], regime$opossum[2], nrow(df_opossum)))
  1098. cat(" Y ~ dC | dB: r =", round(pcor_C_given_B$obs_r, 3),
  1099. " p =", signif(pcor_C_given_B$p_emp, 3), "\n")
  1100. cat(" Y ~ dB | dC: r =", round(pcor_B_given_C$obs_r, 3),
  1101. " p =", signif(pcor_B_given_C$p_emp, 3), "\n")
  1102. }
  1103. ```
  1105. ```{r}
  1106. # Set the Python path back for Seurat (restart R)
  1107. Sys.setenv(RETICULATE_PYTHON = "C:/Users/TLab/AppData/Local/Programs/Python/Python311/python.exe")
  1108. ```

3FGHIJ_OpossumMouse_PCGradients.Rmd at commit 8c490f6, under MIT · at the source

Overview

Authors: Ryan Gorzek1, Joshua T Trachtenberg1
ORCID iDs: Joshua T Trachtenberg
  1. Department of Neurobiology, David Geffen School of Medicine, University of California, Los Angeles, Los Angeles, CA 90095, USA
Institutions: University of California, Los Angeles (United States)
Journal: PNAS nexus, volume 5, issue 4, article pgag055
Dates: received 13 October 2025; accepted 19 February 2026; published online 16 April 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1093/pnasnexus/pgag055 · PMID 42005962 · PMCID PMC13089494 · OpenAlex W7154582350
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: genetics / omics (modality), mouse (organism), cellular / molecular (subfield)
Methods: Connectivity, Statistics, Smoothing, state filtering, decompositions, Preprocessing, fMRI & imaging
Keywords: neocortex, transcriptomics, comparative, evolution, column
Journal subjects: Biological, Health, and Medical Sciences, Neuroscience
Topic: Neural dynamics and brain function (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: NIH (R01 EY023871)
Citations: not cited yet (Europe PMC); 62 references in the paper

Abstract

The neocortex, a layered structure unique to mammals, supports higher-order functions, including perception, learning, and decision-making. While its laminar architecture is broadly conserved, the cell type–specific organization of the cortical column has not been compared across species that diverged early in mammalian evolution. To address this, we used single-nucleus RNA sequencing and spatial transcriptomics to compare gene expression, cell types, and laminar architecture in the primary visual cortex (V1) of metatherian (Monodelphis domestica) and eutherian (Mus musculus) mammals. We show that spatio-transcriptomic distinctions between supragranular (layer 2/3) and infragranular (layer 5) intratelencephalic neurons are more pronounced in mice, consistent with lineage-specific specialization. Mouse cortex also exhibits a lower relative density of parvalbumin-positive GABAergic neurons and redistributed perineuronal nets, consistent with altered constraints on plasticity. Together, these findings demonstrate substantial variation in the cellular and spatial organization of the cortical column across deeply diverged mammals, challenging the view that local cortical architecture is uniformly conserved.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repositories

Its files are read in the Code ↔ Paper reader above, with 14 matches between paragraphs and lines of code.

shekharlab/mouseVC

License: none: the authors keep all their rights
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: ce19e14782295577364850ffa5c91d346e4500af, 2 September 2024
Languages: Jupyter (50)
Size: 51 files, 50 scripts
Software Heritage: not archived
Found in: “Data Availability”
Holds: README, 50 notebooks
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: Matplotlib (4 files), NumPy (4 files), pandas (4 files), Scanpy (4 files), SciPy (4 files), seaborn (2 files), scikit-learn (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
4 files
At the source: github.com/shekharlab/mouseVC

ryan-gorzek/opossum-V1-omics

License: MIT
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: 8c490f6ef5d283fb52fcd1caf94be2381b94b983, 20 January 2026
Languages: R (32), Jupyter (3), MATLAB (1), Shell (1)
Size: 182 files, 37 scripts
Software Heritage: not archived
Found in: “Data Availability”
Holds: README, license file, 34 notebooks
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: tidyverse (31 files), ggplot2 (30 files), Seurat (29 files), patchwork (10 files), data.table (8 files), reticulate (8 files), reshape2 (6 files), NumPy (4 files), pandas (4 files), SciPy (4 files), Scanpy (3 files), Matplotlib (2 files), Plotly (2 files), seaborn (2 files), NetworkX (1 file), SAMtools (1 file), scikit-learn (1 file), WGCNA (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
39 files
At the source: github.com/ryan-gorzek/opossum-V1-omics

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 2 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 41 scripts, each with its path and the digest of its content;
  • 14 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

Datasets cited

Data Availability

Code is available on GitHub (github.com/ryan-gorzek/opossum-V1-omics). Raw and processed opossum snRNA-seq (GSE299387) and Stereo-seq (GSE299386) data are available on NCBI Gene Expression Omnibus (GEO). Raw mouse snRNA-seq data from our previous study (36) are available on GEO (GSE190940; P38 normally reared samples GSM5754081-3), and processed/labeled data are available by request (github.com/shekharlab/mouseVC). Immunofluorescence images are available on Figshare (doi.org/10.6084/m9.figshare.31427822 (https://doi.org/10.6084/m9.figshare.31427822)).

Reproduced under the paper's license (CC BY), from the paper cited above.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 29 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 2 authors, 5 keywords, 1 funder, 62 references.

Cite

This paper

Gorzek, R., & Trachtenberg, J. T. (2026). Comparative transcriptomics reveals differences in cortical cell type organization between metatherian and eutherian mammals. PNAS nexus, 5(4), pgag055. https://doi.org/10.1093/pnasnexus/pgag055

BibTeX

@article{gorzek2026comparative,
author = {Gorzek, Ryan and Trachtenberg, Joshua T},
title = {{Comparative transcriptomics reveals differences in cortical cell type organization between metatherian and eutherian mammals}},
journal = {PNAS nexus},
year = {2026},
month = apr,
volume = {5},
number = {4},
pages = {pgag055},
publisher = {Oxford University Press},
issn = {2752-6542},
doi = {10.1093/pnasnexus/pgag055},
url = {https://doi.org/10.1093/pnasnexus/pgag055},
pmid = {42005962},
pmcid = {PMC13089494}
}

RIS

TY - JOUR
AU - Gorzek, Ryan
AU - Trachtenberg, Joshua T
TI - Comparative transcriptomics reveals differences in cortical cell type organization between metatherian and eutherian mammals
T2 - PNAS nexus
J2 - PNAS Nexus
PY - 2026
DA - 2026/04/16
VL - 5
IS - 4
SP - pgag055
SN - 2752-6542
PB - Oxford University Press
DO - 10.1093/pnasnexus/pgag055
UR - https://doi.org/10.1093/pnasnexus/pgag055
LA - en
ER -

CSL-JSON

{
"id": "10.1093/pnasnexus/pgag055",
"type": "article-journal",
"title": "Comparative transcriptomics reveals differences in cortical cell type organization between metatherian and eutherian mammals",
"container-title": "PNAS nexus",
"author": [
{
"family": "Gorzek",
"given": "Ryan"
},
{
"family": "Trachtenberg",
"given": "Joshua T"
}
],
"container-title-short": "PNAS Nexus",
"volume": "5",
"issue": "4",
"page": "pgag055",
"DOI": "10.1093/pnasnexus/pgag055",
"PMID": "42005962",
"PMCID": "PMC13089494",
"ISSN": "2752-6542",
"publisher": "Oxford University Press",
"URL": "https://doi.org/10.1093/pnasnexus/pgag055",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
16
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1186/s13059-026-04177-w [code]
Genomic sequence evolution underlying human neocortical interareal diversification.
Journal: Genome biology
In common: SAMtools, reticulate, Scanpy, 12 other tools, genetics / omics, mouse, cellular / molecular, 4 references
[2] doi:10.1038/s41586-026-10629-x [code]
Whole-genome duplication shaped cell-type evolution in the vertebrate brain.
Journal: Nature
In common: reticulate, Scanpy, NetworkX, 11 other tools, genetics / omics, mouse, cellular / molecular, 4 references
[3] doi:10.1126/sciadv.aeg3223 [code]
The extreme diversity of retinal amacrine cells has deep evolutionary roots.
Journal: Science advances
In common: WGCNA, reticulate, Scanpy, 13 other tools, genetics / omics, cellular / molecular, 2 references
[4] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: WGCNA, SAMtools, reticulate, 14 other tools, mouse, cellular / molecular
[5] doi:10.1016/j.xcrm.2026.102766 [code]
A longitudinal single-cell and spatial multiomic atlas of pediatric high-grade glioma.
Journal: Cell reports. Medicine
In common: WGCNA, Scanpy, NetworkX, 13 other tools, genetics / omics, cellular / molecular, 2 references
[6] doi:10.1093/bioinformatics/btag592 [code]
Network-based stratification of allele-specific expression reveals patient subgroups in Huntington's disease.
Journal: Bioinformatics (Oxford, England)
In common: WGCNA, SAMtools, reticulate, 13 other tools, genetics / omics
[7] doi:10.1038/s41467-026-76675-1 [code]
Long-read proteogenomic atlas of human neuronal differentiation reveals isoform diversity informing neurodevelopmental risk mechanisms.
Journal: Nature communications
In common: WGCNA, SAMtools, reticulate, 13 other tools, genetics / omics
[8] doi:10.1038/s41586-026-10512-9 [code]
Astrocyte glucocorticoid receptor signalling restricts neuronal plasticity.
Journal: Nature
In common: SAMtools, Seurat, reshape2, 7 other tools, mouse, cellular / molecular, 6 references
[9] doi:10.1038/s41467-026-72935-2 [code]
Spindle neurons in human cortex possess distinctive firing properties and transcriptomic signatures.
Journal: Nature communications
In common: WGCNA, Scanpy, Seurat, 10 other tools, genetics / omics, cellular / molecular, 4 references
[10] doi:10.1038/s41467-026-71803-3 [code]
Charting the transition from in vitro gliogenesis to the in vivo maturation of human glial progenitor cells transplanted into the hypomyelinated mouse brain.
Journal: Nature communications
In common: SAMtools, reticulate, Scanpy, 12 other tools, genetics / omics, mouse, cellular / molecular

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.