OSCR

An emergent disease-associated motor neuron state precedes cell death in ALS.

Code ↔ Paper

40 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 40 matches
  1. [1] § STAR★METHODS › METHOD DETAILS › Multiome Sequencing: Cholinergic Neuron Peak Calling with Downsampled Datasets ↔ 07. Multiome 3 - input preparation for Fig. 3D-F, S4E-H.ipynb, lines 358–384 · score 0.97 · bgdGroups, maxCells, useGroups, PeakMatrix, testMethod, getMarkerFeatures
  2. [2] § STAR★METHODS › METHOD DETAILS › Multiome Sequencing: Alpha Motor Neuron Differentially Accessible Peaks with Disease ↔ 07. Multiome 3 - input preparation for Fig. 3D-F, S4E-H.ipynb, lines 358–384 · score 0.97 · bgdGroups, maxCells, useGroups, PeakMatrix, testMethod, getMarkerFeatures
  3. [3] § STAR★METHODS › METHOD DETAILS › snRNA-seq/Multiome Sequencing: Label Transfer from Multiome to snRNA-seq Alpha Motor Neurons ↔ 11. Multiome & snRNA-seq 1 - input preparation (cross-modal label transfer, multiome RNA differential expression).ipynb, lines 169–174 · score 0.96 · FindTransferAnchors, TransferData, query.assay, reference.assay, AddMetaData, multiome RNA
  4. [4] § STAR★METHODS › METHOD DETAILS › Multiome Sequencing: Cholinergic Neuron and Alpha Motor Neuron Subclustering ↔ 05. Multiome 1 - initial processing and input preparation for Fig. 3B-C, 3G-J, S4A-D, S5A-B.ipynb, lines 383–400 · score 0.94 · Gex_nUMI, firstSelection, varFeatures, depthCol, clusterParams, addIterativeLSI
  5. [5] § STAR★METHODS › METHOD DETAILS › Multiome Sequencing: Clustering and Doublet Removal ↔ 05. Multiome 1 - initial processing and input preparation for Fig. 3B-C, 3G-J, S4A-D, S5A-B.ipynb, lines 177–194 · score 0.94 · Gex_nUMI, firstSelection, varFeatures, depthCol, clusterParams, addIterativeLSI
  6. [6] § RESULTS › A DM signature in alpha motor neurons ↔ 04. snRNA-seq 4 - Fig. 2A-J, S2E, S3A-H.ipynb, lines 433–531 · score 0.93 · synaptic transmission, axon guidance, proteasomal protein catabolism, endoplasmic reticulum, unfolded protein, amino acid
  7. [7] § STAR★METHODS › METHOD DETAILS › snRNA-seq: Cholinergic Neuron and Alpha Motor Neuron Subclustering ↔ 01. snRNA-seq 1 - initial processing and input preparation.ipynb, lines 539–550 · score 0.92 · RunUMAP, FindClusters, FindNeighbors, RunPCA, ScaleData, DefaultAssay
  8. [8] § STAR★METHODS › METHOD DETAILS › MERFISH: Generation of a Custom Motor Neuron Segmentation Model ↔ 14. MERFISH spatial transcriptomics analysis.ipynb, lines 388–487 · score 0.92 · Aldh1l1, Cx3cr1, Slc6a5, Slc5a7, Slc17a6, Trem2
  9. [9] § STAR★METHODS › METHOD DETAILS › Multiome Sequencing: Identification of Positive Transcription Factor Regulators ↔ 09. Multiome 5 - input preparation for Fig. 4A-D, S6A-G.ipynb, lines 209–216 · score 0.92 · correlateMatrices, useMatrix1, useMatrix2, LSI_Combined, MotifMatrix, reducedDims
  10. [10] § STAR★METHODS › METHOD DETAILS › snRNA-seq: Data Pre-Processing and Ambient RNA Removal ↔ 01. snRNA-seq 1 - initial processing and input preparation.ipynb, lines 76–89 · score 0.92 · NormalizeData, FindClusters, FindNeighbors, RunPCA, ScaleData, FindVariableFeatures
  11. [11] § STAR★METHODS › METHOD DETAILS › Multiome Sequencing: Cholinergic Neuron Peak Calling with Downsampled Datasets ↔ 07. Multiome 3 - input preparation for Fig. 3D-F, S4E-H.ipynb, lines 168–192 · score 0.90 · minReplicates, minCells, addGroupCoverages, addPeakMatrix, addReproduciblePeakSet, groupBy
  12. [12] § STAR★METHODS › METHOD DETAILS › Multiome Sequencing: Cholinergic Neuron Peak Calling with Downsampled Datasets ↔ 07. Multiome 3 - input preparation for Fig. 3D-F, S4E-H.ipynb, lines 168–192 · score 0.90 · minReplicates, minCells, addGroupCoverages, addPeakMatrix, addReproduciblePeakSet, peak matrices
  13. [13] § STAR★METHODS › METHOD DETAILS › snRNA-seq: Integration, Quality Control, and Clustering ↔ 01. snRNA-seq 1 - initial processing and input preparation.ipynb, lines 215–223 · score 0.86 · RunUMAP, FindClusters, FindNeighbors, RunPCA, ScaleData, DefaultAssay
  14. [14] § RESULTS › TFs associated with the DM state transition ↔ 10. Multiome 6 - Fig. 4A-D, S6A-G.ipynb, lines 64–126 · score 0.86 · E4f1, ps sum, perturbation score, CellOracle, Jund, Klf6
  15. [15] § RESULTS › A DM signature in alpha motor neurons ↔ 04. snRNA-seq 4 - Fig. 2A-J, S2E, S3A-H.ipynb, lines 880–949 · score 0.84 · extracellular matrix organization, potassium ion transport, integrated stress response, amino acid, negative regulation, signaling
  16. [16] § STAR★METHODS › METHOD DETAILS › In Vitro Motor Neuron Differentiation, Lentiviral Transduction, Western Blot Analysis, Bulk RNA Sequencing, and Gene Set Enrichment Analysis ↔ 13. iMN in vitro TF OE - Fig. 5.ipynb, lines 131–205 · score 0.83 · fgseaMultilevel, minSize, maxSize, DESeq2, NES, ranked
  17. [17] § STAR★METHODS › METHOD DETAILS › snRNA-seq: Differential Expression and Gene Ontology (GO) Enrichment Analyses ↔ 02. snRNA-seq 2 - DESeq2 differential expression analysis.ipynb, lines 136–163 · score 0.82 · DESeqDataSetFromMatrix, minReplicatesForReplace, ex, DESeq2, padj, frame
  18. [18] § STAR★METHODS › METHOD DETAILS › snRNA-seq: Integration, Quality Control, and Clustering ↔ 01. snRNA-seq 1 - initial processing and input preparation.ipynb, lines 360–362 · score 0.82 · Read10X, endpoint female, nextseqs_11_18, CreateSeuratObject, cellranger, intron
  19. [19] § STAR★METHODS › METHOD DETAILS › MERFISH: Cholinergic Neuron and Alpha Motor Neuron Subclustering ↔ 14. MERFISH spatial transcriptomics analysis.ipynb, lines 734–748 · score 0.80 · n_iterations, min_dist, igraph, flavor, BBKNN, external
  20. [20] § STAR★METHODS › METHOD DETAILS › MERFISH: Alpha Motor Neuron Morphological Quantification ↔ 14. MERFISH spatial transcriptomics analysis.ipynb, lines 5867–5891 · score 0.79 · Otsu threshold, DAPI_high_pass, log10 transformed, MERFISH
  21. [21] § RESULTS › A DM signature in alpha motor neurons ↔ 13. iMN in vitro TF OE - Fig. 5.ipynb, lines 591–660 · score 0.75 · axon guidance, proteasomal protein catabolism, endoplasmic reticulum, axonogenesis, synaptic, transport
  22. [22] § RESULTS › TFs associated with the DM state transition ↔ 10. Multiome 6 - Fig. 4A-D, S6A-G.ipynb, lines 64–126 · score 0.72 · Nfe2l1, Nfe2l2, Nfe2l3, Xbp1, Nfil3, CREB3
  23. [23] § STAR★METHODS › METHOD DETAILS › MERFISH: Data Pre-Processing and Initial Clustering ↔ 14. MERFISH spatial transcriptomics analysis.ipynb, lines 734–748 · score 0.71 · n_iterations, igraph, flavor, BBKNN, external, UMAP
  24. [24] § RESULTS › Gene expression changes in spinal motor neurons during neurodegeneration ↔ 03. snRNA-seq 3 - Fig. 2B, 2D-H, S1B-C, S2A-D.ipynb, lines 663–732 · score 0.70 · sciatic nerve crush, nerve injury, SOD1 G93A, gamma, disease, gene
  25. [25] § STAR★METHODS › METHOD DETAILS › MERFISH: Reactive Glial Cell Classification ↔ 14. MERFISH spatial transcriptomics analysis.ipynb, lines 3759–3813 · score 0.69 · control astrocytes, control microglia, Apoe, Gfap, thresholds, reactive
  26. [26] § STAR★METHODS › METHOD DETAILS › snRNA-seq/Multiome Sequencing: In Silico Transcription Factor Perturbation with CellOracle ↔ 14. MERFISH spatial transcriptomics analysis.ipynb, lines 5194–5271 · score 0.69 · fast firing, slow firing, late DM, early DM, UMAP, Scanpy
  27. [27] § STAR★METHODS › METHOD DETAILS › MERFISH: Label Transfer from snRNA-seq to MERFISH Alpha Motor Neurons ↔ 14. MERFISH spatial transcriptomics analysis.ipynb, lines 5051–5192 · score 0.69 · Fast Firing, Slow Firing, Late DM, Early DM, Predicted, Intermediate
  28. [28] § STAR★METHODS › METHOD DETAILS › snRNA-seq: Integration, Quality Control, and Clustering ↔ 01. snRNA-seq 1 - initial processing and input preparation.ipynb, lines 141–150 · score 0.65 · nova_CZI, sod1_mn_nuclei_2_9, seq
  29. [29] § STAR★METHODS › METHOD DETAILS › snRNA-seq: Integration, Quality Control, and Clustering ↔ 11. Multiome & snRNA-seq 1 - input preparation (cross-modal label transfer, multiome RNA differential expression).ipynb, lines 157–160 · score 0.65 · NormalizeData, FindVariableFeatures, vst, selection, seq
  30. [30] § STAR★METHODS › METHOD DETAILS › Multiome Sequencing: Cholinergic Neuron Peak Calling with Downsampled Datasets ↔ 08. Multiome 4 - Fig. 3D-F, S4E-H.ipynb, lines 268–334 · score 0.63 · downsampled control, Gamma MNs, Alpha MNs, ArchR, Peak, cholinergic
  31. [31] § STAR★METHODS › METHOD DETAILS › Multiome Sequencing: Cholinergic Neuron Peak Calling with Downsampled Datasets ↔ 07. Multiome 3 - input preparation for Fig. 3D-F, S4E-H.ipynb, lines 243–250 · score 0.62 · Gamma MNs, metadata column, Alpha MNs, ArchR, downsampled, neurons
  32. [32] § STAR★METHODS › METHOD DETAILS › Human Spinal Cord snRNA-seq/Fragment-seq: Cross-Species Wilcoxon Rank-Based Gene Set Enrichment and DM Scoring ↔ 14. MERFISH spatial transcriptomics analysis.ipynb, lines 1332–1420 · score 0.61 · log2 fold change, downregulated genes, upregulated genes, snRNA, seq
  33. [33] § STAR★METHODS › METHOD DETAILS › MERFISH: Data Pre-Processing and Initial Clustering ↔ 14. MERFISH spatial transcriptomics analysis.ipynb, lines 168–222 · score 0.61 · detected genes, filtered AnnData, blank, MERFISH, slide, transcripts
  34. [34] § STAR★METHODS › METHOD DETAILS › Human Spinal Cord snRNA-seq/Fragment-seq: Data Pre-Processing and Integration ↔ 11. Multiome & snRNA-seq 1 - input preparation (cross-modal label transfer, multiome RNA differential expression).ipynb, lines 157–160 · score 0.60 · NormalizeData, FindVariableFeatures, nfeature, vst, RNA seq
  35. [35] § STAR★METHODS › METHOD DETAILS › MERFISH: Alpha Motor Neuron Differential Expression Analysis with Disease ↔ 14. MERFISH spatial transcriptomics analysis.ipynb, lines 1250–1324 · score 0.59 · Benjamini Hochberg, Fold changes, raw, log2, MERFISH, mid
  36. [36] § STAR★METHODS › METHOD DETAILS › MERFISH: Cell Segmentation, Transcript Partitioning, and Cell Metadata Calculation ↔ 14. MERFISH spatial transcriptomics analysis.ipynb, lines 69–166 · score 0.59 · sum signals, cell metadata, DAPI, MERFISH, transcript
  37. [37] § STAR★METHODS › METHOD DETAILS › MERFISH: Generation of a Custom Motor Neuron Segmentation Model ↔ 05. Multiome 1 - initial processing and input preparation for Fig. 3B-C, 3G-J, S4A-D, S5A-B.ipynb, lines 227–238 · score 0.57 · Slc5a7, Slc17a6, Aqp4, Mog, Atf3, cholinergic
  38. [38] § STAR★METHODS › METHOD DETAILS › snRNA-seq: Differential Expression and Gene Ontology (GO) Enrichment Analyses ↔ 04. snRNA-seq 4 - Fig. 2A-J, S2E, S3A-H.ipynb, lines 41–61 · score 0.57 · GO Biological Process, DESeq2, downregulated, upregulated, cholinergic, gene
  39. [39] § STAR★METHODS › METHOD DETAILS › Human Spinal Cord snRNA-seq/Fragment-seq: Differential Gene Expression Analysis ↔ 14. MERFISH spatial transcriptomics analysis.ipynb, lines 1250–1324 · score 0.56 · Benjamini Hochberg, fold change, FDR, raw, Gene
  40. [40] § STAR★METHODS › METHOD DETAILS › Human Spinal Cord snRNA-seq/Fragment-seq: Cross-Species Wilcoxon Rank-Based Gene Set Enrichment and DM Scoring ↔ 14. MERFISH spatial transcriptomics analysis.ipynb, lines 1332–1420 · score 0.54 · log2 fold change, downregulated genes, v1, upregulated, snRNA, seq

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

Jupyter notebook · 6,326 lines · 198 KB · no license · 13 matches

  1. # %%
  2. import anndata as ad
  3. import scanpy as sc
  4. import pandas as pd
  5. import os
  6. import numpy as np
  7. import squidpy as sq
  8. import bbknn
  9. import seaborn as sns
  10. import matplotlib.pyplot as plt
  11. from matplotlib.colors import ListedColormap
  12. import shutil
  13. import scvi
  14. import scipy.sparse
  15. from scipy.stats import pearsonr, spearmanr
  17. # %%
  18. working_dir = "/home/users/ogautier/oak/Shared/SOD1_Paper/Vizgen/mn_nonmn_segmentation"
  19. os.chdir(working_dir)
  21. figures_dir = os.path.join(working_dir, "figures")
  23. # %% [markdown]
  24. # ### Create anndata objects with metadata
  26. # %%
  27. def is_point_inside_rotated_rect(px, py, rx, ry, width, height, angle):
  28. """
  29. Check if a point (px, py) is inside a rotated rectangle.
  31. - (rx, ry): Bottom-left corner of the rectangle
  32. - width, height: Dimensions of the rectangle
  33. - angle: Rotation angle in degrees
  34. """
  35. # Convert angle to radians
  36. theta = np.radians(-angle) # Negative to rotate in the opposite direction
  38. # Translate point and rectangle to origin
  39. px, py = px - rx, py - ry
  41. # Apply inverse rotation to the point
  42. rotated_x = px * np.cos(theta) - py * np.sin(theta)
  43. rotated_y = px * np.sin(theta) + py * np.cos(theta)
  45. # Check if rotated point is within rectangle bounds
  46. return 0 <= rotated_x <= width and 0 <= rotated_y <= height
  48. # %%
  49. slide_list = ['202401150953_MsSpinalCord-VS119-Lumbar-Ctrl5-SOD11_Beta8',
  50. '202405281419_MsSpinalCord-VS223-Lumbar-CM5-SM8-S1_VMSC01801',
  51. '202406071120_MsSpinalCord-VS223-Lumbar-CE5-SE6-S1_VMSC01801',
  52. '202401151110_MsSpinalCord-VS119-Lumbar-Ctrl1-SOD8_VMSC07101',
  53. '202401241136_HuSpinalCord-VS119-Lumbar-Ctrl2-SOD9_Beta8',
  54. '202405281702_MsSpinalCord-VS223-Lumbar-CE2-SE4-S1_VMSC02701',
  55. '202406071119_MsSpinalCord-VS223-Lumbar-CE1-SE3-S2_Beta8',
  56. '202405281416_MsSpinalCord-VS223-Lumbar-CM2-SM4-S1_VMSC15302',
  57. '202401241119_HuSpinalCord-VS119-Cervical-Ctrl3-SOD11_VMSC07101_reanalysis',
  58. '202401150956_MsSpinalCord-VS119-Cervical-Ctrl2-SOD10_VMSC10802',
  59. '202406031049_MsSpinalCord-VS223-Cervical-CE2-SE3-S1_VMSC10802',
  60. '202406071222_MsSpinalCord-VS223-Cervical-CE5-SE5-S2_VMSC02011',
  61. '202406071118_MsSpinalCord-VS223-Cervical-CM2-SM4-S1_VMSC10802',
  62. '202312251515_MsSpinalCord-L4-S1-VS119-YS_Beta8',
  63. '202405281527_MsSpinalCord-VS223-Lubmar-CM4-SM6-S1_VMSC02011',
  64. #'202405281422_MsSpinalCord-VS223-Lumbar-CE3-SE5-S1_VMSC12002', Exclude due to batch effect
  65. '202406031050_MsSpinalCord-VS223-Cervical-CM5-SM5-S1_VMSC07201',
  66. '202406071239_MsSpinalCord-VS223-Lumbar-CM3-SM5-S2_VMSC02701',
  67. '202401241200_HuSpinalCord-VS119-Lubmar-Ctrl3-SOD10_VMSC10802']
  69. # %%
  70. csv_file_path = 'Merfish_Metadata.csv'
  71. rect_df_all = pd.read_csv(csv_file_path)
  73. data_fn = "analysis_outputs_7000_900/cell_by_gene.csv"
  74. meta_fn = "analysis_outputs_7000_900/cell_metadata.csv"
  75. sumsig_fn = "analysis_outputs_7000_900/sum_signals.csv"
  77. for slide_dir in slide_list:
  78. print(slide_dir)
  80. # read in and make anndata object
  81. adata = sc.read_csv(os.path.join(slide_dir, data_fn), first_column_names=True)
  82. print(f'adata initial shape is {adata.shape}')
  83. metadata = pd.read_csv(os.path.join(slide_dir,meta_fn), index_col=0)
  84. metadata.index = metadata.index.map(str)
  86. ### make sumsigs consistent start
  87. sumsig = pd.read_csv(os.path.join(slide_dir,sumsig_fn), index_col=0)
  88. sumsig.index = sumsig.index.map(str)
  89. if 'hSOD1G93A_raw' not in sumsig:
  90. sumsig['hSOD1G93A_raw'] = [float('nan')] * sumsig['DAPI_raw'].shape[0]
  91. sumsig['hSOD1G93A_high_pass'] = [float('nan')] * sumsig['DAPI_raw'].shape[0]
  92. ### end
  94. result = pd.merge(metadata, sumsig, left_index=True, right_index=True)
  95. result.index = adata.obs_names
  96. adata.obs = result
  98. adata.obsm['spatial'] = adata.obs[["center_x", "center_y"]].to_numpy()
  100. # get additional critical metadata from rect_df_all
  101. rect_df = rect_df_all[rect_df_all['slide'] == slide_dir]
  102. x, y = adata.obsm['spatial'][:, 0], adata.obsm['spatial'][:, 1]
  104. # initialize metadata columns
  105. slide = ['na'] * len(x)
  106. section = ['na'] * len(x)
  107. region = ['na'] * len(x)
  108. stage = ['na'] * len(x)
  110. # loop through rect_df to populate metadata of appropriate cells
  111. # rect_df allows us to map a coordinate to section and its
  112. # corresponding conditions
  113. for index, row in rect_df.iterrows():
  114. rect_x, rect_y = row['x']-150, row['y']-150
  115. rect_width, rect_height = int(row['w']*1.2), int(row['h']*1.2)
  116. rect_angle = row['angle']
  118. for i in range(len(x)):
  119. point_x, point_y = adata.obsm['spatial'][i, 0], adata.obsm['spatial'][i, 1]
  120. inside = is_point_inside_rotated_rect(point_x,
  121. point_y,
  122. rect_x,
  123. rect_y,
  124. rect_width,
  125. rect_height,
  126. rect_angle)
  127. if inside == True:
  128. section[i] = row['section']
  129. slide[i] = row['slide']
  130. region[i] = row['region']
  131. stage[i] = row['stage']
  133. # append metadata lists to adata.obs
  134. adata.obs["section"] = section
  135. adata.obs["slide"] = slide
  136. adata.obs["region"] = region
  137. adata.obs["stage"] = stage
  139. # remove cells that are not assigned section metadata
  140. # Ensure 'section' is treated as a string
  141. adata.obs["section"] = adata.obs["section"].astype(str)
  142. adata = adata[adata.obs["section"] != "na"].copy()
  143. print(f'adata shape after filtering is {adata.shape}')
  145. # make VS metadata column
  146. VS = []
  147. slide = adata.obs['slide'].to_list()
  149. for s in slide:
  150. if "VS119" in s:
  151. VS.append("VS119")
  152. elif "VS223" in s:
  153. VS.append("VS223")
  154. else:
  155. print("uh oh")
  157. adata.obs['VS'] = VS
  159. list(set(adata.obs['stage'].to_list()))
  160. print(f"adata.obs.shape is {adata.obs.shape}")
  161. # save anndata
  162. save_name = f"{slide_dir}.h5ad"
  163. adata.write_h5ad(os.path.join(working_dir,
  164. slide_dir,
  165. "analysis_outputs_7000_900",
  166. save_name))
  168. # %% [markdown]
  169. # ### Filter and combine anndata objects
  171. # %%
  172. def filter_anndata(slide_list, min_count, min_genes):
  173. """
  174. Filters anndata objects for each slide in slide_list based on transcript count and detected genes.
  176. Parameters:
  177. slide_list (list): List of slide names.
  178. min_count (int): Minimum transcript count threshold.
  179. min_genes (int): Minimum number of detected genes.
  181. Returns:
  182. None
  183. """
  184. for slide in slide_list:
  185. # Construct file paths
  186. input_path = f"{slide}/analysis_outputs_7000_900/{slide}.h5ad"
  187. output_dir = f"{slide}/analysis_outputs_7000_900/"
  188. output_path = os.path.join(output_dir, f"{slide}_filtered.h5ad")
  190. # Check if the file exists
  191. if not os.path.exists(input_path):
  192. print(f"File not found: {input_path}, skipping...")
  193. continue
  195. print(f"Processing {slide}...")
  197. # Load the AnnData object
  198. adata = sc.read_h5ad(input_path)
  200. # Remove blank genes
  201. non_blank_genes = [gene for gene in adata.var_names if "blank" not in gene.lower()]
  202. adata = adata[:, non_blank_genes].copy()
  204. # Compute number of detected genes and total transcript count
  205. adata.obs["num_genes"] = np.count_nonzero(adata.X, axis=1)
  206. adata.obs["num_transcripts"] = np.sum(adata.X, axis=1)
  208. # Filter cells based on criteria
  209. prev_len = adata.shape[0]
  210. adata = adata[
  211. (adata.obs["num_transcripts"] > min_count) &
  212. (adata.obs["num_genes"] > min_genes), :
  213. ].copy()
  215. print(f"Filtered from {prev_len} to {adata.shape[0]} cells.")
  217. # Ensure output directory exists
  218. os.makedirs(output_dir, exist_ok=True)
  220. # Save the processed AnnData object
  221. adata.write_h5ad(output_path)
  222. print(f"Saved filtered data to {output_path}\n")
  224. # %%
  225. # Filter anndata objects
  226. min_count = 20
  227. min_genes = 5
  229. filter_anndata(slide_list, min_count, min_genes)
  231. # %%
  232. # Combine filtered anndata objects
  233. idx = 0
  235. for slide_dir in slide_list:
  236. print(slide_dir)
  238. # read in and make anndata object
  239. load_dir = os.path.join(slide_dir,
  240. "analysis_outputs_7000_900",
  241. (slide_dir+'_filtered.h5ad'))
  242. adata = sc.read_h5ad(load_dir)
  244. if idx == 0:
  245. adata_combined = adata.copy()
  246. idx += 1
  247. continue
  249. adata_combined = ad.concat([adata_combined, adata]).copy()
  250. adata_combined.obs_names_make_unique()
  252. print(f'adata_combined shape is {adata_combined.shape}')
  253. idx += 1
  255. # %%
  256. # Saving count data
  257. adata_combined.layers["counts"] = adata_combined.X.copy()
  259. # %%
  260. # save anndata
  261. save_name = f"adata_objects/combined_filtered_anndata.h5ad"
  262. adata_combined.write_h5ad(os.path.join(working_dir, save_name))
  264. # %% [markdown]
  265. # # All cells BBKNN integration
  267. # %%
  268. # Read in AnnData
  269. adata = sc.read_h5ad(f"adata_objects/combined_filtered_anndata.h5ad")
  271. # %%
  272. # Add metadata columns
  273. # Slide + section and slide + stage
  274. adata.obs["slide_section"] = adata.obs["slide"].astype(str) + "_" + adata.obs["section"].astype(str)
  275. adata.obs["slide_stage"] = adata.obs["slide"].astype(str) + "_" + adata.obs["stage"].astype(str)
  277. # Auxillary channels normalized by volume
  278. columns_to_normalize = [
  279. "Gfap_raw", "Gfap_high_pass",
  280. "Apoe_raw", "Apoe_high_pass",
  281. "hSOD1G93A_raw", "hSOD1G93A_high_pass"
  282. ]
  284. for col in columns_to_normalize:
  285. norm_col = col + "_norm"
  286. adata.obs[norm_col] = adata.obs[col] / adata.obs["volume"]
  288. # %%
  289. # Remove low-quality tissue sections
  290. # List of slide_section values to remove
  291. to_remove = [
  292. '202401150953_MsSpinalCord-VS119-Lumbar-Ctrl5-SOD11_Beta8_R2C2',
  293. '202401151110_MsSpinalCord-VS119-Lumbar-Ctrl1-SOD8_VMSC07101_R2C1',
  294. '202405281416_MsSpinalCord-VS223-Lumbar-CM2-SM4-S1_VMSC15302_R2C1',
  295. '202406031050_MsSpinalCord-VS223-Cervical-CM5-SM5-S1_VMSC07201_R2C1'
  296. ]
  298. # Keep cells NOT in the to_remove list
  299. adata = adata[~adata.obs['slide_section'].isin(to_remove)].copy()
  301. # %%
  302. # Normalization of data by volume
  303. adata.X = adata.X/np.array(adata.obs['volume'])[:,None]
  305. # Normalize total to 250
  306. sc.pp.normalize_total(adata, target_sum=250)
  308. # Log transform
  309. sc.pp.log1p(adata)
  311. # Z-score (need to do)
  312. sc.pp.scale(adata, max_value=10)
  314. # Run pca
  315. sc.tl.pca(adata)
  317. # %%
  318. # Neighbors and UMAP
  319. sc.external.pp.bbknn(adata, batch_key='VS') # use inplace of sc.pp.neighbors()
  320. sc.tl.umap(adata)
  322. # %%
  323. # Clustering
  324. sc.tl.leiden(adata,
  325. key_added="leiden_0.5",
  326. resolution=0.5,
  327. flavor="igraph",
  328. n_iterations=2)
  330. # %%
  331. sc.pl.umap(adata, color="leiden_0.5")
  333. # %% [markdown]
  334. # ## Fig. S1D
  336. # %%
  337. import matplotlib.pyplot as plt
  338. import scanpy as sc
  340. # 0) Set all font sizes to 7
  341. plt.rcParams.update({
  342. "font.size": 7,
  343. "axes.titlesize": 7,
  344. "axes.labelsize": 7,
  345. "xtick.labelsize": 7,
  346. "ytick.labelsize": 7,
  347. "legend.fontsize": 7,
  348. "legend.title_fontsize": 7,
  349. "figure.titlesize": 7
  350. })
  352. # 1) Create a high‐DPI figure (this sets the base resolution for rasterized artists)
  353. fig, ax = plt.subplots(dpi=300) # <-- 300 DPI here
  355. # 2) Draw UMAP off‐screen, no title, into that axes
  356. sc.pl.umap(
  357. adata,
  358. color="leiden_0.5",
  359. legend_loc='on data',
  360. legend_fontsize=7, # redundant now, but explicit
  361. title="",
  362. show=False,
  363. ax=ax
  364. )
  366. # 3) Rasterize only the scatter collections
  367. for coll in ax.collections:
  368. coll.set_rasterized(True)
  370. # 4) Fix the output size in inches
  371. fig.set_size_inches(2.15, 2.15)
  373. # 5) Save with an even higher DPI if you like (affects only raster parts in a vector file)
  374. fig.savefig(
  375. "figures/umap/UMAP_all_leiden.svg",
  376. format="svg",
  377. bbox_inches="tight",
  378. dpi=600 # <-- rasterized points will now be 600 DPI
  379. )
  382. # %%
  383. sc.pl.umap(adata, color="stage")
  385. # %%
  386. sc.pl.umap(adata, color="slide")
  388. # %% [markdown]
  389. # ## Fig. S1E
  391. # %%
  392. import matplotlib.pyplot as plt
  393. import seaborn as sns
  394. import os
  396. genes = ["Chat", "Prph", "Slc5a7", "Rbfox3", "Slc17a6", "Gad1", "Slc6a5", "Tnfrsf12a", "Atf3", "Cx3cr1", "Trem2",
  397. "Mog", "Stmn4", "Aqp4", "Aldh1l1", "Slc2a1", "Slc7a1", "Il34", "Anxa2", "Atp1a1", "Hsp90ab1", "Gria3",
  398. "Grik4"]
  400. # Define the desired cluster order
  401. desired_order = ["6", "10", "9", "12", "1", "2", "7", "8", "0", "11", "5", "4", "3"]
  403. adata_counts = adata[:, genes].copy()
  404. adata_counts.X = adata_counts.layers['counts']
  406. # Convert to a DataFrame
  407. counts_df = pd.DataFrame(adata_counts.X, index=adata_counts.obs_names, columns=adata_counts.var_names)
  409. # Normalize total counts to 250
  410. sc.pp.normalize_total(adata_counts, target_sum=250)
  412. # Add cluster information
  413. cluster_key = "leiden_0.5" # Update this if using a different cluster key
  414. counts_df["cluster"] = adata_counts.obs[cluster_key].values
  416. # Compute average expression per cluster
  417. cluster_avg = counts_df.groupby("cluster")[genes].mean().T # Transpose to have genes on y-axis
  419. # Convert row_min and row_max to NumPy arrays
  420. row_min = cluster_avg.min(axis=1).to_numpy()
  421. row_max = cluster_avg.max(axis=1).to_numpy()
  423. # Avoid division by zero by checking where min == max
  424. constant_rows = row_max == row_min
  426. # Perform row normalization (Min-Max Scaling)
  427. cluster_avg_norm = (cluster_avg - row_min[:, np.newaxis]) / (row_max - row_min)[:, np.newaxis]
  429. # Set constant rows to 0 (or another value like NaN if needed)
  430. cluster_avg_norm[constant_rows] = 0
  432. # Reorder the columns of the DataFrame
  433. cluster_avg_norm = cluster_avg_norm[desired_order]
  435. # Plot the heatmap
  436. fig, ax = plt.subplots(figsize=(5.6, 3.5))
  438. # draw heatmap with only two ticks at 0 and 1
  439. heatmap = sns.heatmap(
  440. cluster_avg_norm,
  441. cmap="viridis",
  442. annot=False,
  443. fmt=".2f",
  444. linewidths=0.5,
  445. ax=ax,
  446. cbar_kws={
  447. "ticks": [0.0, 1.0], # only these two positions
  448. "shrink": 0.9,
  449. "pad": 0.13
  450. }
  451. )
  453. # 1) Remove all tick-marks (but keep the labels)
  454. ax.tick_params(axis="both", which="both", length=0)
  456. # 2) Rotate the x-axis labels 90°
  457. ax.set_xticklabels(ax.get_xticklabels(), rotation=-90)
  459. # 3) Move the gene/row names (y-tick labels) to the right & make them horizontal
  460. ax.tick_params(axis="y", labelleft=False, labelright=True, left=False, right=True)
  461. ax.set_yticklabels(ax.get_yticklabels(), rotation=0)#, ha="right")
  463. # 4) Clear axis titles and labels
  464. ax.set_xlabel("")
  465. ax.set_ylabel("")
  466. ax.set_title("")
  468. # 5) Tweak the colorbar
  469. cbar = heatmap.collections[0].colorbar
  470. # a) remove the little tick‐lines
  471. cbar.ax.tick_params(length=0)
  472. # b) replace the two tick labels
  473. cbar.ax.set_yticklabels(["Min", "Max"])
  474. # c) remove any other labels (there won’t be any beyond your two ticks)
  475. # (no extra step needed since we only set two ticks)
  476. # d) add a vertically-oriented label “By Row” centered along the bar
  477. cbar.ax.set_ylabel(
  478. "By Row",
  479. rotation=-90, # text runs horizontally
  480. va="center", # center along the bar
  481. labelpad=-6 # push it out away from the bar
  482. )
  484. # 6) Save
  485. heatmap_path = os.path.join(figures_dir, "heatmap_all.svg")
  486. fig.savefig(heatmap_path, dpi=300, bbox_inches="tight", transparent=True)
  487. plt.show()
  490. # %%
  491. # Add cell class labels
  492. type_map = {'0': 'Astrocytes',
  493. '1': 'Microglia/Macrophages',
  494. '2': 'Oligodendrocytes',
  495. '3': 'Other',
  496. '4': 'Putative Ependymal Cells',
  497. '5': 'Putative Perivascular/Meningeal Cells',
  498. '6': 'Cholinergic Neurons',
  499. '7': 'Oligodendrocytes',
  500. '8': 'Oligodendrocytes',
  501. '9': 'Non-Cholinergic Interneurons',
  502. '10': 'Non-Cholinergic Interneurons',
  503. '11': 'Putative Vascular Cells',
  504. '12': 'Disease-Associated Interneurons'}
  506. cell_class = []
  507. leiden_cluster = adata.obs['leiden_0.5'].to_list()
  509. for l in leiden_cluster:
  510. cell_class.append(type_map[l])
  512. adata.obs['cell_class'] = cell_class
  514. # %%
  515. # Plot the new sub-clusters
  516. sc.pl.umap(adata, color="cell_class")
  518. # %% [markdown]
  519. # ## Fig. S1F
  521. # %%
  522. # 0) Set all font sizes to 7
  523. plt.rcParams.update({
  524. "font.size": 7,
  525. "axes.titlesize": 7,
  526. "axes.labelsize": 7,
  527. "xtick.labelsize": 7,
  528. "ytick.labelsize": 7,
  529. "legend.fontsize": 7,
  530. "legend.title_fontsize": 7,
  531. "figure.titlesize": 7
  532. })
  534. # 1) Create a high‐DPI figure (this sets the base resolution for rasterized artists)
  535. fig, ax = plt.subplots(dpi=300) # <-- 300 DPI here
  537. # your abbr dict
  538. abbr = {
  539. "Astrocytes": "Ast",
  540. "Cholinergic Neurons": "CholN",
  541. "Disease-Associated Interneurons": "DAI",
  542. "Microglia/Macrophages": "MG",
  543. "Non-Cholinergic Interneurons": "NCI",
  544. "Oligodendrocytes": "Oligo",
  545. "Other": "Other",
  546. "Putative Ependymal Cells": "Epen",
  547. "Putative Perivascular/Meningeal Cells": "PVM",
  548. "Putative Vascular Cells": "Vasc"
  549. }
  551. # 2) Draw UMAP off‐screen, no title, into that axes
  552. sc.pl.umap(
  553. adata,
  554. color="cell_class",
  555. legend_loc='on data',
  556. legend_fontsize=7,
  557. title="",
  558. show=False,
  559. ax=ax
  560. )
  562. # 2b) Replace each on‐data label with its abbr
  563. for txt in ax.texts:
  564. orig = txt.get_text()
  565. if orig in abbr:
  566. txt.set_text(abbr[orig])
  568. # now continue with your rasterization + sizing + saving…
  569. # 3) Rasterize only the scatter collections
  570. for coll in ax.collections:
  571. coll.set_rasterized(True)
  573. # 4) Fix the output size in inches
  574. fig.set_size_inches(2.15, 2.15)
  576. # 5) Save...
  577. fig.savefig(
  578. "figures/umap/UMAP_cell_class.svg",
  579. format="svg",
  580. bbox_inches="tight",
  581. dpi=600
  582. )
  585. # %%
  586. # save anndata
  587. save_name = f"adata_objects/all_anndata.h5ad"
  588. adata.write_h5ad(os.path.join(working_dir, save_name))
  590. # %%
  591. adata = sc.read_h5ad(os.path.join(working_dir, f"adata_objects/all_anndata.h5ad"))
  593. # %% [markdown]
  594. # ## Subcluster cholinergic neurons
  596. # %%
  597. adata = sc.read_h5ad(os.path.join(working_dir, f"adata_objects/all_anndata.h5ad"))
  599. # %%
  600. # Select cholinergic neurons
  601. adata_chol = adata[adata.obs["cell_class"] == "Cholinergic Neurons"].copy()
  603. # %%
  604. # Neighbors and UMAP
  605. sc.external.pp.bbknn(adata_chol, batch_key='VS') # use inplace of sc.pp.neighbors()
  606. sc.tl.umap(adata_chol,
  607. min_dist=0.1,
  608. spread=1.0)
  610. # %%
  611. # Clustering
  612. sc.tl.leiden(adata_chol,
  613. key_added="chol_leiden_1",
  614. resolution=1,
  615. flavor="igraph",
  616. n_iterations=2)
  618. # %%
  619. # Plot the sub-clusters
  620. sc.pl.umap(adata_chol, color="chol_leiden_1")
  622. # %%
  623. # Remove Mog+ oligodendrocyte doublets
  624. sc.pl.umap(adata_chol, color=["Mog"])
  626. # %% [markdown]
  627. # #### Get barcodes for peri-motor neurons oligodendrocytes
  629. # %%
  630. # Assess volume distribution of exisiting Oligodendrocytes
  632. import matplotlib.pyplot as plt
  633. import seaborn as sns
  635. # Subset to Oligodendrocytes
  636. adata_oligo = adata[adata.obs['cell_class'] == 'Oligodendrocytes']
  638. # Extract the volume values
  639. vals = adata_oligo.obs['volume'].dropna()
  641. # Plot
  642. fig, ax = plt.subplots(figsize=(4, 6))
  643. sns.violinplot(y=vals, inner="box", ax=ax)
  644. ax.set_ylabel('volume')
  645. ax.set_title('Oligodendrocytes — Volume Distribution')
  646. plt.tight_layout()
  647. plt.show()
  649. # Compute quartiles
  650. q1 = vals.quantile(0.25)
  651. median = vals.quantile(0.50)
  652. q3 = vals.quantile(0.75)
  653. iqr = q3 - q1
  655. # Compute whisker positions (1.5 × IQR rule)
  656. lower_whisker = vals[vals >= (q1 - 1.5 * iqr)].min()
  657. upper_whisker = vals[vals <= (q3 + 1.5 * iqr)].max()
  659. # Print them out
  660. print(f"Count: {len(vals)}")
  661. print(f"Q1 (25th pct): {q1:.3f}")
  662. print(f"Median (50th): {median:.3f}")
  663. print(f"Q3 (75th pct): {q3:.3f}")
  664. print(f"IQR: {iqr:.3f}")
  665. print(f"Lower whisker: {lower_whisker:.3f}")
  666. print(f"Upper whisker: {upper_whisker:.3f}")
  668. # %%
  669. # Assess volume distribution of putative Oligodendrocytes/Oligo-MN doublets
  671. import matplotlib.pyplot as plt
  672. import seaborn as sns
  674. # Subset to putative Oligodendrocytes/Oligo-MN doublets
  675. adata_periMN_oligo = adata_chol[adata_chol.obs["chol_leiden_1"].isin(["12", "13", "14"])]
  677. # Extract the volume values
  678. vals = adata_periMN_oligo.obs['volume'].dropna()
  680. # Plot
  681. fig, ax = plt.subplots(figsize=(4, 6))
  682. sns.violinplot(y=vals, inner="box", ax=ax)
  683. ax.set_ylabel('volume')
  684. ax.set_title('Volume Distribution')
  685. plt.tight_layout()
  686. plt.show()
  688. # Compute quartiles
  689. q1 = vals.quantile(0.25)
  690. median = vals.quantile(0.50)
  691. q3 = vals.quantile(0.75)
  692. iqr = q3 - q1
  694. # Compute whisker positions (1.5 × IQR rule)
  695. lower_whisker = vals[vals >= (q1 - 1.5 * iqr)].min()
  696. upper_whisker = vals[vals <= (q3 + 1.5 * iqr)].max()
  698. # Print them out
  699. print(f"Count: {len(vals)}")
  700. print(f"Q1 (25th pct): {q1:.3f}")
  701. print(f"Median (50th): {median:.3f}")
  702. print(f"Q3 (75th pct): {q3:.3f}")
  703. print(f"IQR: {iqr:.3f}")
  704. print(f"Lower whisker: {lower_whisker:.3f}")
  705. print(f"Upper whisker: {upper_whisker:.3f}")
  707. # %%
  708. # Save metadata for cells within the lower and upper whiskers
  710. # Build the boolean mask
  711. mask = (
  712. (adata_periMN_oligo.obs['volume'] >= lower_whisker) &
  713. (adata_periMN_oligo.obs['volume'] <= upper_whisker)
  714. )
  716. # Get the filtered obs DataFrame
  717. filtered_obs = adata_periMN_oligo.obs.loc[mask]
  719. # Change cell_class to Oligodendrocytes
  720. filtered_obs['cell_class'] = 'Oligodendrocytes'
  722. # Save with the index as a column
  723. filtered_obs.to_csv(os.path.join(working_dir, 'periMN_oligo_metadata.csv'), index=True)
  725. # %% [markdown]
  726. # #### Back to cholinergic neurons
  728. # %%
  729. clusters_to_remove = ["12", "13", "14"]
  730. adata_chol_filtered = adata_chol[~adata_chol.obs["chol_leiden_1"].isin(clusters_to_remove)].copy()
  732. sc.pl.umap(adata_chol_filtered, color="chol_leiden_1")
  734. # %%
  735. # Re-run BBKNN, UMAP, and clustering
  737. # Neighbors and UMAP
  738. sc.external.pp.bbknn(adata_chol_filtered, batch_key='VS') # use inplace of sc.pp.neighbors()
  739. sc.tl.umap(adata_chol_filtered,
  740. min_dist=0.5,
  741. spread=1.0)
  743. # Clustering
  744. sc.tl.leiden(adata_chol_filtered,
  745. key_added="chol_leiden_1.2",
  746. resolution=1.2,
  747. flavor="igraph",
  748. n_iterations=2)
  750. # %%
  751. # Plot the new sub-clusters
  752. sc.pl.umap(adata_chol_filtered, color="chol_leiden_1.2")
  753. sc.pl.umap(adata_chol_filtered, color="stage")
  754. sc.pl.umap(adata_chol_filtered, color="slide")
  756. # %% [markdown]
  757. # ## Fig. S2F
  759. # %%
  760. import matplotlib.pyplot as plt
  761. import scanpy as sc
  763. # 0) Set all font sizes to 7
  764. plt.rcParams.update({
  765. "font.size": 7,
  766. "axes.titlesize": 7,
  767. "axes.labelsize": 7,
  768. "xtick.labelsize": 7,
  769. "ytick.labelsize": 7,
  770. "legend.fontsize": 7,
  771. "legend.title_fontsize": 7,
  772. "figure.titlesize": 7
  773. })
  775. # 1) Create a high‐DPI figure (this sets the base resolution for rasterized artists)
  776. fig, ax = plt.subplots(dpi=300) # <-- 300 DPI here
  778. # 2) Draw UMAP off‐screen, no title, into that axes
  779. sc.pl.umap(
  780. adata_chol_filtered,
  781. color="chol_leiden_1.2",
  782. size=5,
  783. legend_loc='on data',
  784. legend_fontsize=7, # redundant now, but explicit
  785. title="",
  786. show=False,
  787. ax=ax
  788. )
  790. # 3) Rasterize only the scatter collections
  791. for coll in ax.collections:
  792. coll.set_rasterized(True)
  794. # 4) Fix the output size in inches
  795. fig.set_size_inches(2.15, 2.15)
  797. # 5) Save with an even higher DPI if you like (affects only raster parts in a vector file)
  798. fig.savefig(
  799. "figures/umap/UMAP_chol_leiden.svg",
  800. format="svg",
  801. bbox_inches="tight",
  802. dpi=600 # <-- rasterized points will now be 600 DPI
  803. )
  806. # %% [markdown]
  807. # ## Fig. S2G
  809. # %%
  810. import matplotlib.pyplot as plt
  811. import seaborn as sns
  812. import os
  814. genes = ["Bcl6", "Stk32a", "Vipr2", "Npas1", "Creb5", "Plch1", "Gap43", "Chat", "Slc5a7", "Prph"]
  816. # Define the desired cluster order
  817. desired_order = ['12', '4', '10', '18', '2', '7', '8', '15', '14', '19',
  818. '11', '17', '5', '3', '6', '16', '9', '13', '1', '0']
  820. adata_chol_filtered_counts = adata_chol_filtered[:, genes].copy()
  821. adata_chol_filtered_counts.X = adata_chol_filtered_counts.layers['counts']
  823. # Convert to a DataFrame
  824. counts_df = pd.DataFrame(adata_chol_filtered_counts.X, index=adata_chol_filtered_counts.obs_names, columns=adata_chol_filtered_counts.var_names)
  826. # Normalize total counts to 250
  827. sc.pp.normalize_total(adata_chol_filtered_counts, target_sum=250)
  829. # Add cluster information
  830. cluster_key = "chol_leiden_1.2" # Update this if using a different cluster key
  831. counts_df["cluster"] = adata_chol_filtered_counts.obs[cluster_key].values
  833. # Compute average expression per cluster
  834. cluster_avg = counts_df.groupby("cluster")[genes].mean().T # Transpose to have genes on y-axis
  836. # Convert row_min and row_max to NumPy arrays
  837. row_min = cluster_avg.min(axis=1).to_numpy()
  838. row_max = cluster_avg.max(axis=1).to_numpy()
  840. # Avoid division by zero by checking where min == max
  841. constant_rows = row_max == row_min
  843. # Perform row normalization (Min-Max Scaling)
  844. cluster_avg_norm = (cluster_avg - row_min[:, np.newaxis]) / (row_max - row_min)[:, np.newaxis]
  846. # Set constant rows to 0 (or another value like NaN if needed)
  847. cluster_avg_norm[constant_rows] = 0
  849. # Reorder the columns of the DataFrame
  850. cluster_avg_norm = cluster_avg_norm[desired_order]
  852. # Plot the heatmap
  853. fig, ax = plt.subplots(figsize=(5.7, 2.4))
  855. # draw heatmap with only two ticks at 0 and 1
  856. heatmap = sns.heatmap(
  857. cluster_avg_norm,
  858. cmap="viridis",
  859. annot=False,
  860. fmt=".2f",
  861. linewidths=0.5,
  862. ax=ax,
  863. cbar_kws={
  864. "ticks": [0.0, 1.0], # only these two positions
  865. "shrink": 0.9,
  866. "pad": 0.13
  867. }
  868. )
  870. # 1) Remove all tick-marks (but keep the labels)
  871. ax.tick_params(axis="both", which="both", length=0)
  873. # 2) Rotate the x-axis labels 90°
  874. ax.set_xticklabels(ax.get_xticklabels(), rotation=-90)
  876. # 3) Move the gene/row names (y-tick labels) to the right & make them horizontal
  877. ax.tick_params(axis="y", labelleft=False, labelright=True, left=False, right=True)
  878. ax.set_yticklabels(ax.get_yticklabels(), rotation=0)#, ha="right")
  880. # 4) Clear axis titles and labels
  881. ax.set_xlabel("")
  882. ax.set_ylabel("")
  883. ax.set_title("")
  885. # 5) Tweak the colorbar
  886. cbar = heatmap.collections[0].colorbar
  887. # a) remove the little tick‐lines
  888. cbar.ax.tick_params(length=0)
  889. # b) replace the two tick labels
  890. cbar.ax.set_yticklabels(["Min", "Max"])
  891. # c) remove any other labels (there won’t be any beyond your two ticks)
  892. # (no extra step needed since we only set two ticks)
  893. # d) add a vertically-oriented label “By Row” centered along the bar
  894. cbar.ax.set_ylabel(
  895. "By Row",
  896. rotation=-90, # text runs horizontally
  897. va="center", # center along the bar
  898. labelpad=-6 # push it out away from the bar
  899. )
  901. # 6) Save
  902. heatmap_path = os.path.join(figures_dir, "heatmap_chol.svg")
  903. fig.savefig(heatmap_path, dpi=300, bbox_inches="tight", transparent=True)
  904. plt.show()
  907. # %%
  908. # Add cholinergic type labels
  909. type_map = {'0': 'Cholinergic Interneurons',
  910. '1': 'Visceral MNs',
  911. '2': 'Alpha MNs',
  912. '3': 'Alpha MNs',
  913. '4': 'Alpha MNs',
  914. '5': 'Alpha MNs',
  915. '6': 'Alpha MNs',
  916. '7': 'Alpha MNs',
  917. '8': 'Alpha MNs',
  918. '9': 'Gamma MNs',
  919. '10': 'Alpha MNs',
  920. '11': 'Alpha MNs',
  921. '12': 'Alpha MNs',
  922. '13': 'Gamma* MNs',
  923. '14': 'Alpha MNs',
  924. '15': 'Alpha MNs',
  925. '16': 'Alpha MNs',
  926. '17': 'Alpha MNs',
  927. '18': 'Alpha MNs',
  928. '19': 'Alpha MNs'}
  930. cholinergic_type = []
  931. leiden_cluster = adata_chol_filtered.obs['chol_leiden_1.2'].to_list()
  933. for l in leiden_cluster:
  934. cholinergic_type.append(type_map[l])
  936. adata_chol_filtered.obs['cholinergic_type'] = cholinergic_type
  938. # %%
  939. # Plot the annotated UMAP
  940. sc.pl.umap(adata_chol_filtered, color="cholinergic_type", save="/UMAP_cholinergic_type.png")
  942. # %% [markdown]
  943. # ## Fig. S2H
  945. # %%
  946. # 0) Set all font sizes to 7
  947. plt.rcParams.update({
  948. "font.size": 7,
  949. "axes.titlesize": 7,
  950. "axes.labelsize": 7,
  951. "xtick.labelsize": 7,
  952. "ytick.labelsize": 7,
  953. "legend.fontsize": 7,
  954. "legend.title_fontsize": 7,
  955. "figure.titlesize": 7
  956. })
  958. # 1) Create a high‐DPI figure (this sets the base resolution for rasterized artists)
  959. fig, ax = plt.subplots(dpi=300) # <-- 300 DPI here
  961. # your abbr dict
  962. abbr = {
  963. "Alpha MNs": "Alpha MNs",
  964. "Gamma* MNs": "Gamma* MNs",
  965. "Gamma MNs": "Gamma MNs",
  966. "Visceral MNs": "Visceral \nMNs",
  967. "Cholinergic Interneurons": "Chol. \nInt."
  968. }
  970. # 2) Draw UMAP off‐screen, no title, into that axes
  971. sc.pl.umap(
  972. adata_chol_filtered,
  973. size=5,
  974. color="cholinergic_type",
  975. legend_loc='on data',
  976. legend_fontsize=7,
  977. title="",
  978. show=False,
  979. ax=ax
  980. )
  982. # 2b) Replace each on‐data label with its abbr
  983. for txt in ax.texts:
  984. orig = txt.get_text()
  985. if orig in abbr:
  986. txt.set_text(abbr[orig])
  988. # now continue with your rasterization + sizing + saving…
  989. # 3) Rasterize only the scatter collections
  990. for coll in ax.collections:
  991. coll.set_rasterized(True)
  993. # 4) Fix the output size in inches
  994. fig.set_size_inches(2.15, 2.15)
  996. # 5) Save...
  997. fig.savefig(
  998. "figures/umap/UMAP_chol_type.svg",
  999. format="svg",
  1000. bbox_inches="tight",
  1001. dpi=600
  1002. )
  1005. # %%
  1006. sc.pl.violin(adata_chol_filtered, keys=['volume'], groupby='cholinergic_type', rotation=90)
  1008. # %%
  1009. # Build the mask for cells to keep
  1010. keep_mask = adata_chol_filtered.obs['volume'] >= 1000
  1012. # Make a new AnnData
  1013. adata_chol_filtered_highvol = adata_chol_filtered[keep_mask, :].copy()
  1015. # %%
  1016. # Plot the new sub-clusters
  1017. sc.pl.umap(adata_chol_filtered_highvol, color="chol_leiden_1.2")
  1019. # %%
  1020. # Plot the annotated UMAP
  1021. sc.pl.umap(adata_chol_filtered_highvol, color="cholinergic_type")
  1023. # %%
  1024. sc.pl.violin(adata_chol_filtered_highvol, keys=['volume'], groupby='cholinergic_type', rotation=90)
  1026. # %%
  1027. # Save anndata
  1028. save_name = f"adata_objects/cholinergic_anndata.h5ad"
  1029. adata_chol_filtered.write_h5ad(os.path.join(working_dir, save_name))
  1031. save_name = f"adata_objects/cholinergic_anndata_highvol.h5ad"
  1032. adata_chol_filtered_highvol.write_h5ad(os.path.join(working_dir, save_name))
  1034. # %%
  1035. adata = sc.read_h5ad(os.path.join(working_dir, f"adata_objects/cholinergic_anndata.h5ad"))
  1037. # %%
  1038. adata_chol_filtered = adata
  1040. # %% [markdown]
  1041. # ## Subcluster alpha MNs
  1043. # %%
  1044. adata = sc.read_h5ad(os.path.join(working_dir, f"adata_objects/cholinergic_anndata_highvol.h5ad"))
  1046. # %%
  1047. # Select alpha MNs
  1048. adata_alpha = adata[adata.obs["cholinergic_type"] == "Alpha MNs"].copy()
  1050. # %%
  1051. # Neighbors and UMAP
  1052. sc.external.pp.bbknn(adata_alpha, batch_key='VS') # use inplace of sc.pp.neighbors()
  1053. sc.tl.umap(adata_alpha,
  1054. min_dist=0.5,
  1055. spread=1.0)
  1057. # %%
  1058. # Clustering
  1059. sc.tl.leiden(adata_alpha,
  1060. key_added="alpha_leiden_0.45",
  1061. resolution=0.45,
  1062. flavor="igraph",
  1063. n_iterations=2)
  1065. # %%
  1066. # Plot the sub-clusters
  1067. sc.pl.umap(adata_alpha, color="alpha_leiden_0.45", save="/UMAP_alpha_leiden.png")
  1069. # %%
  1070. import matplotlib.pyplot as plt
  1071. import scanpy as sc
  1073. # 0) Set all font sizes to 7
  1074. plt.rcParams.update({
  1075. "font.size": 7,
  1076. "axes.titlesize": 7,
  1077. "axes.labelsize": 7,
  1078. "xtick.labelsize": 7,
  1079. "ytick.labelsize": 7,
  1080. "legend.fontsize": 7,
  1081. "legend.title_fontsize": 7,
  1082. "figure.titlesize": 7
  1083. })
  1085. # 1) Create a high‐DPI figure (this sets the base resolution for rasterized artists)
  1086. fig, ax = plt.subplots(dpi=300) # <-- 300 DPI here
  1088. # 2) Draw UMAP off‐screen, no title, into that axes
  1089. sc.pl.umap(
  1090. adata_alpha,
  1091. color="alpha_leiden_0.45",
  1092. size=10,
  1093. legend_loc='on data',
  1094. legend_fontsize=7, # redundant now, but explicit
  1095. title="",
  1096. show=False,
  1097. ax=ax
  1098. )
  1100. # 3) Rasterize only the scatter collections
  1101. for coll in ax.collections:
  1102. coll.set_rasterized(True)
  1104. # 4) Fix the output size in inches
  1105. fig.set_size_inches(2.15, 2.15)
  1107. # 5) Save with an even higher DPI if you like (affects only raster parts in a vector file)
  1108. fig.savefig(
  1109. "figures/umap/UMAP_alpha_leiden.svg",
  1110. format="svg",
  1111. bbox_inches="tight",
  1112. dpi=600 # <-- rasterized points will now be 600 DPI
  1113. )
  1116. # %%
  1117. sc.pl.violin(adata_alpha, keys=['volume'], groupby='alpha_leiden_0.45')
  1119. # %%
  1120. # Plot the sub-clusters
  1121. sc.pl.umap(adata_alpha, color="stage")
  1122. sc.pl.umap(adata_alpha, color="slide")
  1124. # %%
  1125. sc.pl.umap(adata_alpha, color=["Prkcd", "Chodl", "Atf3", "Gap43"])
  1127. # %%
  1128. # Save anndata
  1129. save_name = f"adata_objects/alpha_anndata.h5ad"
  1130. adata_alpha.write_h5ad(os.path.join(working_dir, save_name))
  1132. # %% [markdown]
  1133. # ## Alpha MN UMAP labeled by stage
  1135. # %%
  1136. adata_alpha = sc.read_h5ad(os.path.join(working_dir, f"adata_objects/alpha_anndata.h5ad"))
  1138. # %% [markdown]
  1139. # ## Fig. S3I
  1141. # %%
  1142. import scanpy as sc
  1143. import matplotlib.pyplot as plt
  1144. import pandas as pd
  1146. # ---- Enforce stage order ----
  1147. desired_order = ["Control", "Early", "Mid", "End"]
  1149. adata_alpha.obs["stage"] = pd.Categorical(
  1150. adata_alpha.obs["stage"],
  1151. categories=desired_order,
  1152. ordered=True
  1153. )
  1155. # Global font size = 7
  1156. plt.rcParams.update({
  1157. "font.size": 7,
  1158. "axes.titlesize": 7,
  1159. "axes.labelsize": 7,
  1160. "xtick.labelsize": 7,
  1161. "ytick.labelsize": 7,
  1162. "legend.fontsize": 7,
  1163. "legend.title_fontsize": 6
  1164. })
  1166. # Create UMAP and return figure
  1167. fig = sc.pl.umap(
  1168. adata_alpha,
  1169. color="stage",
  1170. title="",
  1171. size=5,
  1172. show=False,
  1173. return_fig=True
  1174. )
  1176. # Set exact figure size AFTER creation
  1177. fig.set_size_inches(1.85, 1.3306)
  1179. plt.tight_layout()
  1180. plt.show()
  1182. fig.savefig(
  1183. "figures/umap/adata_alpha_stage_umap.svg",
  1184. format="svg",
  1185. bbox_inches="tight"
  1186. )
  1188. # %% [markdown]
  1189. # ## Differentially expressed genes in alpha MNs
  1191. # %%
  1192. # Read in AnnData
  1193. adata = sc.read_h5ad(os.path.join(working_dir, f"adata_objects/alpha_anndata_label_transfer.h5ad"))
  1195. # %%
  1196. # Get all gene names from the AnnData object
  1197. gene_names = adata.var_names
  1199. # Convert to DataFrame with a column name
  1200. genes_df = pd.DataFrame(gene_names, columns=["Gene"])
  1202. # Save to CSV (no row index, just gene names)
  1203. genes_df.to_csv("MERFISH_genes.csv", index=False)
  1205. # %%
  1206. # Read the CSV file of differentially expressed genes with disease in Alpha MNs from snRNA-seq
  1207. alpha_snrna_end = pd.read_csv("/home/users/ogautier/oak/Shared/SOD1_Paper/RNA/DESeq2/Cholinergic_Type/Alpha MNs_sod.end_vs_ctl.csv", index_col=0)
  1209. # %%
  1210. # Filter alpha_snrna_end for padj < 0.01 & gene/row name in adata
  1211. alpha_snrna_end_sig = alpha_snrna_end[
  1212. (alpha_snrna_end["padj"] < 0.01) & alpha_snrna_end.index.isin(adata.var_names)
  1213. ]
  1215. # %%
  1216. # Get upregulated and downregulated genes
  1217. alpha_snrna_upregulated = alpha_snrna_end_sig[
  1218. (alpha_snrna_end_sig["log2FoldChange"] > 0)
  1219. ]
  1221. alpha_snrna_downregulated = alpha_snrna_end_sig[
  1222. (alpha_snrna_end_sig["log2FoldChange"] < 0)
  1223. ]
  1225. # %%
  1226. alpha_snrna_end_sig
  1228. # %%
  1229. alpha_snrna_upregulated
  1231. # %%
  1232. alpha_snrna_downregulated
  1234. # %%
  1235. # Filter adata to keep genes in alpha_snrna_end_sig
  1236. mask = adata.var_names.isin(alpha_snrna_end_sig.index)
  1237. adata_filtered = adata[:, mask]
  1239. # %%
  1240. adata_filtered = adata_filtered[:, :].copy()
  1241. adata_filtered.X = adata_filtered.layers['counts']
  1243. # Normalization of data by volume
  1244. adata_filtered.X = adata_filtered.X/np.array(adata_filtered.obs['volume'])[:,None]
  1245. # Normalize total to 250
  1246. sc.pp.normalize_total(adata_filtered, target_sum=250)
  1247. # Log transform
  1248. sc.pp.log1p(adata_filtered)
  1250. # %%
  1251. import pandas as pd
  1252. import numpy as np
  1253. from scipy.stats import mannwhitneyu
  1254. from statsmodels.stats.multitest import multipletests
  1256. # Initialize lists to store the results
  1257. genes = []
  1258. p_values_comparison1 = []
  1259. log2foldchange_comparison1 = []
  1260. p_values_comparison2 = []
  1261. log2foldchange_comparison2 = []
  1263. # Iterate over all genes
  1264. for gene in adata_filtered.var_names:
  1266. # Extract expression data (dense format) for the gene
  1267. control_expr = np.asarray(adata_filtered[adata_filtered.obs["stage"] == "Control", gene].X).flatten()
  1268. mid_expr = np.asarray(adata_filtered[adata_filtered.obs["stage"] == "Mid", gene].X).flatten()
  1269. end_expr = np.asarray(adata_filtered[adata_filtered.obs["stage"] == "End", gene].X).flatten()
  1271. # Control vs Mid
  1272. p_mid = float(mannwhitneyu(control_expr, mid_expr, alternative='two-sided')[1])
  1273. fc_mid = np.nanmean(np.exp(mid_expr) - 1) / np.nanmean(np.exp(control_expr) - 1)
  1274. log2_fc_mid = np.log2(fc_mid)
  1276. # Control vs End
  1277. p_end = float(mannwhitneyu(control_expr, end_expr, alternative='two-sided')[1])
  1278. fc_end = np.nanmean(np.exp(end_expr) - 1) / np.nanmean(np.exp(control_expr) - 1)
  1279. log2_fc_end = np.log2(fc_end)
  1281. # Store results
  1282. genes.append(gene)
  1283. p_values_comparison1.append(p_mid)
  1284. log2foldchange_comparison1.append(log2_fc_mid)
  1285. p_values_comparison2.append(p_end)
  1286. log2foldchange_comparison2.append(log2_fc_end)
  1288. # Create a DataFrame with the raw p-values and log2 fold changes
  1289. results_df = pd.DataFrame({
  1290. "Gene": genes,
  1291. "p-value_Control_vs_Mid": p_values_comparison1,
  1292. "log2FoldChange_Control_vs_Mid": log2foldchange_comparison1,
  1293. "p-value_Control_vs_End": p_values_comparison2,
  1294. "log2FoldChange_Control_vs_End": log2foldchange_comparison2
  1295. })
  1297. # Adjust p-values using Benjamini-Hochberg (FDR) correction
  1298. # For Control vs Mid:
  1299. adj_mid = multipletests(results_df["p-value_Control_vs_Mid"], method="fdr_bh")
  1300. results_df["adj-p-value_Control_vs_Mid"] = adj_mid[1]
  1302. # For Control vs End:
  1303. adj_end = multipletests(results_df["p-value_Control_vs_End"], method="fdr_bh")
  1304. results_df["adj-p-value_Control_vs_End"] = adj_end[1]
  1306. # Sort by adjusted p-value for one of the comparisons:
  1307. results_df = results_df.sort_values("adj-p-value_Control_vs_End")
  1309. # Specify the desired column order
  1310. desired_order = [
  1311. "Gene",
  1312. "log2FoldChange_Control_vs_Mid",
  1313. "p-value_Control_vs_Mid",
  1314. "adj-p-value_Control_vs_Mid",
  1315. "log2FoldChange_Control_vs_End",
  1316. "p-value_Control_vs_End",
  1317. "adj-p-value_Control_vs_End"
  1318. ]
  1320. # Reorder the DataFrame
  1321. results_df = results_df[desired_order]
  1323. # Display the reordered DataFrame
  1324. results_df
  1327. # %%
  1328. # Save to CSV in the figures directory
  1329. output_path = os.path.join(figures_dir, "alpha_differential_gene_expression_results.csv")
  1330. results_df.to_csv(output_path, index=False)
  1332. # %% [markdown]
  1333. # ## Fig. S3J
  1335. # %%
  1336. import matplotlib.pyplot as plt
  1337. from matplotlib_venn import venn3
  1339. # 1) Prepare gene sets as before
  1341. # Upregulated Genes (adj‐p < 0.01, log2FC > 0)
  1342. mid_upregulated = results_df[
  1343. (results_df["adj-p-value_Control_vs_Mid"] < 0.01) &
  1344. (results_df["log2FoldChange_Control_vs_Mid"] > 0)
  1345. ]
  1346. end_upregulated = results_df[
  1347. (results_df["adj-p-value_Control_vs_End"] < 0.01) &
  1348. (results_df["log2FoldChange_Control_vs_End"] > 0)
  1349. ]
  1351. # Downregulated Genes (adj‐p < 0.01, log2FC < 0)
  1352. mid_downregulated = results_df[
  1353. (results_df["adj-p-value_Control_vs_Mid"] < 0.01) &
  1354. (results_df["log2FoldChange_Control_vs_Mid"] < 0)
  1355. ]
  1356. end_downregulated = results_df[
  1357. (results_df["adj-p-value_Control_vs_End"] < 0.01) &
  1358. (results_df["log2FoldChange_Control_vs_End"] < 0)
  1359. ]
  1361. mid_up_set = set(mid_upregulated["Gene"])
  1362. end_up_set = set(end_upregulated["Gene"])
  1363. mid_down_set = set(mid_downregulated["Gene"])
  1364. end_down_set = set(end_downregulated["Gene"])
  1366. snrna_up_set = set(alpha_snrna_upregulated.index)
  1367. snrna_down_set = set(alpha_snrna_downregulated.index)
  1369. # 2) Create one figure with 2 rows, 1 column
  1370. # Size specified in inches: width=1.075", height=2.15"
  1371. fig, axes = plt.subplots(
  1372. nrows=2, ncols=1,
  1373. figsize=(1.075, 1.95),
  1374. dpi=300
  1375. )
  1377. # 3) Top subplot: Upregulated venn3
  1378. v1 = venn3(
  1379. subsets=[mid_up_set, end_up_set, snrna_up_set],
  1380. set_labels=("MERFISH (Mid)", "MERFISH (End)", "snRNA-seq"),
  1381. ax=axes[0]
  1382. )
  1383. axes[0].set_title("Upregulated Genes", fontsize=7)
  1385. # Adjust all label fonts in the first Venn
  1386. for text in v1.set_labels:
  1387. text.set_fontsize(7)
  1388. for text in v1.subset_labels:
  1389. if text: # some subset regions may be empty (None)
  1390. text.set_fontsize(7)
  1392. # 4) Bottom subplot: Downregulated venn3
  1393. v2 = venn3(
  1394. subsets=[mid_down_set, end_down_set, snrna_down_set],
  1395. set_labels=("MERFISH (Mid)", "MERFISH (End)", "snRNA-seq"),
  1396. ax=axes[1]
  1397. )
  1398. axes[1].set_title("Downregulated Genes", fontsize=7)
  1400. # Adjust all label fonts in the second Venn
  1401. for text in v2.set_labels:
  1402. text.set_fontsize(7)
  1403. for text in v2.subset_labels:
  1404. if text:
  1405. text.set_fontsize(7)
  1407. # 5) Manually adjust margins so no labels get cut off
  1408. fig.subplots_adjust(
  1409. left=0.12,
  1410. right=0.98,
  1411. top=0.98,
  1412. bottom=0.02,
  1413. hspace=0.3 # space between the two plots
  1414. )
  1416. # 6) Save the combined figure
  1417. fig.savefig("figures/alpha_venn_up_down.svg", dpi=300)
  1419. # 7) Display
  1420. plt.show()
  1423. # %% [markdown]
  1424. # ## Apoptosis/Stress genes
  1426. # %%
  1427. # Read in AnnData
  1428. adata = sc.read_h5ad(os.path.join(working_dir, f"adata_objects/alpha_anndata_label_transfer.h5ad"))
  1430. # %%
  1431. adata_violin = adata[:, :].copy()
  1432. adata_violin.X = adata_violin.layers['counts']
  1434. # Normalization of data by volume
  1435. adata_violin.X = adata_violin.X/np.array(adata_violin.obs['volume'])[:,None]
  1436. # Normalize total to 250
  1437. sc.pp.normalize_total(adata_violin, target_sum=250)
  1438. # Log transform
  1439. sc.pp.log1p(adata_violin)
  1441. # %% [markdown]
  1442. # ## Fig. S3K
  1444. # %%
  1445. import os
  1446. import numpy as np
  1447. import matplotlib as mpl
  1448. import matplotlib.pyplot as plt
  1449. import scanpy as sc
  1450. from matplotlib.collections import PolyCollection
  1452. # global font size
  1453. mpl.rcParams.update({
  1454. "font.size": 7,
  1455. "axes.titlesize": 7,
  1456. "axes.labelsize": 7,
  1457. "xtick.labelsize": 7,
  1458. "ytick.labelsize": 7,
  1459. "axes.linewidth": 0.5,
  1460. "xtick.major.width": 0.5,
  1461. "ytick.major.width": 0.5,
  1462. "xtick.minor.width": 0.5,
  1463. "ytick.minor.width": 0.5
  1464. })
  1466. # genes and stage order
  1467. keys = ['Hrk', 'Ddit3', 'Trib3']
  1468. order = ['Control', 'Early', 'Mid', 'End']
  1470. # prepare figure with independent y-axes
  1471. fig, axes = plt.subplots(
  1472. nrows=1, ncols=len(keys),
  1473. figsize=(2, 0.9),
  1474. sharey=False
  1475. )
  1477. # draw one violins
  1478. # then compute and plot a single median dot
  1479. for idx, (ax, gene) in enumerate(zip(axes, keys)):
  1480. sc.pl.violin(
  1481. adata_violin,
  1482. keys=[gene],
  1483. groupby='stage',
  1484. order=order,
  1485. rotation=90,
  1486. multi_panel=False,
  1487. stripplot=False, # no individual points
  1488. jitter=False, # no jitter
  1489. inner=None, # no quartile/median lines
  1490. ax=ax,
  1491. show=False
  1492. )
  1493. # thin the violin outlines
  1494. for coll in ax.collections:
  1495. if isinstance(coll, PolyCollection):
  1496. coll.set_linewidth(0.75)
  1497. # thin the axes spines
  1498. for spine in ax.spines.values():
  1499. spine.set_linewidth(0.5)
  1501. # title & axis labels
  1502. ax.set_title(gene)
  1503. if idx == 0:
  1504. ax.set_ylabel("Expression")
  1505. else:
  1506. ax.set_ylabel("")
  1507. ax.set_xlabel("")
  1508. ax.tick_params(axis='y', labelleft=True)
  1509. ax.grid(False)
  1511. # get expression values and overlay medians
  1512. expr = adata_violin.obs_vector(gene)
  1513. for xi, stage in enumerate(order):
  1514. mask = adata_violin.obs['stage'] == stage
  1515. med = np.median(expr[mask.values])
  1516. ax.scatter(xi, med,
  1517. color='black',
  1518. marker='o',
  1519. s=1,
  1520. zorder=10)
  1522. # Reduce horizontal space between panels
  1523. fig.subplots_adjust(wspace=0.8) # try 0.05–0.2
  1525. plt.show()
  1527. fig.savefig(
  1528. "figures/violin/apoptosis_stress_genes_violin_stage.svg",
  1529. format="svg",
  1530. bbox_inches="tight",
  1531. pad_inches=0.02 # reduces outer whitespace
  1532. )
  1534. # %% [markdown]
  1535. # ## Alpha MN label transfer from snRNA-seq data
  1537. # %% [markdown]
  1538. # #### Create h5ad file for all data
  1540. # %%
  1541. # read the matrix
  1542. adata = sc.read_10x_mtx(
  1543. "/oak/stanford/groups/agitler/Shared/SOD1_Paper/RNA/files_to_make_h5ad/final_obj/",
  1544. var_names='gene_symbols',
  1545. make_unique=True
  1546. )
  1548. # %%
  1549. # read the metadata
  1550. md = pd.read_csv(
  1551. "/oak/stanford/groups/agitler/Shared/SOD1_Paper/RNA/files_to_make_h5ad/final_obj/cell_metadata.tsv",
  1552. sep="\t",
  1553. index_col=0
  1554. )
  1556. # %%
  1557. # make sure the index matches adata.obs_names
  1558. md = md.reindex(adata.obs_names)
  1560. # %%
  1561. # assign
  1562. adata.obs = md
  1564. # %%
  1565. # Save AnnData
  1566. save_name = f"adata_objects/all_snrna_data.h5ad"
  1567. adata.write_h5ad(os.path.join(working_dir, save_name))
  1569. # %% [markdown]
  1570. # #### Create h5ad file from alpha MN snRNA-seq data
  1572. # %%
  1573. # read the matrix
  1574. adata = sc.read_10x_mtx(
  1575. "/oak/stanford/groups/agitler/Shared/SOD1_Paper/RNA/files_to_make_h5ad/alpha_label_transfer_50/",
  1576. var_names='gene_symbols',
  1577. make_unique=True
  1578. )
  1580. # %%
  1581. # read the metadata
  1582. md = pd.read_csv(
  1583. "/oak/stanford/groups/agitler/Shared/SOD1_Paper/RNA/files_to_make_h5ad/alpha_label_transfer_50/cell_metadata.tsv",
  1584. sep="\t",
  1585. index_col=0
  1586. )
  1588. # %%
  1589. # make sure the index matches adata.obs_names
  1590. md = md.reindex(adata.obs_names)
  1592. # %%
  1593. # assign
  1594. adata.obs = md
  1596. # %%
  1597. # Save AnnData
  1598. save_name = f"adata_objects/alpha_snrna_data.h5ad"
  1599. adata.write_h5ad(os.path.join(working_dir, save_name))
  1601. # %% [markdown]
  1602. # #### Label transfer
  1604. # %%
  1605. # Load MERFISH and snRNA-seq datasets
  1606. merfish = sc.read_h5ad(os.path.join(working_dir, f"adata_objects/alpha_anndata.h5ad"))
  1607. snrna = sc.read_h5ad(os.path.join(working_dir, f"adata_objects/alpha_snrna_data.h5ad"))
  1609. # %%
  1610. merfish.X = merfish.layers["counts"]
  1612. # %%
  1613. # Find common genes between MERFISH and snRNA-seq
  1614. common_genes = list(set(merfish.var_names) & set(snrna.var_names))
  1616. # %%
  1617. # Filter both datasets to keep only the common genes
  1618. merfish = merfish[:, common_genes]
  1619. snrna = snrna[:, common_genes]
  1621. # %%
  1622. merfish.obs["batch"] = "MERFISH"
  1623. snrna.obs["batch"] = "snRNA"
  1625. # Concatenate datasets
  1626. adata_combined = ad.concat([merfish, snrna], join="outer", label="batch", keys=["MERFISH", "snRNA"])
  1628. # %%
  1629. scvi.model.SCVI.setup_anndata(adata_combined, batch_key="batch")
  1630. model = scvi.model.SCVI(adata_combined)
  1632. # %%
  1633. model.train()
  1635. # %%
  1636. adata_combined.obs['predicted.id'] = adata_combined.obs['predicted.id'].cat.add_categories('Unknown')
  1637. adata_combined.obs = adata_combined.obs.fillna(value = {'predicted.id': 'Unknown'})
  1639. # %%
  1640. model2 = scvi.model.SCANVI.from_scvi_model(model, adata = adata_combined, unlabeled_category = 'Unknown',
  1641. labels_key = 'predicted.id')
  1643. # %%
  1644. model2.train(max_epochs = 400)
  1646. # %%
  1647. adata_combined.obs['predicted'] = model2.predict(adata_combined)
  1649. # %% [markdown]
  1650. # #### Add the predicted labels to the alpha MN anndata object
  1652. # %%
  1653. cell_mapper = dict(zip(adata_combined.obs.index, adata_combined.obs.predicted))
  1655. # %%
  1656. adata = sc.read_h5ad(os.path.join(working_dir, f"adata_objects/alpha_anndata.h5ad"))
  1658. # %%
  1659. adata.obs['predicted.id'] = adata.obs.index.map(cell_mapper)
  1661. # %%
  1662. # Plot the transferred labels
  1663. sc.pl.umap(adata, color="predicted.id")
  1665. # %%
  1666. sc.pl.violin(
  1667. adata,
  1668. keys=['Prkcd', 'Chodl', 'Atf3', 'Gap43'],
  1669. groupby='predicted.id',
  1670. order=["Slow-Firing", "Intermediate", "Fast-Firing", "Early DAMN", "Late DAMN"],
  1671. rotation=90
  1672. )
  1674. # %%
  1675. # Save anndata
  1676. save_name = f"adata_objects/alpha_anndata_label_transfer.h5ad"
  1677. adata.write_h5ad(os.path.join(working_dir, save_name))
  1679. # %% [markdown]
  1680. # ## Alpha MN violin plots
  1682. # %%
  1683. # Read in AnnData
  1684. adata_alpha = sc.read_h5ad(os.path.join(working_dir, f"adata_objects/alpha_anndata_label_transfer.h5ad"))
  1686. # %%
  1687. adata_violin = adata_alpha[:, :].copy()
  1688. adata_violin.X = adata_violin.layers['counts']
  1690. # Normalization of data by volume
  1691. adata_violin.X = adata_violin.X/np.array(adata_violin.obs['volume'])[:,None]
  1692. # Normalize total to 250
  1693. sc.pp.normalize_total(adata_violin, target_sum=250)
  1694. # Log transform
  1695. sc.pp.log1p(adata_violin)
  1697. # %% [markdown]
  1698. # ## Fig. 2K
  1700. # %%
  1701. import os
  1702. import numpy as np
  1703. import matplotlib as mpl
  1704. import matplotlib.pyplot as plt
  1705. import scanpy as sc
  1706. from matplotlib.collections import PolyCollection
  1708. # ensure output folder exists
  1709. os.makedirs("figures/violin", exist_ok=True)
  1711. # global font size and thin axis spines
  1712. mpl.rcParams.update({
  1713. "font.size": 7,
  1714. "axes.titlesize": 7,
  1715. "axes.labelsize": 7,
  1716. "xtick.labelsize": 7,
  1717. "ytick.labelsize": 7,
  1718. "axes.linewidth": 0.5,
  1719. "xtick.major.width": 0.5,
  1720. "ytick.major.width": 0.5,
  1721. "xtick.minor.width": 0.5,
  1722. "ytick.minor.width": 0.5
  1723. })
  1725. # genes and stage order
  1726. keys = [
  1727. 'Tenm1','Kcng1','Kcnj14','Nalcn','Grm8','Grik4','Gria3',
  1728. 'Gabra5','Nefh','Ina','Slc7a11','Slc7a1','Sqstm1','Taf15'
  1729. ]
  1730. order = ['Control','Early','Mid','End']
  1732. # figure: 2×7 panels
  1733. ncol = len(keys)//2
  1734. fig, axes = plt.subplots(2, ncol, figsize=(6.5936, 2.5296), sharey=False)
  1735. axes_flat = axes.flatten()
  1737. for idx, (ax, gene) in enumerate(zip(axes_flat, keys)):
  1738. sc.pl.violin(
  1739. adata_violin,
  1740. keys=[gene],
  1741. groupby='stage',
  1742. order=order,
  1743. rotation=90,
  1744. multi_panel=False,
  1745. stripplot=False,
  1746. jitter=False,
  1747. inner=None,
  1748. ax=ax,
  1749. show=False
  1750. )
  1751. # thin the violin outlines
  1752. for coll in ax.collections:
  1753. if isinstance(coll, PolyCollection):
  1754. coll.set_linewidth(0.75)
  1755. # thin the axes spines
  1756. for spine in ax.spines.values():
  1757. spine.set_linewidth(0.5)
  1759. # title & labels
  1760. ax.set_title(gene)
  1761. if idx % ncol == 0:
  1762. ax.set_ylabel("Expression")
  1763. else:
  1764. ax.set_ylabel("")
  1765. ax.set_xlabel("")
  1766. ax.tick_params(axis='y', labelleft=True)
  1768. # overlay median dot
  1769. expr = adata_violin.obs_vector(gene)
  1770. for xi, stage in enumerate(order):
  1771. med = np.median(expr[adata_violin.obs['stage'] == stage])
  1772. ax.scatter(xi, med, color='black', s=1, zorder=10)
  1774. for idx, ax in enumerate(axes_flat):
  1775. # first ncol are top row
  1776. if idx < ncol:
  1777. ax.tick_params(axis='x', labelbottom=False)
  1778. else:
  1779. ax.tick_params(axis='x', labelbottom=True)
  1781. plt.tight_layout()
  1782. plt.show()
  1783. fig.savefig(
  1784. "figures/violin/disease_genes_violin.svg",
  1785. format="svg",
  1786. bbox_inches="tight"
  1787. )
  1789. # %% [markdown]
  1790. # ## Fig. 4E
  1792. # %%
  1793. import os
  1794. import numpy as np
  1795. import matplotlib as mpl
  1796. import matplotlib.pyplot as plt
  1797. import scanpy as sc
  1798. from matplotlib.collections import PolyCollection
  1800. # global font size
  1801. mpl.rcParams.update({
  1802. "font.size": 7,
  1803. "axes.titlesize": 7,
  1804. "axes.labelsize": 7,
  1805. "xtick.labelsize": 7,
  1806. "ytick.labelsize": 7,
  1807. "axes.linewidth": 0.5,
  1808. "xtick.major.width": 0.5,
  1809. "ytick.major.width": 0.5,
  1810. "xtick.minor.width": 0.5,
  1811. "ytick.minor.width": 0.5
  1812. })
  1814. # genes and stage order
  1815. keys = ['Nfia', 'Nfil3', 'Atf5', 'Atf3', 'Jun']
  1816. order = ['Control', 'Early', 'Mid', 'End']
  1818. # prepare figure with independent y-axes
  1819. fig, axes = plt.subplots(
  1820. nrows=1, ncols=len(keys),
  1821. figsize=(6.5, 1.4712),
  1822. sharey=False
  1823. )
  1825. # draw one violins
  1826. # then compute and plot a single median dot
  1827. for idx, (ax, gene) in enumerate(zip(axes, keys)):
  1828. sc.pl.violin(
  1829. adata_violin,
  1830. keys=[gene],
  1831. groupby='stage',
  1832. order=order,
  1833. rotation=90,
  1834. multi_panel=False,
  1835. stripplot=False, # no individual points
  1836. jitter=False, # no jitter
  1837. inner=None, # no quartile/median lines
  1838. ax=ax,
  1839. show=False
  1840. )
  1841. # thin the violin outlines
  1842. for coll in ax.collections:
  1843. if isinstance(coll, PolyCollection):
  1844. coll.set_linewidth(0.75)
  1845. # thin the axes spines
  1846. for spine in ax.spines.values():
  1847. spine.set_linewidth(0.5)
  1849. # title & axis labels
  1850. ax.set_title(gene)
  1851. if idx == 0:
  1852. ax.set_ylabel("Expression")
  1853. else:
  1854. ax.set_ylabel("")
  1855. ax.set_xlabel("")
  1856. ax.tick_params(axis='y', labelleft=True)
  1857. ax.grid(False)
  1859. # get expression values and overlay medians
  1860. expr = adata_violin.obs_vector(gene)
  1861. for xi, stage in enumerate(order):
  1862. mask = adata_violin.obs['stage'] == stage
  1863. med = np.median(expr[mask.values])
  1864. ax.scatter(xi, med,
  1865. color='black',
  1866. marker='o',
  1867. s=1,
  1868. zorder=10)
  1870. # tidy up, display & save
  1871. plt.tight_layout()
  1872. plt.show()
  1873. fig.savefig(
  1874. "figures/violin/disease_TFs_violin.svg",
  1875. format="svg",
  1876. bbox_inches="tight"
  1877. )
  1880. # %% [markdown]
  1881. # ## Create a final anndata object where initial cholinergic neurons are replaced
  1883. # %%
  1884. # Read in AnnData
  1885. adata_all = sc.read_h5ad(os.path.join(working_dir, f"adata_objects/all_anndata.h5ad"))
  1886. adata_chol = sc.read_h5ad(os.path.join(working_dir, f"adata_objects/cholinergic_anndata_highvol.h5ad"))
  1887. adata_alpha = sc.read_h5ad(os.path.join(working_dir, f"adata_objects/alpha_anndata_label_transfer.h5ad"))
  1889. # %%
  1890. # Change cell class of peri-MN oligodendrocytes
  1891. df = pd.read_csv(os.path.join(working_dir, 'periMN_oligo_metadata.csv'), index_col=0)
  1893. common = adata_all.obs.index.intersection(df.index)
  1894. adata_all.obs.loc[common, 'cell_class'] = 'Oligodendrocytes'
  1896. # %%
  1897. # Remove cells where cell_class == "Cholinergic Neurons" from adata_all
  1898. adata_all_filtered = adata_all[adata_all.obs["cell_class"] != "Cholinergic Neurons"].copy()
  1900. # Concatenate adata_all_filtered with adata_chol
  1901. adata_all_chol_cat = adata_all_filtered.concatenate(adata_chol, index_unique=None)
  1903. # Remove cells where cholinergic_type == "Alpha MNs" from adata_all_chol_cat
  1904. adata_all_chol_filtered = adata_all_chol_cat[adata_all_chol_cat.obs["cholinergic_type"] != "Alpha MNs"].copy()
  1906. # Concatenate adata_all_chol_cat with adata_alpha
  1907. adata_final = adata_all_chol_filtered.concatenate(adata_alpha, index_unique=None)
  1909. # %%
  1910. # Neighbors and UMAP
  1911. sc.external.pp.bbknn(adata_final, batch_key='VS') # use inplace of sc.pp.neighbors()
  1912. sc.tl.umap(adata_final)
  1913. sc.pl.umap(adata_final, color="cell_class")
  1915. # %% [markdown]
  1916. # #### Add DAMN_status metadata
  1918. # %%
  1919. # Create DAMN_status column
  1920. adata_final.obs['DAMN_status'] = pd.NA # initialize with NA
  1922. # Mark DAMN cells
  1923. adata_final.obs.loc[
  1924. adata_final.obs['predicted.id'].isin(['Early DAMN', 'Late DAMN']),
  1925. 'DAMN_status'
  1926. ] = 'DAMN'
  1928. # Mark Non-DAMN cells (non-NA and not DAMN)
  1929. adata_final.obs.loc[
  1930. (~adata_final.obs['predicted.id'].isin(['Early DAMN', 'Late DAMN'])) &
  1931. (adata_final.obs['predicted.id'].notna()),
  1932. 'DAMN_status'
  1933. ] = 'Non-DAMN'
  1935. # %%
  1936. # Save anndata
  1937. save_name = f"adata_objects/all_anndata_final.h5ad"
  1938. adata_final.write_h5ad(os.path.join(working_dir, save_name))
  1940. # %% [markdown]
  1941. # ## Rotate tissue sections for visualization
  1943. # %% [markdown]
  1944. # #### Adapted from Sun et al., Nature (2025)
  1946. # %%
  1947. adata = sc.read_h5ad(os.path.join(working_dir, f"adata_objects/all_anndata_final.h5ad"))
  1949. # %%
  1950. # Check initial visualization
  1951. fig, axarr = plt.subplots(20, 6, sharex=False, sharey=False, figsize=(20, 40)) # 20 rows, 6 columns
  1953. mids = np.sort(np.unique(adata.obs['slide_section']))
  1955. for i in range(20):
  1956. for j in range(6):
  1957. index = i * 6 + j # Compute the 1D index from 2D indices
  1958. if index < len(mids): # Ensure we don't go out of bounds
  1959. mid = mids[index]
  1960. sub_adata = adata[adata.obs['slide_section'] == mid].copy()
  1961. sc.pl.embedding(sub_adata, 'spatial', color="cell_class", size=50, show=False,
  1962. ax=axarr[i, j], vmin=-10, vmax=10, title=None)
  1963. axarr[i, j].legend_.remove() if axarr[i, j].get_legend() else None # Remove legend if it exists
  1965. plt.tight_layout()
  1966. plt.show()
  1968. # %%
  1969. # Function for rotating about the origin
  1970. def rotate(p, origin=(0, 0), degrees=0):
  1972. # Rigid rotation by degrees around origin
  1973. angle = np.deg2rad(degrees)
  1974. R = np.array([[np.cos(angle), -np.sin(angle)],
  1975. [np.sin(angle), np.cos(angle)]])
  1976. o = np.atleast_2d(origin)
  1977. p = np.atleast_2d(p)
  1978. return np.squeeze((R @ (p.T-o.T) + o.T).T)
  1980. # %%
  1981. # Center spatial coordinates
  1982. new_spatial = np.zeros(adata.obsm['spatial'].shape)
  1984. mids = np.sort(np.unique(adata.obs['slide_section']))
  1985. for mid in mids:
  1986. X = np.array(adata[adata.obs.slide_section==mid].obsm["spatial"].copy())
  1987. new_spatial[adata.obs.slide_section==mid,:] = X-np.mean(X,axis=0)
  1989. adata.obsm['spatial'] = new_spatial
  1991. # %%
  1992. # Rotate by manually determined angles
  1993. rotation_dict = {
  1994. '202312251515_MsSpinalCord-L4-S1-VS119-YS_Beta8_R1C1': 180,
  1995. '202312251515_MsSpinalCord-L4-S1-VS119-YS_Beta8_R1C2': 176,
  1996. '202312251515_MsSpinalCord-L4-S1-VS119-YS_Beta8_R1C3': -177,
  1997. '202401150953_MsSpinalCord-VS119-Lumbar-Ctrl5-SOD11_Beta8_R1C1': 168,
  1998. '202401150953_MsSpinalCord-VS119-Lumbar-Ctrl5-SOD11_Beta8_R1C2': 168,
  1999. '202401150953_MsSpinalCord-VS119-Lumbar-Ctrl5-SOD11_Beta8_R1C3': 173,
  2000. '202401150953_MsSpinalCord-VS119-Lumbar-Ctrl5-SOD11_Beta8_R2C1': -12,
  2001. '202401150953_MsSpinalCord-VS119-Lumbar-Ctrl5-SOD11_Beta8_R2C3': 123,
  2002. '202401150956_MsSpinalCord-VS119-Cervical-Ctrl2-SOD10_VMSC10802_R1C1': -175,
  2003. '202401150956_MsSpinalCord-VS119-Cervical-Ctrl2-SOD10_VMSC10802_R1C2': -167,
  2004. '202401150956_MsSpinalCord-VS119-Cervical-Ctrl2-SOD10_VMSC10802_R1C3': 170,
  2005. '202401150956_MsSpinalCord-VS119-Cervical-Ctrl2-SOD10_VMSC10802_R2C1': 7,
  2006. '202401150956_MsSpinalCord-VS119-Cervical-Ctrl2-SOD10_VMSC10802_R2C2': 7,
  2007. '202401150956_MsSpinalCord-VS119-Cervical-Ctrl2-SOD10_VMSC10802_R2C3': 8,
  2008. '202401151110_MsSpinalCord-VS119-Lumbar-Ctrl1-SOD8_VMSC07101_R1C1': 170,
  2009. '202401151110_MsSpinalCord-VS119-Lumbar-Ctrl1-SOD8_VMSC07101_R1C2': 166,
  2010. '202401151110_MsSpinalCord-VS119-Lumbar-Ctrl1-SOD8_VMSC07101_R1C3': 158,
  2011. '202401151110_MsSpinalCord-VS119-Lumbar-Ctrl1-SOD8_VMSC07101_R2C2': -18,
  2012. '202401151110_MsSpinalCord-VS119-Lumbar-Ctrl1-SOD8_VMSC07101_R2C3': -175, #19
  2013. '202401241119_HuSpinalCord-VS119-Cervical-Ctrl3-SOD11_VMSC07101_reanalysis_R1C1': 180,
  2014. '202401241119_HuSpinalCord-VS119-Cervical-Ctrl3-SOD11_VMSC07101_reanalysis_R1C2': -166,
  2015. '202401241119_HuSpinalCord-VS119-Cervical-Ctrl3-SOD11_VMSC07101_reanalysis_R1C3': -172,
  2016. '202401241119_HuSpinalCord-VS119-Cervical-Ctrl3-SOD11_VMSC07101_reanalysis_R1C4': 179,
  2017. '202401241119_HuSpinalCord-VS119-Cervical-Ctrl3-SOD11_VMSC07101_reanalysis_R2C1': 0,
  2018. '202401241119_HuSpinalCord-VS119-Cervical-Ctrl3-SOD11_VMSC07101_reanalysis_R2C2': 0,
  2019. '202401241119_HuSpinalCord-VS119-Cervical-Ctrl3-SOD11_VMSC07101_reanalysis_R2C3': 3,
  2020. '202401241136_HuSpinalCord-VS119-Lumbar-Ctrl2-SOD9_Beta8_R1C1': 174,
  2021. '202401241136_HuSpinalCord-VS119-Lumbar-Ctrl2-SOD9_Beta8_R1C2': 180,
  2022. '202401241136_HuSpinalCord-VS119-Lumbar-Ctrl2-SOD9_Beta8_R1C3': 174,
  2023. '202401241136_HuSpinalCord-VS119-Lumbar-Ctrl2-SOD9_Beta8_R2C1': 0,
  2024. '202401241136_HuSpinalCord-VS119-Lumbar-Ctrl2-SOD9_Beta8_R2C2': 3,
  2025. '202401241136_HuSpinalCord-VS119-Lumbar-Ctrl2-SOD9_Beta8_R2C3': 12,
  2026. '202401241136_HuSpinalCord-VS119-Lumbar-Ctrl2-SOD9_Beta8_R2C4': 25,
  2027. '202401241200_HuSpinalCord-VS119-Lubmar-Ctrl3-SOD10_VMSC10802_R1C1': -175,
  2028. '202401241200_HuSpinalCord-VS119-Lubmar-Ctrl3-SOD10_VMSC10802_R1C2': -178,
  2029. '202401241200_HuSpinalCord-VS119-Lubmar-Ctrl3-SOD10_VMSC10802_R1C3': 165,
  2030. '202401241200_HuSpinalCord-VS119-Lubmar-Ctrl3-SOD10_VMSC10802_R2C1': 6,
  2031. '202401241200_HuSpinalCord-VS119-Lubmar-Ctrl3-SOD10_VMSC10802_R2C2': 7,
  2032. '202401241200_HuSpinalCord-VS119-Lubmar-Ctrl3-SOD10_VMSC10802_R2C3': -4,
  2033. '202405281416_MsSpinalCord-VS223-Lumbar-CM2-SM4-S1_VMSC15302_R1C1': -30,
  2034. '202405281416_MsSpinalCord-VS223-Lumbar-CM2-SM4-S1_VMSC15302_R1C2': -19,
  2035. '202405281416_MsSpinalCord-VS223-Lumbar-CM2-SM4-S1_VMSC15302_R1C3': -16,
  2036. '202405281416_MsSpinalCord-VS223-Lumbar-CM2-SM4-S1_VMSC15302_R2C2': 155,
  2037. '202405281416_MsSpinalCord-VS223-Lumbar-CM2-SM4-S1_VMSC15302_R2C3': 152,
  2038. '202405281416_MsSpinalCord-VS223-Lumbar-CM2-SM4-S1_VMSC15302_R2C4': -28,
  2039. '202405281419_MsSpinalCord-VS223-Lumbar-CM5-SM8-S1_VMSC01801_R1C1': 35,
  2040. '202405281419_MsSpinalCord-VS223-Lumbar-CM5-SM8-S1_VMSC01801_R1C2': 34,
  2041. '202405281419_MsSpinalCord-VS223-Lumbar-CM5-SM8-S1_VMSC01801_R1C3': 32,
  2042. '202405281419_MsSpinalCord-VS223-Lumbar-CM5-SM8-S1_VMSC01801_R2C1': -144,
  2043. '202405281419_MsSpinalCord-VS223-Lumbar-CM5-SM8-S1_VMSC01801_R2C2': -146,
  2044. '202405281419_MsSpinalCord-VS223-Lumbar-CM5-SM8-S1_VMSC01801_R2C3': -144,
  2045. '202405281419_MsSpinalCord-VS223-Lumbar-CM5-SM8-S1_VMSC01801_R2C4': -144,
  2046. '202405281527_MsSpinalCord-VS223-Lubmar-CM4-SM6-S1_VMSC02011_R1C1': 41,
  2047. '202405281527_MsSpinalCord-VS223-Lubmar-CM4-SM6-S1_VMSC02011_R1C2': 51,
  2048. '202405281527_MsSpinalCord-VS223-Lubmar-CM4-SM6-S1_VMSC02011_R1C3': 36,
  2049. '202405281527_MsSpinalCord-VS223-Lubmar-CM4-SM6-S1_VMSC02011_R2C1': -146,
  2050. '202405281527_MsSpinalCord-VS223-Lubmar-CM4-SM6-S1_VMSC02011_R2C2': -133,
  2051. '202405281527_MsSpinalCord-VS223-Lubmar-CM4-SM6-S1_VMSC02011_R2C3': -145,
  2052. '202405281527_MsSpinalCord-VS223-Lubmar-CM4-SM6-S1_VMSC02011_R2C4': -155,
  2053. '202405281702_MsSpinalCord-VS223-Lumbar-CE2-SE4-S1_VMSC02701_R1C1': -43,
  2054. '202405281702_MsSpinalCord-VS223-Lumbar-CE2-SE4-S1_VMSC02701_R1C2': -39,
  2055. '202405281702_MsSpinalCord-VS223-Lumbar-CE2-SE4-S1_VMSC02701_R1C3': -44,
  2056. '202405281702_MsSpinalCord-VS223-Lumbar-CE2-SE4-S1_VMSC02701_R1C4': -41,
  2057. '202405281702_MsSpinalCord-VS223-Lumbar-CE2-SE4-S1_VMSC02701_R2C1': 138,
  2058. '202405281702_MsSpinalCord-VS223-Lumbar-CE2-SE4-S1_VMSC02701_R2C2': 135,
  2059. '202405281702_MsSpinalCord-VS223-Lumbar-CE2-SE4-S1_VMSC02701_R2C3': 127,
  2060. '202405281702_MsSpinalCord-VS223-Lumbar-CE2-SE4-S1_VMSC02701_R2C4': 145,
  2061. '202406031049_MsSpinalCord-VS223-Cervical-CE2-SE3-S1_VMSC10802_R1C1': -27,
  2062. '202406031049_MsSpinalCord-VS223-Cervical-CE2-SE3-S1_VMSC10802_R1C2': -29,
  2063. '202406031049_MsSpinalCord-VS223-Cervical-CE2-SE3-S1_VMSC10802_R1C3': -30,
  2064. '202406031049_MsSpinalCord-VS223-Cervical-CE2-SE3-S1_VMSC10802_R1C4': -28,
  2065. '202406031049_MsSpinalCord-VS223-Cervical-CE2-SE3-S1_VMSC10802_R2C1': 145,
  2066. '202406031049_MsSpinalCord-VS223-Cervical-CE2-SE3-S1_VMSC10802_R2C2': 155,
  2067. '202406031049_MsSpinalCord-VS223-Cervical-CE2-SE3-S1_VMSC10802_R2C3': 139,
  2068. '202406031050_MsSpinalCord-VS223-Cervical-CM5-SM5-S1_VMSC07201_R1C1': 49,
  2069. '202406031050_MsSpinalCord-VS223-Cervical-CM5-SM5-S1_VMSC07201_R1C2': 42,
  2070. '202406031050_MsSpinalCord-VS223-Cervical-CM5-SM5-S1_VMSC07201_R1C3': 37,
  2071. '202406031050_MsSpinalCord-VS223-Cervical-CM5-SM5-S1_VMSC07201_R2C2': -138,
  2072. '202406031050_MsSpinalCord-VS223-Cervical-CM5-SM5-S1_VMSC07201_R2C3': -143,
  2073. '202406031050_MsSpinalCord-VS223-Cervical-CM5-SM5-S1_VMSC07201_R2C4': -128,
  2074. '202406071118_MsSpinalCord-VS223-Cervical-CM2-SM4-S1_VMSC10802_R1C1': -17,
  2075. '202406071118_MsSpinalCord-VS223-Cervical-CM2-SM4-S1_VMSC10802_R1C2': -4,
  2076. '202406071118_MsSpinalCord-VS223-Cervical-CM2-SM4-S1_VMSC10802_R1C3': -7,
  2077. '202406071118_MsSpinalCord-VS223-Cervical-CM2-SM4-S1_VMSC10802_R2C1': 174,
  2078. '202406071118_MsSpinalCord-VS223-Cervical-CM2-SM4-S1_VMSC10802_R2C2': 177,
  2079. '202406071118_MsSpinalCord-VS223-Cervical-CM2-SM4-S1_VMSC10802_R2C3': -172,
  2080. '202406071118_MsSpinalCord-VS223-Cervical-CM2-SM4-S1_VMSC10802_R2C4': 178,
  2081. '202406071119_MsSpinalCord-VS223-Lumbar-CE1-SE3-S2_Beta8_R1C1': 0,
  2082. '202406071119_MsSpinalCord-VS223-Lumbar-CE1-SE3-S2_Beta8_R1C2': -16,
  2083. '202406071119_MsSpinalCord-VS223-Lumbar-CE1-SE3-S2_Beta8_R1C3': 2,
  2084. '202406071119_MsSpinalCord-VS223-Lumbar-CE1-SE3-S2_Beta8_R1C4': 8,
  2085. '202406071119_MsSpinalCord-VS223-Lumbar-CE1-SE3-S2_Beta8_R2C1': -171,
  2086. '202406071119_MsSpinalCord-VS223-Lumbar-CE1-SE3-S2_Beta8_R2C2': -175,
  2087. '202406071119_MsSpinalCord-VS223-Lumbar-CE1-SE3-S2_Beta8_R2C3': -173,
  2088. '202406071119_MsSpinalCord-VS223-Lumbar-CE1-SE3-S2_Beta8_R2C4': -165,
  2089. '202406071120_MsSpinalCord-VS223-Lumbar-CE5-SE6-S1_VMSC01801_R1C1': -171,
  2090. '202406071120_MsSpinalCord-VS223-Lumbar-CE5-SE6-S1_VMSC01801_R1C2': -12,
  2091. '202406071120_MsSpinalCord-VS223-Lumbar-CE5-SE6-S1_VMSC01801_R1C3': -1,
  2092. '202406071120_MsSpinalCord-VS223-Lumbar-CE5-SE6-S1_VMSC01801_R1C4': 12,
  2093. '202406071120_MsSpinalCord-VS223-Lumbar-CE5-SE6-S1_VMSC01801_R2C1': 180,
  2094. '202406071120_MsSpinalCord-VS223-Lumbar-CE5-SE6-S1_VMSC01801_R2C2': -174,
  2095. '202406071120_MsSpinalCord-VS223-Lumbar-CE5-SE6-S1_VMSC01801_R2C3': -176,
  2096. '202406071120_MsSpinalCord-VS223-Lumbar-CE5-SE6-S1_VMSC01801_R2C4': 166,
  2097. '202406071222_MsSpinalCord-VS223-Cervical-CE5-SE5-S2_VMSC02011_R1C1': -57,
  2098. '202406071222_MsSpinalCord-VS223-Cervical-CE5-SE5-S2_VMSC02011_R1C2': -45,
  2099. '202406071222_MsSpinalCord-VS223-Cervical-CE5-SE5-S2_VMSC02011_R1C3': -38,
  2100. '202406071222_MsSpinalCord-VS223-Cervical-CE5-SE5-S2_VMSC02011_R1C4': -47,
  2101. '202406071222_MsSpinalCord-VS223-Cervical-CE5-SE5-S2_VMSC02011_R2C1': 149,
  2102. '202406071222_MsSpinalCord-VS223-Cervical-CE5-SE5-S2_VMSC02011_R2C2': 147,
  2103. '202406071222_MsSpinalCord-VS223-Cervical-CE5-SE5-S2_VMSC02011_R2C3': 149,
  2104. '202406071239_MsSpinalCord-VS223-Lumbar-CM3-SM5-S2_VMSC02701_R1C1': -13,
  2105. '202406071239_MsSpinalCord-VS223-Lumbar-CM3-SM5-S2_VMSC02701_R1C2': -17,
  2106. '202406071239_MsSpinalCord-VS223-Lumbar-CM3-SM5-S2_VMSC02701_R1C3': -16,
  2107. '202406071239_MsSpinalCord-VS223-Lumbar-CM3-SM5-S2_VMSC02701_R2C1': 170,
  2108. '202406071239_MsSpinalCord-VS223-Lumbar-CM3-SM5-S2_VMSC02701_R2C2': 166,
  2109. '202406071239_MsSpinalCord-VS223-Lumbar-CM3-SM5-S2_VMSC02701_R2C3': 169,
  2110. '202406071239_MsSpinalCord-VS223-Lumbar-CM3-SM5-S2_VMSC02701_R2C4': 163}
  2112. # %%
  2113. # Rotational alignment
  2114. new_spatial = np.zeros(adata.obsm['spatial'].shape)
  2116. mids = np.sort(np.unique(adata.obs['slide_section']))
  2117. for mid in mids:
  2118. X = np.array(adata[adata.obs.slide_section==mid].obsm["spatial"].copy())
  2119. new_spatial[adata.obs.slide_section==mid,:] = rotate(X, degrees=360-rotation_dict[mid])
  2121. adata.obsm['spatial'] = new_spatial
  2123. # %%
  2124. # Check alignment
  2125. fig, axarr = plt.subplots(20, 6, sharex=False, sharey=False, figsize=(20, 40)) # 20 rows, 6 columns
  2127. mids = np.sort(np.unique(adata.obs['slide_section']))
  2129. for i in range(20):
  2130. for j in range(6):
  2131. index = i * 6 + j # Compute the 1D index from 2D indices
  2132. if index < len(mids): # Ensure we don't go out of bounds
  2133. mid = mids[index]
  2134. sub_adata = adata[adata.obs['slide_section'] == mid].copy()
  2135. sc.pl.embedding(sub_adata, 'spatial', color="cell_class", size=50, show=False,
  2136. ax=axarr[i, j], vmin=-10, vmax=10, title=None)
  2137. axarr[i, j].legend_.remove() if axarr[i, j].get_legend() else None # Remove legend if it exists
  2139. plt.tight_layout()
  2140. plt.show()
  2142. # %%
  2143. # Save anndata
  2144. save_name = f"adata_objects/all_anndata_final_rotated.h5ad"
  2145. adata.write_h5ad(os.path.join(working_dir, save_name))
  2147. # %% [markdown]
  2148. # ## Get spatial plot
  2150. # %%
  2151. # Read in AnnData
  2152. adata = sc.read_h5ad(os.path.join(working_dir, f"adata_objects/all_anndata_final_rotated.h5ad"))
  2154. # %% [markdown]
  2155. # ## Fig. 1C
  2157. # %%
  2158. import matplotlib.pyplot as plt
  2159. import squidpy as sq
  2160. import numpy as np
  2161. import pandas as pd
  2162. from matplotlib.colors import ListedColormap
  2164. # 1. Subset the data
  2165. slide_id = '202312251515_MsSpinalCord-L4-S1-VS119-YS_Beta8_R1C2'
  2166. sub_adata = adata[adata.obs['slide_section'] == slide_id].copy()
  2168. # 2. Assign custom cell group
  2169. def assign_group(row):
  2170. if row["cell_class"] == "Cholinergic Neurons":
  2171. return "CholN"
  2172. elif row["cell_class"] == "Non-Cholinergic Interneurons":
  2173. return "NCI"
  2174. elif row["cell_class"] in ["Astrocytes", "Microglia/Macrophages", "Oligodendrocytes"]:
  2175. return "Glia"
  2176. else:
  2177. return "Other"
  2179. sub_adata.obs["cell_group"] = sub_adata.obs.apply(assign_group, axis=1)
  2181. # 3. Remove "Other" and set categorical order
  2182. sub_adata = sub_adata[sub_adata.obs["cell_group"] != "Other"].copy()
  2183. sub_adata.obs["cell_group"] = pd.Categorical(
  2184. sub_adata.obs["cell_group"],
  2185. categories=["CholN", "NCI", "Glia"],
  2186. ordered=True
  2187. )
  2189. # 4. Define colormap matching the order above
  2190. colormap = ListedColormap(["#FF0000", "#0000FF", "#C0C0C0"]) # red, blue, light gray
  2192. # 5. Plot
  2193. fig, ax = plt.subplots(figsize=(10, 10), dpi=600)
  2194. sq.pl.spatial_scatter(
  2195. sub_adata,
  2196. shape=None,
  2197. color="cell_group",
  2198. size=150,
  2199. library_id="spatial",
  2200. palette=colormap,
  2201. ax=ax,
  2202. legend_loc="upper right",
  2203. title="",
  2204. axis_label=""
  2205. )
  2207. # Rasterize the scatter points
  2208. for coll in ax.collections:
  2209. coll.set_rasterized(True)
  2211. # Adjust legend font size manually
  2212. legend = ax.get_legend()
  2213. if legend is not None:
  2214. for text in legend.get_texts():
  2215. text.set_fontsize(10)
  2217. # Remove ticks and box
  2218. ax.set_xticks([])
  2219. ax.set_yticks([])
  2220. ax.axis("off")
  2222. # Rotate 180°
  2223. ax.invert_xaxis()
  2224. ax.invert_yaxis()
  2226. plt.show()
  2228. # 6. Save high-resolution SVG
  2229. fig_path = os.path.join(figures_dir, "spatial_plot_clean.svg")
  2230. fig.savefig(fig_path, format="svg", bbox_inches="tight", dpi=600)
  2233. # %% [markdown]
  2234. # ## Get a subset of high-quality tissue sections for cell type ratio and spatial analyses
  2236. # %%
  2237. # Read in AnnData
  2238. adata = sc.read_h5ad(os.path.join(working_dir, f"adata_objects/all_anndata_final_rotated.h5ad"))
  2240. # %%
  2241. # Specify which sections/section parts to keep or remove
  2242. sections_to_keep_dict = {
  2243. '202312251515_MsSpinalCord-L4-S1-VS119-YS_Beta8_R1C1': "remove",
  2244. '202312251515_MsSpinalCord-L4-S1-VS119-YS_Beta8_R1C2': "remove",
  2245. '202312251515_MsSpinalCord-L4-S1-VS119-YS_Beta8_R1C3': "keep",
  2246. '202401150953_MsSpinalCord-VS119-Lumbar-Ctrl5-SOD11_Beta8_R1C1': "keep",
  2247. '202401150953_MsSpinalCord-VS119-Lumbar-Ctrl5-SOD11_Beta8_R1C2': "keep",
  2248. '202401150953_MsSpinalCord-VS119-Lumbar-Ctrl5-SOD11_Beta8_R1C3': "keep",
  2249. '202401150953_MsSpinalCord-VS119-Lumbar-Ctrl5-SOD11_Beta8_R2C1': "remove",
  2250. '202401150953_MsSpinalCord-VS119-Lumbar-Ctrl5-SOD11_Beta8_R2C3': "remove",
  2251. '202401150956_MsSpinalCord-VS119-Cervical-Ctrl2-SOD10_VMSC10802_R1C1': "left",
  2252. '202401150956_MsSpinalCord-VS119-Cervical-Ctrl2-SOD10_VMSC10802_R1C2': "keep",
  2253. '202401150956_MsSpinalCord-VS119-Cervical-Ctrl2-SOD10_VMSC10802_R1C3': "remove",
  2254. '202401150956_MsSpinalCord-VS119-Cervical-Ctrl2-SOD10_VMSC10802_R2C1': "remove",
  2255. '202401150956_MsSpinalCord-VS119-Cervical-Ctrl2-SOD10_VMSC10802_R2C2': "keep",
  2256. '202401150956_MsSpinalCord-VS119-Cervical-Ctrl2-SOD10_VMSC10802_R2C3': "right",
  2257. '202401151110_MsSpinalCord-VS119-Lumbar-Ctrl1-SOD8_VMSC07101_R1C1': "remove",
  2258. '202401151110_MsSpinalCord-VS119-Lumbar-Ctrl1-SOD8_VMSC07101_R1C2': "left",
  2259. '202401151110_MsSpinalCord-VS119-Lumbar-Ctrl1-SOD8_VMSC07101_R1C3': "remove",
  2260. '202401151110_MsSpinalCord-VS119-Lumbar-Ctrl1-SOD8_VMSC07101_R2C2': "keep",
  2261. '202401151110_MsSpinalCord-VS119-Lumbar-Ctrl1-SOD8_VMSC07101_R2C3': "remove",
  2262. '202401241119_HuSpinalCord-VS119-Cervical-Ctrl3-SOD11_VMSC07101_reanalysis_R1C1': "remove",
  2263. '202401241119_HuSpinalCord-VS119-Cervical-Ctrl3-SOD11_VMSC07101_reanalysis_R1C2': "keep",
  2264. '202401241119_HuSpinalCord-VS119-Cervical-Ctrl3-SOD11_VMSC07101_reanalysis_R1C3': "keep",
  2265. '202401241119_HuSpinalCord-VS119-Cervical-Ctrl3-SOD11_VMSC07101_reanalysis_R1C4': "right",
  2266. '202401241119_HuSpinalCord-VS119-Cervical-Ctrl3-SOD11_VMSC07101_reanalysis_R2C1': "remove",
  2267. '202401241119_HuSpinalCord-VS119-Cervical-Ctrl3-SOD11_VMSC07101_reanalysis_R2C2': "keep",
  2268. '202401241119_HuSpinalCord-VS119-Cervical-Ctrl3-SOD11_VMSC07101_reanalysis_R2C3': "keep",
  2269. '202401241136_HuSpinalCord-VS119-Lumbar-Ctrl2-SOD9_Beta8_R1C1': "keep",
  2270. '202401241136_HuSpinalCord-VS119-Lumbar-Ctrl2-SOD9_Beta8_R1C2': "right",
  2271. '202401241136_HuSpinalCord-VS119-Lumbar-Ctrl2-SOD9_Beta8_R1C3': "right",
  2272. '202401241136_HuSpinalCord-VS119-Lumbar-Ctrl2-SOD9_Beta8_R2C1': "remove",
  2273. '202401241136_HuSpinalCord-VS119-Lumbar-Ctrl2-SOD9_Beta8_R2C2': "keep",
  2274. '202401241136_HuSpinalCord-VS119-Lumbar-Ctrl2-SOD9_Beta8_R2C3': "right",
  2275. '202401241136_HuSpinalCord-VS119-Lumbar-Ctrl2-SOD9_Beta8_R2C4': "remove",
  2276. '202401241200_HuSpinalCord-VS119-Lubmar-Ctrl3-SOD10_VMSC10802_R1C1': "right",
  2277. '202401241200_HuSpinalCord-VS119-Lubmar-Ctrl3-SOD10_VMSC10802_R1C2': "keep",
  2278. '202401241200_HuSpinalCord-VS119-Lubmar-Ctrl3-SOD10_VMSC10802_R1C3': "right",
  2279. '202401241200_HuSpinalCord-VS119-Lubmar-Ctrl3-SOD10_VMSC10802_R2C1': "remove",
  2280. '202401241200_HuSpinalCord-VS119-Lubmar-Ctrl3-SOD10_VMSC10802_R2C2': "keep",
  2281. '202401241200_HuSpinalCord-VS119-Lubmar-Ctrl3-SOD10_VMSC10802_R2C3': "remove",
  2282. '202405281416_MsSpinalCord-VS223-Lumbar-CM2-SM4-S1_VMSC15302_R1C1': "keep",
  2283. '202405281416_MsSpinalCord-VS223-Lumbar-CM2-SM4-S1_VMSC15302_R1C2': "keep",
  2284. '202405281416_MsSpinalCord-VS223-Lumbar-CM2-SM4-S1_VMSC15302_R1C3': "keep",
  2285. '202405281416_MsSpinalCord-VS223-Lumbar-CM2-SM4-S1_VMSC15302_R2C2': "left",
  2286. '202405281416_MsSpinalCord-VS223-Lumbar-CM2-SM4-S1_VMSC15302_R2C3': "keep",
  2287. '202405281416_MsSpinalCord-VS223-Lumbar-CM2-SM4-S1_VMSC15302_R2C4': "keep",
  2288. '202405281419_MsSpinalCord-VS223-Lumbar-CM5-SM8-S1_VMSC01801_R1C1': "keep",
  2289. '202405281419_MsSpinalCord-VS223-Lumbar-CM5-SM8-S1_VMSC01801_R1C2': "keep",
  2290. '202405281419_MsSpinalCord-VS223-Lumbar-CM5-SM8-S1_VMSC01801_R1C3': "right",
  2291. '202405281419_MsSpinalCord-VS223-Lumbar-CM5-SM8-S1_VMSC01801_R2C1': "keep",
  2292. '202405281419_MsSpinalCord-VS223-Lumbar-CM5-SM8-S1_VMSC01801_R2C2': "keep",
  2293. '202405281419_MsSpinalCord-VS223-Lumbar-CM5-SM8-S1_VMSC01801_R2C3': "keep",
  2294. '202405281419_MsSpinalCord-VS223-Lumbar-CM5-SM8-S1_VMSC01801_R2C4': "keep",
  2295. '202405281527_MsSpinalCord-VS223-Lubmar-CM4-SM6-S1_VMSC02011_R1C1': "keep",
  2296. '202405281527_MsSpinalCord-VS223-Lubmar-CM4-SM6-S1_VMSC02011_R1C2': "remove",
  2297. '202405281527_MsSpinalCord-VS223-Lubmar-CM4-SM6-S1_VMSC02011_R1C3': "keep",
  2298. '202405281527_MsSpinalCord-VS223-Lubmar-CM4-SM6-S1_VMSC02011_R2C1': "keep",
  2299. '202405281527_MsSpinalCord-VS223-Lubmar-CM4-SM6-S1_VMSC02011_R2C2': "keep",
  2300. '202405281527_MsSpinalCord-VS223-Lubmar-CM4-SM6-S1_VMSC02011_R2C3': "right",
  2301. '202405281527_MsSpinalCord-VS223-Lubmar-CM4-SM6-S1_VMSC02011_R2C4': "remove",
  2302. '202405281702_MsSpinalCord-VS223-Lumbar-CE2-SE4-S1_VMSC02701_R1C1': "right",
  2303. '202405281702_MsSpinalCord-VS223-Lumbar-CE2-SE4-S1_VMSC02701_R1C2': "remove",
  2304. '202405281702_MsSpinalCord-VS223-Lumbar-CE2-SE4-S1_VMSC02701_R1C3': "remove",
  2305. '202405281702_MsSpinalCord-VS223-Lumbar-CE2-SE4-S1_VMSC02701_R1C4': "remove",
  2306. '202405281702_MsSpinalCord-VS223-Lumbar-CE2-SE4-S1_VMSC02701_R2C1': "remove",
  2307. '202405281702_MsSpinalCord-VS223-Lumbar-CE2-SE4-S1_VMSC02701_R2C2': "remove",
  2308. '202405281702_MsSpinalCord-VS223-Lumbar-CE2-SE4-S1_VMSC02701_R2C3': "keep",
  2309. '202405281702_MsSpinalCord-VS223-Lumbar-CE2-SE4-S1_VMSC02701_R2C4': "remove",
  2310. '202406031049_MsSpinalCord-VS223-Cervical-CE2-SE3-S1_VMSC10802_R1C1': "keep",
  2311. '202406031049_MsSpinalCord-VS223-Cervical-CE2-SE3-S1_VMSC10802_R1C2': "keep",
  2312. '202406031049_MsSpinalCord-VS223-Cervical-CE2-SE3-S1_VMSC10802_R1C3': "right",
  2313. '202406031049_MsSpinalCord-VS223-Cervical-CE2-SE3-S1_VMSC10802_R1C4': "keep",
  2314. '202406031049_MsSpinalCord-VS223-Cervical-CE2-SE3-S1_VMSC10802_R2C1': "left",
  2315. '202406031049_MsSpinalCord-VS223-Cervical-CE2-SE3-S1_VMSC10802_R2C2': "right",
  2316. '202406031049_MsSpinalCord-VS223-Cervical-CE2-SE3-S1_VMSC10802_R2C3': "remove",
  2317. '202406031050_MsSpinalCord-VS223-Cervical-CM5-SM5-S1_VMSC07201_R1C1': "keep",
  2318. '202406031050_MsSpinalCord-VS223-Cervical-CM5-SM5-S1_VMSC07201_R1C2': "remove",
  2319. '202406031050_MsSpinalCord-VS223-Cervical-CM5-SM5-S1_VMSC07201_R1C3': "keep",
  2320. '202406031050_MsSpinalCord-VS223-Cervical-CM5-SM5-S1_VMSC07201_R2C2': "remove",
  2321. '202406031050_MsSpinalCord-VS223-Cervical-CM5-SM5-S1_VMSC07201_R2C3': "keep",
  2322. '202406031050_MsSpinalCord-VS223-Cervical-CM5-SM5-S1_VMSC07201_R2C4': "remove",
  2323. '202406071118_MsSpinalCord-VS223-Cervical-CM2-SM4-S1_VMSC10802_R1C1': "keep",
  2324. '202406071118_MsSpinalCord-VS223-Cervical-CM2-SM4-S1_VMSC10802_R1C2': "keep",
  2325. '202406071118_MsSpinalCord-VS223-Cervical-CM2-SM4-S1_VMSC10802_R1C3': "keep",
  2326. '202406071118_MsSpinalCord-VS223-Cervical-CM2-SM4-S1_VMSC10802_R2C1': "right",
  2327. '202406071118_MsSpinalCord-VS223-Cervical-CM2-SM4-S1_VMSC10802_R2C2': "left",
  2328. '202406071118_MsSpinalCord-VS223-Cervical-CM2-SM4-S1_VMSC10802_R2C3': "left",
  2329. '202406071118_MsSpinalCord-VS223-Cervical-CM2-SM4-S1_VMSC10802_R2C4': "remove",
  2330. '202406071119_MsSpinalCord-VS223-Lumbar-CE1-SE3-S2_Beta8_R1C1': "remove",
  2331. '202406071119_MsSpinalCord-VS223-Lumbar-CE1-SE3-S2_Beta8_R1C2': "keep",
  2332. '202406071119_MsSpinalCord-VS223-Lumbar-CE1-SE3-S2_Beta8_R1C3': "right",
  2333. '202406071119_MsSpinalCord-VS223-Lumbar-CE1-SE3-S2_Beta8_R1C4': "keep",
  2334. '202406071119_MsSpinalCord-VS223-Lumbar-CE1-SE3-S2_Beta8_R2C1': "keep",
  2335. '202406071119_MsSpinalCord-VS223-Lumbar-CE1-SE3-S2_Beta8_R2C2': "left",
  2336. '202406071119_MsSpinalCord-VS223-Lumbar-CE1-SE3-S2_Beta8_R2C3': "keep",
  2337. '202406071119_MsSpinalCord-VS223-Lumbar-CE1-SE3-S2_Beta8_R2C4': "right",
  2338. '202406071120_MsSpinalCord-VS223-Lumbar-CE5-SE6-S1_VMSC01801_R1C1': "remove",
  2339. '202406071120_MsSpinalCord-VS223-Lumbar-CE5-SE6-S1_VMSC01801_R1C2': "keep",
  2340. '202406071120_MsSpinalCord-VS223-Lumbar-CE5-SE6-S1_VMSC01801_R1C3': "remove",
  2341. '202406071120_MsSpinalCord-VS223-Lumbar-CE5-SE6-S1_VMSC01801_R1C4': "keep",
  2342. '202406071120_MsSpinalCord-VS223-Lumbar-CE5-SE6-S1_VMSC01801_R2C1': "remove",
  2343. '202406071120_MsSpinalCord-VS223-Lumbar-CE5-SE6-S1_VMSC01801_R2C2': "left",
  2344. '202406071120_MsSpinalCord-VS223-Lumbar-CE5-SE6-S1_VMSC01801_R2C3': "left",
  2345. '202406071120_MsSpinalCord-VS223-Lumbar-CE5-SE6-S1_VMSC01801_R2C4': "right",
  2346. '202406071222_MsSpinalCord-VS223-Cervical-CE5-SE5-S2_VMSC02011_R1C1': "right",
  2347. '202406071222_MsSpinalCord-VS223-Cervical-CE5-SE5-S2_VMSC02011_R1C2': "keep",
  2348. '202406071222_MsSpinalCord-VS223-Cervical-CE5-SE5-S2_VMSC02011_R1C3': "keep",
  2349. '202406071222_MsSpinalCord-VS223-Cervical-CE5-SE5-S2_VMSC02011_R1C4': "keep",
  2350. '202406071222_MsSpinalCord-VS223-Cervical-CE5-SE5-S2_VMSC02011_R2C1': "remove",
  2351. '202406071222_MsSpinalCord-VS223-Cervical-CE5-SE5-S2_VMSC02011_R2C2': "remove",
  2352. '202406071222_MsSpinalCord-VS223-Cervical-CE5-SE5-S2_VMSC02011_R2C3': "left",
  2353. '202406071239_MsSpinalCord-VS223-Lumbar-CM3-SM5-S2_VMSC02701_R1C1': "right",
  2354. '202406071239_MsSpinalCord-VS223-Lumbar-CM3-SM5-S2_VMSC02701_R1C2': "keep",
  2355. '202406071239_MsSpinalCord-VS223-Lumbar-CM3-SM5-S2_VMSC02701_R1C3': "keep",
  2356. '202406071239_MsSpinalCord-VS223-Lumbar-CM3-SM5-S2_VMSC02701_R2C1': "right",
  2357. '202406071239_MsSpinalCord-VS223-Lumbar-CM3-SM5-S2_VMSC02701_R2C2': "left",
  2358. '202406071239_MsSpinalCord-VS223-Lumbar-CM3-SM5-S2_VMSC02701_R2C3': "remove",
  2359. '202406071239_MsSpinalCord-VS223-Lumbar-CM3-SM5-S2_VMSC02701_R2C4': "right"}
  2361. # %%
  2362. # Create a new column in adata.obs that maps each cell's slide_section to its label in sections_to_keep_dict
  2363. adata.obs["section_label"] = adata.obs["slide_section"].map(sections_to_keep_dict)
  2365. # Subset the AnnData object based on the section label
  2366. adata_keep = adata[adata.obs["section_label"] == "keep"].copy()
  2367. adata_remove = adata[adata.obs["section_label"] == "remove"].copy()
  2368. adata_left = adata[adata.obs["section_label"] == "left"].copy()
  2369. adata_right = adata[adata.obs["section_label"] == "right"].copy()
  2371. # %%
  2372. highlight_classes = {
  2373. "Non-Cholinergic Interneurons": "#1f77b4", # blue
  2374. "Cholinergic Neurons": "#ff7f0e", # orange
  2375. "Putative Ependymal Cells": "#2ca02c" # green
  2376. }
  2378. # %%
  2379. import matplotlib.pyplot as plt
  2380. import scanpy as sc
  2381. import numpy as np
  2383. # Make sure cell_class is categorical
  2384. adata_keep.obs['cell_class'] = adata_keep.obs['cell_class'].astype('category')
  2386. # Unique slide sections
  2387. keep_mids = np.sort(adata_keep.obs['slide_section'].unique())
  2389. # Loop through each slide_section
  2390. for mid in keep_mids:
  2391. print(f"Plotting slide_section: {mid}")
  2393. # Subset data
  2394. sub_keep = adata_keep[adata_keep.obs['slide_section'] == mid].copy()
  2396. # Create color list for categories
  2397. unique_classes = sub_keep.obs['cell_class'].cat.categories
  2398. class_colors = [highlight_classes.get(cls, "#d3d3d3") for cls in unique_classes]
  2399. sub_keep.uns['cell_class_colors'] = class_colors
  2401. # Plot spatial embedding
  2402. sc.pl.embedding(
  2403. sub_keep,
  2404. basis='spatial',
  2405. color='cell_class',
  2406. size=40,
  2407. title=f"Slide Section: {mid}",
  2408. show=True
  2409. )
  2412. # %%
  2413. import matplotlib.pyplot as plt
  2414. import scanpy as sc
  2415. import numpy as np
  2417. # Make sure cell_class is categorical
  2418. adata_remove.obs['cell_class'] = adata_remove.obs['cell_class'].astype('category')
  2420. # Unique slide sections
  2421. remove_mids = np.sort(adata_remove.obs['slide_section'].unique())
  2423. # Loop through each slide_section
  2424. for mid in remove_mids:
  2425. print(f"Plotting slide_section: {mid}")
  2427. # Subset data
  2428. sub_remove = adata_remove[adata_remove.obs['slide_section'] == mid].copy()
  2430. # Create color list for categories
  2431. unique_classes = sub_remove.obs['cell_class'].cat.categories
  2432. class_colors = [highlight_classes.get(cls, "#d3d3d3") for cls in unique_classes]
  2433. sub_remove.uns['cell_class_colors'] = class_colors
  2435. # Plot spatial embedding
  2436. sc.pl.embedding(
  2437. sub_remove,
  2438. basis='spatial',
  2439. color='cell_class',
  2440. size=40,
  2441. title=f"Slide Section: {mid}",
  2442. show=True
  2443. )
  2446. # %%
  2447. import scanpy as sc
  2448. import matplotlib.pyplot as plt
  2449. import numpy as np
  2450. from matplotlib.colors import to_hex
  2452. # Degrees of rotation and x-shift as fraction of section width
  2453. line_config = {
  2454. "202401150956_MsSpinalCord-VS119-Cervical-Ctrl2-SOD10_VMSC10802_R1C1": {"angle": -6, "x_shift_frac": 0.0375},
  2455. "202401151110_MsSpinalCord-VS119-Lumbar-Ctrl1-SOD8_VMSC07101_R1C2": {"angle": -7, "x_shift_frac": 0.0325},
  2456. "202405281416_MsSpinalCord-VS223-Lumbar-CM2-SM4-S1_VMSC15302_R2C2": {"angle": 1, "x_shift_frac": 0.02},
  2457. "202406031049_MsSpinalCord-VS223-Cervical-CE2-SE3-S1_VMSC10802_R2C1": {"angle": -2, "x_shift_frac": -0.015},
  2458. "202406071118_MsSpinalCord-VS223-Cervical-CM2-SM4-S1_VMSC10802_R2C2": {"angle": -5, "x_shift_frac": 0.07},
  2459. "202406071118_MsSpinalCord-VS223-Cervical-CM2-SM4-S1_VMSC10802_R2C3": {"angle": -3, "x_shift_frac": 0.035},
  2460. "202406071119_MsSpinalCord-VS223-Lumbar-CE1-SE3-S2_Beta8_R2C2": {"angle": 0, "x_shift_frac": 0.02},
  2461. "202406071120_MsSpinalCord-VS223-Lumbar-CE5-SE6-S1_VMSC01801_R2C2": {"angle": -1, "x_shift_frac": 0.01},
  2462. "202406071120_MsSpinalCord-VS223-Lumbar-CE5-SE6-S1_VMSC01801_R2C3": {"angle": 0, "x_shift_frac": 0.01},
  2463. "202406071222_MsSpinalCord-VS223-Cervical-CE5-SE5-S2_VMSC02011_R2C3": {"angle": -2, "x_shift_frac": 0.025},
  2464. "202406071239_MsSpinalCord-VS223-Lumbar-CM3-SM5-S2_VMSC02701_R2C2": {"angle": -2, "x_shift_frac": 0.025}
  2465. }
  2467. # Store filtered subsets
  2468. filtered_subsets = []
  2470. mids = np.sort(np.unique(adata_left.obs['slide_section']))
  2472. for mid in mids:
  2473. print(f"Plotting and filtering slide_section: {mid}")
  2475. sub_adata = adata_left[adata_left.obs['slide_section'] == mid].copy()
  2476. sub_adata.obs['cell_class'] = sub_adata.obs['cell_class'].astype('category')
  2478. coords = sub_adata.obsm['spatial']
  2479. x = coords[:, 0]
  2480. y = coords[:, 1]
  2482. config = line_config.get(mid, {"angle": 0, "x_shift_frac": 0})
  2483. angle_deg = config["angle"]
  2484. x_shift_frac = config["x_shift_frac"]
  2486. section_width = x.max() - x.min()
  2487. x_shift = x_shift_frac * section_width
  2488. x_center = np.median(x) + x_shift
  2489. y_min, y_max = y.min(), y.max()
  2491. print(f"Slide: {mid}")
  2492. print(f" x range: {x.min()} to {x.max()} (width = {section_width:.2f})")
  2493. print(f" x_shift_frac: {x_shift_frac} => x_shift: {x_shift:.2f}")
  2494. print(f" x_center: {x_center:.2f}\n")
  2496. # === Filter for left side ===
  2497. theta = np.deg2rad(-angle_deg)
  2498. rot_matrix = np.array([
  2499. [np.cos(theta), -np.sin(theta)],
  2500. [np.sin(theta), np.cos(theta)]
  2501. ])
  2502. coords_shifted = coords.copy()
  2503. coords_shifted[:, 0] -= x_center # translate
  2504. coords_rotated = coords_shifted @ rot_matrix.T # rotate
  2505. mask_left = coords_rotated[:, 0] < 0
  2507. sub_filtered = sub_adata[mask_left].copy()
  2508. filtered_subsets.append(sub_filtered)
  2510. # === Plotting ===
  2511. unique_classes = sub_adata.obs['cell_class'].cat.categories
  2512. class_colors = [highlight_classes.get(cls, "#d3d3d3") for cls in unique_classes]
  2513. sub_adata.uns['cell_class_colors'] = class_colors
  2515. line_x = np.array([0, 0])
  2516. line_y = np.array([y_min - 50, y_max + 50])
  2517. theta_plot = np.deg2rad(angle_deg)
  2518. rot_matrix_plot = np.array([
  2519. [np.cos(theta_plot), -np.sin(theta_plot)],
  2520. [np.sin(theta_plot), np.cos(theta_plot)]
  2521. ])
  2522. line_coords = np.stack([line_x, line_y])
  2523. rotated = rot_matrix_plot @ line_coords
  2524. rotated[0, :] += x_center
  2526. fig, ax = plt.subplots(1, 1, figsize=(5, 5))
  2527. sc.pl.embedding(
  2528. sub_adata,
  2529. basis='spatial',
  2530. color='cell_class',
  2531. size=50,
  2532. show=False,
  2533. ax=ax,
  2534. title=f"Slide Section: {mid}"
  2535. )
  2536. ax.plot(rotated[0], rotated[1], color="black", linestyle="--", linewidth=2)
  2537. ax.axvline(x.min(), color='gray', linestyle=':', linewidth=1)
  2538. ax.axvline(x.max(), color='gray', linestyle=':', linewidth=1)
  2539. if ax.get_legend():
  2540. ax.legend_.remove()
  2541. plt.tight_layout()
  2542. plt.show()
  2544. # === Combine filtered subsets into new AnnData ===
  2545. adata_left_filtered = filtered_subsets[0].concatenate(
  2546. *filtered_subsets[1:],
  2547. batch_key=None
  2548. )
  2550. print(f"Original shape: {adata_left.shape}")
  2551. print(f"Filtered (left side) shape: {adata_left_filtered.shape}")
  2554. # %%
  2555. import matplotlib.pyplot as plt
  2556. import scanpy as sc
  2557. import numpy as np
  2559. # Make sure cell_class is categorical
  2560. adata_left_filtered.obs['cell_class'] = adata_left_filtered.obs['cell_class'].astype('category')
  2562. # Get sorted slide_section values
  2563. filtered_mids = np.sort(adata_left_filtered.obs['slide_section'].unique())
  2565. for mid in filtered_mids:
  2566. print(f"Plotting filtered (left-side) cells for slide_section: {mid}")
  2568. # Subset filtered AnnData
  2569. sub_filtered = adata_left_filtered[adata_left_filtered.obs['slide_section'] == mid].copy()
  2571. # Use consistent coloring as before
  2572. unique_classes = sub_filtered.obs['cell_class'].cat.categories
  2573. class_colors = [highlight_classes.get(cls, "#d3d3d3") for cls in unique_classes]
  2574. sub_filtered.uns['cell_class_colors'] = class_colors
  2576. # Plot
  2577. sc.pl.embedding(
  2578. sub_filtered,
  2579. basis='spatial',
  2580. color='cell_class',
  2581. size=50,
  2582. title=f"Filtered Left Cells: {mid}",
  2583. show=True
  2584. )
  2586. # %%
  2587. import scanpy as sc
  2588. import matplotlib.pyplot as plt
  2589. import numpy as np
  2590. from matplotlib.colors import to_hex
  2592. # Degrees of rotation and x-shift as fraction of section width
  2593. line_config = {
  2594. "202401150956_MsSpinalCord-VS119-Cervical-Ctrl2-SOD10_VMSC10802_R2C3": {"angle": -2, "x_shift_frac": -0.05},
  2595. "202401241119_HuSpinalCord-VS119-Cervical-Ctrl3-SOD11_VMSC07101_reanalysis_R1C4": {"angle": 6, "x_shift_frac": 0},
  2596. "202401241136_HuSpinalCord-VS119-Lumbar-Ctrl2-SOD9_Beta8_R1C2": {"angle": -4, "x_shift_frac": -0.02},
  2597. "202401241136_HuSpinalCord-VS119-Lumbar-Ctrl2-SOD9_Beta8_R1C3": {"angle": 0, "x_shift_frac": -0.065},
  2598. "202401241136_HuSpinalCord-VS119-Lumbar-Ctrl2-SOD9_Beta8_R2C3": {"angle": 0, "x_shift_frac": -0.005},
  2599. "202401241200_HuSpinalCord-VS119-Lubmar-Ctrl3-SOD10_VMSC10802_R1C1": {"angle": -2, "x_shift_frac": -0.01},
  2600. "202401241200_HuSpinalCord-VS119-Lubmar-Ctrl3-SOD10_VMSC10802_R1C3": {"angle": 1, "x_shift_frac": -0.18},
  2601. "202405281419_MsSpinalCord-VS223-Lumbar-CM5-SM8-S1_VMSC01801_R1C3": {"angle": -3, "x_shift_frac": -0.02},
  2602. "202405281527_MsSpinalCord-VS223-Lubmar-CM4-SM6-S1_VMSC02011_R2C3": {"angle": 6, "x_shift_frac": -0.045},
  2603. "202405281702_MsSpinalCord-VS223-Lumbar-CE2-SE4-S1_VMSC02701_R1C1": {"angle": 2, "x_shift_frac": -0.015},
  2604. "202406031049_MsSpinalCord-VS223-Cervical-CE2-SE3-S1_VMSC10802_R1C3": {"angle": 4, "x_shift_frac": -0.015},
  2605. "202406031049_MsSpinalCord-VS223-Cervical-CE2-SE3-S1_VMSC10802_R2C2": {"angle": 2, "x_shift_frac": 0},
  2606. "202406071118_MsSpinalCord-VS223-Cervical-CM2-SM4-S1_VMSC10802_R2C1": {"angle": 2, "x_shift_frac": -0.01},
  2607. "202406071119_MsSpinalCord-VS223-Lumbar-CE1-SE3-S2_Beta8_R1C3": {"angle": -5, "x_shift_frac": -0.0075},
  2608. "202406071119_MsSpinalCord-VS223-Lumbar-CE1-SE3-S2_Beta8_R2C4": {"angle": 3, "x_shift_frac": -0.0525},
  2609. "202406071120_MsSpinalCord-VS223-Lumbar-CE5-SE6-S1_VMSC01801_R2C4": {"angle": 4, "x_shift_frac": -0.01},
  2610. "202406071222_MsSpinalCord-VS223-Cervical-CE5-SE5-S2_VMSC02011_R1C1": {"angle": 6, "x_shift_frac": -0.035},
  2611. "202406071239_MsSpinalCord-VS223-Lumbar-CM3-SM5-S2_VMSC02701_R1C1": {"angle": -1, "x_shift_frac": -0.005},
  2612. "202406071239_MsSpinalCord-VS223-Lumbar-CM3-SM5-S2_VMSC02701_R2C1": {"angle": 0, "x_shift_frac": -0.008},
  2613. "202406071239_MsSpinalCord-VS223-Lumbar-CM3-SM5-S2_VMSC02701_R2C4": {"angle": 5, "x_shift_frac": -.03}
  2614. }
  2616. # Store filtered subsets
  2617. filtered_subsets = []
  2619. mids = np.sort(np.unique(adata_right.obs['slide_section']))
  2621. for mid in mids:
  2622. print(f"Plotting and filtering slide_section: {mid}")
  2624. sub_adata = adata_right[adata_right.obs['slide_section'] == mid].copy()
  2625. sub_adata.obs['cell_class'] = sub_adata.obs['cell_class'].astype('category')
  2627. coords = sub_adata.obsm['spatial']
  2628. x = coords[:, 0]
  2629. y = coords[:, 1]
  2631. config = line_config.get(mid, {"angle": 0, "x_shift_frac": 0})
  2632. angle_deg = config["angle"]
  2633. x_shift_frac = config["x_shift_frac"]
  2635. section_width = x.max() - x.min()
  2636. x_shift = x_shift_frac * section_width
  2637. x_center = np.median(x) + x_shift
  2638. y_min, y_max = y.min(), y.max()
  2640. print(f"Slide: {mid}")
  2641. print(f" x range: {x.min()} to {x.max()} (width = {section_width:.2f})")
  2642. print(f" x_shift_frac: {x_shift_frac} => x_shift: {x_shift:.2f}")
  2643. print(f" x_center: {x_center:.2f}\n")
  2645. # === Filter for right side ===
  2646. theta = np.deg2rad(-angle_deg)
  2647. rot_matrix = np.array([
  2648. [np.cos(theta), -np.sin(theta)],
  2649. [np.sin(theta), np.cos(theta)]
  2650. ])
  2651. coords_shifted = coords.copy()
  2652. coords_shifted[:, 0] -= x_center # translate
  2653. coords_rotated = coords_shifted @ rot_matrix.T # rotate
  2654. mask_right = coords_rotated[:, 0] > 0
  2656. sub_filtered = sub_adata[mask_right].copy()
  2657. filtered_subsets.append(sub_filtered)
  2659. # === Plotting ===
  2660. unique_classes = sub_adata.obs['cell_class'].cat.categories
  2661. class_colors = [highlight_classes.get(cls, "#d3d3d3") for cls in unique_classes]
  2662. sub_adata.uns['cell_class_colors'] = class_colors
  2664. line_x = np.array([0, 0])
  2665. line_y = np.array([y_min - 50, y_max + 50])
  2666. theta_plot = np.deg2rad(angle_deg)
  2667. rot_matrix_plot = np.array([
  2668. [np.cos(theta_plot), -np.sin(theta_plot)],
  2669. [np.sin(theta_plot), np.cos(theta_plot)]
  2670. ])
  2671. line_coords = np.stack([line_x, line_y])
  2672. rotated = rot_matrix_plot @ line_coords
  2673. rotated[0, :] += x_center
  2675. fig, ax = plt.subplots(1, 1, figsize=(5, 5))
  2676. sc.pl.embedding(
  2677. sub_adata,
  2678. basis='spatial',
  2679. color='cell_class',
  2680. size=50,
  2681. show=False,
  2682. ax=ax,
  2683. title=f"Slide Section: {mid}"
  2684. )
  2685. ax.plot(rotated[0], rotated[1], color="black", linestyle="--", linewidth=2)
  2686. ax.axvline(x.min(), color='gray', linestyle=':', linewidth=1)
  2687. ax.axvline(x.max(), color='gray', linestyle=':', linewidth=1)
  2688. if ax.get_legend():
  2689. ax.legend_.remove()
  2690. plt.tight_layout()
  2691. plt.show()
  2693. # === Combine filtered subsets into new AnnData ===
  2694. adata_right_filtered = filtered_subsets[0].concatenate(
  2695. *filtered_subsets[1:],
  2696. batch_key=None
  2697. )
  2699. print(f"Original shape: {adata_right.shape}")
  2700. print(f"Filtered (right side) shape: {adata_right_filtered.shape}")
  2703. # %%
  2704. import matplotlib.pyplot as plt
  2705. import scanpy as sc
  2706. import numpy as np
  2708. # Make sure cell_class is categorical
  2709. adata_right_filtered.obs['cell_class'] = adata_right_filtered.obs['cell_class'].astype('category')
  2711. # Get sorted slide_section values
  2712. filtered_mids = np.sort(adata_right_filtered.obs['slide_section'].unique())
  2714. for mid in filtered_mids:
  2715. print(f"Plotting filtered (right-side) cells for slide_section: {mid}")
  2717. # Subset filtered AnnData
  2718. sub_filtered = adata_right_filtered[adata_right_filtered.obs['slide_section'] == mid].copy()
  2720. # Use consistent coloring as before
  2721. unique_classes = sub_filtered.obs['cell_class'].cat.categories
  2722. class_colors = [highlight_classes.get(cls, "#d3d3d3") for cls in unique_classes]
  2723. sub_filtered.uns['cell_class_colors'] = class_colors
  2725. # Plot
  2726. sc.pl.embedding(
  2727. sub_filtered,
  2728. basis='spatial',
  2729. color='cell_class',
  2730. size=50,
  2731. title=f"Filtered right Cells: {mid}",
  2732. show=True
  2733. )
  2735. # %%
  2736. adata_filtered = adata_keep.concatenate(
  2737. adata_left_filtered,
  2738. adata_right_filtered,
  2739. index_unique=None
  2740. )
  2742. # %%
  2743. # Save anndata
  2744. save_name = f"adata_objects/all_anndata_final_rotated_filtered.h5ad"
  2745. adata_filtered.write_h5ad(os.path.join(working_dir, save_name))
  2747. # %% [markdown]
  2748. # ## Cell types neighboring motor neurons in control and disease
  2750. # %%
  2751. # Read in AnnData
  2752. adata = sc.read_h5ad(os.path.join(working_dir, f"adata_objects/all_anndata_final_rotated_filtered.h5ad"))
  2754. # %% [markdown]
  2755. # ## Fig. 6A
  2757. # %%
  2758. import os
  2759. import pandas as pd
  2760. import numpy as np
  2761. import seaborn as sns
  2762. import matplotlib.pyplot as plt
  2763. from collections import defaultdict
  2764. import squidpy as sq
  2766. # Ensure all text in the figure is at least size 7
  2767. plt.rcParams.update({
  2768. "font.size": 7,
  2769. "axes.titlesize": 7,
  2770. "axes.labelsize": 7,
  2771. "xtick.labelsize": 7,
  2772. "ytick.labelsize": 7,
  2773. "legend.fontsize": 7,
  2774. "legend.title_fontsize": 7
  2775. })
  2777. # Parameters
  2778. groups = ["Non-DAMN", "DAMN"]
  2779. title_map = {"Non-DAMN": "Non-DM", "DAMN": "DM"}
  2781. # Abbreviations for cell class names
  2782. abbr = {
  2783. "Astrocytes": "Ast",
  2784. "Cholinergic Neurons": "CholN",
  2785. "Disease-Associated Interneurons": "DAI",
  2786. "Microglia/Macrophages": "MG",
  2787. "Non-Cholinergic Interneurons": "NCI",
  2788. "Oligodendrocytes": "Oligo",
  2789. "Other": "Other",
  2790. "Putative Ependymal Cells": "Epen",
  2791. "Putative Perivascular/Meningeal Cells": "PVM",
  2792. "Putative Vascular Cells": "Vasc"
  2793. }
  2795. # Prepare accumulators
  2796. neighbor_counts = {g: [defaultdict(int) for _ in range(6)] for g in groups}
  2797. cell_totals = {g: 0 for g in groups}
  2799. # Loop over each slide_section
  2800. for sec in adata.obs["slide_section"].unique():
  2801. sub = adata[adata.obs["slide_section"] == sec].copy()
  2803. # compute 6-NN on this section
  2804. sq.gr.spatial_neighbors(sub, coord_type="generic", n_neighs=6, key_added="spatial_sec")
  2805. conn = sub.obsp["spatial_sec_connectivities"]
  2806. classes = sub.obs["cell_class"]
  2807. status = sub.obs["DAMN_status"]
  2809. for g in groups:
  2810. mask = (status == g)
  2811. idx = np.where(mask)[0]
  2812. cell_totals[g] += len(idx)
  2814. for i in idx:
  2815. row = conn[i].tocoo()
  2816. top6 = sorted(zip(row.col, row.data), key=lambda x: -x[1])[:6]
  2818. for rank, (nbr, _) in enumerate(top6):
  2819. neighbor_counts[g][rank][classes.iloc[nbr]] += 1
  2821. # Build DataFrame of proportions: count / total cells
  2822. rows = []
  2823. for g in groups:
  2824. total_cells = cell_totals[g]
  2826. for rank, ctr in enumerate(neighbor_counts[g], start=1):
  2827. for cell_type, count in ctr.items():
  2828. rows.append({
  2829. "Neighbor Rank": str(rank),
  2830. "Cell Class": cell_type,
  2831. "Proportion": count / total_cells,
  2832. "Group": g
  2833. })
  2835. df_combined = pd.DataFrame(rows)
  2837. # Pivot for plotting
  2838. df_pivot = df_combined.pivot_table(
  2839. index=["Neighbor Rank", "Group"],
  2840. columns="Cell Class",
  2841. values="Proportion",
  2842. aggfunc="sum"
  2843. ).fillna(0)
  2845. # Plot: Non-DM vs DM with the desired size and save as SVG
  2846. fig, axes = plt.subplots(1, 2, figsize=(3.25, 2.15), sharey=True)
  2848. for ax, g in zip(axes, groups):
  2849. data = df_pivot.xs(g, level="Group")
  2850. bottom = np.zeros(len(data))
  2852. for ct in data.columns:
  2853. ax.bar(
  2854. data.index,
  2855. data[ct],
  2856. bottom=bottom,
  2857. label=abbr.get(ct, ct)
  2858. )
  2859. bottom += data[ct]
  2861. ax.set_title(title_map.get(g, g))
  2862. ax.set_xlabel("Neighbor Rank")
  2863. ax.set_ylabel("Proportion")
  2865. # legend on the right of the second subplot, with abbreviations
  2866. axes[1].legend(
  2867. title="Cell Class",
  2868. bbox_to_anchor=(1.02, 0.5),
  2869. loc="center left",
  2870. ncol=1
  2871. )
  2873. plt.tight_layout()
  2875. # Define the filename and directory
  2876. fig_path = os.path.join(figures_dir, "neighbor_barplots_dm.svg")
  2878. # Save high-quality SVG
  2879. fig.savefig(
  2880. fig_path,
  2881. format="svg",
  2882. bbox_inches="tight"
  2883. )
  2885. # %%
  2886. from scipy.stats import fisher_exact
  2887. from statsmodels.stats.multitest import multipletests
  2889. # Create a pivot table from df_combined for easier comparison;
  2890. # here, the index will be (Neighbor Rank, Group)
  2891. df_pivot = df_combined.pivot_table(
  2892. index=["Neighbor Rank", "Group"],
  2893. columns="Cell Class",
  2894. values="Proportion",
  2895. aggfunc="sum"
  2896. ).fillna(0)
  2898. # Get indices of DAMN and Non-DAMN cells
  2899. damn_indices = np.where(adata.obs["DAMN_status"] == "DAMN")[0]
  2900. nondamn_indices = np.where(adata.obs["DAMN_status"] == "Non-DAMN")[0]
  2902. # Precompute total numbers in each group using the same criteria from Block 1.
  2903. damn_total = len(damn_indices) # DAMN group total
  2904. nondamn_total = len(nondamn_indices) # Non-DAMN group total
  2906. fisher_results = []
  2907. # Loop over each unique neighbor rank found in df_combined
  2908. for rank in df_combined["Neighbor Rank"].unique():
  2909. # For each cell class, compare proportions between DAMN and Non-DAMN at this rank.
  2910. for cell_class in df_pivot.columns:
  2911. # Use the pivot table to get proportions:
  2912. try:
  2913. prop_damn = df_pivot.loc[(rank, "DAMN"), cell_class]
  2914. except KeyError:
  2915. prop_damn = 0
  2916. try:
  2917. prop_nondamn = df_pivot.loc[(rank, "Non-DAMN"), cell_class]
  2918. except KeyError:
  2919. prop_nondamn = 0
  2921. # Convert proportions to counts using precomputed totals:
  2922. count_damn = prop_damn * damn_total
  2923. count_nondamn = prop_nondamn * nondamn_total
  2925. # Build the 2x2 contingency table:
  2926. contingency_table = np.array([
  2927. [count_damn, damn_total - count_damn],
  2928. [count_nondamn, nondamn_total - count_nondamn]
  2929. ])
  2931. # Perform Fisher's Exact Test:
  2932. try:
  2933. odds_ratio, p_value = fisher_exact(contingency_table)
  2934. except Exception:
  2935. odds_ratio, p_value = np.nan, np.nan
  2937. fisher_results.append({
  2938. "Neighbor Rank": rank,
  2939. "Cell Class": cell_class,
  2940. "Odds Ratio": odds_ratio,
  2941. "p-value": p_value
  2942. })
  2944. # Convert the results list to a DataFrame
  2945. fisher_results_df = pd.DataFrame(fisher_results)
  2947. # Apply multiple hypothesis corrections:
  2948. fisher_results_df["padj"] = multipletests(fisher_results_df["p-value"], method="bonferroni")[1]
  2950. # Display the Fisher's test results DataFrame
  2951. fisher_results_df
  2953. # %%
  2954. # Save as CSV without row names
  2955. fisher_results_df.to_csv("DAMN_nearest_neighbors_fisher_results.csv", index=False)
  2957. # %% [markdown]
  2958. # ## Fig. S7A
  2960. # %%
  2961. import os
  2962. import pandas as pd
  2963. import numpy as np
  2964. import seaborn as sns
  2965. import matplotlib.pyplot as plt
  2966. from collections import defaultdict
  2967. import squidpy as sq
  2969. # Ensure all text in the figure is at least size 7
  2970. plt.rcParams.update({
  2971. "font.size": 7,
  2972. "axes.titlesize": 7,
  2973. "axes.labelsize": 7,
  2974. "xtick.labelsize": 7,
  2975. "ytick.labelsize": 7,
  2976. "legend.fontsize": 7,
  2977. "legend.title_fontsize": 7
  2978. })
  2980. # Abbreviations for cell class names
  2981. abbr = {
  2982. "Astrocytes": "Ast",
  2983. "Cholinergic Neurons": "CholN",
  2984. "Disease-Associated Interneurons": "DAI",
  2985. "Microglia/Macrophages": "MG",
  2986. "Non-Cholinergic Interneurons": "NCI",
  2987. "Oligodendrocytes": "Oligo",
  2988. "Other": "Other",
  2989. "Putative Ependymal Cells": "Epen",
  2990. "Putative Perivascular/Meningeal Cells": "PVM",
  2991. "Putative Vascular Cells": "Vasc"
  2992. }
  2994. # Parameters
  2995. cholinergic_types = ["Alpha MNs", "Gamma MNs", "Gamma* MNs"]
  2996. conditions = {
  2997. "Control": lambda st: st == "Control",
  2998. "Disease": lambda st: st.isin(["Early", "Mid", "End"])
  2999. }
  3001. # Prepare accumulators
  3002. neighbor_counts = {}
  3003. cell_totals = {}
  3005. for sec in adata.obs["slide_section"].unique():
  3006. sub = adata[adata.obs["slide_section"] == sec].copy()
  3007. sq.gr.spatial_neighbors(sub, coord_type="generic", n_neighs=6, key_added="spatial_sec")
  3008. conn = sub.obsp["spatial_sec_connectivities"]
  3009. classes = sub.obs["cell_class"]
  3010. stages = sub.obs["stage"]
  3011. types = sub.obs["cholinergic_type"]
  3013. for chol in cholinergic_types:
  3014. for cond_label, cond_fn in conditions.items():
  3015. mask = (types == chol) & cond_fn(stages)
  3016. idx = np.where(mask)[0]
  3017. if len(idx) == 0:
  3018. continue
  3019. key = (chol, cond_label)
  3020. if key not in neighbor_counts:
  3021. neighbor_counts[key] = [defaultdict(int) for _ in range(6)]
  3022. cell_totals[key] = 0
  3023. cell_totals[key] += len(idx)
  3024. for i in idx:
  3025. row = conn[i].tocoo()
  3026. top6 = sorted(zip(row.col, row.data), key=lambda x: -x[1])[:6]
  3027. for rank, (nbr, _) in enumerate(top6, start=1):
  3028. neighbor_counts[key][rank-1][classes.iloc[nbr]] += 1
  3030. # Build DataFrame of proportions
  3031. rows = []
  3032. for (chol, cond_label), rank_dicts in neighbor_counts.items():
  3033. total_cells = cell_totals[(chol, cond_label)]
  3034. for rank, ctr in enumerate(rank_dicts, start=1):
  3035. for cell_type, count in ctr.items():
  3036. rows.append({
  3037. "Neighbor Rank": str(rank),
  3038. "Cell Class": cell_type,
  3039. "Proportion": count / total_cells,
  3040. "Cholinergic Type": chol,
  3041. "Stage": cond_label
  3042. })
  3043. df_combined = pd.DataFrame(rows)
  3045. # Pivot for plotting
  3046. df_pivot = df_combined.pivot_table(
  3047. index=["Neighbor Rank", "Cholinergic Type", "Stage"],
  3048. columns="Cell Class",
  3049. values="Proportion",
  3050. aggfunc="sum"
  3051. ).fillna(0)
  3053. # Plot: 3 rows = skeletal MN types, 2 cols = conditions
  3054. fig, axes = plt.subplots(
  3055. nrows=3,
  3056. ncols=2,
  3057. figsize=(3.25, 4.3),
  3058. sharey=True
  3059. )
  3061. for i, chol in enumerate(cholinergic_types):
  3062. for j, cond_label in enumerate(conditions):
  3063. ax = axes[i, j]
  3064. try:
  3065. data = df_pivot.xs(
  3066. (chol, cond_label),
  3067. level=("Cholinergic Type", "Stage")
  3068. )
  3069. except KeyError:
  3070. data = pd.DataFrame()
  3071. bottom = np.zeros(len(data))
  3072. for ct in data.columns:
  3073. ax.bar(
  3074. data.index,
  3075. data[ct],
  3076. bottom=bottom,
  3077. label=abbr.get(ct, ct)
  3078. )
  3079. bottom += data[ct]
  3081. # custom titles with extra padding for Gamma MNs rows
  3082. if chol == "Gamma MNs" and cond_label == "Control":
  3083. title_str = "Gamma MNs - Control "
  3084. elif chol == "Gamma MNs" and cond_label == "Disease":
  3085. title_str = " Gamma MNs - Disease"
  3086. elif chol == "Gamma* MNs" and cond_label == "Control":
  3087. title_str = "Gamma* MNs - Control "
  3088. elif chol == "Gamma* MNs" and cond_label == "Disease":
  3089. title_str = " Gamma* MNs - Disease"
  3090. else:
  3091. title_str = f"{chol} – {cond_label}"
  3093. ax.set_title(title_str)
  3094. ax.set_xlabel("Neighbor Rank")
  3095. if j == 0:
  3096. ax.set_ylabel("Proportion")
  3097. else:
  3098. ax.set_ylabel("")
  3100. # only add legend on the top‐right subplot
  3101. if i == 0 and j == 1:
  3102. handles, labels = ax.get_legend_handles_labels()
  3103. ax.legend(
  3104. handles,
  3105. labels,
  3106. title="Cell Class",
  3107. bbox_to_anchor=(1.02, 0.5),
  3108. loc="center left",
  3109. labelspacing=0.2,
  3110. handletextpad=0.3,
  3111. columnspacing=0.5
  3112. )
  3114. plt.tight_layout()
  3116. fig_path = os.path.join(figures_dir, "neighbor_barplots_skeletal_disease.svg")
  3117. fig.savefig(fig_path, format="svg", bbox_inches="tight")
  3119. # %%
  3120. from scipy.stats import fisher_exact
  3121. from statsmodels.stats.multitest import multipletests
  3123. # Extract needed data
  3124. stage = adata.obs["stage"]
  3126. # Pre-compute totals for each condition
  3127. control_total = len(np.where(stage == "Control")[0])
  3128. disease_total = len(np.where(stage.isin(["Early", "Mid", "End"]))[0])
  3130. fisher_results = []
  3132. # Loop over each cholinergic type, neighbor rank (1-6), and each cell class
  3133. for cholinergic_group in cholinergic_types:
  3134. for rank in range(1, 7):
  3135. rank_str = str(rank)
  3136. # Get proportions for Control and Disease for this (cholinergic_group, rank)
  3137. try:
  3138. control_data = df_pivot.loc[(rank_str, cholinergic_group, "Control")]
  3139. except KeyError:
  3140. control_data = pd.Series(0, index=df_pivot.columns)
  3141. try:
  3142. disease_data = df_pivot.loc[(rank_str, cholinergic_group, "Disease")]
  3143. except KeyError:
  3144. disease_data = pd.Series(0, index=df_pivot.columns)
  3145. # Loop over each cell class
  3146. for cell_class in df_pivot.columns:
  3147. control_prop = control_data[cell_class]
  3148. disease_prop = disease_data[cell_class]
  3149. control_count = control_prop * control_total
  3150. disease_count = disease_prop * disease_total
  3151. contingency_table = np.array([
  3152. [disease_count, disease_total - disease_count], # Disease group as the first row
  3153. [control_count, control_total - control_count] # Control group as the second row
  3154. ])
  3155. # Perform Fisher's Exact Test
  3156. try:
  3157. odds_ratio, p_value = fisher_exact(contingency_table)
  3158. except Exception:
  3159. odds_ratio, p_value = np.nan, np.nan
  3160. fisher_results.append({
  3161. "Cholinergic Type": cholinergic_group,
  3162. "Neighbor Rank": rank,
  3163. "Cell Class": cell_class,
  3164. "Odds Ratio": odds_ratio,
  3165. "p-value": p_value
  3166. })
  3168. # Convert results to DataFrame
  3169. fisher_results_df = pd.DataFrame(fisher_results)
  3171. # Apply Bonferroni correction to the p-values
  3172. fisher_results_df["padj"] = multipletests(fisher_results_df["p-value"], method="bonferroni")[1]
  3174. # Display the final results
  3175. fisher_results_df
  3177. # %%
  3178. # Save as CSV without row names
  3179. fisher_results_df.to_csv("Skeletal_nearest_neighbors_fisher_results.csv", index=False)
  3181. # %% [markdown]
  3182. # ## Cell type abundance changes with disease
  3184. # %%
  3185. # Read in AnnData
  3186. adata = sc.read_h5ad(os.path.join(working_dir, f"adata_objects/all_anndata_final_rotated_filtered.h5ad"))
  3188. # %% [markdown]
  3189. # ## Fig. 6B and S7B
  3191. # %%
  3192. import os
  3193. import numpy as np
  3194. import pandas as pd
  3195. import matplotlib.pyplot as plt
  3196. import seaborn as sns
  3197. from scipy.stats import ttest_ind
  3198. from statannotations.Annotator import Annotator
  3199. from statsmodels.stats.multitest import multipletests
  3201. # ——————————————————————————————————
  3202. # 1) Ensure all text in the figures is size 7
  3203. # ——————————————————————————————————
  3204. plt.rcParams.update({
  3205. "font.size": 7,
  3206. "axes.titlesize": 7,
  3207. "axes.labelsize": 7,
  3208. "xtick.labelsize": 7,
  3209. "ytick.labelsize": 7,
  3210. "legend.fontsize": 7,
  3211. "legend.title_fontsize": 7
  3212. })
  3214. # 2) Color mapping
  3215. point_colors = {
  3216. "Microglia/Macrophages": "#d62728",
  3217. "Astrocytes": "#1f77b4",
  3218. "Oligodendrocytes": "#8c564b",
  3219. "Alpha MNs": "#1f77b4",
  3220. "Gamma MNs": "#2ca02c",
  3221. "Gamma* MNs": "#d62728",
  3222. }
  3224. stage_order = ["Control", "Early", "Mid", "End"]
  3226. # 3) Ratio function (denominator = all interneurons)
  3227. def compute_ratio(x, column, value):
  3228. num = (x[column] == value).sum()
  3229. den = (
  3230. (x["cell_class"] == "Non-Cholinergic Interneurons").sum() +
  3231. (x["cholinergic_type"] == "Cholinergic Interneurons").sum() +
  3232. (x["cholinergic_type"] == "Disease-Associated Interneurons").sum()
  3233. )
  3234. return num / den if den > 0 else np.nan
  3236. # =============================================================================
  3237. # First plot: 1×2 for Microglia/Macrophages & Astrocytes
  3238. # =============================================================================
  3239. cell_types_g1 = [
  3240. ("cell_class", "Microglia/Macrophages", "Microglia/Macrophages"),
  3241. ("cell_class", "Astrocytes", "Astrocytes"),
  3242. ]
  3244. fig1, axs1 = plt.subplots(1, 2, figsize=(3.25, 2.15), sharey=False)
  3245. stat_tests1 = {}
  3247. for ax, (col, val, title) in zip(axs1, cell_types_g1):
  3248. # a) per-slide_stage raw ratios
  3249. df = (
  3250. adata.obs
  3251. .groupby(["slide_section", "slide_stage", "stage"], observed=True)
  3252. .apply(lambda x: compute_ratio(x, col, val))
  3253. .reset_index(name="celltype_ratio")
  3254. )
  3255. # b) average per slide_stage
  3256. df_avg = (
  3257. df
  3258. .groupby("slide_stage", as_index=False)
  3259. .agg(celltype_ratio=("celltype_ratio", "mean"),
  3260. stage=("stage", "first"))
  3261. )
  3262. df_avg["stage"] = pd.Categorical(df_avg["stage"], categories=stage_order, ordered=True)
  3263. # c) scale by Control mean
  3264. ctrl_mean = df_avg.loc[df_avg.stage == "Control", "celltype_ratio"].mean()
  3265. df_avg["scaled"] = df_avg["celltype_ratio"] / ctrl_mean
  3267. # d) plotting with dot size = 4
  3268. sns.stripplot(
  3269. data=df_avg, x="stage", y="scaled",
  3270. jitter=True, alpha=0.7, size=4,
  3271. color="black", ax=ax
  3272. )
  3273. sns.pointplot(
  3274. data=df_avg, x="stage", y="scaled",
  3275. estimator="mean", errorbar=("ci", 95),
  3276. markers="o", color=point_colors[title],
  3277. ax=ax
  3278. )
  3280. ax.set_title(title)
  3281. ax.set_xlabel("")
  3282. ax.set_ylabel("Relative Abundance")
  3284. # e) two-sided, unequal-variance t-tests vs Control
  3285. ctrl_vals = df_avg.loc[df_avg.stage == "Control", "scaled"]
  3286. raw_p = []
  3287. for s in ["Early", "Mid", "End"]:
  3288. grp = df_avg.loc[df_avg.stage == s, "scaled"]
  3289. raw_p.append(
  3290. ttest_ind(ctrl_vals, grp, equal_var=False).pvalue
  3291. if len(grp) > 0 else np.nan
  3292. )
  3293. raw_p = np.array(raw_p)
  3294. mask = ~np.isnan(raw_p)
  3295. corr = np.full_like(raw_p, np.nan, dtype=float)
  3296. if mask.sum() > 0:
  3297. _, p_corr, _, _ = multipletests(raw_p[mask], method="bonferroni")
  3298. corr[mask] = p_corr
  3299. pvals_corr = corr.tolist()
  3301. # f) annotate
  3302. annot = Annotator(
  3303. ax,
  3304. [("Control", "Early"), ("Control", "Mid"), ("Control", "End")],
  3305. data=df_avg, x="stage", y="scaled",
  3306. order=stage_order, perform_stat_test=False
  3307. )
  3308. annot.configure(test=None, text_format="star", loc="inside")
  3309. annot.set_pvalues_and_annotate(pvals_corr)
  3311. # Nudge tick labels on fig1
  3312. for ax in axs1:
  3313. labels = [t.get_text() for t in ax.get_xticklabels()]
  3314. new_labels = [
  3315. "Control  " if lbl == "Control" else
  3316. " Early" if lbl == "Early" else
  3317. lbl
  3318. for lbl in labels
  3319. ]
  3320. ax.set_xticklabels(new_labels)
  3322. fig1.tight_layout()
  3323. fig1.savefig(
  3324. os.path.join(figures_dir, "celltype_group1.svg"),
  3325. format="svg", bbox_inches="tight"
  3326. )
  3327. plt.show()
  3329. # =============================================================================
  3330. # Second plot: 2×2 for Oligodendrocytes & Motor Neuron subtypes
  3331. # =============================================================================
  3332. cell_types_g2 = [
  3333. ("cell_class", "Oligodendrocytes", "Oligodendrocytes"),
  3334. ("cholinergic_type", "Alpha MNs", "Alpha MNs"),
  3335. ("cholinergic_type", "Gamma MNs", "Gamma MNs"),
  3336. ("cholinergic_type", "Gamma* MNs", "Gamma* MNs"),
  3337. ]
  3339. fig2, axs2 = plt.subplots(2, 2, figsize=(3.25, 4.3), sharey=False)
  3340. axs2_flat = axs2.flatten()
  3341. stat_tests2 = {}
  3343. for ax, (col, val, title) in zip(axs2_flat, cell_types_g2):
  3344. # a) per-slide_stage raw ratios
  3345. df = (
  3346. adata.obs
  3347. .groupby(["slide_section", "slide_stage", "stage"], observed=True)
  3348. .apply(lambda x: compute_ratio(x, col, val))
  3349. .reset_index(name="celltype_ratio")
  3350. )
  3351. # b) average per slide_stage
  3352. df_avg = (
  3353. df
  3354. .groupby("slide_stage", as_index=False)
  3355. .agg(celltype_ratio=("celltype_ratio", "mean"),
  3356. stage=("stage", "first"))
  3357. )
  3358. df_avg["stage"] = pd.Categorical(df_avg["stage"], categories=stage_order, ordered=True)
  3359. # c) scale by Control mean
  3360. ctrl_mean = df_avg.loc[df_avg.stage == "Control", "celltype_ratio"].mean()
  3361. df_avg["scaled"] = df_avg["celltype_ratio"] / ctrl_mean
  3363. # d) plotting
  3364. sns.stripplot(
  3365. data=df_avg, x="stage", y="scaled",
  3366. jitter=True, alpha=0.7, size=4,
  3367. color="black", ax=ax
  3368. )
  3369. sns.pointplot(
  3370. data=df_avg, x="stage", y="scaled",
  3371. estimator="mean", errorbar=("ci", 95), markers="o",
  3372. color=point_colors[title], ax=ax
  3373. )
  3375. ax.set_title(title)
  3376. ax.set_xlabel("")
  3377. # only leftmost column gets y-label
  3378. if ax in (axs2[0, 0], axs2[1, 0]):
  3379. ax.set_ylabel("Relative Abundance")
  3380. else:
  3381. ax.set_ylabel("")
  3383. # e) one-sided t-tests vs Control
  3384. ctrl_vals = df_avg.loc[df_avg.stage == "Control", "scaled"]
  3385. raw_p = []
  3386. for s in ["Early", "Mid", "End"]:
  3387. grp = df_avg.loc[df_avg.stage == s, "scaled"]
  3388. raw_p.append(
  3389. ttest_ind(ctrl_vals, grp, equal_var=False).pvalue
  3390. if len(grp) > 0 else np.nan
  3391. )
  3392. raw_p = np.array(raw_p)
  3393. mask = ~np.isnan(raw_p)
  3394. corr = np.full_like(raw_p, np.nan, dtype=float)
  3395. if mask.sum() > 0:
  3396. _, p_corr, _, _ = multipletests(raw_p[mask], method="bonferroni")
  3397. corr[mask] = p_corr
  3398. pvals_corr = corr.tolist()
  3400. # f) annotate
  3401. annot = Annotator(
  3402. ax,
  3403. [("Control", "Early"), ("Control", "Mid"), ("Control", "End")],
  3404. data=df_avg, x="stage", y="scaled",
  3405. order=stage_order, perform_stat_test=False
  3406. )
  3407. annot.configure(test=None, text_format="star", loc="inside")
  3408. annot.set_pvalues_and_annotate(pvals_corr)
  3410. # Nudge tick labels on fig2
  3411. for ax in axs2_flat:
  3412. labels = [t.get_text() for t in ax.get_xticklabels()]
  3413. new_labels = [
  3414. "Control  " if lbl == "Control" else
  3415. " Early" if lbl == "Early" else
  3416. lbl
  3417. for lbl in labels
  3418. ]
  3419. ax.set_xticklabels(new_labels)
  3421. fig2.tight_layout()
  3422. fig2.savefig(
  3423. os.path.join(figures_dir, "celltype_group2.svg"),
  3424. format="svg", bbox_inches="tight"
  3425. )
  3426. plt.show()
  3429. # %% [markdown]
  3430. # ## Fig. 6H
  3432. # %%
  3433. import os
  3434. import numpy as np
  3435. import pandas as pd
  3436. import matplotlib.pyplot as plt
  3437. import seaborn as sns
  3438. from scipy.stats import ttest_ind
  3439. from statannotations.Annotator import Annotator
  3440. from statsmodels.stats.multitest import multipletests
  3442. # ——————————————————————————————————
  3443. # Ensure all text is at least size 7
  3444. # ——————————————————————————————————
  3445. plt.rcParams.update({
  3446. "font.size": 7,
  3447. "axes.titlesize": 7,
  3448. "axes.labelsize": 7,
  3449. "xtick.labelsize": 7,
  3450. "ytick.labelsize": 7,
  3451. "legend.fontsize": 7,
  3452. "legend.title_fontsize": 7
  3453. })
  3455. # Define cell class of interest
  3456. cell_class_value = "Disease-Associated Interneurons"
  3458. # Order for stage categories
  3459. stage_order = ["Control", "Early", "Mid", "End"]
  3461. # 1) Compute ratios per slide_section using NCI + Cholinergic as denominator
  3462. df = (
  3463. adata.obs
  3464. .groupby(["slide_section", "slide_stage", "stage", "region"], observed=True)
  3465. .apply(lambda x: (x["cell_class"] == cell_class_value).sum() /
  3466. ((x["cell_class"] == "Non-Cholinergic Interneurons") |
  3467. (x["cell_class"] == "Cholinergic Interneurons")).sum()
  3468. if ((x["cell_class"] == "Non-Cholinergic Interneurons") |
  3469. (x["cell_class"] == "Cholinergic Interneurons")).sum() > 0
  3470. else np.nan
  3471. )
  3472. .reset_index(name="celltype_ratio")
  3473. )
  3475. # 2) Average ratio per slide_stage
  3476. df_stage_avg = df.groupby("slide_stage", as_index=False).agg(
  3477. celltype_ratio=("celltype_ratio", "mean"),
  3478. stage=("stage", "first"),
  3479. region=("region", "first")
  3480. )
  3482. # 3) Categorical ordering
  3483. df_stage_avg["stage"] = pd.Categorical(df_stage_avg["stage"],
  3484. categories=stage_order,
  3485. ordered=True)
  3487. # 4) Scale by Control mean
  3488. control_mean = df_stage_avg.loc[df_stage_avg.stage == "Control", "celltype_ratio"].mean()
  3489. df_stage_avg["celltype_ratio_scaled"] = df_stage_avg["celltype_ratio"] / control_mean
  3491. # 5) Plot
  3492. fig, ax = plt.subplots(figsize=(1.625, 2.15))
  3494. sns.stripplot(
  3495. data=df_stage_avg,
  3496. x="stage", y="celltype_ratio_scaled",
  3497. jitter=True, alpha=0.7, color="black",size=4,
  3498. ax=ax
  3499. )
  3501. sns.pointplot(
  3502. data=df_stage_avg,
  3503. x="stage", y="celltype_ratio_scaled",
  3504. estimator="mean", errorbar=("ci", 95),
  3505. markers="o", color="#55A868",
  3506. ax=ax
  3507. )
  3509. ax.set_title("DAI")
  3510. ax.set_xlabel(None)
  3511. ax.set_ylabel("Relative Abundance")
  3513. # 6) Comparisons
  3514. box_pairs = [("Control", "Early"), ("Control", "Mid"), ("Control", "End")]
  3516. control_vals = df_stage_avg.loc[df_stage_avg.stage == "Control", "celltype_ratio_scaled"]
  3517. early_vals = df_stage_avg.loc[df_stage_avg.stage == "Early", "celltype_ratio_scaled"]
  3518. mid_vals = df_stage_avg.loc[df_stage_avg.stage == "Mid", "celltype_ratio_scaled"]
  3519. end_vals = df_stage_avg.loc[df_stage_avg.stage == "End", "celltype_ratio_scaled"]
  3521. # 7) Unequal‑variance t‑tests
  3522. p_ce = ttest_ind(control_vals, early_vals, equal_var=False).pvalue if len(early_vals)>0 else np.nan
  3523. p_cm = ttest_ind(control_vals, mid_vals, equal_var=False).pvalue if len(mid_vals)>0 else np.nan
  3524. p_cE = ttest_ind(control_vals, end_vals, equal_var=False).pvalue if len(end_vals)>0 else np.nan
  3525. pvals = [p_ce, p_cm, p_cE]
  3527. # 8) Bonferroni correction
  3528. _, pvals_corr, _, _ = multipletests(pvals, method="bonferroni")
  3530. # 9) Annotate
  3531. annotator = Annotator(
  3532. ax, box_pairs,
  3533. data=df_stage_avg,
  3534. x="stage", y="celltype_ratio_scaled",
  3535. order=stage_order,
  3536. perform_stat_test=False
  3537. )
  3538. annotator.configure(test=None, text_format="star", loc="inside")
  3539. annotator.set_pvalues_and_annotate(pvals_corr)
  3541. # 9b) Nudge “Control” and “Early” apart via padded labels
  3542. padded = []
  3543. for l in stage_order:
  3544. if l == "Control":
  3545. padded.append("Control ")
  3546. elif l == "Early":
  3547. padded.append(" Early")
  3548. else:
  3549. padded.append(l)
  3550. ax.set_xticklabels(padded)
  3552. # 10) Save & show
  3553. plt.tight_layout()
  3554. out_path = os.path.join(figures_dir, "DAI_ratio_small.svg")
  3555. fig.savefig(out_path, format="svg", bbox_inches="tight")
  3556. plt.show()
  3558. # 11) Print corrected p‑values
  3559. print("Bonferroni‑corrected p‑values:")
  3560. for cmp, p in zip(["Control vs Early","Control vs Mid","Control vs End"], pvals_corr):
  3561. print(f" {cmp}: p = {p:.3e}")
  3564. # %% [markdown]
  3565. # ## Microglia/Macrophage follow-up
  3567. # %% [markdown]
  3568. # ### Check if control microglia/macrophages are near gene & transcript cutoff
  3570. # %%
  3571. # Read in AnnData
  3572. adata = sc.read_h5ad(os.path.join(working_dir, f"adata_objects/all_anndata_final_rotated.h5ad"))
  3574. # %% [markdown]
  3575. # ## Fig. S7C
  3577. # %%
  3578. import os
  3579. import seaborn as sns
  3580. import matplotlib.pyplot as plt
  3581. import pandas as pd
  3582. import numpy as np
  3584. # Filter to only Microglia/Macrophages
  3585. microglia = adata[adata.obs['cell_class'] == "Microglia/Macrophages"].copy()
  3587. # Split into control and disease
  3588. control = microglia[microglia.obs['stage'] == "Control"].copy()
  3589. disease = microglia[microglia.obs['stage'] != "Control"].copy()
  3591. # Create a combined DataFrame for plotting
  3592. control_df = pd.DataFrame({
  3593. 'num_transcripts': control.obs['num_transcripts'],
  3594. 'num_genes': control.obs['num_genes'],
  3595. 'condition': 'Control'
  3596. })
  3598. disease_df = pd.DataFrame({
  3599. 'num_transcripts': disease.obs['num_transcripts'],
  3600. 'num_genes': disease.obs['num_genes'],
  3601. 'condition': 'Disease'
  3602. })
  3604. plot_df = pd.concat([control_df, disease_df])
  3606. # Plotting
  3607. fig, axs = plt.subplots(1, 2, figsize=(1.625, 2.15))
  3609. for ax, ycol, ylabel in zip(
  3610. axs,
  3611. ['num_transcripts', 'num_genes'],
  3612. ['# Transcripts', '# Genes']
  3613. ):
  3614. # draw violin, no inner box
  3615. sns.violinplot(
  3616. data=plot_df,
  3617. x='condition',
  3618. y=ycol,
  3619. color="#d62728",
  3620. inner=None,
  3621. ax=ax
  3622. )
  3624. # drop x-label, set y-label
  3625. ax.set_xlabel("")
  3626. ax.set_ylabel(ylabel)
  3628. # adjust y-axis spacing
  3629. ax.tick_params(axis='y', pad = 0.5) # space between ticks and tick labels
  3630. ax.yaxis.labelpad = 0.5 # space between label and tick labels
  3632. # rotate x-tick labels
  3633. ax.tick_params(axis='x', rotation=90)
  3635. # compute & plot medians
  3636. medians = plot_df.groupby('condition')[ycol].median()
  3637. for i, median_val in enumerate(medians):
  3638. ax.scatter(i, median_val, color='black', s=8, zorder=3)
  3640. # add a single title above both plots
  3641. fig.suptitle("Microglia/Macrophages", x=0.6, y=0.93, fontsize=7)
  3643. # adjust so that suptitle and plots don't overlap
  3644. plt.tight_layout(rect=[0, 0, 1, 1])
  3646. # save and show
  3647. out_path = os.path.join(figures_dir, "microglia_transcripts_genes.svg")
  3648. plt.savefig(out_path, format="svg", bbox_inches="tight")
  3649. plt.show()
  3651. # Function to compute median and mean
  3652. def describe_metric(data, metric):
  3653. values = data.obs[metric]
  3654. median = np.median(values)
  3655. mean = np.mean(values)
  3656. return median, mean
  3658. # Compute for num_transcripts and num_genes
  3659. metrics = ["num_transcripts", "num_genes"]
  3661. for condition_name, data in zip(["Control", "Disease"], [control, disease]):
  3662. print(f"\n{condition_name} condition:")
  3663. for metric in metrics:
  3664. median_val, mean_val = describe_metric(data, metric)
  3665. print(f" {metric}: median = {median_val:.2f}, mean = {mean_val:.2f}")
  3667. # %% [markdown]
  3668. # ### Spatial plots of microglia/macrophages with disease
  3670. # %%
  3671. # Read in AnnData
  3672. adata = sc.read_h5ad(os.path.join(working_dir, f"adata_objects/all_anndata_final_rotated.h5ad"))
  3674. # %%
  3675. import os
  3676. import numpy as np
  3677. import pandas as pd
  3678. import matplotlib.pyplot as plt
  3680. # 1) Ensure all text in the figures is size 7
  3681. plt.rcParams.update({
  3682. "font.size": 7,
  3683. "axes.titlesize": 7,
  3684. "axes.labelsize": 7,
  3685. "xtick.labelsize": 7,
  3686. "ytick.labelsize": 7,
  3687. "legend.fontsize": 7,
  3688. "legend.title_fontsize": 7
  3689. })
  3691. # 2) Define (slide, section) pairs
  3692. sections = [
  3693. ("202405281702_MsSpinalCord-VS223-Lumbar-CE2-SE4-S1_VMSC02701", "R1C2"),
  3694. ("202405281416_MsSpinalCord-VS223-Lumbar-CM2-SM4-S1_VMSC15302", "R2C3"),
  3695. ("202401241200_HuSpinalCord-VS119-Lubmar-Ctrl3-SOD10_VMSC10802", "R1C2"),
  3696. ("202405281702_MsSpinalCord-VS223-Lumbar-CE2-SE4-S1_VMSC02701", "R2C3"),
  3697. ("202405281416_MsSpinalCord-VS223-Lumbar-CM2-SM4-S1_VMSC15302", "R1C3"),
  3698. ("202401241200_HuSpinalCord-VS119-Lubmar-Ctrl3-SOD10_VMSC10802", "R2C2")
  3699. ]
  3701. # 3) Extract subsets
  3702. sub_adata_list = [
  3703. adata[(adata.obs["slide"] == slide_id) & (adata.obs["section"] == section_id)].copy()
  3704. for slide_id, section_id in sections
  3705. ]
  3707. # 4) Compute global bounds with padding
  3708. xmins, xmaxs, ymins, ymaxs = [], [], [], []
  3709. for sub in sub_adata_list:
  3710. coords = sub.obsm["spatial"]
  3711. xmins.append(coords[:, 0].min()); xmaxs.append(coords[:, 0].max())
  3712. ymins.append(coords[:, 1].min()); ymaxs.append(coords[:, 1].max())
  3713. global_xmin, global_xmax = min(xmins), max(xmaxs)
  3714. global_ymin, global_ymax = min(ymins), max(ymaxs)
  3715. dx, dy = global_xmax - global_xmin, global_ymax - global_ymin
  3716. global_xmin -= 0.05 * dx
  3717. global_xmax += 0.00 * dx
  3718. global_ymin -= 0.05 * dy
  3719. global_ymax += 0.075 * dy
  3721. # ------------------ Microglia/Macrophages (2×3) — Swapped Rows & Titles ------------------ #
  3722. fig1, axes1 = plt.subplots(2, 3, figsize=(4.35, 2.2))
  3723. axes1 = axes1.reshape(2, 3)
  3724. axes1 = np.flipud(axes1).flatten() # Flip the subplot rows
  3726. # Correctly reordered titles to match flipped layout
  3727. titles1 = [
  3728. "Early – Disease", "Mid – Disease", "End – Disease",
  3729. "Early – Control", "Mid – Control", "End – Control"
  3730. ]
  3732. for ax, sub, title in zip(axes1, sub_adata_list, titles1):
  3733. coords = sub.obsm["spatial"]
  3734. mask = (sub.obs["cell_class"] == "Microglia/Macrophages").values
  3735. ax.scatter(coords[~mask, 0], coords[~mask, 1],
  3736. s=4, c="lightgray", marker="o", linewidth=0)
  3737. ax.scatter(coords[mask, 0], coords[mask, 1],
  3738. s=4, c="#d62728", marker="o", linewidth=0)
  3739. ax.set_xlim(global_xmin, global_xmax)
  3740. ax.set_ylim(global_ymin, global_ymax)
  3741. ax.set_xticks([]); ax.set_yticks([])
  3742. ax.set_title(title, pad=2)
  3744. fig1.suptitle("Microglia/Macrophages", y=0.93, fontsize=7)
  3745. fig1.subplots_adjust(top=0.88)
  3747. plt.tight_layout()
  3748. fig1_path = os.path.join(figures_dir, "microglia_macrophages.svg")
  3749. fig1.savefig(fig1_path, format="svg", bbox_inches="tight")
  3750. plt.show()
  3753. # %% [markdown]
  3754. # ## Reactive glia with disease
  3756. # %%
  3757. adata = sc.read_h5ad(os.path.join(working_dir, f"adata_objects/all_anndata_final_rotated.h5ad"))
  3759. # %% [markdown]
  3760. # ### Define reactive glia
  3762. # %%
  3763. # Step 1: Compute the 95th percentiles for Microglia and Astrocytes in each slide
  3764. control_95th_percentile_microglia = {}
  3765. control_95th_percentile_astrocytes = {}
  3767. # Exclude control only slide
  3768. excluded_slide = "202312251515_MsSpinalCord-L4-S1-VS119-YS_Beta8"
  3769. unique_slides = [s for s in adata.obs["slide"].unique() if s != excluded_slide]
  3771. for slide in unique_slides:
  3772. # Microglia: use Apoe
  3773. control_microglia = adata.obs[
  3774. (adata.obs["slide"] == slide) &
  3775. (adata.obs["stage"] == "Control") &
  3776. (adata.obs["cell_class"] == "Microglia/Macrophages")
  3777. ]["Apoe_high_pass_norm"].dropna()
  3779. control_95th_percentile_microglia[slide] = (
  3780. np.percentile(control_microglia, 95) if not control_microglia.empty else np.nan
  3781. )
  3783. # Astrocytes: use Gfap
  3784. control_astrocytes = adata.obs[
  3785. (adata.obs["slide"] == slide) &
  3786. (adata.obs["stage"] == "Control") &
  3787. (adata.obs["cell_class"] == "Astrocytes")
  3788. ]["Gfap_high_pass_norm"].dropna()
  3790. control_95th_percentile_astrocytes[slide] = (
  3791. np.percentile(control_astrocytes, 95) if not control_astrocytes.empty else np.nan
  3792. )
  3794. # Step 2: Define functions to determine reactivity
  3795. def is_reactive_microglia(row):
  3796. slide = row["slide"]
  3797. if row["cell_class"] == "Microglia/Macrophages" and slide in control_95th_percentile_microglia:
  3798. threshold = control_95th_percentile_microglia[slide]
  3799. if not np.isnan(threshold):
  3800. return row["Apoe_high_pass_norm"] > threshold
  3801. return False
  3803. def is_reactive_or_wm_astrocyte(row):
  3804. slide = row["slide"]
  3805. if row["cell_class"] == "Astrocytes" and slide in control_95th_percentile_astrocytes:
  3806. threshold = control_95th_percentile_astrocytes[slide]
  3807. if not np.isnan(threshold):
  3808. return row["Gfap_high_pass_norm"] > threshold
  3809. return False
  3811. # Step 3: Apply the functions to create new metadata columns
  3812. adata.obs["reactive_microglia"] = adata.obs.apply(is_reactive_microglia, axis=1)
  3813. adata.obs["reactive_or_wm_astrocytes"] = adata.obs.apply(is_reactive_or_wm_astrocyte, axis=1)
  3815. # %%
  3816. # Save anndata
  3817. save_name = f"adata_objects/all_anndata_final_rotated_w_anno.h5ad"
  3818. adata.write_h5ad(os.path.join(working_dir, save_name))
  3820. # %% [markdown]
  3821. # ### Reactive glia spatial plots
  3823. # %%
  3824. adata = sc.read_h5ad(os.path.join(working_dir, f"adata_objects/all_anndata_final_rotated_w_anno.h5ad"))
  3826. # %% [markdown]
  3827. # ## Fig. 6C
  3829. # %%
  3830. import os
  3831. import numpy as np
  3832. import pandas as pd
  3833. import matplotlib.pyplot as plt
  3834. import seaborn as sns
  3835. from scipy.spatial import ConvexHull
  3837. # Ensure all text in the figures is size 7
  3838. plt.rcParams.update({
  3839. "font.size": 7,
  3840. "axes.titlesize": 7,
  3841. "axes.labelsize": 7,
  3842. "xtick.labelsize": 7,
  3843. "ytick.labelsize": 7,
  3844. "legend.fontsize": 7,
  3845. "legend.title_fontsize": 7
  3846. })
  3848. # Define (slide, section) pairs
  3849. sections = [
  3850. ("202405281702_MsSpinalCord-VS223-Lumbar-CE2-SE4-S1_VMSC02701", "R1C2"),
  3851. ("202405281416_MsSpinalCord-VS223-Lumbar-CM2-SM4-S1_VMSC15302", "R2C3"),
  3852. ("202401241200_HuSpinalCord-VS119-Lubmar-Ctrl3-SOD10_VMSC10802", "R1C2"),
  3853. ("202405281702_MsSpinalCord-VS223-Lumbar-CE2-SE4-S1_VMSC02701", "R2C3"),
  3854. ("202405281416_MsSpinalCord-VS223-Lumbar-CM2-SM4-S1_VMSC15302", "R1C3"),
  3855. ("202401241200_HuSpinalCord-VS119-Lubmar-Ctrl3-SOD10_VMSC10802", "R2C2")
  3856. ]
  3858. # Extract subsets
  3859. sub_adata_list = [
  3860. adata[(adata.obs["slide"] == slide_id) & (adata.obs["section"] == section_id)].copy()
  3861. for slide_id, section_id in sections
  3862. ]
  3864. # Compute global bounds
  3865. xmins, xmaxs, ymins, ymaxs = [], [], [], []
  3866. for sub in sub_adata_list:
  3867. coords = sub.obsm["spatial"]
  3868. xmins.append(coords[:, 0].min()); xmaxs.append(coords[:, 0].max())
  3869. ymins.append(coords[:, 1].min()); ymaxs.append(coords[:, 1].max())
  3870. global_xmin, global_xmax = min(xmins), max(xmaxs)
  3871. global_ymin, global_ymax = min(ymins), max(ymaxs)
  3872. dx, dy = global_xmax - global_xmin, global_ymax - global_ymin
  3873. global_xmin -= 0.05 * dx
  3874. global_xmax += 0.00 * dx
  3875. global_ymin -= 0.05 * dy
  3876. global_ymax += 0.075 * dy
  3878. # Subplot titles
  3879. titles = [
  3880. "Early – Disease", "Mid – Disease", "End – Disease",
  3881. "Early – Control", "Mid – Control", "End – Control"
  3882. ]
  3884. # ------------------ Combined 3×3 Plot ------------------ #
  3885. fig, axes = plt.subplots(3, 3, figsize=(3.1132, 1.9816))
  3886. axes = axes.reshape(3, 3)
  3888. # ------------------ Top 2 rows: Reactive Microglia ------------------ #
  3889. # Flip rows vertically
  3890. marker_axes = np.flipud(axes[:2]).flatten()
  3891. for ax, sub, title in zip(marker_axes, sub_adata_list, titles):
  3892. coords = sub.obsm["spatial"]
  3893. mask = sub.obs["reactive_microglia"].astype(bool).values
  3894. ax.scatter(coords[~mask, 0], coords[~mask, 1], s=4, c="lightgray", marker="o", linewidth=0)
  3895. ax.scatter(coords[ mask, 0], coords[ mask, 1], s=4, c="#d62728", marker="o", linewidth=0)
  3896. ax.set_xlim(global_xmin, global_xmax)
  3897. ax.set_ylim(global_ymin, global_ymax)
  3898. ax.set_xticks([]); ax.set_yticks([])
  3899. ax.set_title(title, pad=2)
  3901. # ------------------ Top 2 rows: Rasterize points ------------------ #
  3902. for ax in axes[:2].flatten():
  3903. for coll in ax.collections:
  3904. coll.set_rasterized(True)
  3906. # ------------------ Bottom row: Reactive Microglia Density + Convex Hull ------------------ #
  3907. for ax, sub, title in zip(axes[2], sub_adata_list[:3], titles[:3]):
  3908. coords = sub.obsm["spatial"]
  3910. # Plot reactive microglia density
  3911. mask = (sub.obs["cell_class"] == "Microglia/Macrophages") & (sub.obs["reactive_microglia"] == True)
  3912. coords_mask = coords[mask.values]
  3913. sns.kdeplot(
  3914. x=coords_mask[:, 0], y=coords_mask[:, 1],
  3915. fill=True, thresh=0, levels=100, cmap="Reds", bw_method="scott", ax=ax
  3916. )
  3918. # Add convex hull of all cells
  3919. if coords.shape[0] >= 3:
  3920. try:
  3921. hull = ConvexHull(coords)
  3922. hull_coords = coords[hull.vertices]
  3923. hull_path = np.append(hull_coords, [hull_coords[0]], axis=0) # close the loop
  3924. ax.plot(hull_path[:, 0], hull_path[:, 1], color="black", linewidth=0.5)
  3925. except:
  3926. pass # silently skip if hull fails
  3928. ax.set_xlim(global_xmin, global_xmax)
  3929. ax.set_ylim(global_ymin, global_ymax)
  3930. ax.set_xticks([]); ax.set_yticks([])
  3931. ax.set_title(title, pad=2)
  3933. # Final formatting
  3934. plt.tight_layout(pad=0.325)
  3935. fig.suptitle("Reactive Microglia/Macrophages", y=1, fontsize=7)
  3936. fig.subplots_adjust(top=0.90)
  3938. out_path = os.path.join(figures_dir, "reactive_microglia_combined_with_hull.svg")
  3939. fig.savefig(out_path, format="svg", bbox_inches="tight", dpi=600)
  3940. plt.show()
  3942. # %% [markdown]
  3943. # ### Dorsal/ventral location of reactive glia and disease-associated interneurons
  3945. # %%
  3946. adata = sc.read_h5ad(os.path.join(working_dir, f"adata_objects/all_anndata_final_rotated_w_anno.h5ad"))
  3948. # %%
  3949. # Normalize y values and add to spatial data
  3950. import pandas as pd
  3952. # 1) pull out the y‑coordinate and slide_section (as string)
  3953. y = pd.Series(adata.obsm["spatial"][:, 1], index=adata.obs.index, name="y")
  3954. slide_sec = adata.obs["slide_section"].astype(str)
  3956. # 2) shift each section so its minimum y becomes zero
  3957. y_shifted = y.groupby(slide_sec).transform(lambda v: v - v.min())
  3959. # 3) compute the median of the shifted values for each section
  3960. y_median = y_shifted.groupby(slide_sec).transform("median")
  3962. # 4) normalize by dividing by that median
  3963. adata.obs["y_normalized"] = (y_shifted / y_median).values
  3965. # %% [markdown]
  3966. # ## Fig. 6D
  3968. # %%
  3969. import os
  3970. import numpy as np
  3971. import pandas as pd
  3972. import matplotlib.pyplot as plt
  3973. import seaborn as sns
  3974. from scipy.stats import f_oneway
  3975. from statsmodels.stats.multicomp import pairwise_tukeyhsd
  3976. from statannotations.Annotator import Annotator
  3978. # ——————————————————————————————————
  3979. # Ensure all text is at least size 7
  3980. # ——————————————————————————————————
  3981. plt.rcParams.update({
  3982. "font.size": 7,
  3983. "axes.titlesize": 7,
  3984. "axes.labelsize": 7,
  3985. "xtick.labelsize": 7,
  3986. "ytick.labelsize": 7,
  3987. "legend.fontsize": 7,
  3988. "legend.title_fontsize": 7
  3989. })
  3991. # Subset adata to only include "Lumbar" region
  3992. adata_lumbar = adata[adata.obs["region"] == "Lumbar"].copy()
  3994. # 1) Filter reactive microglia & drop Control
  3995. stage_order = ["Early", "Mid", "End"]
  3996. reactive = (
  3997. adata_lumbar.obs
  3998. .loc[
  3999. adata_lumbar.obs["reactive_microglia"] == True,
  4000. ["y_normalized", "stage", "slide_stage", "slide_section"]
  4001. ]
  4002. .copy()
  4003. )
  4004. reactive = reactive[reactive["stage"].isin(stage_order)]
  4006. # 2) Per‑slide_section average of y_normalized
  4007. ss_avg = (
  4008. reactive
  4009. .groupby(["slide_section", "slide_stage", "stage"], observed=True)
  4010. .agg(avg_y=("y_normalized", "mean"))
  4011. .reset_index()
  4012. )
  4014. # 3) Per‑slide_stage average of those slide_section avgs
  4015. stg_avg = (
  4016. ss_avg
  4017. .groupby(["slide_stage", "stage"], observed=True)
  4018. .agg(avg_y=("avg_y", "mean"))
  4019. .reset_index()
  4020. )
  4022. # -------------------------
  4023. # 4) STATISTICS
  4024. # -------------------------
  4026. # ANOVA across stages
  4027. groups = [stg_avg.loc[stg_avg.stage == s, "avg_y"] for s in stage_order]
  4028. F, p_an = f_oneway(*groups)
  4029. print(f"ANOVA F = {F:.3f}, p = {p_an:.3e}")
  4031. # Tukey HSD
  4032. tukey = pairwise_tukeyhsd(
  4033. endog=stg_avg["avg_y"],
  4034. groups=stg_avg["stage"],
  4035. alpha=0.05
  4036. )
  4037. print("\nTukey HSD results:")
  4038. print(tukey.summary())
  4040. # extract p‑values for annotator
  4041. tuk_df = pd.DataFrame(tukey._results_table.data[1:], columns=tukey._results_table.data[0])
  4042. pairs = [("Early", "Mid"), ("Early", "End"), ("Mid", "End")]
  4043. pvals = []
  4044. for a, b in pairs:
  4045. m = tuk_df.query("(group1==@a & group2==@b) or (group1==@b & group2==@a)")
  4046. pvals.append(m["p-adj"].values[0] if not m.empty else np.nan)
  4048. # -------------------------
  4049. # 5) PLOT
  4050. # -------------------------
  4051. fig, ax = plt.subplots(figsize=(1.625, 2.15))
  4053. # boxplot with all boxes colored red
  4054. sns.boxplot(
  4055. data=stg_avg,
  4056. x="stage",
  4057. y="avg_y",
  4058. order=stage_order,
  4059. color="#d62728",
  4060. showfliers=False,
  4061. ax=ax
  4062. )
  4064. # stripplot on top
  4065. sns.stripplot(
  4066. data=stg_avg,
  4067. x="stage",
  4068. y="avg_y",
  4069. order=stage_order,
  4070. color="black",
  4071. size=4,
  4072. jitter=True,
  4073. alpha=0.8,
  4074. ax=ax
  4075. )
  4077. # add stat annotations
  4078. annotator = Annotator(
  4079. ax, pairs, data=stg_avg,
  4080. x="stage", y="avg_y",
  4081. order=stage_order
  4082. )
  4083. annotator.configure(test=None, text_format="star", loc="inside")
  4084. annotator.set_pvalues(pvals)
  4085. annotator.annotate()
  4087. ax.set_xlabel("")
  4088. ax.set_ylabel("Avg. Dorsal/Ventral Location")
  4089. ax.set_title("Reactive MG - Lumbar")
  4091. plt.tight_layout()
  4092. out_path = os.path.join(figures_dir, "reactive_microglia_DV_small.svg")
  4093. fig.savefig(out_path, format="svg", bbox_inches="tight")
  4094. plt.show()
  4097. # %% [markdown]
  4098. # ## Fig. 6J
  4100. # %%
  4101. import numpy as np
  4102. import pandas as pd
  4103. import matplotlib.pyplot as plt
  4104. import seaborn as sns
  4105. from scipy.stats import ttest_rel
  4106. from statannotations.Annotator import Annotator
  4108. # ——————————————————————————————————
  4109. # Ensure all text in the figure is size 7
  4110. # ——————————————————————————————————
  4111. plt.rcParams.update({
  4112. "font.size": 7,
  4113. "axes.titlesize": 7,
  4114. "axes.labelsize": 7,
  4115. "xtick.labelsize": 7,
  4116. "ytick.labelsize": 7,
  4117. "legend.fontsize": 7,
  4118. "legend.title_fontsize": 7,
  4119. "figure.titlesize": 7
  4120. })
  4122. # Subset to Lumbar region AND exclude Control-stage
  4123. adata_sub = adata[
  4124. (adata.obs["region"] == "Lumbar") &
  4125. (adata.obs["stage"] != "Control")
  4126. ].copy()
  4128. # Define the cell types (for filtering only)
  4129. cell_types = {
  4130. "Disease-Associated Interneurons": "Disease-Associated Interneurons",
  4131. "Motor Neurons": ["Alpha MNs", "Gamma MNs", "Gamma* MNs"]
  4132. }
  4134. # 1) Filter each and tag a simplified label
  4135. dai = (
  4136. adata_sub.obs
  4137. .loc[
  4138. adata_sub.obs["cell_class"] == cell_types["Disease-Associated Interneurons"],
  4139. ["y_normalized", "slide_section", "slide_stage", "stage"]
  4140. ]
  4141. .copy()
  4142. )
  4143. dai["cell_type"] = "DAI"
  4145. mot = (
  4146. adata_sub.obs
  4147. .loc[
  4148. adata_sub.obs["cholinergic_type"].isin(cell_types["Motor Neurons"]),
  4149. ["y_normalized", "slide_section", "slide_stage", "stage"]
  4150. ]
  4151. .copy()
  4152. )
  4153. mot["cell_type"] = "Skeletal MNs"
  4155. combined = pd.concat([dai, mot], ignore_index=True)
  4157. # 2) Per‑slide_section average of y_normalized
  4158. ss_avg = (
  4159. combined
  4160. .groupby(["slide_section", "slide_stage", "stage", "cell_type"], observed=True)
  4161. .agg(avg_y=("y_normalized", "mean"))
  4162. .reset_index()
  4163. )
  4165. # 3) Per‑slide_stage average of those slide_section avgs
  4166. stg_lvl_avg = (
  4167. ss_avg
  4168. .groupby(["slide_stage", "stage", "cell_type"], observed=True)
  4169. .agg(stage_avg_y=("avg_y", "mean"))
  4170. .reset_index()
  4171. )
  4173. # 4) ONE‑SIDED PAIRED t‑TEST (H₁: DAI > Skeletal MNs)
  4174. paired = (
  4175. stg_lvl_avg
  4176. .pivot(index="slide_stage", columns="cell_type", values="stage_avg_y")
  4177. .dropna()
  4178. )
  4180. from scipy.stats import ttest_rel
  4181. t_stat, p_two_sided = ttest_rel(paired["DAI"], paired["Skeletal MNs"])
  4182. if t_stat > 0:
  4183. p_one_sided = p_two_sided / 2
  4184. else:
  4185. p_one_sided = 1 - p_two_sided / 2
  4187. print(f"paired one‑sided t = {t_stat:.3f}, p = {p_one_sided:.3e}")
  4189. pairs = [("DAI", "Skeletal MNs")]
  4190. pvals = [p_one_sided]
  4192. # 5) PLOT using slide_stage averages with custom colors
  4193. plt.figure(figsize=(1.625, 2.15))
  4194. ax = sns.boxplot(
  4195. data=stg_lvl_avg,
  4196. x="cell_type",
  4197. y="stage_avg_y",
  4198. order=["DAI", "Skeletal MNs"],
  4199. palette={"DAI": "#2ca02c", "Skeletal MNs": "#ff7f0e"},
  4200. showfliers=False,
  4201. ax=plt.gca()
  4202. )
  4203. sns.stripplot(
  4204. data=stg_lvl_avg,
  4205. x="cell_type",
  4206. y="stage_avg_y",
  4207. order=["DAI", "Skeletal MNs"],
  4208. color="black",
  4209. size=4,
  4210. jitter=True,
  4211. alpha=0.8,
  4212. ax=ax
  4213. )
  4215. # connect paired points from same slide_stage
  4216. for slide_stage in paired.index:
  4217. ax.plot(
  4218. ["DAI", "Skeletal MNs"],
  4219. [paired.loc[slide_stage, "DAI"], paired.loc[slide_stage, "Skeletal MNs"]],
  4220. color="gray", linewidth=0.8, alpha=0.6
  4221. )
  4223. # annotate
  4224. annotator = Annotator(
  4225. ax, [("DAI", "Skeletal MNs")], data=stg_lvl_avg,
  4226. x="cell_type", y="stage_avg_y",
  4227. order=["DAI", "Skeletal MNs"]
  4228. )
  4229. annotator.configure(test=None, text_format="star", loc="inside")
  4230. annotator.set_pvalues([p_one_sided])
  4231. annotator.annotate()
  4233. ax.set_xlabel("")
  4234. ax.set_ylabel("Avg. Dorsal/Ventral Location")
  4235. ax.set_title("DAI vs. Skeletal MNs")
  4237. plt.tight_layout()
  4238. out_path = os.path.join(figures_dir, "DAI_MN_DV_paired_small.svg")
  4239. plt.savefig(out_path, format="svg", bbox_inches="tight")
  4240. plt.show()
  4243. # %% [markdown]
  4244. # ## Reactive and non-reactive MG - distance to nearest MN
  4246. # %%
  4247. adata = sc.read_h5ad(os.path.join(working_dir, f"adata_objects/all_anndata_final_rotated_w_anno.h5ad"))
  4249. # %% [markdown]
  4250. # ## Fig. 6E
  4252. # %%
  4253. import os
  4254. import numpy as np
  4255. import pandas as pd
  4256. import matplotlib.pyplot as plt
  4257. import seaborn as sns
  4258. from scipy.spatial.distance import cdist
  4259. from scipy.stats import ttest_rel
  4260. from statannotations.Annotator import Annotator
  4262. # ——————————————————————————————
  4263. # Ensure all text is size 7
  4264. # ——————————————————————————————
  4265. plt.rcParams.update({
  4266. "font.size": 7,
  4267. "axes.titlesize": 7,
  4268. "axes.labelsize": 7,
  4269. "xtick.labelsize": 7,
  4270. "ytick.labelsize": 7,
  4271. "legend.fontsize": 7,
  4272. "legend.title_fontsize": 7
  4273. })
  4275. # ——————————————————————————————
  4276. # 1) Subset to Lumbar & Early
  4277. # ——————————————————————————————
  4278. adata_sub = adata[
  4279. (adata.obs["region"] == "Lumbar") &
  4280. (adata.obs["stage"] == "Early")
  4281. ].copy()
  4283. # ——————————————————————————————
  4284. # 2) Compute per-slide_stage avg distances
  4285. # ——————————————————————————————
  4286. records = []
  4287. for slide_stage in adata_sub.obs["slide_stage"].unique():
  4288. mask_ss = adata_sub.obs["slide_stage"] == slide_stage
  4289. sections = adata_sub.obs.loc[mask_ss, "slide_section"].unique()
  4290. for reactive_status in [True, False]:
  4291. sec_means = []
  4292. for sec in sections:
  4293. mask_sec = mask_ss & (adata_sub.obs["slide_section"] == sec)
  4294. coords = adata_sub.obsm["spatial"][mask_sec.values]
  4296. is_motor = (
  4297. adata_sub.obs.loc[mask_sec, "cholinergic_type"]
  4298. .isin(["Alpha MNs","Gamma MNs","Gamma* MNs"])
  4299. .to_numpy()
  4300. )
  4302. # restrict to microglia/macrophages first
  4303. is_micro_class = (
  4304. adata_sub.obs.loc[mask_sec, "cell_class"] == "Microglia/Macrophages"
  4305. ).to_numpy()
  4307. is_reactive_flag = (
  4308. adata_sub.obs.loc[mask_sec, "reactive_microglia"]
  4309. .astype(bool)
  4310. .to_numpy()
  4311. )
  4313. is_micro = is_micro_class & (is_reactive_flag == reactive_status)
  4315. pts_micro = coords[is_micro]
  4316. pts_motor = coords[is_motor]
  4318. if pts_micro.size and pts_motor.size:
  4319. D = cdist(pts_micro, pts_motor, "euclidean")
  4320. sec_means.append(D.min(axis=1).mean())
  4322. if sec_means:
  4323. records.append({
  4324. "slide_stage": slide_stage,
  4325. "reactive": reactive_status,
  4326. "avg_dist": np.mean(sec_means)
  4327. })
  4329. dist_df = pd.DataFrame(records)
  4331. # ——————————————————————————————
  4332. # 3) Build plot_df
  4333. # ——————————————————————————————
  4334. plot_df = dist_df.copy()
  4335. plot_df["cell_type"] = plot_df["reactive"].map({
  4336. True: "Reactive",
  4337. False: "Non-Reactive"
  4338. })
  4340. # ——————————————————————————————
  4341. # 4) Compute one-sided p-value (Non-Reactive > Reactive)
  4342. # ——————————————————————————————
  4343. pivot = plot_df.pivot(
  4344. index="slide_stage",
  4345. columns="cell_type",
  4346. values="avg_dist"
  4347. ).dropna(subset=["Reactive", "Non-Reactive"])
  4349. stat, p_two = ttest_rel(pivot["Non-Reactive"], pivot["Reactive"])
  4350. p_one = p_two / 2 if stat > 0 else 1 - p_two / 2
  4351. print(f"One-sided p-value (Non-Reactive > Reactive): {p_one:.3e}")
  4353. # ——————————————————————————————
  4354. # 5) Plot paired box+strip with lines and annotate
  4355. # ——————————————————————————————
  4356. fig, ax = plt.subplots(figsize=(1.625, 2.15))
  4358. sns.boxplot(
  4359. data=plot_df,
  4360. x="cell_type", y="avg_dist",
  4361. order=["Reactive","Non-Reactive"],
  4362. palette={"Reactive":"#d62728","Non-Reactive":"#ea9393"},
  4363. showfliers=False,
  4364. linewidth=1,
  4365. ax=ax, zorder=1
  4366. )
  4368. sns.stripplot(
  4369. data=plot_df,
  4370. x="cell_type", y="avg_dist",
  4371. order=["Reactive","Non-Reactive"],
  4372. color="black", size=4, jitter=True, alpha=0.8,
  4373. ax=ax, zorder=2
  4374. )
  4376. for ss, grp in plot_df.groupby("slide_stage"):
  4377. y0 = grp.loc[grp.cell_type=="Reactive", "avg_dist"].values
  4378. y1 = grp.loc[grp.cell_type=="Non-Reactive","avg_dist"].values
  4379. if y0.size and y1.size:
  4380. ax.plot(
  4381. ["Reactive","Non-Reactive"],
  4382. [y0[0], y1[0]],
  4383. color="gray", linewidth=0.8, alpha=0.6, zorder=3
  4384. )
  4386. pairs = [("Reactive", "Non-Reactive")]
  4387. annot = Annotator(
  4388. ax, pairs,
  4389. data=plot_df,
  4390. x="cell_type", y="avg_dist",
  4391. order=["Reactive","Non-Reactive"]
  4392. )
  4393. annot.set_pvalues([p_one])
  4394. annot.configure(text_format="star", loc="inside")
  4395. annot.annotate()
  4397. ax.set_title("Early Disease - Lumbar", fontsize=7)
  4398. ax.set_xlabel("Microglia/Macrophages")
  4399. ax.set_ylabel("Avg. Dist. to Nearest MN")
  4401. # ——————————————————————————————
  4402. # FORCE tick + spine thickness to 1
  4403. # ——————————————————————————————
  4404. ax.tick_params(width=1)
  4405. for spine in ax.spines.values():
  4406. spine.set_linewidth(1)
  4408. plt.tight_layout()
  4409. out_path = os.path.join(
  4410. figures_dir,
  4411. "reactive_microglia_nearest_MN_small_fixed.svg"
  4412. )
  4413. fig.savefig(out_path, format="svg", bbox_inches="tight")
  4414. plt.show()
  4416. # %% [markdown]
  4417. # ## Reactive/WM and other Astrocytes - distance to nearest reactive MG
  4419. # %%
  4420. import numpy as np
  4421. import pandas as pd
  4422. import matplotlib.pyplot as plt
  4423. import seaborn as sns
  4424. from scipy.spatial.distance import cdist
  4425. from scipy.stats import ttest_rel
  4426. from statannotations.Annotator import Annotator
  4428. # ——————————————————————————————
  4429. # 1) Subset to Lumbar & Early
  4430. # ——————————————————————————————
  4431. adata_sub = adata[
  4432. (adata.obs["region"] == "Lumbar") &
  4433. (adata.obs["stage"] == "Early")
  4434. ].copy()
  4436. # ——————————————————————————————
  4437. # 2) Compute per-slide_stage avg distances
  4438. # ——————————————————————————————
  4439. records = []
  4440. for slide_stage in adata_sub.obs["slide_stage"].unique():
  4441. mask_ss = adata_sub.obs["slide_stage"] == slide_stage
  4442. sections = adata_sub.obs.loc[mask_ss, "slide_section"].unique()
  4443. for is_reactive_wm, label in [(True, "Reactive/WM"), (False, "Other")]:
  4444. sec_means = []
  4445. for sec in sections:
  4446. mask_sec = mask_ss & (adata_sub.obs["slide_section"] == sec)
  4447. coords = adata_sub.obsm["spatial"][mask_sec.values]
  4449. # Query: astrocytes of this group
  4450. is_astro = (
  4451. (adata_sub.obs.loc[mask_sec, "cell_class"] == "Astrocytes") &
  4452. (adata_sub.obs.loc[mask_sec, "reactive_or_wm_astrocytes"] == is_reactive_wm)
  4453. ).to_numpy()
  4455. # Reference: reactive microglia
  4456. is_reactive_micro = (
  4457. (adata_sub.obs.loc[mask_sec, "cell_class"] == "Microglia/Macrophages") &
  4458. (adata_sub.obs.loc[mask_sec, "reactive_microglia"])
  4459. ).to_numpy()
  4461. pts_astro = coords[is_astro]
  4462. pts_micro = coords[is_reactive_micro]
  4464. if pts_astro.size and pts_micro.size:
  4465. D = cdist(pts_astro, pts_micro, metric="euclidean")
  4466. sec_means.append(D.min(axis=1).mean())
  4468. if sec_means:
  4469. records.append({
  4470. "slide_stage": slide_stage,
  4471. "astro_group": label,
  4472. "avg_dist": np.mean(sec_means)
  4473. })
  4475. # ——————————————————————————————
  4476. # 3) Create plot_df and perform stats
  4477. # ——————————————————————————————
  4478. dist_df = pd.DataFrame(records)
  4479. plot_df = dist_df.copy()
  4480. plot_df["cell_type"] = plot_df["astro_group"]
  4482. # Paired one-sided t-test (Other > Reactive/WM)
  4483. pivot = plot_df.pivot(index="slide_stage", columns="cell_type", values="avg_dist")
  4484. stat, p_two = ttest_rel(pivot["Other"], pivot["Reactive/WM"])
  4485. p_one = p_two / 2 if stat > 0 else 1 - p_two / 2
  4486. print(f"One-sided p-value (Other > Reactive/WM): {p_one:.3e}")
  4488. # ——————————————————————————————
  4489. # 4) Plot
  4490. # ——————————————————————————————
  4491. plt.rcParams.update({
  4492. "font.size": 7,
  4493. "axes.titlesize": 7,
  4494. "axes.labelsize": 7,
  4495. "xtick.labelsize": 7,
  4496. "ytick.labelsize": 7,
  4497. "legend.fontsize": 7
  4498. })
  4500. fig, ax = plt.subplots(figsize=(1.625, 2.15))
  4502. sns.boxplot(
  4503. data=plot_df,
  4504. x="cell_type", y="avg_dist",
  4505. order=["Reactive/WM", "Other"],
  4506. palette={"Reactive/WM": "#1f77b4", "Other": "#8fbbd9"},
  4507. showfliers=False,
  4508. ax=ax, zorder=1
  4509. )
  4510. sns.stripplot(
  4511. data=plot_df,
  4512. x="cell_type", y="avg_dist",
  4513. order=["Reactive/WM", "Other"],
  4514. color="black", size=4, jitter=True, alpha=0.8,
  4515. ax=ax, zorder=2
  4516. )
  4518. # Paired lines
  4519. for ss, grp in plot_df.groupby("slide_stage"):
  4520. y_reactive = grp.loc[grp.cell_type == "Reactive/WM", "avg_dist"].values
  4521. y_other = grp.loc[grp.cell_type == "Other", "avg_dist"].values
  4522. if y_reactive.size and y_other.size:
  4523. ax.plot(
  4524. ["Reactive/WM", "Other"],
  4525. [y_reactive[0], y_other[0]],
  4526. color="gray", linewidth=0.8, alpha=0.6, zorder=3
  4527. )
  4529. # Annotate p-value
  4530. pairs = [("Reactive/WM", "Other")]
  4531. annot = Annotator(
  4532. ax, pairs,
  4533. data=plot_df,
  4534. x="cell_type", y="avg_dist",
  4535. order=["Reactive/WM", "Other"]
  4536. )
  4537. annot.set_pvalues([p_one])
  4538. annot.configure(text_format="star", loc="inside")
  4539. annot.annotate()
  4541. # Labels
  4542. ax.set_title("Early Disease - Lumbar")
  4543. ax.set_xlabel("Astrocytes")
  4544. ax.set_ylabel("Avg. Dist. to Nearest Reactive MG")
  4546. plt.tight_layout()
  4547. fig.savefig(os.path.join(figures_dir, "astro_dist_to_reactive_microglia_early.svg"), format="svg", bbox_inches="tight")
  4548. plt.show()
  4551. # %% [markdown]
  4552. # ## Fig. 6F
  4554. # %%
  4555. import numpy as np
  4556. import pandas as pd
  4557. import matplotlib.pyplot as plt
  4558. import seaborn as sns
  4559. from scipy.spatial.distance import cdist
  4560. from scipy.stats import ttest_rel
  4561. from statannotations.Annotator import Annotator
  4563. # ——————————————————————————————
  4564. # 1) Subset to Lumbar & Mid
  4565. # ——————————————————————————————
  4566. adata_sub = adata[
  4567. (adata.obs["region"] == "Lumbar") &
  4568. (adata.obs["stage"] == "Mid")
  4569. ].copy()
  4571. # ——————————————————————————————
  4572. # 2) Compute per-slide_stage avg distances
  4573. # ——————————————————————————————
  4574. records = []
  4575. for slide_stage in adata_sub.obs["slide_stage"].unique():
  4576. mask_ss = adata_sub.obs["slide_stage"] == slide_stage
  4577. sections = adata_sub.obs.loc[mask_ss, "slide_section"].unique()
  4578. for is_reactive_wm, label in [(True, "Reactive/WM"), (False, "Other")]:
  4579. sec_means = []
  4580. for sec in sections:
  4581. mask_sec = mask_ss & (adata_sub.obs["slide_section"] == sec)
  4582. coords = adata_sub.obsm["spatial"][mask_sec.values]
  4584. # Query: astrocytes of this group
  4585. is_astro = (
  4586. (adata_sub.obs.loc[mask_sec, "cell_class"] == "Astrocytes") &
  4587. (adata_sub.obs.loc[mask_sec, "reactive_or_wm_astrocytes"] == is_reactive_wm)
  4588. ).to_numpy()
  4590. # Reference: reactive microglia
  4591. is_reactive_micro = (
  4592. (adata_sub.obs.loc[mask_sec, "cell_class"] == "Microglia/Macrophages") &
  4593. (adata_sub.obs.loc[mask_sec, "reactive_microglia"])
  4594. ).to_numpy()
  4596. pts_astro = coords[is_astro]
  4597. pts_micro = coords[is_reactive_micro]
  4599. if pts_astro.size and pts_micro.size:
  4600. D = cdist(pts_astro, pts_micro, metric="euclidean")
  4601. sec_means.append(D.min(axis=1).mean())
  4603. if sec_means:
  4604. records.append({
  4605. "slide_stage": slide_stage,
  4606. "astro_group": label,
  4607. "avg_dist": np.mean(sec_means)
  4608. })
  4610. # ——————————————————————————————
  4611. # 3) Create plot_df and perform stats
  4612. # ——————————————————————————————
  4613. dist_df = pd.DataFrame(records)
  4614. plot_df = dist_df.copy()
  4615. plot_df["cell_type"] = plot_df["astro_group"]
  4617. # Paired one-sided t-test (Other > Reactive/WM)
  4618. pivot = plot_df.pivot(index="slide_stage", columns="cell_type", values="avg_dist")
  4619. stat, p_two = ttest_rel(pivot["Other"], pivot["Reactive/WM"])
  4620. p_one = p_two / 2 if stat > 0 else 1 - p_two / 2
  4621. print(f"One-sided p-value (Other > Reactive/WM): {p_one:.3e}")
  4623. # ——————————————————————————————
  4624. # 4) Plot
  4625. # ——————————————————————————————
  4626. plt.rcParams.update({
  4627. "font.size": 7,
  4628. "axes.titlesize": 7,
  4629. "axes.labelsize": 7,
  4630. "xtick.labelsize": 7,
  4631. "ytick.labelsize": 7,
  4632. "legend.fontsize": 7
  4633. })
  4635. fig, ax = plt.subplots(figsize=(1.625, 2.15))
  4637. sns.boxplot(
  4638. data=plot_df,
  4639. x="cell_type", y="avg_dist",
  4640. order=["Reactive/WM", "Other"],
  4641. palette={"Reactive/WM": "#1f77b4", "Other": "#8fbbd9"},
  4642. showfliers=False,
  4643. ax=ax, zorder=1
  4644. )
  4645. sns.stripplot(
  4646. data=plot_df,
  4647. x="cell_type", y="avg_dist",
  4648. order=["Reactive/WM", "Other"],
  4649. color="black", size=4, jitter=True, alpha=0.8,
  4650. ax=ax, zorder=2
  4651. )
  4653. # Paired lines
  4654. for ss, grp in plot_df.groupby("slide_stage"):
  4655. y_reactive = grp.loc[grp.cell_type == "Reactive/WM", "avg_dist"].values
  4656. y_other = grp.loc[grp.cell_type == "Other", "avg_dist"].values
  4657. if y_reactive.size and y_other.size:
  4658. ax.plot(
  4659. ["Reactive/WM", "Other"],
  4660. [y_reactive[0], y_other[0]],
  4661. color="gray", linewidth=0.8, alpha=0.6, zorder=3
  4662. )
  4664. # Annotate p-value
  4665. pairs = [("Reactive/WM", "Other")]
  4666. annot = Annotator(
  4667. ax, pairs,
  4668. data=plot_df,
  4669. x="cell_type", y="avg_dist",
  4670. order=["Reactive/WM", "Other"]
  4671. )
  4672. annot.set_pvalues([p_one])
  4673. annot.configure(text_format="star", loc="inside")
  4674. annot.annotate()
  4676. # Labels
  4677. ax.set_title("Mid Disease - Lumbar")
  4678. ax.set_xlabel("Astrocytes")
  4679. ax.set_ylabel("Avg. Dist. to Nearest Reactive MG")
  4681. plt.tight_layout()
  4682. fig.savefig(os.path.join(figures_dir, "astro_dist_to_reactive_microglia_mid.svg"), format="svg", bbox_inches="tight")
  4683. plt.show()
  4686. # %%
  4687. import numpy as np
  4688. import pandas as pd
  4689. import matplotlib.pyplot as plt
  4690. import seaborn as sns
  4691. from scipy.spatial.distance import cdist
  4692. from scipy.stats import ttest_rel
  4693. from statannotations.Annotator import Annotator
  4695. # ——————————————————————————————
  4696. # 1) Subset to Lumbar & End
  4697. # ——————————————————————————————
  4698. adata_sub = adata[
  4699. (adata.obs["region"] == "Lumbar") &
  4700. (adata.obs["stage"] == "End")
  4701. ].copy()
  4703. # ——————————————————————————————
  4704. # 2) Compute per-slide_stage avg distances
  4705. # ——————————————————————————————
  4706. records = []
  4707. for slide_stage in adata_sub.obs["slide_stage"].unique():
  4708. mask_ss = adata_sub.obs["slide_stage"] == slide_stage
  4709. sections = adata_sub.obs.loc[mask_ss, "slide_section"].unique()
  4710. for is_reactive_wm, label in [(True, "Reactive/WM"), (False, "Other")]:
  4711. sec_means = []
  4712. for sec in sections:
  4713. mask_sec = mask_ss & (adata_sub.obs["slide_section"] == sec)
  4714. coords = adata_sub.obsm["spatial"][mask_sec.values]
  4716. # Query: astrocytes of this group
  4717. is_astro = (
  4718. (adata_sub.obs.loc[mask_sec, "cell_class"] == "Astrocytes") &
  4719. (adata_sub.obs.loc[mask_sec, "reactive_or_wm_astrocytes"] == is_reactive_wm)
  4720. ).to_numpy()
  4722. # Reference: reactive microglia
  4723. is_reactive_micro = (
  4724. (adata_sub.obs.loc[mask_sec, "cell_class"] == "Microglia/Macrophages") &
  4725. (adata_sub.obs.loc[mask_sec, "reactive_microglia"])
  4726. ).to_numpy()
  4728. pts_astro = coords[is_astro]
  4729. pts_micro = coords[is_reactive_micro]
  4731. if pts_astro.size and pts_micro.size:
  4732. D = cdist(pts_astro, pts_micro, metric="euclidean")
  4733. sec_means.append(D.min(axis=1).mean())
  4735. if sec_means:
  4736. records.append({
  4737. "slide_stage": slide_stage,
  4738. "astro_group": label,
  4739. "avg_dist": np.mean(sec_means)
  4740. })
  4742. # ——————————————————————————————
  4743. # 3) Create plot_df and perform stats
  4744. # ——————————————————————————————
  4745. dist_df = pd.DataFrame(records)
  4746. plot_df = dist_df.copy()
  4747. plot_df["cell_type"] = plot_df["astro_group"]
  4749. # Paired one-sided t-test (Other > Reactive/WM)
  4750. pivot = plot_df.pivot(index="slide_stage", columns="cell_type", values="avg_dist")
  4751. stat, p_two = ttest_rel(pivot["Other"], pivot["Reactive/WM"])
  4752. p_one = p_two / 2 if stat > 0 else 1 - p_two / 2
  4753. print(f"One-sided p-value (Other > Reactive/WM): {p_one:.3e}")
  4755. # ——————————————————————————————
  4756. # 4) Plot
  4757. # ——————————————————————————————
  4758. plt.rcParams.update({
  4759. "font.size": 7,
  4760. "axes.titlesize": 7,
  4761. "axes.labelsize": 7,
  4762. "xtick.labelsize": 7,
  4763. "ytick.labelsize": 7,
  4764. "legend.fontsize": 7
  4765. })
  4767. fig, ax = plt.subplots(figsize=(1.625, 2.15))
  4769. sns.boxplot(
  4770. data=plot_df,
  4771. x="cell_type", y="avg_dist",
  4772. order=["Reactive/WM", "Other"],
  4773. palette={"Reactive/WM": "#1f77b4", "Other": "#8fbbd9"},
  4774. showfliers=False,
  4775. ax=ax, zorder=1
  4776. )
  4777. sns.stripplot(
  4778. data=plot_df,
  4779. x="cell_type", y="avg_dist",
  4780. order=["Reactive/WM", "Other"],
  4781. color="black", size=4, jitter=True, alpha=0.8,
  4782. ax=ax, zorder=2
  4783. )
  4785. # Paired lines
  4786. for ss, grp in plot_df.groupby("slide_stage"):
  4787. y_reactive = grp.loc[grp.cell_type == "Reactive/WM", "avg_dist"].values
  4788. y_other = grp.loc[grp.cell_type == "Other", "avg_dist"].values
  4789. if y_reactive.size and y_other.size:
  4790. ax.plot(
  4791. ["Reactive/WM", "Other"],
  4792. [y_reactive[0], y_other[0]],
  4793. color="gray", linewidth=0.8, alpha=0.6, zorder=3
  4794. )
  4796. # Annotate p-value
  4797. pairs = [("Reactive/WM", "Other")]
  4798. annot = Annotator(
  4799. ax, pairs,
  4800. data=plot_df,
  4801. x="cell_type", y="avg_dist",
  4802. order=["Reactive/WM", "Other"]
  4803. )
  4804. annot.set_pvalues([p_one])
  4805. annot.configure(text_format="star", loc="inside")
  4806. annot.annotate()
  4808. # Labels
  4809. ax.set_title("End Disease - Lumbar")
  4810. ax.set_xlabel("Astrocytes")
  4811. ax.set_ylabel("Avg. Dist. to Nearest Reactive MG")
  4813. # Ensure y-axis ticks are integers only
  4814. ax.yaxis.set_major_locator(plt.MaxNLocator(integer=True))
  4816. plt.tight_layout()
  4817. fig.savefig(os.path.join(figures_dir, "astro_dist_to_reactive_microglia_end.svg"), format="svg", bbox_inches="tight")
  4818. plt.show()
  4820. # %% [markdown]
  4821. # ## Reactive glia, DAI, and DAMN proportions with disease
  4823. # %%
  4824. adata = sc.read_h5ad(os.path.join(working_dir, f"adata_objects/all_anndata_final_rotated_w_anno.h5ad"))
  4826. # %% [markdown]
  4827. # ## Fig. S7D
  4829. # %%
  4830. import matplotlib.pyplot as plt
  4831. import seaborn as sns
  4833. # 0) Set all fonts to size 7
  4834. plt.rcParams.update({
  4835. "font.size": 7,
  4836. "axes.titlesize": 7,
  4837. "axes.labelsize": 7,
  4838. "xtick.labelsize": 7,
  4839. "ytick.labelsize": 7,
  4840. "legend.fontsize": 7,
  4841. "legend.title_fontsize": 7
  4842. })
  4844. # Step 1: Subset to Microglia/Macrophages only
  4845. mg_obs = adata.obs[adata.obs["cell_class"] == "Microglia/Macrophages"].copy()
  4847. # Step 2: Count reactive vs non‑reactive by stage
  4848. stage_reactive_counts = (
  4849. mg_obs
  4850. .groupby(["stage", "reactive_microglia"], observed=True)
  4851. .size()
  4852. .unstack(fill_value=0)
  4853. )
  4855. # Step 3: Convert to proportions within each stage
  4856. stage_reactive_props = stage_reactive_counts.div(stage_reactive_counts.sum(axis=1), axis=0)
  4858. # Step 4: Ensure stage order
  4859. stage_order = ["Control", "Early", "Mid", "End"]
  4860. stage_reactive_props = stage_reactive_props.reindex(stage_order).fillna(0)
  4862. # Step 5: Force True first (bottom) then False (top)
  4863. stage_reactive_props = stage_reactive_props.reindex(columns=[True, False])
  4865. # Step 6: Plot
  4866. fig, ax = plt.subplots(figsize=(1.625, 2.15))
  4867. stage_reactive_props.plot(
  4868. kind="bar",
  4869. stacked=True,
  4870. color=["#d62728", "#ea9393"], # True (bottom), False (top)
  4871. edgecolor="black",
  4872. ax=ax
  4873. )
  4875. # Step 7: Labels, legend, title
  4876. ax.set_xlabel("") # no x-axis label
  4877. ax.set_ylabel("Proportion")
  4878. ax.set_xticklabels(stage_order, rotation=0)
  4879. ax.legend(
  4880. title="Reactive",
  4881. labels=["True", "False"],
  4882. loc="upper center",
  4883. bbox_to_anchor=(0.5, -0.12),
  4884. ncol=2,
  4885. handlelength=1, # shorten the legend color box length
  4886. handletextpad=0.4, # reduce space between color box and text
  4887. columnspacing=0.8, # reduce space between columns
  4888. borderpad=0.3 # reduce padding inside the legend box
  4889. )
  4890. ax.set_title("Microglia/Macrophages")
  4892. plt.tight_layout()
  4893. out_path = os.path.join(figures_dir, "reactive_microglia_proportion.svg")
  4894. plt.savefig(out_path, format="svg", bbox_inches="tight")
  4895. plt.show()
  4897. # %% [markdown]
  4898. # ## Fig. S7E
  4900. # %%
  4901. import matplotlib.pyplot as plt
  4902. import seaborn as sns
  4904. # 0) Set all fonts to size 7
  4905. plt.rcParams.update({
  4906. "font.size": 7,
  4907. "axes.titlesize": 7,
  4908. "axes.labelsize": 7,
  4909. "xtick.labelsize": 7,
  4910. "ytick.labelsize": 7,
  4911. "legend.fontsize": 7,
  4912. "legend.title_fontsize": 7
  4913. })
  4915. # Step 1: Subset to Astrocytes only
  4916. ast_obs = adata.obs[adata.obs["cell_class"] == "Astrocytes"].copy()
  4918. # Step 2: Count reactive vs non‑reactive by stage
  4919. stage_reactive_counts = (
  4920. ast_obs
  4921. .groupby(["stage", "reactive_or_wm_astrocytes"], observed=True)
  4922. .size()
  4923. .unstack(fill_value=0)
  4924. )
  4926. # Step 3: Convert to proportions within each stage
  4927. stage_reactive_props = stage_reactive_counts.div(stage_reactive_counts.sum(axis=1), axis=0)
  4929. # Step 4: Ensure stage order
  4930. stage_order = ["Control", "Early", "Mid", "End"]
  4931. stage_reactive_props = stage_reactive_props.reindex(stage_order).fillna(0)
  4933. # Step 5: Force True first (bottom) then False (top)
  4934. stage_reactive_props = stage_reactive_props.reindex(columns=[True, False])
  4936. # Step 6: Plot
  4937. fig, ax = plt.subplots(figsize=(1.625, 2.15))
  4938. stage_reactive_props.plot(
  4939. kind="bar",
  4940. stacked=True,
  4941. color=["#1f77b4", "#8fbbd9"], # True (bottom), False (top)
  4942. edgecolor="black",
  4943. ax=ax
  4944. )
  4946. # Step 7: Labels, legend, title
  4947. ax.set_xlabel("") # no x-axis label
  4948. ax.set_ylabel("Proportion")
  4949. ax.set_xticklabels(stage_order, rotation=0)
  4950. ax.legend(
  4951. title="Reactive",
  4952. labels=["True", "False"],
  4953. loc="upper center",
  4954. bbox_to_anchor=(0.5, -0.12),
  4955. ncol=2,
  4956. handlelength=1, # shorten the legend color box length
  4957. handletextpad=0.4, # reduce space between color box and text
  4958. columnspacing=0.8, # reduce space between columns
  4959. borderpad=0.3 # reduce padding inside the legend box
  4960. )
  4961. ax.set_title("Astrocytes")
  4963. plt.tight_layout()
  4964. out_path = os.path.join(figures_dir, "reactive_astrocyte_proportion.svg")
  4965. plt.savefig(out_path, format="svg", bbox_inches="tight")
  4966. plt.show()
  4968. # %% [markdown]
  4969. # ## Fig. S7F
  4971. # %%
  4972. import matplotlib.pyplot as plt
  4973. import seaborn as sns
  4975. # 0) Set all fonts to size 7
  4976. plt.rcParams.update({
  4977. "font.size": 7,
  4978. "axes.titlesize": 7,
  4979. "axes.labelsize": 7,
  4980. "xtick.labelsize": 7,
  4981. "ytick.labelsize": 7,
  4982. "legend.fontsize": 7,
  4983. "legend.title_fontsize": 7
  4984. })
  4986. # Step 1: Subset to Alpha MNs only
  4987. alpha_obs = adata.obs[adata.obs["cholinergic_type"] == "Alpha MNs"].copy()
  4989. # Step 2: Count DAMN vs non‑DAMN by stage
  4990. stage_DAMN_counts = (
  4991. alpha_obs
  4992. .groupby(["stage", "DAMN_status"], observed=True)
  4993. .size()
  4994. .unstack(fill_value=0)
  4995. )
  4997. # Step 3: Convert to proportions within each stage
  4998. stage_DAMN_props = stage_DAMN_counts.div(stage_DAMN_counts.sum(axis=1), axis=0)
  5000. # Step 4: Ensure stage order
  5001. stage_order = ["Control", "Early", "Mid", "End"]
  5002. stage_DAMN_props = stage_DAMN_props.reindex(stage_order).fillna(0)
  5004. # 5) reorder to DAMN bottom, Non-DAMN top
  5005. stage_DAMN_props = stage_DAMN_props[["DAMN","Non-DAMN"]].fillna(0)
  5007. # 6) plot
  5008. fig, ax = plt.subplots(figsize=(1.625, 2.15))
  5009. stage_DAMN_props.plot(
  5010. kind="bar",
  5011. stacked=True,
  5012. color=["#1f77b4", "#8fbbd9"], # bottom=“DAMN”, top=“Non-DAMN”
  5013. edgecolor="black",
  5014. ax=ax
  5015. )
  5017. # Step 7: Labels, legend, title
  5018. ax.set_xlabel("") # no x-axis label
  5019. ax.set_ylabel("Proportion")
  5020. ax.set_xticklabels(stage_order, rotation=0)
  5021. ax.legend(
  5022. title="DM",
  5023. labels=["True", "False"],
  5024. loc="upper center",
  5025. bbox_to_anchor=(0.5, -0.12),
  5026. ncol=2,
  5027. handlelength=1, # shorten the legend color box length
  5028. handletextpad=0.4, # reduce space between color box and text
  5029. columnspacing=0.8, # reduce space between columns
  5030. borderpad=0.3 # reduce padding inside the legend box
  5031. )
  5032. ax.set_title("Alpha MNs")
  5034. plt.tight_layout()
  5035. out_path = os.path.join(figures_dir, "DM_proportion.svg")
  5036. plt.savefig(out_path, format="svg", bbox_inches="tight")
  5037. plt.show()
  5039. # %%
  5040. print("\nProportion DAMN_status == 'DAMN' by stage (percent):")
  5041. for stage, prop in stage_DAMN_props["DAMN"].items():
  5042. print(f"{stage}: {prop:.1%}")
  5044. # %% [markdown]
  5045. # ## Alpha MN subtype proportion plot
  5047. # %%
  5048. # Read in AnnData
  5049. adata = sc.read_h5ad(os.path.join(working_dir, f"adata_objects/alpha_anndata_label_transfer.h5ad"))
  5051. # %% [markdown]
  5052. # ## Fig. S7G
  5054. # %%
  5055. import pandas as pd
  5056. import seaborn as sns
  5057. import matplotlib.pyplot as plt
  5058. import os
  5060. # ------------------------------------------------------------------
  5061. # 0) Set all fonts to size 7 (match your other figure)
  5062. # ------------------------------------------------------------------
  5063. plt.rcParams.update({
  5064. "font.size": 7,
  5065. "axes.titlesize": 7,
  5066. "axes.labelsize": 7,
  5067. "xtick.labelsize": 7,
  5068. "ytick.labelsize": 7,
  5069. "legend.fontsize": 7,
  5070. "legend.title_fontsize": 7
  5071. })
  5073. # ------------------------------------------------------------------
  5074. # 1) Subset to nuclear cells (optional)
  5075. # ------------------------------------------------------------------
  5076. adata_sub = adata # (or: adata[adata.obs["nuclear"] == True])
  5078. # ------------------------------------------------------------------
  5079. # 2) Extract relevant metadata (now includes region)
  5080. # ------------------------------------------------------------------
  5081. df = adata_sub.obs[["stage", "predicted.id", "region"]].copy()
  5082. df = df.dropna(subset=["stage", "predicted.id", "region"])
  5084. stage_order = ["Control", "Early", "Mid", "End"]
  5085. pred_order = ["Slow-Firing", "Intermediate", "Fast-Firing", "Early DAMN", "Late DAMN"]
  5086. pred_order_stack = list(reversed(pred_order))
  5088. # Display-only legend labels
  5089. label_map = {"Early DAMN": "Early DM", "Late DAMN": "Late DM"}
  5091. df["stage"] = pd.Categorical(df["stage"], categories=stage_order, ordered=True)
  5092. df["predicted.id"] = pd.Categorical(df["predicted.id"], categories=pred_order, ordered=True)
  5094. # ------------------------------------------------------------------
  5095. # 3) Define colors
  5096. # ------------------------------------------------------------------
  5097. alpha_colors = {
  5098. "Slow-Firing": "#F47D2B",
  5099. "Intermediate": "#272E6A",
  5100. "Fast-Firing": "#208A42",
  5101. "Early DAMN": "#89288F",
  5102. "Late DAMN": "#D51F26"
  5103. }
  5105. # ------------------------------------------------------------------
  5106. # 4) Helper: compute proportions for a given region
  5107. # ------------------------------------------------------------------
  5108. def compute_prop_for_region(df_in: pd.DataFrame, region_name: str) -> pd.DataFrame:
  5109. d = df_in[df_in["region"] == region_name].copy()
  5111. counts = d.groupby(["stage", "predicted.id"]).size().to_frame("count")
  5112. counts["proportion"] = counts["count"] / counts.groupby(level=0)["count"].transform("sum")
  5113. prop = counts.reset_index()
  5115. # Ensure all stage x predicted.id combos exist (so bars stack cleanly even if missing)
  5116. full = (
  5117. pd.MultiIndex.from_product([stage_order, pred_order], names=["stage", "predicted.id"])
  5118. .to_frame(index=False)
  5119. )
  5120. prop = full.merge(prop, on=["stage", "predicted.id"], how="left").fillna({"proportion": 0, "count": 0})
  5121. prop["stage"] = pd.Categorical(prop["stage"], categories=stage_order, ordered=True)
  5122. prop["predicted.id"] = pd.Categorical(prop["predicted.id"], categories=pred_order, ordered=True)
  5123. return prop
  5125. # ------------------------------------------------------------------
  5126. # 5) Plot: two stacked barplots (Lumbar + Cervical)
  5127. # ------------------------------------------------------------------
  5128. regions = ["Lumbar", "Cervical"]
  5130. fig, axes = plt.subplots(
  5131. 1, 2,
  5132. figsize=(3.25, 1.625), # ~2x width of your single panel (1.625 -> 3.25)
  5133. sharey=True
  5134. )
  5136. legend_handles = None # we will grab once and use a single legend for the figure
  5138. for ax, region_name in zip(axes, regions):
  5139. prop = compute_prop_for_region(df, region_name)
  5141. bottom = pd.Series([0.0] * len(stage_order), index=stage_order)
  5142. handles = {}
  5144. for pred in pred_order_stack:
  5145. sub = prop[prop["predicted.id"] == pred].sort_values("stage")
  5147. bars = ax.bar(
  5148. sub["stage"].astype(str),
  5149. sub["proportion"].values,
  5150. bottom=bottom[sub["stage"].astype(str)].values if bottom.index.dtype == object else bottom[sub["stage"]].values,
  5151. color=alpha_colors[pred],
  5152. width=0.8,
  5153. edgecolor="none"
  5154. )
  5156. handles[pred] = bars[0]
  5158. # Update bottom by stage order
  5159. bottom.loc[sub["stage"].astype(str).values] = (
  5160. bottom.loc[sub["stage"].astype(str).values].values + sub["proportion"].values
  5161. )
  5163. ax.set_title(region_name)
  5164. ax.set_xlabel("")
  5165. ax.set_ylim(0, 1)
  5166. ax.set_xticklabels(stage_order, rotation=0)
  5167. sns.despine(ax=ax)
  5169. if legend_handles is None:
  5170. legend_handles = handles # save for figure-level legend
  5172. # Y label only on left
  5173. axes[0].set_ylabel("Proportion")
  5174. axes[1].set_ylabel("")
  5176. # One legend for the whole figure (no title)
  5177. fig.legend(
  5178. handles=[legend_handles[p] for p in pred_order],
  5179. labels=[label_map.get(p, p) for p in pred_order],
  5180. bbox_to_anchor=(1.02, 1),
  5181. loc="upper left",
  5182. frameon=False
  5183. )
  5185. plt.tight_layout()
  5187. # ------------------------------------------------------------------
  5188. # 6) Save figure
  5189. # ------------------------------------------------------------------
  5190. out_path = os.path.join(figures_dir, "alpha_mn_subtype_barplot_Lumbar_Cervical_DM.svg")
  5191. plt.savefig(out_path, format="svg", bbox_inches="tight")
  5192. plt.show()
  5194. # %% [markdown]
  5195. # ## Fig. S7H
  5197. # %%
  5198. import scanpy as sc
  5199. import matplotlib.pyplot as plt
  5200. import pandas as pd
  5201. import os
  5202. from matplotlib.collections import PathCollection
  5204. # ---- Enforce predicted.id order ----
  5205. pred_order = ["Slow-Firing", "Intermediate", "Fast-Firing", "Early DAMN", "Late DAMN"]
  5206. adata.obs["predicted.id"] = pd.Categorical(
  5207. adata.obs["predicted.id"],
  5208. categories=pred_order,
  5209. ordered=True
  5210. )
  5212. # ---- Display-only labels for plotting ----
  5213. label_map = {"Early DAMN": "Early DM", "Late DAMN": "Late DM"}
  5214. pred_order_plot = [label_map.get(c, c) for c in pred_order]
  5216. adata.obs["predicted.id_plot"] = adata.obs["predicted.id"].cat.rename_categories(label_map)
  5217. adata.obs["predicted.id_plot"] = pd.Categorical(
  5218. adata.obs["predicted.id_plot"],
  5219. categories=pred_order_plot,
  5220. ordered=True
  5221. )
  5223. # ---- Colors ----
  5224. alpha_colors = {
  5225. "Slow-Firing": "#F47D2B",
  5226. "Intermediate": "#272E6A",
  5227. "Fast-Firing": "#208A42",
  5228. "Early DM": "#89288F",
  5229. "Late DM": "#D51F26"
  5230. }
  5231. adata.uns["predicted.id_plot_colors"] = [alpha_colors[c] for c in pred_order_plot]
  5233. # Global font size = 7
  5234. plt.rcParams.update({
  5235. "font.size": 7,
  5236. "axes.titlesize": 7,
  5237. "axes.labelsize": 7,
  5238. "xtick.labelsize": 7,
  5239. "ytick.labelsize": 7,
  5240. "legend.fontsize": 7,
  5241. "legend.title_fontsize": 6
  5242. })
  5244. # Create UMAP and return figure
  5245. fig = sc.pl.umap(
  5246. adata,
  5247. color="predicted.id_plot",
  5248. title="",
  5249. size=5,
  5250. show=False,
  5251. return_fig=True
  5252. )
  5254. # Hard-remove any lingering title
  5255. for ax in fig.axes:
  5256. ax.set_title("")
  5258. # Set exact figure size AFTER creation
  5259. fig.set_size_inches(2.3, 1.525)
  5261. # ---- Force VECTOR points: turn OFF rasterization on the scatter collection(s)
  5262. for ax in fig.axes:
  5263. for coll in ax.collections:
  5264. if isinstance(coll, PathCollection):
  5265. coll.set_rasterized(False)
  5267. plt.tight_layout()
  5268. plt.show()
  5270. out_path = os.path.join(figures_dir, "alpha_mn_subtype_umap_DM.svg")
  5271. fig.savefig(out_path, format="svg", bbox_inches="tight")
  5273. # %% [markdown]
  5274. # ## Fig. 6I
  5276. # %%
  5277. import numpy as np
  5278. import matplotlib.pyplot as plt
  5279. import seaborn as sns
  5281. # ——————————————————————————————————
  5282. # Ensure all text is size 7
  5283. # ——————————————————————————————————
  5284. plt.rcParams.update({
  5285. "font.size": 7,
  5286. "axes.titlesize": 7,
  5287. "axes.labelsize": 7,
  5288. "xtick.labelsize": 7,
  5289. "ytick.labelsize": 7,
  5290. "legend.fontsize": 7,
  5291. "legend.title_fontsize": 7
  5292. })
  5294. # 1) Define the three groups in bottom→top stacking order
  5295. group_names = [
  5296. "Disease-Associated Interneurons", # bottom
  5297. "Cholinergic Interneurons", # middle
  5298. "Non-Cholinergic Interneurons", # top
  5299. ]
  5301. # 2) Filter and tag each cell into one of those groups
  5302. mask = (
  5303. (adata.obs["cell_class"] == "Disease-Associated Interneurons") |
  5304. (adata.obs["cholinergic_type"] == "Cholinergic Interneurons") |
  5305. (adata.obs["cell_class"] == "Non-Cholinergic Interneurons")
  5306. )
  5307. df = adata.obs.loc[mask].copy()
  5308. df["cell_group"] = np.select(
  5309. [
  5310. df["cell_class"] == "Disease-Associated Interneurons",
  5311. df["cholinergic_type"] == "Cholinergic Interneurons",
  5312. df["cell_class"] == "Non-Cholinergic Interneurons",
  5313. ],
  5314. group_names
  5315. )
  5317. # 3) Count per (stage, cell_group)
  5318. stage_order = ["Control", "Early", "Mid", "End"]
  5319. counts = (
  5320. df
  5321. .groupby(["stage", "cell_group"], observed=True)
  5322. .size()
  5323. .unstack(fill_value=0)
  5324. .reindex(stage_order)
  5325. .fillna(0)
  5326. )
  5328. # 4) Proportions within each stage
  5329. props = counts.div(counts.sum(axis=1), axis=0)
  5331. # 5) Reorder columns to match stacking bottom→top
  5332. props = props[group_names]
  5334. # 6) Define colors in the same bottom→top order
  5335. colors = [
  5336. "#2ca02c", # DAI (bottom)
  5337. "#ff7f0e", # CI (middle)
  5338. "#9467bd", # NCI (top)
  5339. ]
  5341. # 7) Plot
  5342. fig, ax = plt.subplots(figsize=(1.625, 2.2852))
  5343. props.plot(
  5344. kind="bar",
  5345. stacked=True,
  5346. color=colors,
  5347. edgecolor="black",
  5348. ax=ax
  5349. )
  5351. # 8) Labels & legend
  5352. ax.set_xlabel("")
  5353. ax.set_ylabel("Proportion")
  5354. ax.set_xticklabels(stage_order, rotation=0)
  5355. ax.set_title("Interneurons")
  5357. short_labels = ["DAI", "CI", "NCI"]
  5358. ax.legend(
  5359. title="",
  5360. labels=short_labels,
  5361. loc="lower center",
  5362. bbox_to_anchor=(0.5, -0.35),
  5363. ncol=3,
  5364. columnspacing=0.5, # ↓ Reduce space between columns
  5365. handletextpad=0.3, # ↓ Reduce space between handle and text
  5366. borderpad=0.2, # ↓ Reduce border padding inside legend box
  5367. handlelength=1.0 # ↓ Optional: reduce legend key size
  5368. )
  5370. plt.tight_layout()
  5371. out_path = os.path.join(figures_dir, "interneuron_proportions_small.svg")
  5372. plt.savefig(out_path, format="svg", bbox_inches="tight")
  5373. plt.show()
  5375. # %%
  5376. print("\nProportions of each interneuron type by stage (percent):")
  5377. for stage in stage_order:
  5378. print(f"{stage}:")
  5379. for group in group_names:
  5380. pct = props.loc[stage, group]
  5381. print(f" {group}: {pct:.1%}")
  5383. # %% [markdown]
  5384. # ## Add additional metadata to all_anndata_final.h5ad
  5386. # %%
  5387. adata = sc.read_h5ad(os.path.join(working_dir, f"adata_objects/all_anndata_final.h5ad"))
  5388. adata_w_anno = sc.read_h5ad(os.path.join(working_dir, "adata_objects/all_anndata_final_rotated_w_anno.h5ad"))
  5390. # %%
  5391. adata.obs["predicted.id"] = (
  5392. adata.obs["predicted.id"]
  5393. .astype("category")
  5394. .cat.add_categories(["Not_Alpha_MN"])
  5395. .fillna("Not_Alpha_MN")
  5396. )
  5398. adata.obs["DAMN_status"] = (
  5399. adata.obs["DAMN_status"]
  5400. .astype("category")
  5401. .cat.add_categories(["Not_Alpha_MN"])
  5402. .fillna("Not_Alpha_MN")
  5403. )
  5405. # %%
  5406. cols_to_add = ["reactive_microglia", "reactive_or_wm_astrocytes"]
  5408. adata.obs[cols_to_add] = adata_w_anno.obs[cols_to_add].to_numpy()
  5410. # %%
  5411. # Make sure the needed columns exist
  5412. need = ["cell_class", "reactive_microglia", "reactive_or_wm_astrocytes"]
  5413. missing = [c for c in need if c not in adata.obs.columns]
  5414. if missing:
  5415. raise ValueError(f"Missing required columns in adata.obs: {missing}")
  5417. # Start with default
  5418. adata.obs["cell_class_reactivity"] = "Other"
  5420. # Cholinergic neurons
  5421. mask_chol = adata.obs["cell_class"] == "Cholinergic Neurons"
  5422. adata.obs.loc[mask_chol, "cell_class_reactivity"] = "Cholinergic Neurons"
  5424. # Microglia/Macrophages → Reactive vs Non-Reactive
  5425. mask_mg = adata.obs["cell_class"] == "Microglia/Macrophages"
  5426. adata.obs.loc[mask_mg & (adata.obs["reactive_microglia"] == True), "cell_class_reactivity"] = "Reactive MG"
  5427. adata.obs.loc[mask_mg & (adata.obs["reactive_microglia"] == False), "cell_class_reactivity"] = "Non-Reactive MG"
  5429. # Astrocytes → Reactive vs Non-Reactive
  5430. mask_ast = adata.obs["cell_class"] == "Astrocytes"
  5431. adata.obs.loc[mask_ast & (adata.obs["reactive_or_wm_astrocytes"] == True), "cell_class_reactivity"] = "Reactive Astrocytes"
  5432. adata.obs.loc[mask_ast & (adata.obs["reactive_or_wm_astrocytes"] == False), "cell_class_reactivity"] = "Non-Reactive Astrocytes"
  5434. # %%
  5435. # -------------------------------------------------
  5436. # Create combined DAMN / Reactivity annotation
  5437. # -------------------------------------------------
  5439. # Make sure required columns exist
  5440. need = ["DAMN_status", "cell_class_reactivity"]
  5441. missing = [c for c in need if c not in adata.obs.columns]
  5442. if missing:
  5443. raise ValueError(f"Missing required columns in adata.obs: {missing}")
  5445. # Initialize with default
  5446. adata.obs["DAMN_reactivity_class"] = "Other"
  5448. # DAMN motor neurons
  5449. adata.obs.loc[
  5450. adata.obs["DAMN_status"] == "DAMN",
  5451. "DAMN_reactivity_class"
  5452. ] = "DAMN"
  5454. # Non-DAMN motor neurons
  5455. adata.obs.loc[
  5456. adata.obs["DAMN_status"] == "Non-DAMN",
  5457. "DAMN_reactivity_class"
  5458. ] = "Non-DAMN"
  5460. # Reactive Microglia
  5461. adata.obs.loc[
  5462. adata.obs["cell_class_reactivity"] == "Reactive MG",
  5463. "DAMN_reactivity_class"
  5464. ] = "Reactive MG"
  5466. # Non-Reactive Microglia
  5467. adata.obs.loc[
  5468. adata.obs["cell_class_reactivity"] == "Non-Reactive MG",
  5469. "DAMN_reactivity_class"
  5470. ] = "Non-Reactive MG"
  5472. # Convert to ordered categorical (optional but recommended for Vizualizer)
  5473. adata.obs["DAMN_reactivity_class"] = pd.Categorical(
  5474. adata.obs["DAMN_reactivity_class"],
  5475. categories=["DAMN", "Non-DAMN", "Reactive MG", "Non-Reactive MG", "Other"],
  5476. ordered=True
  5477. )
  5479. # %%
  5480. # Save anndata
  5481. save_name = f"adata_objects/all_anndata_final_vizualizer.h5ad"
  5482. adata.write_h5ad(os.path.join(working_dir, save_name))
  5484. # %% [markdown]
  5485. # ## Save files to use with MERSCOPE Vizualizer
  5487. # %%
  5488. # Paths
  5489. input_file = os.path.join(working_dir, "adata_objects/all_anndata_final_vizualizer.h5ad")
  5490. output_dir = os.path.join(working_dir, "adata_objects_vizualizer")
  5492. # load full AnnData
  5493. adata = sc.read_h5ad(input_file)
  5495. # get all unique slide IDs
  5496. slide_ids = adata.obs["slide"].unique()
  5498. # loop through and save one file per slide
  5499. for slide_id in slide_ids:
  5500. # subset
  5501. ad = adata[adata.obs["slide"] == slide_id].copy()
  5502. # construct filename
  5503. # e.g. "202405281416_MsSpinalCord-...-VMSC15302.hdf5"
  5504. fname = f"{slide_id}.hdf5"
  5505. out_path = os.path.join(output_dir, fname)
  5506. # write
  5507. ad.write_h5ad(out_path)
  5508. print(f"Wrote {out_path}")
  5510. # %% [markdown]
  5511. # ## MN segmentations from parquet files
  5513. # %%
  5514. adata = sc.read_h5ad(os.path.join(working_dir, f"adata_objects/all_anndata_final_vizualizer.h5ad"))
  5516. # %%
  5517. import numpy as np
  5518. import matplotlib.pyplot as plt
  5519. import seaborn as sns
  5520. from skimage.filters import threshold_otsu
  5522. # -----------------------------
  5523. # Restrict to Alpha MNs
  5524. # -----------------------------
  5525. alpha_mask = adata.obs["cholinergic_type"] == "Alpha MNs"
  5527. # Pull DAPI values for Alpha MNs only
  5528. vals = adata.obs.loc[alpha_mask, "DAPI_high_pass"].values
  5529. log_vals = np.log10(vals + 1)
  5531. # -----------------------------
  5532. # Otsu threshold (Alpha MNs only)
  5533. # -----------------------------
  5534. thresh = threshold_otsu(log_vals)
  5535. print("Otsu log10(DAPI) threshold (Alpha MNs) =", thresh)
  5537. # Initialize column (False by default)
  5538. adata.obs["nuclear_alphaMN"] = False
  5540. # Assign nuclear status ONLY for Alpha MNs
  5541. adata.obs.loc[alpha_mask, "nuclear_alphaMN"] = (
  5542. np.log10(adata.obs.loc[alpha_mask, "DAPI_high_pass"].values + 1) >= thresh
  5543. )
  5545. # -----------------------------
  5546. # QC plot
  5547. # -----------------------------
  5548. plt.figure(figsize=(6,4))
  5549. sns.histplot(log_vals, bins=300, color="steelblue", edgecolor=None)
  5550. plt.axvline(thresh, color="red", linestyle="--", label=f"Otsu={thresh:.2f}")
  5551. plt.xlabel("log10(DAPI_high_pass + 1)")
  5552. plt.ylabel("Alpha MN count")
  5553. plt.legend()
  5554. plt.tight_layout()
  5555. plt.show()
  5557. # %% [markdown]
  5558. # ## Fig. S9A
  5560. # %%
  5561. import os, glob
  5562. import numpy as np
  5563. import pandas as pd
  5564. import matplotlib.pyplot as plt
  5565. from shapely import wkb
  5566. from scipy.spatial import cKDTree
  5567. from matplotlib.patches import Polygon as MplPolygon
  5569. # -----------------------------
  5570. # Paths / inputs
  5571. # -----------------------------
  5572. base = "/home/users/ogautier/oak/Shared/SOD1_Paper/Vizgen/mn_nonmn_segmentation/202401241200_HuSpinalCord-VS119-Lubmar-Ctrl3-SOD10_VMSC10802/analysis_outputs_7000_900"
  5573. tile_files = sorted(glob.glob(os.path.join(base, "result_tiles", "cell_*.parquet")))
  5574. FIG_DIR = "/home/users/ogautier/oak/Shared/SOD1_Paper/Vizgen/mn_nonmn_segmentation/figures"
  5575. os.makedirs(FIG_DIR, exist_ok=True)
  5577. # -----------------------------
  5578. # Filters / columns
  5579. # -----------------------------
  5580. slide_section_col = "slide_section"
  5581. mn_filter_col = "cholinergic_type"
  5582. mn_filter_value = "Alpha MNs"
  5583. nuclear_col = "nuclear_alphaMN"
  5584. nuclear_value = True
  5585. color_by_col = "predicted.id"
  5586. tol = 1.7
  5588. # -----------------------------
  5589. # Plot settings
  5590. # -----------------------------
  5591. plt.rcParams.update({
  5592. "font.size": 7,
  5593. "axes.titlesize": 7,
  5594. "axes.labelsize": 7,
  5595. "xtick.labelsize": 7,
  5596. "ytick.labelsize": 7,
  5597. "legend.fontsize": 7,
  5598. "legend.title_fontsize": 7,
  5599. "font.family": "DejaVu Sans",
  5600. "svg.fonttype": "path",
  5601. })
  5603. FIG_W_IN, FIG_H_IN = 4.875, 3.5
  5604. LEFT, RIGHT, BOTTOM, TOP = 0.06, 0.98, 0.18, 0.98
  5605. WSPACE, HSPACE = -0.035, -0.035
  5606. SPINE_LW = 0.9
  5608. BOX_SIZE_UM = 600
  5609. HALF = BOX_SIZE_UM / 2.0
  5611. LEGEND_ORDER = ["Slow-Firing", "Intermediate", "Fast-Firing", "Early DAMN", "Late DAMN"]
  5612. LEGEND_LABEL_MAP = {"Early DAMN": "Early DM", "Late DAMN": "Late DM"}
  5614. COLOR_MAP = {
  5615. "Slow-Firing": "#f47d2b",
  5616. "Intermediate": "#272e6a",
  5617. "Fast-Firing": "#208a42",
  5618. "Early DAMN": "#89288f",
  5619. "Late DAMN": "#d51f26"
  5620. }
  5622. # -----------------------------
  5623. # Checks
  5624. # -----------------------------
  5625. for col in [slide_section_col, mn_filter_col, nuclear_col, color_by_col]:
  5626. if col not in adata.obs.columns:
  5627. raise ValueError(f"adata.obs missing '{col}'")
  5628. if "spatial" not in adata.obsm.keys():
  5629. raise ValueError("adata.obsm missing 'spatial'")
  5631. sp = np.asarray(adata.obsm["spatial"])
  5632. tree = cKDTree(sp)
  5634. # -----------------------------
  5635. # Helpers
  5636. # -----------------------------
  5637. def is_R_prefix(adata_slide_section_vals, prefix):
  5638. suffix = pd.Series(adata_slide_section_vals.astype(str)).str.split("_").str[-1]
  5639. return suffix.str.startswith(prefix).values
  5641. def nuclear_alpha_mask(adata):
  5642. return (
  5643. (adata.obs[mn_filter_col].astype(str) == mn_filter_value) &
  5644. (adata.obs[nuclear_col].astype(bool) == nuclear_value)
  5645. )
  5647. def compute_centroids_from_wkb_bytes(wkb_bytes_arr):
  5648. cx = np.empty(len(wkb_bytes_arr), dtype=float)
  5649. cy = np.empty(len(wkb_bytes_arr), dtype=float)
  5650. ok = np.ones(len(wkb_bytes_arr), dtype=bool)
  5651. for i, b in enumerate(wkb_bytes_arr):
  5652. try:
  5653. g = wkb.loads(b)
  5654. c = g.centroid
  5655. cx[i] = c.x
  5656. cy[i] = c.y
  5657. except Exception:
  5658. ok[i] = False
  5659. cx[i] = np.nan
  5660. cy[i] = np.nan
  5661. return cx, cy, ok
  5663. def refine_center_fixed_window(centroids, half, n_iter=2):
  5664. if len(centroids) == 0:
  5665. return None
  5666. cx, cy = np.median(centroids[:, 0]), np.median(centroids[:, 1])
  5667. for _ in range(n_iter):
  5668. m = (
  5669. (centroids[:, 0] >= cx-half) & (centroids[:, 0] <= cx+half) &
  5670. (centroids[:, 1] >= cy-half) & (centroids[:, 1] <= cy+half)
  5671. )
  5672. if m.sum() == 0:
  5673. break
  5674. xs = centroids[m, 0]
  5675. ys = centroids[m, 1]
  5676. cx = (xs.min() + xs.max()) / 2.0
  5677. cy = (ys.min() + ys.max()) / 2.0
  5678. return cx, cy
  5680. def iter_polygons(g):
  5681. if g.geom_type == "Polygon":
  5682. yield g
  5683. elif g.geom_type == "MultiPolygon":
  5684. for p in g.geoms:
  5685. yield p
  5687. def add_geom_as_patches(ax, geom, facecolor, edgecolor="black", lw=0.35):
  5688. for poly in iter_polygons(geom):
  5689. x, y = poly.exterior.xy
  5690. coords = np.column_stack([x, y])
  5691. ax.add_patch(MplPolygon(
  5692. coords, closed=True,
  5693. facecolor=facecolor, edgecolor=edgecolor,
  5694. linewidth=lw, joinstyle="miter", capstyle="butt",
  5695. antialiased=True
  5696. ))
  5698. def count_nuclear_alphas_in_tile_for_group(tile_path, group_prefix, na_mask_values):
  5699. df = pd.read_parquet(tile_path)
  5700. if df.empty:
  5701. return 0, 0
  5702. df = df[df["Type"] == "cell"]
  5703. if df.empty:
  5704. return 0, 0
  5706. cx, cy, ok = compute_centroids_from_wkb_bytes(df["Geometry"].values)
  5707. cent = np.column_stack([cx, cy])[ok]
  5708. if cent.shape[0] == 0:
  5709. return 0, 0
  5711. dists, idx = tree.query(cent, k=1)
  5712. idx = idx[dists <= tol]
  5713. if idx.size == 0:
  5714. return 0, 0
  5716. ss_vals = adata.obs[slide_section_col].values[idx]
  5717. in_group = is_R_prefix(ss_vals, group_prefix)
  5718. idx_group = idx[in_group]
  5719. n_group = int(idx_group.size)
  5720. if n_group == 0:
  5721. return 0, 0
  5723. n_nuclear_alpha = int(na_mask_values[idx_group].sum())
  5724. return n_nuclear_alpha, n_group
  5726. def get_top_tiles_for_group(group_prefix, top_k=3):
  5727. na_mask_values = nuclear_alpha_mask(adata).values
  5728. rows = []
  5729. for tf in tile_files:
  5730. n_na, n_group = count_nuclear_alphas_in_tile_for_group(tf, group_prefix, na_mask_values)
  5731. rows.append({"tile": tf, "n_nuclear_alpha": n_na, "n_group_cells": n_group})
  5732. summ = (
  5733. pd.DataFrame(rows)
  5734. .sort_values(["n_nuclear_alpha", "n_group_cells"], ascending=False)
  5735. .reset_index(drop=True)
  5736. )
  5737. top = summ.head(top_k).copy()
  5738. if top["n_nuclear_alpha"].max() == 0:
  5739. raise ValueError(f"No nuclear Alpha MNs found for group {group_prefix}.")
  5740. return top
  5742. def load_tile_geoms_cats_centroids(tile_path, group_prefix):
  5743. df = pd.read_parquet(tile_path)
  5744. df = df[df["Type"] == "cell"].copy()
  5745. if df.empty:
  5746. return [], [], np.zeros((0, 2))
  5748. df["geom"] = df["Geometry"].apply(lambda b: wkb.loads(b) if b is not None else None)
  5749. df = df.dropna(subset=["geom"]).copy()
  5750. if df.empty:
  5751. return [], [], np.zeros((0, 2))
  5753. cent = np.column_stack([
  5754. df["geom"].apply(lambda g: g.centroid.x).to_numpy(),
  5755. df["geom"].apply(lambda g: g.centroid.y).to_numpy()
  5756. ])
  5758. dists, idx = tree.query(cent, k=1)
  5759. keep = dists <= tol
  5760. df = df.iloc[keep].copy()
  5761. cent = cent[keep]
  5762. idx = idx[keep]
  5763. if df.empty:
  5764. return [], [], np.zeros((0, 2))
  5766. ss_vals = adata.obs[slide_section_col].values[idx]
  5767. keep = is_R_prefix(ss_vals, group_prefix)
  5768. df = df.iloc[keep].copy()
  5769. cent = cent[keep]
  5770. idx = idx[keep]
  5771. if df.empty:
  5772. return [], [], np.zeros((0, 2))
  5774. na = nuclear_alpha_mask(adata).values[idx]
  5775. df = df.iloc[na].copy()
  5776. cent = cent[na]
  5777. idx = idx[na]
  5778. if df.empty:
  5779. return [], [], np.zeros((0, 2))
  5781. cats = adata.obs[color_by_col].astype(str).values[idx]
  5782. return df["geom"].tolist(), cats.tolist(), cent
  5784. # -----------------------------
  5785. # Select top tiles
  5786. # -----------------------------
  5787. top_end = get_top_tiles_for_group("R1", top_k=3)
  5788. top_ctl = get_top_tiles_for_group("R2", top_k=3)
  5790. control_tiles = top_ctl["tile"].tolist()
  5791. end_tiles = top_end["tile"].tolist()
  5793. # -----------------------------
  5794. # Build panels
  5795. # -----------------------------
  5796. panels = []
  5797. for t in control_tiles:
  5798. geoms, cats, cent = load_tile_geoms_cats_centroids(t, "R2")
  5799. panels.append(("Control", geoms, cats, cent))
  5800. for t in end_tiles:
  5801. geoms, cats, cent = load_tile_geoms_cats_centroids(t, "R1")
  5802. panels.append(("End", geoms, cats, cent))
  5804. # -----------------------------
  5805. # Plot montage (SVG)
  5806. # -----------------------------
  5807. fig = plt.figure(figsize=(FIG_W_IN, FIG_H_IN))
  5808. gs = fig.add_gridspec(
  5809. 2, 3,
  5810. left=LEFT, right=RIGHT,
  5811. bottom=BOTTOM, top=TOP,
  5812. wspace=WSPACE, hspace=HSPACE
  5813. )
  5814. axes = [[fig.add_subplot(gs[r, c]) for c in range(3)] for r in range(2)]
  5816. for i, (row, geoms, cats, cent) in enumerate(panels):
  5817. r = 0 if row == "Control" else 1
  5818. c = i % 3
  5819. ax = axes[r][c]
  5821. for g, cat in zip(geoms, cats):
  5822. fc = COLOR_MAP.get(cat, "#999999")
  5823. add_geom_as_patches(ax, g, facecolor=fc, edgecolor="black", lw=0.35)
  5825. center = refine_center_fixed_window(cent, HALF, n_iter=2)
  5826. if center is not None:
  5827. cx, cy = center
  5828. ax.set_xlim(cx - HALF, cx + HALF)
  5829. ax.set_ylim(cy + HALF, cy - HALF)
  5831. ax.set_aspect("equal")
  5832. ax.set_xticks([]); ax.set_yticks([])
  5834. for s in ax.spines.values():
  5835. s.set_visible(True)
  5836. s.set_linewidth(SPINE_LW)
  5837. s.set_color("black")
  5839. axes[0][0].text(-0.12, 0.5, "Control", transform=axes[0][0].transAxes,
  5840. rotation=90, va="center", ha="right")
  5841. axes[1][0].text(-0.12, 0.5, "End", transform=axes[1][0].transAxes,
  5842. rotation=90, va="center", ha="right")
  5844. handles = [
  5845. plt.Line2D([0], [0], marker='s', linestyle='',
  5846. markersize=6, markerfacecolor=COLOR_MAP[k],
  5847. markeredgecolor='none', label=LEGEND_LABEL_MAP.get(k, k))
  5848. for k in LEGEND_ORDER
  5849. ]
  5850. fig.legend(handles=handles, loc="lower center", ncol=len(handles),
  5851. frameon=False, bbox_to_anchor=(0.5, 0.04))
  5853. out_svg = os.path.join(
  5854. FIG_DIR,
  5855. "Control_End_MN_segmentations_DM.svg"
  5856. )
  5857. fig.savefig(out_svg)
  5858. plt.show()
  5860. # %% [markdown]
  5861. # ## Alpha motor neuron morphological changes
  5863. # %%
  5864. # Read in AnnData
  5865. adata = sc.read_h5ad(os.path.join(working_dir, f"adata_objects/alpha_anndata_label_transfer.h5ad"))
  5867. # %%
  5868. import numpy as np
  5869. from skimage.filters import threshold_otsu
  5870. import matplotlib.pyplot as plt
  5871. import seaborn as sns
  5873. # log10-transform
  5874. vals = adata.obs["DAPI_high_pass"].values
  5875. log_vals = np.log10(vals + 1)
  5877. # Otsu threshold on log-values
  5878. thresh = threshold_otsu(log_vals)
  5879. print("Otsu log10(DAPI) threshold =", thresh)
  5881. adata.obs["nuclear"] = log_vals >= thresh
  5883. # Plot with threshold line
  5884. plt.figure(figsize=(6,4))
  5885. sns.histplot(log_vals, bins=300, color="steelblue", edgecolor=None)
  5886. plt.axvline(thresh, color="red", linestyle="--", label=f"Otsu={thresh:.2f}")
  5887. plt.xlabel("log10(DAPI_high_pass + 1)")
  5888. plt.ylabel("Count")
  5889. plt.legend()
  5890. plt.tight_layout()
  5891. plt.show()
  5893. # %% [markdown]
  5894. # ## Fig. S9B
  5896. # %% [markdown]
  5897. # #### Control FF vs. SF volume
  5899. # %%
  5900. import os
  5901. import numpy as np
  5902. import pandas as pd
  5903. import matplotlib.pyplot as plt
  5904. import seaborn as sns
  5905. from scipy.stats import wilcoxon
  5907. # -----------------------------
  5908. # 0. Aesthetics
  5909. # -----------------------------
  5910. sns.set_theme(
  5911. style="ticks",
  5912. rc={
  5913. "font.size": 7,
  5914. "axes.titlesize": 7,
  5915. "axes.labelsize": 7,
  5916. "xtick.labelsize": 7,
  5917. "ytick.labelsize": 7,
  5918. "legend.fontsize": 7,
  5919. "legend.title_fontsize": 7,
  5920. "axes.linewidth": 0.5,
  5921. "xtick.major.width": 0.5,
  5922. "ytick.major.width": 0.5,
  5923. "pdf.fonttype": 42,
  5924. "ps.fonttype": 42,
  5925. "svg.fonttype": "path"
  5926. }
  5927. )
  5929. group_order = ["Fast-Firing", "Slow-Firing"]
  5930. group_colors = {
  5931. "Fast-Firing": "#2ca02c", # green
  5932. "Slow-Firing": "#ff7f0e" # orange
  5933. }
  5935. # -----------------------------
  5936. # 1. Prepare dataframe (Control, nuclear-only)
  5937. # -----------------------------
  5938. need_cols = ["slide_stage", "slide_section", "stage", "predicted.id", "volume", "nuclear"]
  5939. df = adata.obs[need_cols].copy()
  5941. df = df[df["nuclear"] == True].dropna(
  5942. subset=["slide_stage", "slide_section", "stage", "predicted.id", "volume"]
  5943. )
  5945. df = df[df["stage"] == "Control"].copy()
  5946. df = df[df["predicted.id"].isin(group_order)].copy()
  5948. # -----------------------------
  5949. # 2. Option A: section means -> slide means
  5950. # -----------------------------
  5951. sec_mean = (
  5952. df.groupby(["slide_section", "slide_stage", "predicted.id"], observed=True)
  5953. .agg(sec_mean_volume=("volume", "mean"))
  5954. .reset_index()
  5955. )
  5957. slide_mean = (
  5958. sec_mean.groupby(["slide_stage", "predicted.id"], observed=True)
  5959. .agg(mean_volume=("sec_mean_volume", "mean"))
  5960. .reset_index()
  5961. )
  5963. wide = slide_mean.pivot(
  5964. index="slide_stage",
  5965. columns="predicted.id",
  5966. values="mean_volume"
  5967. )
  5969. paired = wide.dropna(subset=group_order).copy()
  5971. # -----------------------------
  5972. # 3. Paired Wilcoxon signed-rank test (one-sided: SF < FF)
  5973. # -----------------------------
  5974. ff = paired["Fast-Firing"].values
  5975. sf = paired["Slow-Firing"].values
  5977. if len(paired) >= 2:
  5978. res = wilcoxon(
  5979. sf,
  5980. ff,
  5981. alternative="less", # Slow-Firing < Fast-Firing
  5982. zero_method="wilcox"
  5983. )
  5984. p = res.pvalue
  5985. else:
  5986. p = np.nan
  5988. print(f"Paired Wilcoxon test (Slow-Firing < Fast-Firing): p = {p:.3e}")
  5990. # convert to star
  5991. if not np.isfinite(p):
  5992. star = "na"
  5993. elif p < 0.001:
  5994. star = "***"
  5995. elif p < 0.01:
  5996. star = "**"
  5997. elif p < 0.05:
  5998. star = "*"
  5999. else:
  6000. star = "ns"
  6002. # -----------------------------
  6003. # 4. Long format for plotting
  6004. # -----------------------------
  6005. long_means = (
  6006. paired.reset_index()
  6007. .melt(
  6008. id_vars="slide_stage",
  6009. value_vars=group_order,
  6010. var_name="group",
  6011. value_name="mean_volume"
  6012. )
  6013. )
  6015. x_positions = {g: i for i, g in enumerate(group_order)}
  6017. # -----------------------------
  6018. # 5. Boxplot + paired lines
  6019. # -----------------------------
  6020. fig, ax = plt.subplots(figsize=(1.625, 1.7))
  6022. sns.boxplot(
  6023. data=long_means,
  6024. x="group",
  6025. y="mean_volume",
  6026. order=group_order,
  6027. palette=[group_colors[g] for g in group_order],
  6028. showfliers=False,
  6029. width=0.6,
  6030. linewidth=0.8,
  6031. ax=ax
  6032. )
  6034. sns.stripplot(
  6035. data=long_means,
  6036. x="group",
  6037. y="mean_volume",
  6038. order=group_order,
  6039. color="black",
  6040. size=4,
  6041. jitter=0.12,
  6042. alpha=0.8,
  6043. ax=ax
  6044. )
  6046. # connect paired points
  6047. for slide, sub in long_means.groupby("slide_stage"):
  6048. if set(sub["group"]) == set(group_order):
  6049. x1 = x_positions["Fast-Firing"]
  6050. y1 = sub.loc[sub["group"] == "Fast-Firing", "mean_volume"].iloc[0]
  6051. x2 = x_positions["Slow-Firing"]
  6052. y2 = sub.loc[sub["group"] == "Slow-Firing", "mean_volume"].iloc[0]
  6053. ax.plot([x1, x2], [y1, y2], lw=1, c="gray", alpha=0.7)
  6055. # aesthetics
  6056. ax.grid(False)
  6057. for spine in ax.spines.values():
  6058. spine.set_color("black")
  6060. # ↓↓↓ Shorter ticks (Option 2 incorporated here) ↓↓↓
  6061. ax.tick_params(axis="both", which="major", length=2, width=0.5)
  6063. ax.set_xlabel("")
  6064. ax.set_ylabel("Volume")
  6065. ax.set_title("Control")
  6066. ax.set_xticklabels(["FF", "SF"])
  6068. # -----------------------------
  6069. # Stats bracket (ORIGINAL geometry)
  6070. # -----------------------------
  6071. data_min = long_means["mean_volume"].min()
  6072. data_max = long_means["mean_volume"].max()
  6073. data_range = max(1e-12, data_max - data_min)
  6075. y_base = data_max * 1.02
  6076. y_step = 0.12 * data_range
  6077. h = 0.25 * y_step
  6079. x1, x2 = x_positions["Fast-Firing"], x_positions["Slow-Firing"]
  6081. ax.plot(
  6082. [x1, x1, x2, x2],
  6083. [y_base, y_base + h, y_base + h, y_base],
  6084. lw=1.2, c="k"
  6085. )
  6087. ax.text(
  6088. (x1 + x2) / 2,
  6089. y_base + h * 1.05,
  6090. star,
  6091. ha="center",
  6092. va="bottom",
  6093. fontsize=7
  6094. )
  6096. ymin, ymax = ax.get_ylim()
  6097. ax.set_ylim(ymin, max(ymax, y_base + y_step * 1.3))
  6099. plt.tight_layout()
  6101. # -----------------------------
  6102. # 6. Save plot
  6103. # -----------------------------
  6104. out_svg = os.path.join(figures_dir, "control_FF_vs_SF_volume_paired_wilcoxon.svg")
  6105. out_png = os.path.join(figures_dir, "control_FF_vs_SF_volume_paired_wilcoxon.png")
  6107. fig.savefig(out_svg, format="svg", dpi=300, bbox_inches="tight", transparent=True)
  6108. fig.savefig(out_png, format="png", dpi=300, bbox_inches="tight", transparent=True)
  6110. plt.show()
  6112. # %% [markdown]
  6113. # ## Fig. S9C
  6115. # %% [markdown]
  6116. # #### Volume changes with disease stage
  6118. # %%
  6119. import os
  6120. import numpy as np
  6121. import pandas as pd
  6122. import matplotlib.pyplot as plt
  6123. import seaborn as sns
  6124. from scipy.stats import mannwhitneyu
  6125. from statsmodels.stats.multitest import multipletests
  6126. from statannotations.Annotator import Annotator
  6128. # ------------------ Config ------------------
  6129. order = ["Control", "Early", "Mid", "End"]
  6130. comparisons = [("Early", "Control"), ("Mid", "Control"), ("End", "Control")]
  6132. stage_colors = {
  6133. "Control": "#1f77b4",
  6134. "Early": "#ff7f0e",
  6135. "Mid": "#d62728",
  6136. "End": "#2ca02c"
  6137. }
  6139. # ------------------ Global aesthetics ------------------
  6140. sns.set_theme(
  6141. style="ticks",
  6142. rc={
  6143. "font.size": 7,
  6144. "axes.titlesize": 7,
  6145. "axes.labelsize": 7,
  6146. "xtick.labelsize": 7,
  6147. "ytick.labelsize": 7,
  6148. "legend.fontsize": 7,
  6149. "legend.title_fontsize": 7,
  6150. "axes.linewidth": 0.5,
  6151. "xtick.major.width": 0.5,
  6152. "ytick.major.width": 0.5,
  6153. "pdf.fonttype": 42,
  6154. "ps.fonttype": 42,
  6155. "svg.fonttype": "path"
  6156. }
  6157. )
  6159. # ------------------ Load & clean (NUCLEAR ONLY) ------------------
  6160. df = (
  6161. adata.obs[['slide_stage', 'slide_section', 'stage', 'volume', 'nuclear']]
  6162. .copy()
  6163. .dropna(subset=['slide_stage', 'slide_section', 'stage', 'volume', 'nuclear'])
  6164. )
  6166. df = df[df['nuclear'] == True].copy()
  6167. df = df.drop(columns=['nuclear'])
  6169. df['stage'] = df['stage'].astype(str).str.strip()
  6170. df['volume'] = pd.to_numeric(df['volume'], errors='coerce')
  6171. df = df.dropna(subset=['volume'])
  6172. df = df[df['stage'].isin(order)].copy()
  6174. # ------------------ Option A: slide_section means -> slide_stage means ------------------
  6175. sec_mean = (
  6176. df.groupby(['slide_section', 'slide_stage', 'stage'], observed=True)
  6177. .agg(sec_mean_volume=('volume', 'mean'))
  6178. .reset_index()
  6179. )
  6181. stage_per_slide = (
  6182. df.groupby('slide_stage')['stage']
  6183. .agg(['nunique', 'first'])
  6184. .rename(columns={'nunique': 'n_stage_labels', 'first': 'stage'})
  6185. .reset_index()
  6186. )
  6188. bad = stage_per_slide[stage_per_slide['n_stage_labels'] != 1]
  6189. if len(bad):
  6190. print("[WARN] Some slide_stage have multiple stage labels; using the first label:")
  6191. print(bad.head())
  6193. stage_per_slide = stage_per_slide[['slide_stage', 'stage']]
  6195. slide_mean = (
  6196. sec_mean.groupby('slide_stage', observed=True)
  6197. .agg(mean_volume=('sec_mean_volume', 'mean'))
  6198. .reset_index()
  6199. )
  6201. per_slide = slide_mean.merge(stage_per_slide, on='slide_stage', how='left')
  6202. per_slide = per_slide[per_slide['stage'].isin(order)].copy()
  6203. per_slide['stage'] = pd.Categorical(per_slide['stage'], categories=order, ordered=True)
  6205. print("Slides per stage:")
  6206. print(per_slide.groupby('stage')['slide_stage'].nunique(), "\n")
  6208. # ------------------ Build arrays for tests ------------------
  6209. stage_arrays = {
  6210. g: per_slide.loc[per_slide['stage'].eq(g), 'mean_volume'].to_numpy()
  6211. for g in order
  6212. }
  6213. for g in order:
  6214. print(f"{g}: n_slides = {len(stage_arrays[g])}")
  6216. # ------------------ Statistics (MWU one-sided + Bonferroni) ------------------
  6217. rows = []
  6218. for s_label, ctl_label in comparisons:
  6219. x = stage_arrays[s_label]
  6220. y = stage_arrays[ctl_label]
  6222. if len(x) >= 1 and len(y) >= 1:
  6223. try:
  6224. p = mannwhitneyu(x, y, alternative='less', method='asymptotic').pvalue
  6225. except TypeError:
  6226. p = mannwhitneyu(x, y, alternative='less').pvalue
  6227. else:
  6228. p = np.nan
  6230. rows.append((s_label, ctl_label, p))
  6232. res = pd.DataFrame(rows, columns=['stage', 'control', 'p_raw'])
  6234. mask = res['p_raw'].notna()
  6235. res['p_adj'] = np.nan
  6236. if mask.any():
  6237. _, p_adj, _, _ = multipletests(res.loc[mask, 'p_raw'], method='bonferroni')
  6238. res.loc[mask, 'p_adj'] = p_adj
  6240. print(res, "\n")
  6242. # p-values in the same order as `comparisons`
  6243. pvals_adj = [res.loc[i, 'p_adj'] for i in range(len(comparisons))]
  6245. # ------------------ Plot ------------------
  6246. fig, ax = plt.subplots(figsize=(1.625, 1.8))
  6248. sns.boxplot(
  6249. data=per_slide,
  6250. x='stage',
  6251. y='mean_volume',
  6252. order=order,
  6253. palette=[stage_colors[s] for s in order],
  6254. showfliers=False,
  6255. width=0.6,
  6256. linewidth=0.8,
  6257. ax=ax
  6258. )
  6260. sns.stripplot(
  6261. data=per_slide,
  6262. x='stage',
  6263. y='mean_volume',
  6264. order=order,
  6265. color='black',
  6266. size=4,
  6267. jitter=0.15,
  6268. alpha=0.8,
  6269. ax=ax
  6270. )
  6272. ax.grid(False)
  6273. for spine in ax.spines.values():
  6274. spine.set_color("black")
  6276. # shorter ticks (same as your other panels)
  6277. ax.tick_params(axis="both", which="major", length=2, width=0.5)
  6279. ax.set_xlabel("")
  6280. ax.set_ylabel("Volume")
  6281. ax.set_title("All")
  6283. for label in ax.get_xticklabels():
  6284. label.set_rotation(90)
  6286. # ------------------ Stat annotations (automatic bracket geometry) ------------------
  6287. annotator = Annotator(
  6288. ax,
  6289. comparisons,
  6290. data=per_slide,
  6291. x="stage",
  6292. y="mean_volume",
  6293. order=order
  6294. )
  6295. annotator.configure(
  6296. test=None,
  6297. text_format="star",
  6298. loc="inside", # same behavior as your good-looking example
  6299. fontsize=6 # your request
  6300. )
  6301. annotator.set_pvalues(pvals_adj)
  6302. annotator.annotate()
  6304. ax.set_yticks([7500, 10000, 12500, 15000, 17500])
  6306. plt.tight_layout()
  6308. # ------------------ Save ------------------
  6309. out_svg = os.path.join(figures_dir, "stage_volume_per_slide_nuclear_wilcoxon_bonferroni.svg")
  6310. out_png = os.path.join(figures_dir, "stage_volume_per_slide_nuclear_wilcoxon_bonferroni.png")
  6312. fig.savefig(out_svg, dpi=300, bbox_inches='tight', transparent=True)
  6313. fig.savefig(out_png, dpi=300, bbox_inches='tight', transparent=True)
  6315. plt.show()
  6316. print("Saved:", out_svg, "and", out_png)
  6318. # %% [markdown]
  6319. # ## Fig. S9D
  6321. # %%
  6322. import os
  6323. import numpy as np
  6324. import pandas as pd
  6325. import matplotlib.pyplot as plt
  6326. impo

14. MERFISH spatial transcriptomics analysis.ipynb at commit 10e89db, no license · at the source

Overview

Authors: Olivia Gautier1,2,3, Jacob A. Blum1,3, Thao P. Nguyen1, Shaolong Cao4, Sandy Klemm1, Mai Yamakawa5, Dann Huh4, Jessica A. Hurt4, Nasa Sinnott-Armstrong6,7,8, Yi Zeng1,9, Chung-ha O. Davis10, Juliane Bombosch1, Chang Liu1, Lisa N. Encarnacion1, Kevin A. Guttenplan11, Derek Chen1, Arwa Kathiria1, Luke Zhao1, Stephen Moore12, Alex Meng13
and 6 other authorsKailee Ong13, Don W. Cleveland12, John Ravits13, Jessica E. Rexach5,14, William J. Greenleaf1,15,9, Aaron D. Gitler1,9,16,17
ORCID iDs: Yi Zeng, Chang Liu, Alex Meng, Aaron D. Gitler
17 affiliations
  1. Department of Genetics, Stanford University School of Medicine, Stanford, CA 94305, USA
  2. Stanford Neurosciences Graduate Program, Stanford University School of Medicine, Stanford, CA 94305, USA
  3. These authors contributed equally
  4. Research, Biogen Inc., Cambridge, MA 02142, USA
  5. Program in Neurogenetics, Department of Neurology, David Geffen School of Medicine, University of California, Los Angeles, Los Angeles, CA 90095, USA
  6. Herbold Computational Biology Program, Public Health Sciences Division, Fred Hutchinson Cancer Center, Seattle, WA 98195, USA
  7. Department of Genome Sciences, University of Washington, Seattle, WA 98195, USA
  8. Brotman Baty Institute, University of Washington, Seattle, WA 98195, USA
  9. Biohub – San Francisco, San Francisco, CA 94158, USA
  10. Department of Neurobiology, Stanford University, Stanford, CA 94305, USA
  11. Vollum Institute, Oregon Health and Sciences University, Portland, OR 97239, USA
  12. Departments of Cellular and Molecular Medicine, University of California, San Diego, La Jolla, CA 92093, USA
  13. Department of Neurosciences, University of California, San Diego, La Jolla, CA 92093, USA
  14. Department of Human Genetics, David Geffen School of Medicine, University of California, Los Angeles, Los Angeles, CA 90095, USA
  15. Department of Applied Physics, Stanford University, Stanford, CA 94305, USA
  16. The Phil and Penny Knight Initiative for Brain Resilience, Stanford University, Stanford, CA 94305, USA
  17. Lead contact
Institutions: Stanford Medicine (United States); Stanford University (United States); Biogen (United States) (United States); University of California, Los Angeles (United States); University of Washington (United States); Fred Hutch Cancer Center (United States); Brotman Baty Institute (United States); Oregon Health & Science University (United States); Vollum Institute (United States); University of California San Diego (United States)
Journal: Cell, volume 189, issue 16, pages 5044-5064.e12
Dates: published online 23 June 2026; in print 6 August 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1016/j.cell.2026.05.047 · PMID 42335888 · PMCID PMC13446465 · OpenAlex W7165678572
Open access: hybrid, a free copy (OpenAlex)
Status: code verified
Categories: genetics / omics (modality), human (organism), mouse (organism), other condition (population), cellular / molecular (subfield)
Methods: Connectivity, Spectral & time-frequency, Statistics, Smoothing, state filtering, decompositions, Preprocessing, Machine learning
Keywords: Spinal cord, Motor neuron, Neurodegeneration, ALS, Microglial Activation, Selective Vulnerability, Cell States, Spatial Transcriptomics, Snrna-seq, Snatac-seq
MeSH: Amyotrophic Lateral Sclerosis*, Motor Neurons*, Animals, Cell Death, Disease Models, Animal, Female, Humans, Male, Mice, Mice, Transgenic, Spinal Cord, Superoxide Dismutase-1, Transcription Factors, Transcriptome (* major topic)
Topic: Amyotrophic Lateral Sclerosis Research (Neurology, Medicine), according to OpenAlex
Funding: NINDS NIH HHS (R35 NS137159, RF1 NS128800, U54 NS123743, R01 NS128028); National Institutes of Health; NCRR NIH HHS (S10 RR025518); NIA NIH HHS (R01 AG075802, R01 AG064690); NHGRI NIH HHS (RM1 HG010461)
Citations: cited by 3 papers (Europe PMC); 137 references in the paper
Research resources: RRID:AB_2687461, ATF-3 (D2Y5W) Rabbit Monoclonal Antibody RRID:AB_2799039, ATF3 plasmid (TFORF0801) RRID:Addgene_141707, CREB3-V5 plasmid (TFORF3311) RRID:Addgene_144787, mCherry plasmid (TFORF3550) RRID:Addgene_145026, SOD1-G93A mice RRID:IMSR_JAX:002726, ChAT-IRES- Cre mice RRID:IMSR_JAX:006410, ROSAnT-nG mice RRID:IMSR_JAX:023035, B6SJLF1/J mice RRID:IMSR_JAX:100012

Abstract

To define molecular determinants of motor neuron degeneration in amyotrophic lateral sclerosis (ALS), we generated longitudinal single-nucleus transcriptomes and chromatin accessibility profiles of spinal motor neurons together with spatial transcriptomics from the SOD1-G93A mouse model. Vulnerable alpha motor neurons showed thousands of molecular changes, marking a transition into a distinct cell state we named “disease-associated motor neurons” (DMs). We identified transcription factor networks that govern how healthy cells transition into DMs and those associated with motor neuron subtype-selective vulnerability. Upregulation of DM-associated transcription factors in human motor neurons induced key features of DMs, demonstrating an active regulatory component. Human ALS spinal cord single-nucleus RNA sequencing data demonstrated conservation of the DM signature in alpha motor neurons, and human orthologs of regions differentially accessible in SOD1-G93A mouse motor neurons were enriched for ALS genetic risk variants. Together, these findings establish a conserved, genetically linked motor neuron signature in ALS.

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

Repository

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

omgautier/Gautier_Blum_2026

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 10e89dba3fdbd6b3f9d642a161995d913d6bed0e, 23 June 2026
Languages: Jupyter (16)
Size: 17 files, 16 scripts
Software Heritage: not checked
Found in: “Data and code availability”
Holds: README, 16 notebooks
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: tidyverse (13 files), cowplot (12 files), ggpubr (12 files), pheatmap (12 files), Seurat (12 files), ggplot2 (7 files), DESeq2 (6 files), broom (4 files), anndata (1 file), Matplotlib (1 file), NumPy (1 file), pandas (1 file), Scanpy (1 file), scikit-image (1 file), SciPy (1 file), seaborn (1 file), Squidpy (1 file), statannotations (1 file), statsmodels (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
14 files
At the source: github.com/omgautier/Gautier_Blum_2026

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:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 14 scripts, each with its path and the digest of its content;
  • 40 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 and code availability

Raw and processed sequencing data have been deposited in the NCBI Gene Expression Omnibus (GEO) under accession numbers GEO: GSE306676 for the snRNA-seq data and GEO: GSE306675 for the multiome (paired snATAC/snRNA-seq) data. An interactive web portal for exploring the snRNA-seq dataset is available at http://www.spinalcordatlas.org. The processed MERFISH spatial transcriptomics data are available on Zenodo: https://doi.org/10.5281/zenodo.16938739.

Original code is available on GitHub: https://github.com/omgautier/Gautier_Blum_2026.

Any additional information required to reanalyze the data reported in this paper is available from the lead contact upon request.

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 2, 28 September 2026

  • Publisher: n/a → Cell Press

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 26 authors, 10 keywords, 14 MeSH terms, 5 funders, 137 references, 9 RRIDs.

Cite

This paper

Gautier, O., Blum, J. A., Nguyen, T. P., Cao, S., Klemm, S., Yamakawa, M., Huh, D., Hurt, J. A., Sinnott-Armstrong, N., Zeng, Y., Davis, C.-h. O., Bombosch, J., Liu, C., Encarnacion, L. N., Guttenplan, K. A., Chen, D., Kathiria, A., Zhao, L., Moore, S., . . . Gitler, A. D. (2026). An emergent disease-associated motor neuron state precedes cell death in ALS. Cell, 189(16), 5044-5064.e12. https://doi.org/10.1016/j.cell.2026.05.047

BibTeX

@article{gautier2026emergent,
author = {Gautier, Olivia and Blum, Jacob A. and Nguyen, Thao P. and Cao, Shaolong and Klemm, Sandy and Yamakawa, Mai and Huh, Dann and Hurt, Jessica A. and Sinnott-Armstrong, Nasa and Zeng, Yi and Davis, Chung-ha O. and Bombosch, Juliane and Liu, Chang and Encarnacion, Lisa N. and Guttenplan, Kevin A. and Chen, Derek and Kathiria, Arwa and Zhao, Luke and Moore, Stephen and Meng, Alex and Ong, Kailee and Cleveland, Don W. and Ravits, John and Rexach, Jessica E. and Greenleaf, William J. and Gitler, Aaron D.},
title = {{An emergent disease-associated motor neuron state precedes cell death in ALS}},
journal = {Cell},
year = {2026},
month = jun,
volume = {189},
number = {16},
pages = {5044--5064.e12},
publisher = {Cell Press},
issn = {0092-8674},
doi = {10.1016/j.cell.2026.05.047},
url = {https://doi.org/10.1016/j.cell.2026.05.047},
pmid = {42335888},
pmcid = {PMC13446465}
}

RIS

TY - JOUR
AU - Gautier, Olivia
AU - Blum, Jacob A.
AU - Nguyen, Thao P.
AU - Cao, Shaolong
AU - Klemm, Sandy
AU - Yamakawa, Mai
AU - Huh, Dann
AU - Hurt, Jessica A.
AU - Sinnott-Armstrong, Nasa
AU - Zeng, Yi
AU - Davis, Chung-ha O.
AU - Bombosch, Juliane
AU - Liu, Chang
AU - Encarnacion, Lisa N.
AU - Guttenplan, Kevin A.
AU - Chen, Derek
AU - Kathiria, Arwa
AU - Zhao, Luke
AU - Moore, Stephen
AU - Meng, Alex
AU - Ong, Kailee
AU - Cleveland, Don W.
AU - Ravits, John
AU - Rexach, Jessica E.
AU - Greenleaf, William J.
AU - Gitler, Aaron D.
TI - An emergent disease-associated motor neuron state precedes cell death in ALS
T2 - Cell
J2 - Cell
PY - 2026
DA - 2026/06/23
VL - 189
IS - 16
SP - 5044
EP - 5064.e12
SN - 0092-8674
PB - Cell Press
DO - 10.1016/j.cell.2026.05.047
UR - https://doi.org/10.1016/j.cell.2026.05.047
LA - en
ER -

CSL-JSON

{
"id": "10.1016/j.cell.2026.05.047",
"type": "article-journal",
"title": "An emergent disease-associated motor neuron state precedes cell death in ALS",
"container-title": "Cell",
"author": [
{
"family": "Gautier",
"given": "Olivia"
},
{
"family": "Blum",
"given": "Jacob A."
},
{
"family": "Nguyen",
"given": "Thao P."
},
{
"family": "Cao",
"given": "Shaolong"
},
{
"family": "Klemm",
"given": "Sandy"
},
{
"family": "Yamakawa",
"given": "Mai"
},
{
"family": "Huh",
"given": "Dann"
},
{
"family": "Hurt",
"given": "Jessica A."
},
{
"family": "Sinnott-Armstrong",
"given": "Nasa"
},
{
"family": "Zeng",
"given": "Yi"
},
{
"family": "Davis",
"given": "Chung-ha O."
},
{
"family": "Bombosch",
"given": "Juliane"
},
{
"family": "Liu",
"given": "Chang"
},
{
"family": "Encarnacion",
"given": "Lisa N."
},
{
"family": "Guttenplan",
"given": "Kevin A."
},
{
"family": "Chen",
"given": "Derek"
},
{
"family": "Kathiria",
"given": "Arwa"
},
{
"family": "Zhao",
"given": "Luke"
},
{
"family": "Moore",
"given": "Stephen"
},
{
"family": "Meng",
"given": "Alex"
},
{
"family": "Ong",
"given": "Kailee"
},
{
"family": "Cleveland",
"given": "Don W."
},
{
"family": "Ravits",
"given": "John"
},
{
"family": "Rexach",
"given": "Jessica E."
},
{
"family": "Greenleaf",
"given": "William J."
},
{
"family": "Gitler",
"given": "Aaron D."
}
],
"container-title-short": "Cell",
"volume": "189",
"issue": "16",
"page": "5044-5064.e12",
"DOI": "10.1016/j.cell.2026.05.047",
"PMID": "42335888",
"PMCID": "PMC13446465",
"ISSN": "0092-8674",
"publisher": "Cell Press",
"URL": "https://doi.org/10.1016/j.cell.2026.05.047",
"language": "en",
"issued": {
"date-parts": [
[
2026,
6,
23
]
]
}
}

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.1038/s41593-026-02300-5 [code]
Integrated single-cell and spatial transcriptomic profiling in ALS uncovers peripheral-to-central immune infiltration and reprogramming.
Journal: Nature neuroscience
In common: Squidpy, anndata, DESeq2, 11 other tools, genetics / omics, other condition, cellular / molecular, 6 references
[2] doi:10.1186/s13024-026-00944-2
TDP-43: [GU]-ardian of the transcriptome.
Journal: Molecular neurodegeneration
In common: genetics / omics, other condition, cellular / molecular, 15 references
[3] 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: anndata, DESeq2, Scanpy, 12 other tools, genetics / omics, other condition, cellular / molecular, 5 references
[4] doi:10.1038/s42003-026-10034-0 [code]
Region- and cell type-specific changes in gene expression in the cerebellum after classical fear conditioning.
Journal: Communications biology
In common: Squidpy, anndata, DESeq2, 12 other tools, genetics / omics, mouse, cellular / molecular, 3 references
[5] 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: Squidpy, anndata, DESeq2, 12 other tools, genetics / omics, mouse, cellular / molecular, 2 references
[6] doi:10.1038/s41586-026-10629-x [code]
Whole-genome duplication shaped cell-type evolution in the vertebrate brain.
Journal: Nature
In common: anndata, DESeq2, Scanpy, 12 other tools, genetics / omics, mouse, cellular / molecular, 3 references
[7] doi:10.1016/j.isci.2026.116906 [code]
Evaluating exon skipping in the central nervous system in Duchenne muscular dystrophy using spatial transcriptomics.
Journal: iScience
In common: Squidpy, statannotations, anndata, 10 other tools, genetics / omics, other condition, mouse, 3 references
[8] doi:10.1002/imt2.70163 [code]
Spatial multi-omics unveils sphingolipid metabolic reprogramming within the retinal pathological niche.
Journal: iMeta
In common: anndata, DESeq2, Scanpy, 12 other tools, genetics / omics, mouse, cellular / molecular, 2 references
[9] doi:10.1038/s41514-026-00391-9 [code]
Region-specific transcriptional signatures of brain aging in the absence of neuropathology at the single-cell level.
Journal: npj aging
In common: anndata, broom, Scanpy, 11 other tools, genetics / omics, cellular / molecular, 4 references
[10] doi:10.1186/s13059-026-04177-w [code]
Genomic sequence evolution underlying human neocortical interareal diversification.
Journal: Genome biology
In common: Squidpy, anndata, Scanpy, 10 other tools, genetics / omics, mouse, cellular / molecular, 3 references

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.