OSCR

Morphometric analysis reveals that the chick cranial neural tube expands as an active shell.

Code ↔ Paper

16 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 16 matches · 1 of them tie a paragraph to a whole file, not to given lines: a weak match, whose lines are not tinted
  1. [1] § Materials and methods › Finite element modeling ↔ finite_element/fem_plane_stress.py, lines 1–40 · score 1.00 · plane stress finite, shear modulus, rational quadratic, membrane stress, nodal forces, hoop stress
  2. [2] § Materials and methods › Neural tube segmentation ↔ src/spatchcocking/sectioning_utils.py, the whole file · a weak match · score 0.83 · marching cubes, Volumetric segmentation, post processed, napari, Fiji, Slicer
  3. [3] § Materials and methods › Neural tube segmentation ↔ notebooks/01_mesh_generation.ipynb, lines 1–38 · score 0.82 · gamma correction, marching cubes, manual refinement, local thresholding, inner lumen, Fiji
  4. [4] § Materials and methods › Proliferation analysis ↔ notebooks/04_pHH3_density_mapping.ipynb, lines 61–115 · score 0.76 · density field, point cloud, mesh vertex, basal mesh, spots, stacks
  5. [5] § Results › Spatial patterns of mitotic activity are preserved across global expansion ↔ notebooks/06_figure_plots.ipynb, lines 965–1098 · score 0.75 · phospho histone H3, inverse distance weighting, mitotic cells, pHH3, local density, radius
  6. [6] § Materials and methods › Proliferation analysis ↔ notebooks/04_pHH3_density_mapping.py, lines 68–109 · score 0.72 · density field, point cloud, mesh vertex, spots, stacks, radius
  7. [7] § Materials and methods › Tissue shape and morphometric analysis ↔ src/spatchcocking/spatchcocking_utils.py, lines 389–455 · score 0.70 · adjacent vertices, quadratic surface, local neighborhood, fitted, Gaussian, curvature
  8. [8] § Materials and methods › Spatchcocking transformation ↔ notebooks/05_spatchcocking.ipynb, lines 124–176 · score 0.63 · thin plate spline, medial axis, deformation, cross, dorsal, Spatchcocking
  9. [9] § Materials and methods › Spatchcocking transformation ↔ src/spatchcocking/spatchcocking_utils.py, lines 525–606 · score 0.58 · MLS smoothing, medial axis, iterative, spatchcocking, Vedo, mesh
  10. [10] § Materials and methods › Tissue shape and morphometric analysis ↔ notebooks/06_figure_plots.ipynb, lines 726–859 · score 0.56 · Euclidean distance, lumen surface, surface mesh, Tissue thickness, nearest, scalar
  11. [11] § Results › Cranial neural tube enlargement is accompanied by significant lumen rounding ↔ notebooks/01_mesh_generation.ipynb, lines 1–38 · score 0.55 · manual refinement, local thresholding, inner lumen, triangular, neural tube, segmented
  12. [12] § Materials and methods › Chick embryo collection ↔ notebooks/06_figure_plots.ipynb, lines 246–291 · score 0.54 · Fold changes, Surface area, inter, SA, ratio, FB
  13. [13] § Materials and methods › Chick embryo collection ↔ notebooks/06_figure_plots.py, lines 245–290 · score 0.54 · Fold changes, Surface area, inter, SA, ratio, FB
  14. [14] § Results › Surface curvature mapping reveals that brain compartmentalization is defined by localized constrictions amid global inflation ↔ notebooks/06_figure_plots.ipynb, lines 293–428 · score 0.54 · dorso ventral, rostral caudal, Gaussian curvature, DV profiles, Spatchcocked, RC
  15. [15] § Results › Standardized 2D mapping enables direct comparison of local neuroepithelium properties across developmental stages ↔ src/spatchcocking/spatchcocking_utils.py, lines 1–37 · score 0.54 · medial axis extracted, manifold, biological, neural tube, flattening, spatchcocking
  16. [16] § Materials and methods › Statistical analysis ↔ notebooks/06_figure_plots.ipynb, lines 1213–1257 · score 0.51 · quantile bins, Pearson correlation, Spearman, width, compartments, DV

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 · 1,989 lines · 67 KB · MIT · 5 matches

  1. # %% [markdown]
  2. # Connected to ni-plots (Python 3.14.2)
  4. # %% [markdown]
  5. # # Figure reproduction from CSV data
  6. #
  7. # This script reproduces the statistical figures from the paper using the
  8. # pre-computed CSV files in `../data/csv/`. No mesh processing is required —
  9. # all vertex-level measurements have already been extracted via the spatchcocking
  10. # pipeline (notebooks 02–05) and saved as CSV.
  11. #
  12. # | Figure | Content | CSV file |
  13. # |---|---|---|
  14. # | Fig 1j | Cross-section area profile along RC axis | `cross_section_area.csv` |
  15. # | Fig 1e–i | Fold changes: length, SA, volume, SA/V ratio | `compartment_lengths.csv`, `lumen_geometry.csv` |
  16. # | Fig 3g | Gaussian curvature DV profiles per vesicle | `spatchcocked_measurements.csv` |
  17. # | Fig 4c,f,g | Mean curvature: global comparison, DV profiles | `spatchcocked_measurements.csv` |
  18. # | Fig 5c,f,g | Tissue thickness: global comparison, DV profiles | `spatchcocked_measurements.csv` |
  19. # | Fig 6c,f,g | pHH3 mitotic density: global comparison, DV profiles | `spatchcocked_measurements.csv` |
  20. # | Supp Fig 1 | Absolute geometry, fold changes, correlations | all CSVs |
  21. #
  22. # **Dependencies** (in addition to the main spatchcocking environment):
  23. # `statannotations` — install with `pip install statannotations`
  24. #
  25. # **Run in VS Code**: open this file and use "Run Cell" (Shift+Enter) per block,
  26. # or "Run All Cells" from the Jupyter toolbar. Each `# %%` block is one cell.
  27. # Outputs are saved as SVG files alongside this script.
  29. # %% [markdown]
  30. # ## Figure 1 — Lumen geometry
  31. #
  32. # **Fig 1j** — Cross-sectional area of the lumen plotted against normalised
  33. # rostral-caudal position. Each point is the mean area at one z-position;
  34. # shaded band = ±1 SD across embryos. HH17 (blue) and HH20 (red).
  35. #
  36. # **CSV**: `cross_section_area.csv`
  37. # Columns: `z_grid` (µm along RC axis), `area` (µm²), `stage`, `type`
  38. # (`individual` = per-embryo datapoints used for statistics).
  40. # %%
  41. import pandas as pd
  42. import seaborn as sns
  43. import matplotlib.pyplot as plt
  44. import matplotlib.ticker as ticker
  46. sns.set_style("ticks")
  48. fontsize = 10
  50. plt.rcParams.update({
  51. 'font.size': 10,
  52. 'axes.labelsize': 10,
  53. 'axes.linewidth': 1.5,
  54. 'xtick.major.width': 1.5,
  55. 'ytick.major.width': 1.5,
  56. 'xtick.major.size': 6,
  57. 'ytick.major.size': 6,
  58. 'xtick.direction': 'out',
  59. 'ytick.direction': 'out',
  60. 'xtick.labelsize': 10,
  61. 'ytick.labelsize': 10,
  62. 'svg.fonttype': 'none',
  63. 'font.family': 'sans-serif',
  64. 'font.sans-serif': ['Arial']
  65. })
  67. dpival = 100
  69. csv_filename = '../data/csv/cross_section_area.csv'
  70. df = pd.read_csv(csv_filename)
  72. labels = ['HH17', 'HH20']
  73. palette = {'HH17': '#2c7bb6', 'HH20': '#d7191c'}
  75. fig, ax = plt.subplots(figsize=(3, 5), dpi=dpival)
  77. for label in labels:
  78. stage_df = df[(df['stage'] == label) & (df['type'] == 'individual')]
  80. if stage_df.empty:
  81. continue
  83. stats = stage_df.groupby('z_grid')['area'].agg(['mean', 'std']).reset_index()
  85. stats['mean_smooth'] = stats['mean'].rolling(window=10, center=True).mean()
  86. stats['std_smooth'] = stats['std'].rolling(window=10, center=True).mean()
  87. stats = stats.dropna()
  89. ax.fill_betweenx(stats['z_grid'],
  90. stats['mean_smooth'] - stats['std_smooth'],
  91. stats['mean_smooth'] + stats['std_smooth'],
  92. color=palette[label], alpha=0.15, linewidth=0)
  94. ax.plot(stats['mean_smooth'], stats['z_grid'],
  95. color=palette[label], lw=3.0, label=label)
  97. x_step = 1e5
  98. ax.xaxis.set_major_locator(ticker.MultipleLocator(x_step))
  99. x_fmt = ticker.ScalarFormatter(useMathText=True)
  100. x_fmt.set_scientific(True)
  101. x_fmt.set_powerlimits((5, 5))
  102. ax.xaxis.set_major_formatter(x_fmt)
  104. y_fmt = ticker.ScalarFormatter(useMathText=True)
  105. y_fmt.set_scientific(True)
  106. y_fmt.set_powerlimits((3, 3))
  107. ax.yaxis.set_major_formatter(y_fmt)
  109. ax.set_ylabel(r'Rostral-Caudal Distance [$\mu$m]')
  110. ax.set_xlabel(r'Cross-section Area [$\mu$m$^2$]')
  111. ax.set_xlim(left=0)
  112. ax.set_ylim(bottom=0)
  114. sns.despine()
  116. ax.legend(title=" ", frameon=False, fontsize=fontsize, title_fontsize=fontsize,
  117. bbox_to_anchor=(1.02, 1), loc='upper left')
  119. plt.tight_layout()
  120. plt.savefig('__csarea-over-rclength.svg', format='svg', bbox_inches='tight')
  121. plt.show()
  123. # %% [markdown]
  124. # **Fig 1e–g** — Fold changes in total length, surface area, and volume
  125. # (each embryo normalised to the HH17 group mean = 1.0).
  126. # Welch t-test between stages; bracket = significance level.
  127. #
  128. # **Fig 1h–i** — Fold change in SA per compartment, and raw SA/V ratio per
  129. # compartment (FB = forebrain, MB = midbrain, HB = hindbrain).
  130. # Within-compartment (HH17 vs HH20) and inter-compartment (HH20 vs HH20)
  131. # comparisons are shown.
  132. #
  133. # **CSVs**:
  134. # - `compartment_lengths.csv` — columns: `stage`, `end` (total length µm),
  135. # `mhb` (midbrain–hindbrain boundary µm), `fmb` (fore–midbrain boundary µm)
  136. # - `lumen_geometry.csv` — columns: `Stage`, `Region`, `Area` (µm²), `Volume` (µm³)
  138. # %%
  139. import pandas as pd
  140. import matplotlib.pyplot as plt
  141. import matplotlib.ticker as ticker
  142. import seaborn as sns
  143. from scipy import stats
  145. sns.set_style("ticks")
  147. plt.rcParams.update({
  148. 'font.size': 10,
  149. 'axes.labelsize': 10,
  150. 'axes.titlesize': 10,
  151. 'axes.linewidth': 1.5,
  152. 'xtick.major.width': 1.5,
  153. 'ytick.major.width': 1.5,
  154. 'xtick.major.size': 6,
  155. 'ytick.major.size': 6,
  156. 'xtick.direction': 'out',
  157. 'ytick.direction': 'out',
  158. 'xtick.labelsize': 10,
  159. 'ytick.labelsize': 10,
  160. 'svg.fonttype': 'none',
  161. 'font.family': 'sans-serif',
  162. 'font.sans-serif': ['Arial']
  163. })
  165. dpival = 100
  166. PALETTE = {'HH17': '#3182bd', 'HH20': '#de2d26'}
  167. COMPARTMENTS = ['Forebrain', 'Midbrain', 'Hindbrain']
  168. STAGES = ['HH17', 'HH20']
  170. def set_common_style(ax, xlabel, ylabel):
  171. """Applies consistent L-frame (linewidths handled by rcParams)."""
  172. ax.spines['top'].set_visible(False)
  173. ax.spines['right'].set_visible(False)
  174. ax.set_xlabel(xlabel)
  175. ax.set_ylabel(ylabel)
  177. def add_external_stat(ax, x1, x2, level, p_val):
  178. """Adds brackets OUTSIDE the axis."""
  179. base_y = 1.05
  180. step = 0.08
  181. y = base_y + (level * step)
  183. ax.plot([x1, x1, x2, x2], [y, y+0.02, y+0.02, y],
  184. color='black', clip_on=False, transform=ax.get_xaxis_transform())
  186. if p_val < 0.001: text = '***'
  187. elif p_val < 0.01: text = '**'
  188. elif p_val < 0.05: text = '*'
  189. else: text = 'ns'
  191. ax.text((x1+x2)*0.5, y+0.02, text, ha='center', va='bottom',
  192. transform=ax.get_xaxis_transform())
  194. # Length Data
  195. df_len = pd.read_csv('../data/csv/compartment_lengths.csv')
  196. df_len['stage'] = df_len['stage'].astype(str).str.upper()
  197. df_len['Total Length'] = df_len['end']
  199. hh17_mean_len = df_len[df_len['stage'] == 'HH17']['Total Length'].mean()
  200. df_len_fc = df_len.copy()
  201. df_len_fc['Total Length FC'] = df_len['Total Length'] / hh17_mean_len
  203. # Area & Volume Data
  204. df_av = pd.read_csv("../data/csv/lumen_geometry.csv")
  205. df_av['Stage'] = df_av['Stage'].astype(str).str.upper()
  206. df_av['SA_Vol_Ratio'] = df_av['Area'] / df_av['Volume']
  208. df_av_fc = df_av.copy()
  209. for metric in ['Area', 'Volume']:
  210. for reg in COMPARTMENTS:
  211. hh17_mean = df_av[(df_av['Stage'] == 'HH17') & (df_av['Region'] == reg)][metric].mean()
  212. mask = df_av['Region'] == reg
  213. df_av_fc.loc[mask, metric] = df_av.loc[mask, metric] / hh17_mean
  216. # FIGURE 1: Total Fold Changes (Length, Area, Volume)
  217. fig1, axes1 = plt.subplots(1, 3, figsize=(4.3, 2), dpi=dpival)
  219. fc_stage_configs = [
  220. (df_len_fc, 'stage', 'Total Length FC', 'Fold Change (Length)', 0),
  221. (df_av_fc, 'Stage', 'Area', 'Fold Change (Surface Area)', 1),
  222. (df_av_fc, 'Stage', 'Volume', 'Fold Change (Volume)', 2)
  223. ]
  225. for df_plot, x_col, y_col, ylabel, i in fc_stage_configs:
  226. ax = axes1[i]
  227. sns.boxplot(data=df_plot, x=x_col, y=y_col, hue=x_col, palette=PALETTE,
  228. width=0.5, order=STAGES, legend=False, ax=ax)
  230. ax.axhline(1.0, color='black', linestyle='--', alpha=0.7)
  232. g1 = df_plot[df_plot[x_col] == 'HH17'][y_col]
  233. g2 = df_plot[df_plot[x_col] == 'HH20'][y_col]
  234. _, p = stats.ttest_ind(g1, g2)
  235. add_external_stat(ax, 0, 1, 0, p)
  237. set_common_style(ax, ' ', ylabel)
  239. axes1[2].set_ylim(top=20)
  241. fig1.subplots_adjust(top=0.95, bottom=0.05, left=0.10, right=0.95, wspace=0.7)
  242. fig1.savefig("__fig1_total_fold_changes.svg", format='svg', bbox_inches='tight')
  243. plt.show()
  246. # FIGURE 2: Fold Change SA & SA/Vol Ratio by Compartment
  247. fig2, axes2 = plt.subplots(1, 2, figsize=(5.5, 2), dpi=dpival)
  249. ax_fc_area = axes2[0]
  250. sns.boxplot(data=df_av_fc, x='Region', y='Area', hue='Stage',
  251. order=COMPARTMENTS, palette=PALETTE, width=0.6, ax=ax_fc_area)
  252. ax_fc_area.axhline(1.0, color='black', linestyle='--', alpha=0.7)
  253. set_common_style(ax_fc_area, ' ', 'Fold Change (Surface Area)')
  254. ax_fc_area.legend_.remove()
  256. ax_ratio = axes2[1]
  257. sns.boxplot(data=df_av, x='Region', y='SA_Vol_Ratio', hue='Stage',
  258. order=COMPARTMENTS, palette=PALETTE, width=0.6, ax=ax_ratio)
  259. set_common_style(ax_ratio, ' ', r'Surface Area / Volume Ratio [$\mu$m$^{-1}$]')
  260. ax_ratio.set_ylim(top=2.5e-2)
  262. fmt = ticker.ScalarFormatter(useMathText=True)
  263. fmt.set_scientific(True)
  264. fmt.set_powerlimits((-2, -2))
  265. ax_ratio.yaxis.set_major_formatter(fmt)
  267. ax_ratio.legend(frameon=False, loc='upper left', bbox_to_anchor=(1, 1))
  269. inter_comps = [(0, 1, 1), (1, 2, 1), (0, 2, 2)]
  271. for ax, df_plot, metric in [(ax_fc_area, df_av_fc, 'Area'), (ax_ratio, df_av, 'SA_Vol_Ratio')]:
  272. for i, comp in enumerate(COMPARTMENTS):
  273. d1 = df_plot[(df_plot['Region'] == comp) & (df_plot['Stage'] == 'HH17')][metric]
  274. d2 = df_plot[(df_plot['Region'] == comp) & (df_plot['Stage'] == 'HH20')][metric]
  275. _, p = stats.ttest_ind(d1, d2)
  276. add_external_stat(ax, i - 0.15, i + 0.15, 0, p)
  278. for (idx1, idx2, level) in inter_comps:
  279. c1, c2 = COMPARTMENTS[idx1], COMPARTMENTS[idx2]
  280. d1 = df_plot[(df_plot['Region'] == c1) & (df_plot['Stage'] == 'HH20')][metric]
  281. d2 = df_plot[(df_plot['Region'] == c2) & (df_plot['Stage'] == 'HH20')][metric]
  282. _, p = stats.ttest_ind(d1, d2)
  283. add_external_stat(ax, idx1 + 0.2, idx2 + 0.2, level, p)
  285. for ax in axes2:
  286. ax.set_xticks([0, 1, 2])
  287. ax.set_xticklabels(['FB', 'MB', 'HB'])
  289. fig2.subplots_adjust(top=0.95, bottom=0.05, left=0.08, right=0.80, wspace=0.5)
  290. fig2.savefig("__fig2_compartment_sa_and_ratio.svg", format='svg', bbox_inches='tight')
  291. plt.show()
  293. # %% [markdown]
  294. # ## Figure 3 — Gaussian curvature DV profiles
  295. #
  296. # **Fig 3g** — Dorso-ventral profiles of Gaussian curvature *K* [µm⁻²] for each
  297. # brain vesicle (forebrain, midbrain, hindbrain). Line = mean across embryos;
  298. # shaded band = ±1 SD. Angle θ = 0° is dorsal, ±180° is ventral.
  299. #
  300. # Compartments are defined by normalised rostral-caudal position (`norm_height`):
  301. # - HH17: FB > 0.80, MB 0.60–0.80, HB < 0.60
  302. # - HH20: FB > 0.75, MB 0.55–0.75, HB < 0.55
  303. #
  304. # **CSV**: `spatchcocked_measurements.csv`
  305. # Each row is one mesh vertex from one embryo, with columns:
  306. # `stage`, `timepoint` (embryo ID), `norm_height`, `angle_degrees`,
  307. # `Gauss_Curvature`, `Mean_Curvature`, `K1`, `K2`, `thickness`, `phh3`
  309. # %%
  310. import pandas as pd
  311. import numpy as np
  312. import seaborn as sns
  313. import matplotlib.pyplot as plt
  314. import matplotlib.ticker as ticker
  316. sns.set_theme(style="ticks")
  318. plt.rcParams.update({
  319. 'font.size': 10,
  320. 'axes.labelsize': 10,
  321. 'axes.titlesize': 10,
  322. 'axes.titleweight': 'normal',
  323. 'axes.labelweight': 'normal',
  324. 'axes.linewidth': 1.5,
  325. 'xtick.major.width': 1.5,
  326. 'ytick.major.width': 1.5,
  327. 'xtick.major.size': 6,
  328. 'ytick.major.size': 6,
  329. 'xtick.direction': 'out',
  330. 'ytick.direction': 'out',
  331. 'xtick.labelsize': 10,
  332. 'ytick.labelsize': 10,
  333. 'svg.fonttype': 'none',
  334. 'font.family': 'sans-serif',
  335. 'font.sans-serif': ['Arial']
  336. })
  338. TARGET_METRIC = 'Gauss_Curvature'
  340. property_map = {
  341. 'Gauss_Curvature': r'Gaussian Curvature [$\mu m^{-2}$]',
  342. 'Mean_Curvature': r'Mean Curvature [$\mu m^{-1}$]',
  343. 'K1': r'K1 [$\mu m^{-1}$]',
  344. 'K2': r'K2 [$\mu m^{-1}$]',
  345. 'thickness': r'Thickness [$\mu m$]',
  346. 'phh3': 'Local pH3+ cell count'
  347. }
  349. master_csv = "../data/csv/spatchcocked_measurements.csv"
  350. df = pd.read_csv(master_csv)
  352. df['stage'] = df['stage'].astype(str).str.upper()
  354. df['Compartment'] = None
  356. mask_hh17 = df['stage'] == 'HH17'
  357. df.loc[mask_hh17 & (df['norm_height'] < 0.6), 'Compartment'] = 'Hindbrain'
  358. df.loc[mask_hh17 & (df['norm_height'] >= 0.6) & (df['norm_height'] <= 0.8), 'Compartment'] = 'Midbrain'
  359. df.loc[mask_hh17 & (df['norm_height'] > 0.8), 'Compartment'] = 'Forebrain'
  361. mask_hh20 = df['stage'] == 'HH20'
  362. df.loc[mask_hh20 & (df['norm_height'] < 0.55), 'Compartment'] = 'Hindbrain'
  363. df.loc[mask_hh20 & (df['norm_height'] >= 0.55) & (df['norm_height'] <= 0.75), 'Compartment'] = 'Midbrain'
  364. df.loc[mask_hh20 & (df['norm_height'] > 0.75), 'Compartment'] = 'Forebrain'
  366. df['angle_bin'] = pd.cut(df['angle_degrees'], bins=np.arange(-180, 190, 10))
  367. df['angle_bin_center'] = df['angle_bin'].apply(lambda x: x.mid).astype(float)
  369. stage_palette = {"HH17": "#3182bd", "HH20": "#de2d26"}
  370. compartments = ['Forebrain', 'Midbrain', 'Hindbrain']
  371. ylabel = property_map[TARGET_METRIC]
  373. fig, axes = plt.subplots(1, 3, figsize=(6.7, 2.6), sharey=True, dpi=100)
  375. for i, comp in enumerate(compartments):
  376. comp_data = df[df['Compartment'] == comp]
  377. ax = axes[i]
  379. sns.lineplot(
  380. data=comp_data,
  381. x='angle_bin_center',
  382. y=TARGET_METRIC,
  383. hue='stage',
  384. palette=stage_palette,
  385. linewidth=2.5,
  386. errorbar='sd',
  387. ax=ax
  388. )
  390. ax.set_title(comp, pad=10)
  391. ax.set_xlabel('Dorso-ventral axis')
  392. ax.set_xticks([-180, -90, 0, 90, 180])
  393. ax.set_xlim(-180, 180)
  395. if i == 0:
  396. ax.set_ylabel(ylabel)
  397. else:
  398. ax.set_ylabel('')
  400. if i == 2:
  401. ax.legend(title=' ', loc='best', frameon=False)
  402. else:
  403. ax.get_legend().remove()
  405. if 'Curvature' in TARGET_METRIC or TARGET_METRIC in ['K1', 'K2']:
  406. ax.axhline(0, color='black', linestyle='--', linewidth=1, alpha=0.5)
  408. for spine in ax.spines.values():
  409. spine.set_visible(True)
  411. if 'Curvature' in TARGET_METRIC or TARGET_METRIC in ['K1', 'K2']:
  412. ymin, ymax = axes[0].get_ylim()
  413. abs_max = max(abs(ymin), abs(ymax))
  414. axes[0].set_ylim(bottom=-abs_max, top=abs_max)
  416. if TARGET_METRIC in ['thickness', 'phh3']:
  417. axes[0].set_ylim(bottom=0)
  419. formatter = ticker.ScalarFormatter(useMathText=True)
  420. formatter.set_scientific(True)
  421. formatter.set_powerlimits((-2, 3))
  422. axes[0].yaxis.set_major_formatter(formatter)
  424. plt.tight_layout()
  425. save_path = f"__compartment_plot_{TARGET_METRIC}.svg"
  426. plt.savefig(save_path, format='svg', bbox_inches='tight')
  427. print(f"Plot saved: {save_path}")
  428. plt.show()
  430. # %% [markdown]
  431. # ## Figure 4 — Mean curvature
  432. #
  433. # **Fig 4c** — Global mean curvature *H* [µm⁻¹] comparison between HH17 and
  434. # HH20. Each data point is the per-embryo mean; Welch t-test annotated with
  435. # stars (statannotations library).
  436. #
  437. # **Fig 4f** — DV profiles of *H* per vesicle (same layout as Fig 3g).
  438. #
  439. # **Fig 4g** — Overall DV profile of *H* pooling all three vesicles.
  441. # %%
  442. import pandas as pd
  443. import numpy as np
  444. import seaborn as sns
  445. import matplotlib.pyplot as plt
  446. import matplotlib.ticker as ticker
  448. sns.set_theme(style="ticks")
  450. plt.rcParams.update({
  451. 'font.size': 10,
  452. 'axes.labelsize': 10,
  453. 'axes.titlesize': 10,
  454. 'axes.titleweight': 'normal',
  455. 'axes.labelweight': 'normal',
  456. 'axes.linewidth': 1.5,
  457. 'xtick.major.width': 1.5,
  458. 'ytick.major.width': 1.5,
  459. 'xtick.major.size': 6,
  460. 'ytick.major.size': 6,
  461. 'xtick.direction': 'out',
  462. 'ytick.direction': 'out',
  463. 'xtick.labelsize': 10,
  464. 'ytick.labelsize': 10,
  465. 'svg.fonttype': 'none',
  466. 'font.family': 'sans-serif',
  467. 'font.sans-serif': ['Arial']
  468. })
  470. TARGET_METRIC = 'Mean_Curvature'
  472. property_map = {
  473. 'Gauss_Curvature': r'Gaussian Curvature [$\mu m^{-2}$]',
  474. 'Mean_Curvature': r'Mean Curvature [$\mu m^{-1}$]',
  475. 'K1': r'K1 [$\mu m^{-1}$]',
  476. 'K2': r'K2 [$\mu m^{-1}$]',
  477. 'thickness': r'Thickness [$\mu m$]',
  478. 'phh3': 'Local pH3+ cell count'
  479. }
  481. master_csv = "../data/csv/spatchcocked_measurements.csv"
  482. df = pd.read_csv(master_csv)
  484. df['stage'] = df['stage'].astype(str).str.upper()
  486. df['Compartment'] = None
  488. mask_hh17 = df['stage'] == 'HH17'
  489. df.loc[mask_hh17 & (df['norm_height'] < 0.6), 'Compartment'] = 'Hindbrain'
  490. df.loc[mask_hh17 & (df['norm_height'] >= 0.6) & (df['norm_height'] <= 0.8), 'Compartment'] = 'Midbrain'
  491. df.loc[mask_hh17 & (df['norm_height'] > 0.8), 'Compartment'] = 'Forebrain'
  493. mask_hh20 = df['stage'] == 'HH20'
  494. df.loc[mask_hh20 & (df['norm_height'] < 0.55), 'Compartment'] = 'Hindbrain'
  495. df.loc[mask_hh20 & (df['norm_height'] >= 0.55) & (df['norm_height'] <= 0.75), 'Compartment'] = 'Midbrain'
  496. df.loc[mask_hh20 & (df['norm_height'] > 0.75), 'Compartment'] = 'Forebrain'
  498. df['angle_bin'] = pd.cut(df['angle_degrees'], bins=np.arange(-180, 190, 10))
  499. df['angle_bin_center'] = df['angle_bin'].apply(lambda x: x.mid).astype(float)
  501. stage_palette = {"HH17": "#3182bd", "HH20": "#de2d26"}
  502. compartments = ['Forebrain', 'Midbrain', 'Hindbrain']
  503. ylabel = property_map[TARGET_METRIC]
  505. fig, axes = plt.subplots(1, 3, figsize=(6.7, 2.6), sharey=True, dpi=100)
  507. for i, comp in enumerate(compartments):
  508. comp_data = df[df['Compartment'] == comp]
  509. ax = axes[i]
  511. sns.lineplot(
  512. data=comp_data,
  513. x='angle_bin_center',
  514. y=TARGET_METRIC,
  515. hue='stage',
  516. palette=stage_palette,
  517. linewidth=2.5,
  518. errorbar='sd',
  519. ax=ax
  520. )
  522. ax.set_title(comp, pad=10)
  523. ax.set_xlabel('Dorso-ventral axis')
  524. ax.set_xticks([-180, -90, 0, 90, 180])
  525. ax.set_xlim(-180, 180)
  527. if i == 0:
  528. ax.set_ylabel(ylabel)
  529. else:
  530. ax.set_ylabel('')
  532. if i == 2:
  533. ax.legend(title=' ', loc='best', frameon=False)
  534. else:
  535. ax.get_legend().remove()
  537. if 'Curvature' in TARGET_METRIC or TARGET_METRIC in ['K1', 'K2']:
  538. ax.axhline(0, color='black', linestyle='--', linewidth=1, alpha=0.5)
  540. for spine in ax.spines.values():
  541. spine.set_visible(True)
  543. if 'Curvature' in TARGET_METRIC or TARGET_METRIC in ['K1', 'K2']:
  544. ymin, ymax = axes[0].get_ylim()
  545. abs_max = max(abs(ymin), abs(ymax))
  546. axes[0].set_ylim(top=abs_max)
  548. if TARGET_METRIC in ['thickness', 'phh3']:
  549. axes[0].set_ylim(bottom=0)
  551. formatter = ticker.ScalarFormatter(useMathText=True)
  552. formatter.set_scientific(True)
  553. formatter.set_powerlimits((-2, 3))
  554. axes[0].yaxis.set_major_formatter(formatter)
  556. plt.tight_layout()
  557. save_path = f"__compartment_plot_{TARGET_METRIC}.svg"
  558. plt.savefig(save_path, format='svg', bbox_inches='tight')
  559. print(f"Plot saved: {save_path}")
  560. plt.show()
  562. # %%
  563. import pandas as pd
  564. import numpy as np
  565. import seaborn as sns
  566. import matplotlib.pyplot as plt
  567. import matplotlib.ticker as ticker
  569. sns.set_theme(style="ticks")
  571. plt.rcParams.update({
  572. 'font.size': 10,
  573. 'axes.labelsize': 10,
  574. 'axes.titlesize': 10,
  575. 'axes.titleweight': 'normal',
  576. 'axes.labelweight': 'normal',
  577. 'axes.linewidth': 1.5,
  578. 'xtick.major.width': 1.5,
  579. 'ytick.major.width': 1.5,
  580. 'xtick.major.size': 6,
  581. 'ytick.major.size': 6,
  582. 'xtick.direction': 'out',
  583. 'ytick.direction': 'out',
  584. 'xtick.labelsize': 10,
  585. 'ytick.labelsize': 10,
  586. 'svg.fonttype': 'none',
  587. 'font.family': 'sans-serif',
  588. 'font.sans-serif': ['Arial']
  589. })
  591. TARGET_METRIC = 'Mean_Curvature'
  593. property_map = {
  594. 'Gauss_Curvature': r'Gaussian Curvature [$\mu m^{-2}$]',
  595. 'Mean_Curvature': r'Mean Curvature [$\mu m^{-1}$]',
  596. 'K1': r'K1 [$\mu m^{-1}$]',
  597. 'K2': r'K2 [$\mu m^{-1}$]',
  598. 'thickness': r'Thickness [$\mu m$]',
  599. 'phh3': 'Local pH3+ cell count'
  600. }
  602. master_csv = "../data/csv/spatchcocked_measurements.csv"
  603. df = pd.read_csv(master_csv)
  605. df['stage'] = df['stage'].astype(str).str.upper()
  607. df['angle_bin'] = pd.cut(df['angle_degrees'], bins=np.arange(-180, 190, 10))
  608. df['angle_bin_center'] = df['angle_bin'].apply(lambda x: x.mid).astype(float)
  610. stage_palette = {"HH17": "#3182bd", "HH20": "#de2d26"}
  611. ylabel = property_map.get(TARGET_METRIC, TARGET_METRIC)
  613. fig, ax = plt.subplots(figsize=(2.4, 2.8), dpi=100)
  615. sns.lineplot(
  616. data=df,
  617. x='angle_bin_center',
  618. y=TARGET_METRIC,
  619. hue='stage',
  620. palette=stage_palette,
  621. linewidth=3,
  622. errorbar='sd',
  623. ax=ax
  624. )
  626. ax.set_xlabel('Dorso-ventral axis')
  627. ax.set_ylabel(ylabel)
  629. ax.set_xticks([-180, -90, 0, 90, 180])
  630. ax.set_xlim(-180, 180)
  632. if 'Curvature' in TARGET_METRIC or TARGET_METRIC in ['K1', 'K2']:
  633. ax.axhline(0, color='black', linestyle='--', linewidth=1.5, alpha=0.6, zorder=1)
  635. ax.spines['top'].set_visible(False)
  636. ax.spines['right'].set_visible(False)
  638. ax.legend(title=' ', loc='best', frameon=False)
  640. if 'Curvature' in TARGET_METRIC or TARGET_METRIC in ['K1', 'K2']:
  641. ymin, ymax = ax.get_ylim()
  642. abs_max = max(abs(ymin), abs(ymax))
  643. ax.set_ylim(top=abs_max)
  645. if TARGET_METRIC in ['thickness', 'phh3']:
  646. ax.set_ylim(bottom=0)
  648. formatter = ticker.ScalarFormatter(useMathText=True)
  649. formatter.set_scientific(True)
  650. formatter.set_powerlimits((-2, 3))
  651. ax.yaxis.set_major_formatter(formatter)
  653. plt.tight_layout()
  655. save_path = f"__overall_dv_plot_{TARGET_METRIC}.svg"
  656. plt.savefig(save_path, format='svg', bbox_inches='tight')
  657. print(f"Overall plot saved: {save_path}")
  658. plt.show()
  660. # %%
  661. import pandas as pd
  662. import matplotlib.pyplot as plt
  663. import matplotlib.ticker as ticker
  664. import seaborn as sns
  665. from statannotations.Annotator import Annotator
  667. TARGET_METRIC = 'Mean_Curvature'
  668. Y_LABEL = r'Mean Curvature [$\mu m^{-1}$]'
  670. FONT_SIZE = 10
  672. plt.rcParams.update({
  673. 'svg.fonttype': 'none',
  674. 'font.size': FONT_SIZE,
  675. 'axes.labelsize': FONT_SIZE,
  676. 'xtick.labelsize': FONT_SIZE,
  677. 'ytick.labelsize': FONT_SIZE,
  678. 'legend.fontsize': FONT_SIZE,
  679. 'axes.titlesize': FONT_SIZE,
  680. 'axes.linewidth': 1.5,
  681. 'xtick.major.width': 1.5,
  682. 'ytick.major.width': 1.5,
  683. 'font.family': 'sans-serif',
  684. 'font.sans-serif': ['Arial']
  685. })
  687. palette = {'HH17': '#2c7bb6', 'HH20': '#d7191c'}
  689. df = pd.read_csv("../data/csv/spatchcocked_measurements.csv")
  690. df['stage'] = df['stage'].astype(str).str.upper()
  691. median_df = df.groupby(['timepoint', 'stage'])[TARGET_METRIC].mean().reset_index()
  693. fig, ax = plt.subplots(figsize=(2.4, 2.8), dpi=100)
  694. order = ['HH17', 'HH20']
  696. sns.boxplot(data=median_df, x='stage', y=TARGET_METRIC, palette=palette, order=order, width=0.5, ax=ax, fliersize=0)
  698. annotator = Annotator(ax, [("HH17", "HH20")], data=median_df, x='stage', y=TARGET_METRIC, order=order)
  699. annotator.configure(test='t-test_ind', text_format='star', loc='outside')
  700. annotator.apply_and_annotate()
  702. ax.spines['top'].set_visible(False)
  703. ax.spines['right'].set_visible(False)
  704. ax.spines['left'].set_linewidth(1.5)
  705. ax.spines['bottom'].set_linewidth(1.5)
  707. ax.set_ylabel(Y_LABEL)
  708. ax.set_xlabel(" ")
  710. ymin, ymax = ax.get_ylim()
  711. abs_max = max(abs(ymin), abs(ymax))
  712. ax.set_ylim(bottom=0, top=abs_max)
  714. ax.axhline(0, color='black', linestyle='--', linewidth=1.5, alpha=0.5, zorder=0)
  716. fmt = ticker.ScalarFormatter(useMathText=True)
  717. fmt.set_scientific(True)
  718. fmt.set_powerlimits((-3, 3))
  719. ax.yaxis.set_major_formatter(fmt)
  720. ax.yaxis.get_offset_text().set_fontsize(FONT_SIZE)
  722. plt.tight_layout()
  723. plt.savefig(f"__global_stat_{TARGET_METRIC}.svg", format='svg')
  724. plt.show()
  726. # %% [markdown]
  727. # ## Figure 5 — Tissue thickness
  728. #
  729. # **Fig 5c** — Global tissue thickness [µm] comparison HH17 vs HH20 (per-embryo
  730. # means, boxplot + Welch t-test).
  731. #
  732. # **Fig 5f** — DV profiles of thickness per vesicle (same format as Fig 3g).
  733. #
  734. # **Fig 5g** — Compartment-wise boxplots of thickness, with within-compartment
  735. # (HH17 vs HH20) and inter-compartment (HH20 only) significance brackets.
  736. #
  737. # Thickness is measured as the Euclidean distance from each lumen surface vertex
  738. # to the nearest point on the basal (outer) surface mesh (notebook 03).
  740. # %%
  741. import pandas as pd
  742. import numpy as np
  743. import seaborn as sns
  744. import matplotlib.pyplot as plt
  745. import matplotlib.ticker as ticker
  747. sns.set_theme(style="ticks")
  749. plt.rcParams.update({
  750. 'font.size': 10,
  751. 'axes.labelsize': 10,
  752. 'axes.titlesize': 10,
  753. 'axes.titleweight': 'normal',
  754. 'axes.labelweight': 'normal',
  755. 'axes.linewidth': 1.5,
  756. 'xtick.major.width': 1.5,
  757. 'ytick.major.width': 1.5,
  758. 'xtick.major.size': 6,
  759. 'ytick.major.size': 6,
  760. 'xtick.direction': 'out',
  761. 'ytick.direction': 'out',
  762. 'xtick.labelsize': 10,
  763. 'ytick.labelsize': 10,
  764. 'svg.fonttype': 'none',
  765. 'font.family': 'sans-serif',
  766. 'font.sans-serif': ['Arial']
  767. })
  769. TARGET_METRIC = 'thickness'
  771. property_map = {
  772. 'Gauss_Curvature': r'Gaussian Curvature [$\mu m^{-2}$]',
  773. 'Mean_Curvature': r'Mean Curvature [$\mu m^{-1}$]',
  774. 'K1': r'K1 [$\mu m^{-1}$]',
  775. 'K2': r'K2 [$\mu m^{-1}$]',
  776. 'thickness': r'Thickness [$\mu m$]',
  777. 'phh3': 'Local pH3+ cell count'
  778. }
  780. master_csv = "../data/csv/spatchcocked_measurements.csv"
  781. df = pd.read_csv(master_csv)
  783. df['stage'] = df['stage'].astype(str).str.upper()
  785. df['Compartment'] = None
  787. mask_hh17 = df['stage'] == 'HH17'
  788. df.loc[mask_hh17 & (df['norm_height'] < 0.6), 'Compartment'] = 'Hindbrain'
  789. df.loc[mask_hh17 & (df['norm_height'] >= 0.6) & (df['norm_height'] <= 0.8), 'Compartment'] = 'Midbrain'
  790. df.loc[mask_hh17 & (df['norm_height'] > 0.8), 'Compartment'] = 'Forebrain'
  792. mask_hh20 = df['stage'] == 'HH20'
  793. df.loc[mask_hh20 & (df['norm_height'] < 0.55), 'Compartment'] = 'Hindbrain'
  794. df.loc[mask_hh20 & (df['norm_height'] >= 0.55) & (df['norm_height'] <= 0.75), 'Compartment'] = 'Midbrain'
  795. df.loc[mask_hh20 & (df['norm_height'] > 0.75), 'Compartment'] = 'Forebrain'
  797. df['angle_bin'] = pd.cut(df['angle_degrees'], bins=np.arange(-180, 190, 10))
  798. df['angle_bin_center'] = df['angle_bin'].apply(lambda x: x.mid).astype(float)
  800. stage_palette = {"HH17": "#3182bd", "HH20": "#de2d26"}
  801. compartments = ['Forebrain', 'Midbrain', 'Hindbrain']
  802. ylabel = property_map[TARGET_METRIC]
  804. fig, axes = plt.subplots(1, 3, figsize=(6.7, 2.6), sharey=True, dpi=100)
  806. for i, comp in enumerate(compartments):
  807. comp_data = df[df['Compartment'] == comp]
  808. ax = axes[i]
  810. sns.lineplot(
  811. data=comp_data,
  812. x='angle_bin_center',
  813. y=TARGET_METRIC,
  814. hue='stage',
  815. palette=stage_palette,
  816. linewidth=2.5,
  817. errorbar='sd',
  818. ax=ax
  819. )
  821. ax.set_title(comp, pad=10)
  822. ax.set_xlabel('Dorso-ventral axis')
  823. ax.set_xticks([-180, -90, 0, 90, 180])
  824. ax.set_xlim(-180, 180)
  826. if i == 0:
  827. ax.set_ylabel(ylabel)
  828. else:
  829. ax.set_ylabel('')
  831. if i == 2:
  832. ax.legend(title=' ', loc='best', frameon=False)
  833. else:
  834. ax.get_legend().remove()
  836. if 'Curvature' in TARGET_METRIC or TARGET_METRIC in ['K1', 'K2']:
  837. ax.axhline(0, color='black', linestyle='--', linewidth=1, alpha=0.5)
  839. for spine in ax.spines.values():
  840. spine.set_visible(True)
  842. if 'Curvature' in TARGET_METRIC or TARGET_METRIC in ['K1', 'K2']:
  843. ymin, ymax = axes[0].get_ylim()
  844. abs_max = max(abs(ymin), abs(ymax))
  845. axes[0].set_ylim(top=abs_max)
  847. if TARGET_METRIC in ['thickness', 'phh3']:
  848. axes[0].set_ylim(bottom=0)
  850. formatter = ticker.ScalarFormatter(useMathText=True)
  851. formatter.set_scientific(True)
  852. formatter.set_powerlimits((-2, 3))
  853. axes[0].yaxis.set_major_formatter(formatter)
  855. plt.tight_layout()
  856. save_path = f"__compartment_plot_{TARGET_METRIC}.svg"
  857. plt.savefig(save_path, format='svg', bbox_inches='tight')
  858. print(f"Plot saved: {save_path}")
  859. plt.show()
  861. # %%
  862. import pandas as pd
  863. import numpy as np
  864. import matplotlib.pyplot as plt
  865. import seaborn as sns
  866. from scipy import stats
  868. dpival = 100
  869. FONT_SIZE = 10
  871. plt.rcParams.update({
  872. 'svg.fonttype': 'none',
  873. 'font.size': FONT_SIZE,
  874. 'axes.labelsize': FONT_SIZE,
  875. 'xtick.labelsize': FONT_SIZE,
  876. 'ytick.labelsize': FONT_SIZE,
  877. 'legend.fontsize': FONT_SIZE,
  878. 'axes.titlesize': FONT_SIZE,
  879. 'axes.linewidth': 1.5,
  880. 'xtick.major.width': 1.5,
  881. 'ytick.major.width': 1.5,
  882. 'font.family': 'sans-serif',
  883. 'font.sans-serif': ['Arial']
  884. })
  886. PALETTE = {'HH17': '#3182bd', 'HH20': '#de2d26'}
  887. COMPARTMENTS = ['Forebrain', 'Midbrain', 'Hindbrain']
  888. STAGES = ['HH17', 'HH20']
  890. def set_common_style(ax, ylabel):
  891. ax.spines['top'].set_visible(False)
  892. ax.spines['right'].set_visible(False)
  893. for side in ['left', 'bottom']:
  894. ax.spines[side].set_linewidth(1.5)
  895. ax.set_xlabel("")
  896. ax.set_ylabel(ylabel)
  898. def add_external_stat(ax, x1, x2, level, p_val):
  899. base_y = 1.05
  900. step = 0.08
  901. y = base_y + (level * step)
  902. ax.plot([x1, x1, x2, x2], [y, y+0.02, y+0.02, y],
  903. lw=1.5, color='black', clip_on=False,
  904. transform=ax.get_xaxis_transform())
  905. if p_val < 0.001: text = '***'
  906. elif p_val < 0.01: text = '**'
  907. elif p_val < 0.05: text = '*'
  908. else: text = 'ns'
  909. ax.text((x1+x2)*0.5, y+0.02, text, ha='center', va='bottom',
  910. color='black', transform=ax.get_xaxis_transform())
  912. master_csv = "../data/csv/spatchcocked_measurements.csv"
  913. df_raw = pd.read_csv(master_csv)
  914. df_raw['stage'] = df_raw['stage'].astype(str).str.upper()
  916. df_raw['Compartment'] = None
  917. for stage, bounds in {'HH17': (0.6, 0.8), 'HH20': (0.55, 0.75)}.items():
  918. mask = df_raw['stage'] == stage
  919. df_raw.loc[mask & (df_raw['norm_height'] < bounds[0]), 'Compartment'] = 'Hindbrain'
  920. df_raw.loc[mask & (df_raw['norm_height'] >= bounds[0]) & (df_raw['norm_height'] <= bounds[1]), 'Compartment'] = 'Midbrain'
  921. df_raw.loc[mask & (df_raw['norm_height'] > bounds[1]), 'Compartment'] = 'Forebrain'
  923. df_total = df_raw.groupby(['timepoint', 'stage'])['thickness'].mean().reset_index()
  924. df_comp = df_raw.groupby(['timepoint', 'stage', 'Compartment'])['thickness'].mean().reset_index()
  926. def plot_total_thickness(data, y_col, ylabel, filename):
  927. plt.figure(figsize=(2, 3.2), dpi=dpival)
  928. ax = sns.boxplot(data=data, x='stage', y=y_col, hue='stage', palette=PALETTE,
  929. width=0.5, linewidth=1.5, order=STAGES, legend=False)
  930. g1 = data[data['stage'] == 'HH17'][y_col]
  931. g2 = data[data['stage'] == 'HH20'][y_col]
  932. _, p = stats.ttest_ind(g1, g2)
  933. add_external_stat(ax, 0, 1, 0, p)
  934. set_common_style(ax, ylabel)
  935. plt.subplots_adjust(top=0.8)
  936. plt.savefig(f"{filename}.svg", format='svg', bbox_inches='tight')
  938. def plot_compartment_thickness(data, y_col, ylabel, filename):
  939. plt.figure(figsize=(2.5, 3.0), dpi=dpival)
  940. ax = sns.boxplot(data=data, x='Compartment', y=y_col, hue='stage',
  941. order=COMPARTMENTS, palette=PALETTE, width=0.6, linewidth=1.5)
  942. for i, comp in enumerate(COMPARTMENTS):
  943. d1 = data[(data['Compartment'] == comp) & (data['stage'] == 'HH17')][y_col]
  944. d2 = data[(data['Compartment'] == comp) & (data['stage'] == 'HH20')][y_col]
  945. _, p = stats.ttest_ind(d1, d2)
  946. add_external_stat(ax, i - 0.2, i + 0.2, 0, p)
  947. inter_comps = [(0, 1, 1), (1, 2, 1), (0, 2, 2)]
  948. for (idx1, idx2, level) in inter_comps:
  949. comp1, comp2 = COMPARTMENTS[idx1], COMPARTMENTS[idx2]
  950. d1 = data[(data['Compartment'] == comp1) & (data['stage'] == 'HH20')][y_col]
  951. d2 = data[(data['Compartment'] == comp2) & (data['stage'] == 'HH20')][y_col]
  952. _, p = stats.ttest_ind(d1, d2)
  953. add_external_stat(ax, idx1 + 0.2, idx2 + 0.2, level, p)
  954. set_common_style(ax, ylabel)
  955. plt.legend(frameon=False, loc='best', bbox_to_anchor=(1, 1), title=' ')
  956. ax.set_xticks(range(len(COMPARTMENTS)))
  957. ax.set_xticklabels(['FB', 'MB', 'HB'])
  958. plt.subplots_adjust(top=0.75, right=0.75)
  959. plt.savefig(f"{filename}.svg", format='svg', bbox_inches='tight')
  961. plot_total_thickness(df_total, 'thickness', r'Thickness [$\mu$m]', 'thickness_total_raw')
  962. plot_compartment_thickness(df_comp, 'thickness', r'Thickness [$\mu$m]', 'thickness_comp_raw')
  963. plt.show()
  965. # %% [markdown]
  966. # ## Figure 6 — Mitotic cell density (pHH3)
  967. #
  968. # **Fig 6c** — Global pHH3+ cell density comparison HH17 vs HH20.
  969. #
  970. # **Fig 6f** — DV profiles of pHH3+ density per vesicle.
  971. #
  972. # **Fig 6g** — Compartment-wise boxplots of pHH3+ density.
  973. #
  974. # pHH3 (phospho-Histone H3) marks cells in mitosis. The local density at
  975. # each lumen surface vertex is the number of pHH3+ spots (detected in Imaris)
  976. # within a sphere of radius R = 100 µm, interpolated onto the mesh via inverse
  977. # distance weighting (notebook 04).
  979. # %%
  980. import pandas as pd
  981. import numpy as np
  982. import seaborn as sns
  983. import matplotlib.pyplot as plt
  984. import matplotlib.ticker as ticker
  986. sns.set_theme(style="ticks")
  988. plt.rcParams.update({
  989. 'font.size': 10,
  990. 'axes.labelsize': 10,
  991. 'axes.titlesize': 10,
  992. 'axes.titleweight': 'normal',
  993. 'axes.labelweight': 'normal',
  994. 'axes.linewidth': 1.5,
  995. 'xtick.major.width': 1.5,
  996. 'ytick.major.width': 1.5,
  997. 'xtick.major.size': 6,
  998. 'ytick.major.size': 6,
  999. 'xtick.direction': 'out',
  1000. 'ytick.direction': 'out',
  1001. 'xtick.labelsize': 10,
  1002. 'ytick.labelsize': 10,
  1003. 'svg.fonttype': 'none',
  1004. 'font.family': 'sans-serif',
  1005. 'font.sans-serif': ['Arial']
  1006. })
  1008. TARGET_METRIC = 'phh3'
  1010. property_map = {
  1011. 'Gauss_Curvature': r'Gaussian Curvature [$\mu m^{-2}$]',
  1012. 'Mean_Curvature': r'Mean Curvature [$\mu m^{-1}$]',
  1013. 'K1': r'K1 [$\mu m^{-1}$]',
  1014. 'K2': r'K2 [$\mu m^{-1}$]',
  1015. 'thickness': r'Thickness [$\mu m$]',
  1016. 'phh3': 'Local pHH3+ cell count'
  1017. }
  1019. master_csv = "../data/csv/spatchcocked_measurements.csv"
  1020. df = pd.read_csv(master_csv)
  1022. df['stage'] = df['stage'].astype(str).str.upper()
  1024. df['Compartment'] = None
  1026. mask_hh17 = df['stage'] == 'HH17'
  1027. df.loc[mask_hh17 & (df['norm_height'] < 0.6), 'Compartment'] = 'Hindbrain'
  1028. df.loc[mask_hh17 & (df['norm_height'] >= 0.6) & (df['norm_height'] <= 0.8), 'Compartment'] = 'Midbrain'
  1029. df.loc[mask_hh17 & (df['norm_height'] > 0.8), 'Compartment'] = 'Forebrain'
  1031. mask_hh20 = df['stage'] == 'HH20'
  1032. df.loc[mask_hh20 & (df['norm_height'] < 0.55), 'Compartment'] = 'Hindbrain'
  1033. df.loc[mask_hh20 & (df['norm_height'] >= 0.55) & (df['norm_height'] <= 0.75), 'Compartment'] = 'Midbrain'
  1034. df.loc[mask_hh20 & (df['norm_height'] > 0.75), 'Compartment'] = 'Forebrain'
  1036. df['angle_bin'] = pd.cut(df['angle_degrees'], bins=np.arange(-180, 190, 10))
  1037. df['angle_bin_center'] = df['angle_bin'].apply(lambda x: x.mid).astype(float)
  1039. stage_palette = {"HH17": "#3182bd", "HH20": "#de2d26"}
  1040. compartments = ['Forebrain', 'Midbrain', 'Hindbrain']
  1041. ylabel = property_map[TARGET_METRIC]
  1043. fig, axes = plt.subplots(1, 3, figsize=(6.7, 2.6), sharey=True, dpi=100)
  1045. for i, comp in enumerate(compartments):
  1046. comp_data = df[df['Compartment'] == comp]
  1047. ax = axes[i]
  1049. sns.lineplot(
  1050. data=comp_data,
  1051. x='angle_bin_center',
  1052. y=TARGET_METRIC,
  1053. hue='stage',
  1054. palette=stage_palette,
  1055. linewidth=2.5,
  1056. errorbar='sd',
  1057. ax=ax
  1058. )
  1060. ax.set_title(comp, pad=10)
  1061. ax.set_xlabel('Dorso-ventral axis')
  1062. ax.set_xticks([-180, -90, 0, 90, 180])
  1063. ax.set_xlim(-180, 180)
  1065. if i == 0:
  1066. ax.set_ylabel(ylabel)
  1067. else:
  1068. ax.set_ylabel('')
  1070. if i == 2:
  1071. ax.legend(title=' ', loc='best', frameon=False)
  1072. else:
  1073. ax.get_legend().remove()
  1075. if 'Curvature' in TARGET_METRIC or TARGET_METRIC in ['K1', 'K2']:
  1076. ax.axhline(0, color='black', linestyle='--', linewidth=1, alpha=0.5)
  1078. for spine in ax.spines.values():
  1079. spine.set_visible(True)
  1081. if 'Curvature' in TARGET_METRIC or TARGET_METRIC in ['K1', 'K2']:
  1082. ymin, ymax = axes[0].get_ylim()
  1083. abs_max = max(abs(ymin), abs(ymax))
  1084. axes[0].set_ylim(top=abs_max)
  1086. if TARGET_METRIC in ['thickness', 'phh3']:
  1087. axes[0].set_ylim(bottom=0)
  1089. formatter = ticker.ScalarFormatter(useMathText=True)
  1090. formatter.set_scientific(True)
  1091. formatter.set_powerlimits((-2, 3))
  1092. axes[0].yaxis.set_major_formatter(formatter)
  1094. plt.tight_layout()
  1095. save_path = f"__compartment_plot_{TARGET_METRIC}.svg"
  1096. plt.savefig(save_path, format='svg', bbox_inches='tight')
  1097. print(f"Plot saved: {save_path}")
  1098. plt.show()
  1100. # %%
  1101. import pandas as pd
  1102. import numpy as np
  1103. import matplotlib.pyplot as plt
  1104. import seaborn as sns
  1105. from scipy import stats
  1107. dpival = 100
  1108. FONT_SIZE = 10
  1110. plt.rcParams.update({
  1111. 'svg.fonttype': 'none',
  1112. 'font.size': FONT_SIZE,
  1113. 'axes.labelsize': FONT_SIZE,
  1114. 'xtick.labelsize': FONT_SIZE,
  1115. 'ytick.labelsize': FONT_SIZE,
  1116. 'legend.fontsize': FONT_SIZE,
  1117. 'axes.titlesize': FONT_SIZE,
  1118. 'axes.linewidth': 1.5,
  1119. 'xtick.major.width': 1.5,
  1120. 'ytick.major.width': 1.5,
  1121. 'font.family': 'sans-serif',
  1122. 'font.sans-serif': ['Arial']
  1123. })
  1125. PALETTE = {'HH17': '#3182bd', 'HH20': '#de2d26'}
  1126. COMPARTMENTS = ['Forebrain', 'Midbrain', 'Hindbrain']
  1127. STAGES = ['HH17', 'HH20']
  1128. TARGET_METRIC = 'phh3'
  1130. def set_common_style(ax, ylabel):
  1131. ax.spines['top'].set_visible(False)
  1132. ax.spines['right'].set_visible(False)
  1133. for side in ['left', 'bottom']:
  1134. ax.spines[side].set_linewidth(1.5)
  1135. ax.set_xlabel("")
  1136. ax.set_ylabel(ylabel)
  1138. def add_external_stat(ax, x1, x2, level, p_val):
  1139. base_y = 1.05
  1140. step = 0.08
  1141. y = base_y + (level * step)
  1142. ax.plot([x1, x1, x2, x2], [y, y+0.02, y+0.02, y],
  1143. lw=1.5, color='black', clip_on=False,
  1144. transform=ax.get_xaxis_transform())
  1145. if p_val < 0.001: text = '***'
  1146. elif p_val < 0.01: text = '**'
  1147. elif p_val < 0.05: text = '*'
  1148. else: text = 'ns'
  1149. ax.text((x1+x2)*0.5, y+0.02, text, ha='center', va='bottom',
  1150. color='black', transform=ax.get_xaxis_transform())
  1152. master_csv = "../data/csv/spatchcocked_measurements.csv"
  1153. df_raw = pd.read_csv(master_csv)
  1154. df_raw['stage'] = df_raw['stage'].astype(str).str.upper()
  1156. df_raw['Compartment'] = None
  1157. for stage, bounds in {'HH17': (0.6, 0.8), 'HH20': (0.55, 0.75)}.items():
  1158. mask = df_raw['stage'] == stage
  1159. df_raw.loc[mask & (df_raw['norm_height'] < bounds[0]), 'Compartment'] = 'Hindbrain'
  1160. df_raw.loc[mask & (df_raw['norm_height'] >= bounds[0]) & (df_raw['norm_height'] <= bounds[1]), 'Compartment'] = 'Midbrain'
  1161. df_raw.loc[mask & (df_raw['norm_height'] > bounds[1]), 'Compartment'] = 'Forebrain'
  1163. df_total = df_raw.groupby(['timepoint', 'stage'])[TARGET_METRIC].mean().reset_index()
  1164. df_comp = df_raw.groupby(['timepoint', 'stage', 'Compartment'])[TARGET_METRIC].mean().reset_index()
  1166. def plot_total_phh3(data, y_col, ylabel, filename, L=False):
  1167. plt.figure(figsize=(2, 3.2), dpi=dpival)
  1168. ax = sns.boxplot(data=data, x='stage', y=y_col, hue='stage', palette=PALETTE,
  1169. width=0.5, linewidth=1.5, order=STAGES, legend=False)
  1170. if L:
  1171. ax.set_ylim(bottom=0)
  1172. if 'Fold' in ylabel:
  1173. plt.axhline(1.0, color='black', linestyle='--', linewidth=1, alpha=0.7)
  1174. g1 = data[data['stage'] == 'HH17'][y_col]
  1175. g2 = data[data['stage'] == 'HH20'][y_col]
  1176. _, p = stats.ttest_ind(g1, g2)
  1177. add_external_stat(ax, 0, 1, 0, p)
  1178. set_common_style(ax, ylabel)
  1179. plt.subplots_adjust(top=0.8)
  1180. plt.savefig(f"{filename}.svg", format='svg', bbox_inches='tight')
  1182. def plot_compartments_phh3(data, y_col, ylabel, filename, L=False):
  1183. plt.figure(figsize=(2.5, 3), dpi=dpival)
  1184. ax = sns.boxplot(data=data, x='Compartment', y=y_col, hue='stage',
  1185. order=COMPARTMENTS, palette=PALETTE, width=0.6, linewidth=1.5)
  1186. if L:
  1187. ax.set_ylim(bottom=0)
  1188. if 'Fold' in ylabel:
  1189. plt.axhline(1.0, color='black', linestyle='--', linewidth=1, alpha=0.7)
  1190. for i, comp in enumerate(COMPARTMENTS):
  1191. d1 = data[(data['Compartment'] == comp) & (data['stage'] == 'HH17')][y_col]
  1192. d2 = data[(data['Compartment'] == comp) & (data['stage'] == 'HH20')][y_col]
  1193. _, p = stats.ttest_ind(d1, d2)
  1194. add_external_stat(ax, i - 0.2, i + 0.2, 0, p)
  1195. inter_comps = [(0, 1, 1), (1, 2, 1), (0, 2, 2)]
  1196. for (idx1, idx2, level) in inter_comps:
  1197. comp1, comp2 = COMPARTMENTS[idx1], COMPARTMENTS[idx2]
  1198. d1 = data[(data['Compartment'] == comp1) & (data['stage'] == 'HH20')][y_col]
  1199. d2 = data[(data['Compartment'] == comp2) & (data['stage'] == 'HH20')][y_col]
  1200. _, p = stats.ttest_ind(d1, d2)
  1201. add_external_stat(ax, idx1 + 0.2, idx2 + 0.2, level, p)
  1202. set_common_style(ax, ylabel)
  1203. plt.legend(frameon=False, loc='upper left', bbox_to_anchor=(1, 1), title='Stage')
  1204. ax.set_xticks(range(len(COMPARTMENTS)))
  1205. ax.set_xticklabels(['FB', 'MB', 'HB'])
  1206. plt.subplots_adjust(top=0.75, right=0.75)
  1207. plt.savefig(f"{filename}.svg", format='svg', bbox_inches='tight')
  1209. plot_total_phh3(df_total, TARGET_METRIC, 'Local pHH3+ cell count', 'phh3_total_raw', L=True)
  1210. plot_compartments_phh3(df_comp, TARGET_METRIC, 'Local pHH3+ cell count', 'phh3_comp_raw', L=True)
  1211. plt.show()
  1213. # %% [markdown]
  1214. # ## Supplementary Figure 1 — Absolute geometry and correlations
  1215. #
  1216. # **Supp 1a–c** — Absolute lumen length, surface area, and volume at HH17 and
  1217. # HH20 (total and per compartment).
  1218. #
  1219. # **Supp 1d–f** — Fold changes in length and volume per compartment.
  1220. #
  1221. # **Supp 1g–h** — Pearson correlation between tissue thickness and curvature
  1222. # (Gaussian and Mean), computed on binned data (10 quantile bins per stage).
  1223. # Each point = mean of one bin; regression line + r and p shown in legend.
  1224. #
  1225. # **Supp 1i–l** — Spearman rank correlation of the spatial pattern (HH17 vs
  1226. # HH20) for all four metrics. Each point = one 10° DV bin; colour encodes DV
  1227. # position (dorsal = centre, ventral = ends of the cyclic_plasma colormap).
  1229. # %%
  1230. import pandas as pd
  1231. import numpy as np
  1232. import matplotlib.pyplot as plt
  1233. import matplotlib.ticker as ticker
  1234. import seaborn as sns
  1235. from scipy import stats
  1237. dpival = 100
  1238. FONT_SIZE = 10
  1240. plt.rcParams.update({
  1241. 'svg.fonttype': 'none',
  1242. 'font.size': FONT_SIZE,
  1243. 'axes.labelsize': FONT_SIZE,
  1244. 'xtick.labelsize': FONT_SIZE,
  1245. 'ytick.labelsize': FONT_SIZE,
  1246. 'legend.fontsize': FONT_SIZE,
  1247. 'axes.titlesize': FONT_SIZE,
  1248. 'axes.linewidth': 1.5,
  1249. 'xtick.major.width': 1.5,
  1250. 'ytick.major.width': 1.5,
  1251. 'font.family': 'sans-serif',
  1252. 'font.sans-serif': ['Arial']
  1253. })
  1255. PALETTE = {'HH17': '#3182bd', 'HH20': '#de2d26'}
  1256. STAGES = ['HH17', 'HH20']
  1257. COMPARTMENTS = ['Forebrain', 'Midbrain', 'Hindbrain']
  1259. def set_common_style(ax, ylabel):
  1260. ax.spines['top'].set_visible(False)
  1261. ax.spines['right'].set_visible(False)
  1262. for side in ['left', 'bottom']:
  1263. ax.spines[side].set_linewidth(1.5)
  1264. ax.set_xlabel("")
  1265. ax.set_ylabel(ylabel)
  1267. def add_external_stat(ax, x1, x2, level, p_val):
  1268. base_y = 1.05
  1269. step = 0.08
  1270. y = base_y + (level * step)
  1271. ax.plot([x1, x1, x2, x2], [y, y+0.02, y+0.02, y],
  1272. lw=1.5, color='black', clip_on=False,
  1273. transform=ax.get_xaxis_transform())
  1274. if p_val < 0.001: text = '***'
  1275. elif p_val < 0.01: text = '**'
  1276. elif p_val < 0.05: text = '*'
  1277. else: text = 'ns'
  1278. ax.text((x1+x2)*0.5, y+0.02, text, ha='center', va='bottom',
  1279. color='black', transform=ax.get_xaxis_transform())
  1281. # Length Data
  1282. df_len = pd.read_csv('../data/csv/compartment_lengths.csv')
  1283. df_len['stage'] = df_len['stage'].astype(str).str.upper()
  1285. df_len['Hindbrain'] = df_len['mhb']
  1286. df_len['Midbrain'] = df_len['fmb'] - df_len['mhb']
  1287. df_len['Forebrain'] = df_len['end'] - df_len['fmb']
  1288. df_len['Total Length'] = df_len['end']
  1290. hh17_means_len = df_len[df_len['stage'] == 'HH17'][COMPARTMENTS + ['Total Length']].mean()
  1291. df_len_fc = df_len.copy()
  1292. for col in COMPARTMENTS + ['Total Length']:
  1293. df_len_fc[col] = df_len[col] / hh17_means_len[col]
  1295. melted_len_raw = df_len.melt(id_vars=['stage'], value_vars=COMPARTMENTS, var_name='Compartment', value_name='Length')
  1296. melted_len_fc = df_len_fc.melt(id_vars=['stage'], value_vars=COMPARTMENTS, var_name='Compartment', value_name='Fold Change')
  1298. # Area & Volume Data
  1299. df_av = pd.read_csv("../data/csv/lumen_geometry.csv")
  1300. df_av['Stage'] = df_av['Stage'].astype(str).str.upper()
  1302. df_av_fc = df_av.copy()
  1303. for metric in ['Area', 'Volume']:
  1304. for reg in COMPARTMENTS:
  1305. hh17_mean = df_av[(df_av['Stage'] == 'HH17') & (df_av['Region'] == reg)][metric].mean()
  1306. mask = df_av['Region'] == reg
  1307. df_av_fc.loc[mask, metric] = df_av.loc[mask, metric] / hh17_mean
  1309. def plot_total(ax, data, x_col, y_col, ylabel, power=None, is_fc=False):
  1310. stage_col = 'stage' if 'stage' in data.columns else 'Stage'
  1311. sns.boxplot(data=data, x=stage_col, y=y_col, hue=stage_col, palette=PALETTE,
  1312. width=0.5, linewidth=1.5, order=STAGES, legend=False, ax=ax)
  1313. if is_fc:
  1314. ax.axhline(1.0, color='black', linestyle='--', linewidth=1, alpha=0.7)
  1315. else:
  1316. ax.set_ylim(bottom=0)
  1317. g1 = data[data[stage_col] == 'HH17'][y_col]
  1318. g2 = data[data[stage_col] == 'HH20'][y_col]
  1319. _, p = stats.ttest_ind(g1.dropna(), g2.dropna())
  1320. add_external_stat(ax, 0, 1, 0, p)
  1321. set_common_style(ax, ylabel)
  1322. if not is_fc and power is not None:
  1323. fmt = ticker.ScalarFormatter(useMathText=True)
  1324. fmt.set_scientific(True)
  1325. fmt.set_powerlimits((power, power))
  1326. ax.yaxis.set_major_formatter(fmt)
  1328. def plot_compartments(ax, data, comp_col, y_col, ylabel, power=None, is_fc=False, show_legend=False):
  1329. stage_col = 'stage' if 'stage' in data.columns else 'Stage'
  1330. sns.boxplot(data=data, x=comp_col, y=y_col, hue=stage_col,
  1331. order=COMPARTMENTS, palette=PALETTE, width=0.6, linewidth=1.5, ax=ax)
  1332. if is_fc:
  1333. ax.axhline(1.0, color='black', linestyle='--', linewidth=1, alpha=0.7)
  1334. else:
  1335. ax.set_ylim(bottom=0)
  1336. for i, comp in enumerate(COMPARTMENTS):
  1337. d1 = data[(data[comp_col] == comp) & (data[stage_col] == 'HH17')][y_col]
  1338. d2 = data[(data[comp_col] == comp) & (data[stage_col] == 'HH20')][y_col]
  1339. if not d1.empty and not d2.empty:
  1340. _, p = stats.ttest_ind(d1.dropna(), d2.dropna())
  1341. add_external_stat(ax, i - 0.15, i + 0.15, 0, p)
  1342. inter_comps = [(0, 1, 1), (1, 2, 1), (0, 2, 2)]
  1343. for (idx1, idx2, level) in inter_comps:
  1344. comp1, comp2 = COMPARTMENTS[idx1], COMPARTMENTS[idx2]
  1345. d1 = data[(data[comp_col] == comp1) & (data[stage_col] == 'HH20')][y_col]
  1346. d2 = data[(data[comp_col] == comp2) & (data[stage_col] == 'HH20')][y_col]
  1347. if not d1.empty and not d2.empty:
  1348. _, p = stats.ttest_ind(d1.dropna(), d2.dropna())
  1349. add_external_stat(ax, idx1 + 0.2, idx2 + 0.2, level, p)
  1350. set_common_style(ax, ylabel)
  1351. ax.set_xticks(range(len(COMPARTMENTS)))
  1352. ax.set_xticklabels(['FB', 'MB', 'HB'])
  1353. if not is_fc and power is not None:
  1354. fmt = ticker.ScalarFormatter(useMathText=True)
  1355. fmt.set_scientific(True)
  1356. fmt.set_powerlimits((power, power))
  1357. ax.yaxis.set_major_formatter(fmt)
  1358. if show_legend:
  1359. ax.legend(frameon=False, loc='upper left', bbox_to_anchor=(1, 1), title='Stage')
  1360. else:
  1361. ax.legend().remove()
  1363. # Figure 1: Absolute Values (Total)
  1364. fig1, axes1 = plt.subplots(1, 3, figsize=(6, 2.5), dpi=dpival)
  1365. plot_total(axes1[0], df_len, 'stage', 'Total Length', r'Length [$\mu$m]')
  1366. plot_total(axes1[1], df_av, 'Stage', 'Area', r'Surface Area [$\mu$m$^2$]', power=6)
  1367. plot_total(axes1[2], df_av, 'Stage', 'Volume', r'Volume [$\mu$m$^3$]', power=8)
  1368. fig1.tight_layout()
  1369. fig1.subplots_adjust(top=0.8)
  1370. fig1.savefig("fig1_total_absolute.svg", format='svg')
  1372. # Figure 2: Absolute Values (Compartment-wise)
  1373. fig2, axes2 = plt.subplots(1, 3, figsize=(7, 2.5), dpi=dpival)
  1374. plot_compartments(axes2[0], melted_len_raw, 'Compartment', 'Length', r'Length [$\mu$m]')
  1375. plot_compartments(axes2[1], df_av, 'Region', 'Area', r'Surface Area [$\mu$m$^2$]', power=6)
  1376. plot_compartments(axes2[2], df_av, 'Region', 'Volume', r'Volume [$\mu$m$^3$]', power=8, show_legend=True)
  1377. fig2.tight_layout()
  1378. fig2.subplots_adjust(top=0.75, right=0.9)
  1379. fig2.savefig("fig2_compartment_absolute.svg", format='svg')
  1381. # Figure 3: Fold Change (Compartment-wise Length & Volume)
  1382. fig3, axes3 = plt.subplots(1, 2, figsize=(5, 2.5), dpi=dpival)
  1383. plot_compartments(axes3[0], melted_len_fc, 'Compartment', 'Fold Change', 'Fold Change (Length)', is_fc=True)
  1384. plot_compartments(axes3[1], df_av_fc, 'Region', 'Volume', 'Fold Change (Volume)', is_fc=True, show_legend=True)
  1385. fig3.tight_layout()
  1386. fig3.subplots_adjust(top=0.75, right=0.85)
  1387. fig3.savefig("fig3_fold_change_length_volume.svg", format='svg')
  1389. plt.show()
  1391. # %%
  1392. import pandas as pd
  1393. import numpy as np
  1394. import matplotlib.pyplot as plt
  1395. import matplotlib.ticker as ticker
  1396. import seaborn as sns
  1397. from scipy.stats import pearsonr
  1399. dpival = 100
  1400. FONT_SIZE = 10
  1402. plt.rcParams.update({
  1403. 'svg.fonttype': 'none',
  1404. 'font.size': FONT_SIZE,
  1405. 'axes.labelsize': FONT_SIZE+1,
  1406. 'xtick.labelsize': FONT_SIZE,
  1407. 'ytick.labelsize': FONT_SIZE,
  1408. 'legend.fontsize': FONT_SIZE,
  1409. 'axes.titlesize': FONT_SIZE,
  1410. 'axes.linewidth': 1.5,
  1411. 'xtick.major.width': 1.5,
  1412. 'ytick.major.width': 1.5,
  1413. 'font.family': 'sans-serif',
  1414. 'font.sans-serif': ['Arial']
  1415. })
  1417. PALETTE = {'HH17': '#3182bd', 'HH20': '#de2d26'}
  1419. master_csv = "../data/csv/spatchcocked_measurements.csv"
  1420. df = pd.read_csv(master_csv)
  1422. df['stage'] = df['stage'].astype(str).str.upper()
  1424. def plot_binned_correlation(ax, data, x_col, y_col, xlabel, ylabel, n_bins=10):
  1425. """Calculates binned means, Pearson correlation, and plots to a specific axis."""
  1426. if x_col not in data.columns or y_col not in data.columns:
  1427. print(f"Skipping {y_col} vs {x_col}: columns missing from data.")
  1428. return
  1430. df_clean = data.dropna(subset=[x_col, y_col])
  1431. binned_data = []
  1433. for stage in ['HH17', 'HH20']:
  1434. stage_df = df_clean[df_clean['stage'] == stage].copy()
  1435. if len(stage_df) < n_bins:
  1436. continue
  1437. stage_df['x_bin'] = pd.qcut(stage_df[x_col], q=n_bins, duplicates='drop')
  1438. bin_means = stage_df.groupby('x_bin', observed=False)[[x_col, y_col]].mean().reset_index()
  1439. bin_means['stage'] = stage
  1440. bin_means = bin_means.dropna()
  1441. binned_data.append(bin_means)
  1443. if not binned_data:
  1444. return
  1446. binned_df = pd.concat(binned_data, ignore_index=True)
  1448. for stage in ['HH17', 'HH20']:
  1449. stage_binned = binned_df[binned_df['stage'] == stage]
  1450. if len(stage_binned) < 2:
  1451. continue
  1452. corr, pval = pearsonr(stage_binned[x_col], stage_binned[y_col])
  1453. p_text = "p < 0.001" if pval < 0.001 else f"p = {pval:.3f}"
  1454. legend_label = f"{stage} ($r$={corr:.2f}, {p_text})"
  1455. sns.regplot(
  1456. data=stage_binned, x=x_col, y=y_col, ax=ax,
  1457. color=PALETTE[stage],
  1458. scatter_kws={'s': 50, 'edgecolors': 'white', 'linewidths': 0.8},
  1459. line_kws={'linewidth': 2},
  1460. label=legend_label
  1461. )
  1463. ax.spines['top'].set_visible(False)
  1464. ax.spines['right'].set_visible(False)
  1465. for side in ['left', 'bottom']:
  1466. ax.spines[side].set_linewidth(1.5)
  1468. ax.set_xlabel(xlabel)
  1469. ax.set_ylabel(ylabel)
  1471. fmt = ticker.ScalarFormatter(useMathText=True)
  1472. fmt.set_scientific(True)
  1473. fmt.set_powerlimits((-3, 3))
  1474. ax.yaxis.set_major_formatter(fmt)
  1476. ax.legend(frameon=False, loc='lower center', bbox_to_anchor=(0.5, 1.05), ncol=1)
  1478. fig, axes = plt.subplots(1, 2, figsize=(6, 4), dpi=dpival)
  1480. plot_binned_correlation(
  1481. ax=axes[0], data=df,
  1482. x_col='thickness', y_col='Gauss_Curvature',
  1483. xlabel=r'Tissue Thickness [$\mu m$]',
  1484. ylabel='Gaussian Curvature'
  1485. )
  1487. plot_binned_correlation(
  1488. ax=axes[1], data=df,
  1489. x_col='thickness', y_col='Mean_Curvature',
  1490. xlabel=r'Tissue Thickness [$\mu m$]',
  1491. ylabel='Mean Curvature'
  1492. )
  1494. plt.tight_layout()
  1495. plt.savefig("correlation_1x2_thickness_curvatures.svg", format='svg', bbox_inches='tight')
  1496. plt.show()
  1498. # %%
  1499. import pandas as pd
  1500. import numpy as np
  1501. import matplotlib.pyplot as plt
  1502. import matplotlib.ticker as ticker
  1503. import matplotlib.colors as mcolors
  1504. import seaborn as sns
  1505. from scipy.stats import spearmanr
  1507. # Custom cyclic colormap: mirrors 'plasma' so ventral (±180°) is dark at both ends
  1508. # and dorsal (0°) is bright in the centre — matches the DV coordinate convention.
  1509. base_cmap = plt.cm.get_cmap('plasma', 128)
  1510. colors_half = base_cmap(np.linspace(0, 1, 128))
  1511. cyclic_colors = np.vstack((colors_half, colors_half[::-1]))
  1512. cyclic_plasma = mcolors.LinearSegmentedColormap.from_list('cyclic_plasma', cyclic_colors)
  1514. MASTER_CSV = "../data/csv/spatchcocked_measurements.csv"
  1515. N_ANGLE_BINS = 40
  1517. plt.rcParams.update({
  1518. 'font.size': 13,
  1519. 'axes.labelsize': 13,
  1520. 'axes.linewidth': 1.5,
  1521. 'xtick.major.width': 1.5,
  1522. 'ytick.major.width': 1.5,
  1523. 'svg.fonttype': 'none',
  1524. 'font.family': 'sans-serif',
  1525. 'font.sans-serif': ['Arial']
  1526. })
  1528. PROPS = [
  1529. ('Gauss_Curvature', r'$K$ [$\mu m^{-2}$]', -6, 0),
  1530. ('Mean_Curvature', r'$H$ [$\mu m^{-1}$]', -3, 1),
  1531. ('thickness', r'Thickness [$\mu m$]', 0, 2),
  1532. ('phh3', 'Local pH3+ cell count', 0, 3)
  1533. ]
  1535. df = pd.read_csv(MASTER_CSV)
  1536. df['stage'] = df['stage'].astype(str).str.upper()
  1538. fig, axes = plt.subplots(2, 2, figsize=(9, 8), dpi=100)
  1539. axes_flat = axes.flatten()
  1541. for col, base_label, exp, idx in PROPS:
  1542. ax = axes_flat[idx]
  1544. df_clean = df.dropna(subset=['angle_degrees', col])
  1545. bins = np.linspace(-180, 180, N_ANGLE_BINS + 1)
  1546. df_clean['angle_bin'] = pd.cut(df_clean['angle_degrees'], bins=bins)
  1548. grouped = df_clean.groupby('angle_bin', observed=False).agg({
  1549. col: lambda x: x[df_clean.loc[x.index, 'stage'] == 'HH17'].mean(),
  1550. 'angle_degrees': 'mean'
  1551. }).rename(columns={col: 'HH17', 'angle_degrees': 'bin_center'})
  1553. grouped['HH20'] = df_clean[df_clean['stage'] == 'HH20'].groupby('angle_bin', observed=False)[col].mean()
  1554. comp_df = grouped.dropna(subset=['HH17', 'HH20'])
  1556. corr, pval = spearmanr(comp_df['HH17'], comp_df['HH20'])
  1557. p_text = "p < 0.001" if pval < 0.001 else f"p = {pval:.3f}"
  1559. sns.regplot(
  1560. data=comp_df, x='HH17', y='HH20', ax=ax,
  1561. scatter=False, color='gray', line_kws={'linewidth': 1.5, 'linestyle': '--', 'alpha': 0.5}
  1562. )
  1564. scatter = ax.scatter(
  1565. comp_df['HH17'], comp_df['HH20'],
  1566. c=comp_df['bin_center'],
  1567. cmap=cyclic_plasma,
  1568. s=60, edgecolors='black', linewidths=0.5, alpha=0.9
  1569. )
  1571. ax.spines['top'].set_visible(False)
  1572. ax.spines['right'].set_visible(False)
  1574. label_suffix = f" ($\\times 10^{{{exp}}}$)" if exp != 0 else ""
  1575. ax.set_xlabel(f"HH17 {base_label}{label_suffix}")
  1576. ax.set_ylabel(f"HH20 {base_label}{label_suffix}")
  1577. ax.set_title(f"$\\rho$ = {corr:.2f} ({p_text})", fontsize=11, pad=10)
  1579. if exp != 0:
  1580. func = ticker.FuncFormatter(lambda x, pos, e=exp: f'{x/(10**e):g}')
  1581. ax.xaxis.set_major_formatter(func)
  1582. ax.yaxis.set_major_formatter(func)
  1584. if col == 'phh3':
  1585. ax.set_yticks([15, 20, 25])
  1587. cbar_ax = fig.add_axes([0.93, 0.75, 0.015, 0.18])
  1588. cbar = fig.colorbar(scatter, cax=cbar_ax)
  1589. cbar.set_label(' ', rotation=270, labelpad=15)
  1590. cbar.set_ticks([-175, 0, 175])
  1591. cbar.set_ticklabels(['V', 'D', 'V'])
  1593. plt.tight_layout(rect=[0, 0, 0.9, 1])
  1594. plt.savefig("Pattern_Correlation_Spearman.svg", format='svg', bbox_inches='tight')
  1595. plt.show()
  1597. # %% [markdown]
  1598. # ## Supplementary — pHH3 spot density validation
  1599. #
  1600. # Independent validation of pHH3+ spot density comparing HH17 (66 hr incubation)
  1601. # and HH20 (90 hr incubation) tissue sections. Data comes from raw Imaris spot
  1602. # detection (search radius R = 100 µm) on optical sections, prior to mesh
  1603. # projection. This confirms that the difference in pHH3+ density seen in the
  1604. # spatchcocked data (Fig 6) reflects a genuine biological signal rather than an
  1605. # artefact of the projection method.
  1606. #
  1607. # The dataset is small (n ≈ 20 sections per stage) and is embedded inline — it
  1608. # does not require a separate CSV file.
  1610. # %%
  1611. import pandas as pd
  1612. import io
  1613. import seaborn as sns
  1614. import matplotlib.pyplot as plt
  1615. from scipy import stats
  1617. csv_data = """Filename,Total_Spots,Search_Radius_r,Mean_Density,Median_Density,Std_Density,Max_Density
  1618. 66hr-FBMB-bottom1,81,100,4.02,3.0,2.77,16.0
  1619. 66hr-FBMB-bottom10,125,100,5.65,6.0,2.81,14.0
  1620. 66hr-FBMB-bottom11,71,100,3.69,4.0,1.98,9.0
  1621. 66hr-FBMB-bottom12,129,100,5.49,6.0,2.91,13.0
  1622. 66hr-FBMB-bottom13,82,100,4.02,4.0,2.25,10.0
  1623. 66hr-FBMB-bottom2,87,100,3.57,3.0,2.38,11.0
  1624. 66hr-FBMB-bottom3,74,100,5.58,6.0,2.43,11.0
  1625. 66hr-FBMB-bottom4,60,100,5.27,5.0,2.72,12.0
  1626. 66hr-FBMB-bottom8,126,100,4.34,4.0,2.38,11.0
  1627. 66hr-FBMB-bottom9,64,100,5.08,5.0,3.08,12.0
  1628. 66hr-FBMB-top2,69,100,4.56,4.0,2.75,12.0
  1629. 66hr-FBMB-top3,71,100,3.01,3.0,1.6,10.0
  1630. 66hr-FBMB-top4,81,100,4.87,5.0,2.66,14.0
  1631. 66hr-FBMB-top5,121,100,5.22,5.0,2.86,13.0
  1632. 66hr-FBMB-top6,128,100,6.86,7.0,3.85,16.0
  1633. 66hr-FBMB-top7,103,100,3.26,3.0,2.02,11.0
  1634. 66hr-FBMB-top8,65,100,4.6,4.0,2.38,12.0
  1635. 66hr-HB-bottom1,72,100,6.69,7.0,2.79,14.0
  1636. 66hr-HB-bottom2,45,100,9.56,10.0,4.08,20.0
  1637. 66hr-HB-bottom4,55,100,5.81,6.0,2.72,12.0
  1638. 66hr-HB-bottom6,81,100,6.84,7.0,3.64,18.0
  1639. FB-MB-90--Snap-1035,79,100,3.01,3.0,1.75,10.0
  1640. FB-MB-90-Snap-1030,75,100,2.83,3.0,1.53,8.0
  1641. FB-MB-90-Snap-1031,99,100,2.7,3.0,1.3,6.0
  1642. FB-MB-90-Snap-1032,78,100,2.93,3.0,1.28,6.0
  1643. FB-MB-90-Snap-1033,72,100,2.29,2.0,1.21,6.0
  1644. FB-MB-90-Snap-1034,59,100,2.76,3.0,1.33,6.0
  1645. FB-MB-90-Snap-1036,64,100,2.97,3.0,1.3,7.0
  1646. FB-MB-90-Snap-1038,73,100,2.64,3.0,1.31,7.0
  1647. FB-MB-90-Snap-1039,60,100,2.33,2.0,1.26,6.0
  1648. fb-mb-90-Snap-1054,66,100,3.34,3.0,1.42,7.0
  1649. fb-mb-90-Snap-1055,72,100,2.88,3.0,1.34,6.0
  1650. HB-90-Snap-1022,70,100,2.54,2.0,1.45,7.0
  1651. HB-90-Snap-1027,76,100,2.18,2.0,1.16,6.0
  1652. """
  1654. df = pd.read_csv(io.StringIO(csv_data))
  1656. def get_stage(filename):
  1657. filename_lower = filename.lower()
  1658. if '66' in filename_lower: return 'HH17'
  1659. elif '90' in filename_lower: return 'HH20'
  1660. return 'Unknown'
  1662. df['Stage'] = df['Filename'].apply(get_stage)
  1664. dpival = 100
  1665. PALETTE = {'HH17': '#3182bd', 'HH20': '#de2d26'}
  1666. STAGES = ['HH17', 'HH20']
  1668. plt.rcParams.update({
  1669. 'font.family': 'sans-serif',
  1670. 'font.sans-serif': ['Arial']
  1671. })
  1673. def set_common_style(ax, ylabel):
  1674. ax.spines['top'].set_visible(False)
  1675. ax.spines['right'].set_visible(False)
  1676. for side in ['left', 'bottom']:
  1677. ax.spines[side].set_linewidth(1.5)
  1678. ax.grid(False)
  1679. ax.set_xlabel('Stage', fontsize=13, fontweight='normal')
  1680. ax.set_ylabel(ylabel, fontsize=13, fontweight='normal')
  1681. ax.tick_params(labelsize=12, width=1.5)
  1683. def add_external_stat(ax, x1, x2, level, p_val):
  1684. base_y = 1.05
  1685. step = 0.08
  1686. y = base_y + (level * step)
  1687. ax.plot([x1, x1, x2, x2], [y, y+0.02, y+0.02, y],
  1688. lw=1.5, color='black', clip_on=False,
  1689. transform=ax.get_xaxis_transform())
  1690. if p_val < 0.001: text = '***'
  1691. elif p_val < 0.01: text = '**'
  1692. elif p_val < 0.05: text = '*'
  1693. else: text = 'ns'
  1694. ax.text((x1+x2)*0.5, y+0.02, text, ha='center', va='bottom',
  1695. color='black', fontsize=13, fontweight='normal',
  1696. transform=ax.get_xaxis_transform())
  1698. def plot_density(data, y_col, ylabel, filename, L=False):
  1699. plt.figure(figsize=(2, 4), dpi=dpival)
  1700. ax = sns.boxplot(data=data, x='Stage', y=y_col, hue='Stage', palette=PALETTE,
  1701. width=0.5, linewidth=1.5, order=STAGES, legend=False, showfliers=False)
  1702. if L:
  1703. ax.set_ylim(bottom=0)
  1704. g1 = data[data['Stage'] == 'HH17'][y_col].dropna()
  1705. g2 = data[data['Stage'] == 'HH20'][y_col].dropna()
  1706. _, p = stats.ttest_ind(g1, g2, equal_var=False)
  1707. add_external_stat(ax, 0, 1, 0, p)
  1708. set_common_style(ax, ylabel)
  1709. plt.subplots_adjust(top=0.8)
  1710. plt.rcParams['svg.fonttype'] = 'none'
  1711. plt.savefig(f"{filename}.svg", format='svg', bbox_inches='tight')
  1713. plot_density(
  1714. data=df,
  1715. y_col='Mean_Density',
  1716. ylabel='Spots density',
  1717. filename='HH17vsHH20_median_density_template',
  1718. L=True
  1719. )
  1721. plt.show()
  1723. # %% [markdown]
  1724. # ## Single-embryo heatmap
  1725. #
  1726. # Interpolates one scalar field from a single embryo onto a regular 500×500
  1727. # grid and displays it as a dorsoventral × rostrocaudal heatmap.
  1728. #
  1729. # **CSV**: `spatchcocked_measurements.csv` (or any CSV with the same columns)
  1730. # Columns required: `timepoint`, `norm_height`, `angle_degrees`, + the scalar
  1731. #
  1732. # **Parameters to adjust:**
  1733. # - `TARGET_TIMEPOINT` — date-stamp string identifying the embryo
  1734. # - `TARGET_PROPERTY` — column name to plot (see `property_map` below)
  1735. # - `master_csv` — path to the spatchcocked measurements CSV
  1737. # %%
  1738. import pandas as pd
  1739. import numpy as np
  1740. import matplotlib.pyplot as plt
  1741. import matplotlib.ticker as ticker
  1742. from scipy.interpolate import griddata
  1744. # --- Helper: symmetric colour range clipped at median ± sigma × std ---
  1745. def getTightercmap(values, sigma=3):
  1746. """Return (vmin, vmax) clipped at median ± sigma × std."""
  1747. return (np.median(values) - sigma * np.std(values),
  1748. np.median(values) + sigma * np.std(values))
  1750. # --- Property metadata: (axis label, colormap, symmetric range?, exponent) ---
  1751. property_map = {
  1752. "Gauss_Curvature": (r"Gaussian Curvature [$\mu m^{-2}$]", "PiYG", True, -6),
  1753. "Mean_Curvature": (r"Mean Curvature [$\mu m^{-1}$]", "PiYG", True, -3),
  1754. "K1": (r"Max principal k1 [$\mu m^{-1}$]", "Spectral_r", True, -3),
  1755. "K2": (r"Min principal k2 [$\mu m^{-1}$]", "Spectral_r", True, -3),
  1756. "thickness": (r"Thickness [$\mu m$]", "GnBu", False, 0),
  1757. "phh3": (r"Local pHH3+ cell count", "viridis", False, 0),
  1758. }
  1760. # --- Parameters ---
  1761. TARGET_TIMEPOINT = "2025-09-18-13-02" # embryo to plot
  1762. TARGET_PROPERTY = "Gauss_Curvature" # column to visualise (see property_map keys)
  1763. master_csv = "../data/csv/spatchcocked_measurements.csv"
  1765. # --- Load and filter ---
  1766. df_full = pd.read_csv(master_csv)
  1767. df = df_full[df_full["timepoint"] == TARGET_TIMEPOINT].copy()
  1768. print(f"Embryo {TARGET_TIMEPOINT}: {len(df)} vertices")
  1770. label, cmap_name, is_curv, exp = property_map[TARGET_PROPERTY]
  1772. # Rostrocaudal: flip so rostral (norm_height ≈ 1) appears at top of plot
  1773. y_coord = 1 - df["norm_height"] # 0 = rostral, 1 = caudal
  1774. x_coord = df["angle_degrees"] # −180 to +180
  1776. z = df[TARGET_PROPERTY]
  1778. # --- Interpolate onto a regular 500×500 grid ---
  1779. # Normalise both axes to [0,1] for griddata, then map back for display
  1780. y_norm = (y_coord - y_coord.min()) / (y_coord.max() - y_coord.min())
  1781. x_norm = (x_coord - x_coord.min()) / (x_coord.max() - x_coord.min())
  1783. grid_size = 500
  1784. xi, yi = np.meshgrid(np.linspace(0, 1, grid_size),
  1785. np.linspace(0, 1, grid_size))
  1786. zi = griddata((x_norm, y_norm), z, (xi, yi), method="linear")
  1788. # --- Colour limits ---
  1789. vmin, vmax = getTightercmap(z, sigma=3)
  1790. if is_curv:
  1791. vlim = max(abs(vmin), abs(vmax))
  1792. vmin, vmax = -vlim, vlim
  1793. else:
  1794. vmin = 0 # non-curvature fields start at zero
  1796. # --- Plot ---
  1797. line_width = 1.5
  1798. plt.rcParams.update({
  1799. "font.size": 12,
  1800. "axes.labelsize": 14,
  1801. "axes.titlesize": 14,
  1802. "xtick.major.width": line_width,
  1803. "ytick.major.width": line_width,
  1804. "axes.linewidth": line_width,
  1805. })
  1807. fig = plt.figure(figsize=(4, 4), dpi=100)
  1808. ax = fig.add_axes([0.15, 0.1, 0.65, 0.8])
  1810. im = ax.imshow(zi,
  1811. extent=[x_coord.min(), x_coord.max(),
  1812. y_coord.min(), y_coord.max()],
  1813. origin="lower", aspect="auto",
  1814. cmap=cmap_name, vmin=vmin, vmax=vmax)
  1816. ax.invert_yaxis() # rostral at top
  1817. ax.spines["top"].set_visible(False)
  1818. ax.spines["right"].set_visible(False)
  1819. ax.set_xticks([-180, -90, 0, 90, 180])
  1820. ax.set_xlabel("Dorsoventral axis")
  1821. ax.set_ylabel("Rostrocaudal axis")
  1823. cbar = plt.colorbar(im, ax=ax, orientation="vertical", pad=0.05)
  1825. # Scientific notation for curvature values or very small numbers
  1826. if is_curv or z.abs().max() < 0.1:
  1827. mult = 10 ** exp
  1828. cbar.ax.yaxis.set_major_formatter(
  1829. ticker.FuncFormatter(lambda val, pos, m=mult: f"{val/m:g}")
  1830. )
  1831. cbar.ax.text(0.5, 1.02, f"$\\times 10^{{{exp}}}$",
  1832. transform=cbar.ax.transAxes, ha="center", va="bottom")
  1834. cbar.set_label(label, labelpad=10)
  1835. plt.show()
  1837. # %% [markdown]
  1838. # ## Stage-averaged binned heatmap
  1839. #
  1840. # Bins all embryos of one stage into a 50-row RC grid × 10°-wide DV columns,
  1841. # takes the mean of each bin, and displays as a seaborn heatmap.
  1842. # This is the multi-embryo average map used in the paper figures.
  1843. #
  1844. # **Parameters to adjust:**
  1845. # - `TARGET_PROPERTY` — column to visualise (see `property_map` keys)
  1846. # - `TARGET_STAGE` — `"hh17"` or `"hh20"` (lowercase)
  1847. # - `master_csv` — path to the spatchcocked measurements CSV
  1848. #
  1849. # **Output:** SVG saved as `average_{TARGET_PROPERTY}_{TARGET_STAGE}.svg`
  1851. # %%
  1852. # %%
  1853. import pandas as pd
  1854. import numpy as np
  1855. import matplotlib.pyplot as plt
  1856. import matplotlib.ticker as ticker
  1857. import seaborn as sns
  1859. # %%
  1860. # ==========================================
  1861. # CONFIGURATION & TARGETS
  1862. # ==========================================
  1864. # TARGET_PROPERTY = "Gauss_Curvature"
  1865. # TARGET_STAGE = "hh17"
  1866. # TARGET_PROPERTY = "Mean_Curvature"
  1867. # TARGET_STAGE = "hh20"
  1868. # TARGET_PROPERTY = "thickness"
  1869. # TARGET_STAGE = "hh17"
  1871. TARGET_PROPERTY = "Gauss_Curvature"
  1872. TARGET_STAGE = "hh20"
  1874. master_csv = "../data/csv/spatchcocked_measurements.csv"
  1875. dpival = 100
  1877. # Styling
  1878. line_width = 1.5
  1879. font_size = 13
  1880. plt.rcParams.update({
  1881. 'font.size': font_size,
  1882. 'axes.labelsize': font_size + 2,
  1883. 'xtick.major.width': line_width,
  1884. 'ytick.major.width': line_width,
  1885. 'xtick.major.size': 6,
  1886. 'ytick.major.size': 6,
  1887. 'axes.linewidth': line_width,
  1888. 'svg.fonttype': 'none'
  1889. })
  1891. property_map = {
  1892. "Gauss_Curvature": (r"Gaussian Curvature [$\mu m^{-2}$]", "PiYG", True, -5),
  1893. "Mean_Curvature": (r"Mean Curvature [$\mu m^{-1}$]", "PiYG", True, -3),
  1894. "thickness": (r"Thickness [$\mu m$]", "GnBu", False, 0),
  1895. "phh3": (r"Local pH3+ cell count", "viridis", False, 0),
  1896. }
  1898. label, cmap_name, is_curv, exponent = property_map[TARGET_PROPERTY]
  1899. multiplier = 10 ** exponent
  1901. # ==========================================
  1902. # DATA PROCESSING
  1903. # ==========================================
  1904. df = pd.read_csv(master_csv)
  1906. # Bin vertices into RC (50 bins, rostral at top) × DV (10° bins)
  1907. df['rc_bin'] = pd.cut(1 - df['norm_height'], bins=50)
  1908. df['bin_center'] = df['rc_bin'].apply(lambda x: x.mid).astype(float)
  1909. df['angle_bin'] = pd.cut(df['angle_degrees'], bins=np.arange(-180, 190, 10))
  1910. df['angle_bin_center'] = df['angle_bin'].apply(lambda x: x.mid).astype(float)
  1912. df_stage = df[df['stage'] == TARGET_STAGE].copy()
  1913. print(f"Stage {TARGET_STAGE}: {len(df_stage)} vertices")
  1915. # ==========================================
  1916. # PLOTTING
  1917. # ==========================================
  1918. fig = plt.figure(figsize=(5, 5), dpi=dpival)
  1919. ax = fig.add_axes([0.15, 0.15, 0.7, 0.75])
  1921. # Mean per bin, pivot to 2D; interpolate gaps and fill remaining NaN
  1922. grouped = (df_stage
  1923. .groupby(['bin_center', 'angle_bin_center'], observed=False)[TARGET_PROPERTY]
  1924. .mean()
  1925. .reset_index())
  1926. pivot = grouped.pivot(index='bin_center', columns='angle_bin_center', values=TARGET_PROPERTY)
  1927. pivot = pivot.interpolate(axis=1).fillna(0).sort_index(ascending=True)
  1929. # Colour limits: 95th percentile of absolute values
  1930. raw_data = df_stage[TARGET_PROPERTY].dropna()
  1931. v_max_avg = np.percentile(np.abs(raw_data), 95)
  1932. if exponent != 0:
  1933. v_max_avg = np.ceil(v_max_avg / (multiplier * 0.5)) * (multiplier * 0.5)
  1934. v_min_avg = -v_max_avg if is_curv else 0
  1936. sns.heatmap(
  1937. pivot,
  1938. cmap=cmap_name,
  1939. vmin=v_min_avg, vmax=v_max_avg,
  1940. ax=ax,
  1941. linewidths=0.5,
  1942. linecolor='white',
  1943. xticklabels=False,
  1944. yticklabels=False,
  1945. cbar=False
  1946. )
  1948. # ==========================================
  1949. # STYLING & COLORBAR
  1950. # ==========================================
  1951. for _, spine in ax.spines.items():
  1952. spine.set_visible(True)
  1953. spine.set_linewidth(line_width)
  1954. ax.spines['top'].set_visible(False)
  1955. ax.spines['right'].set_visible(False)
  1957. ax.set_xlabel('Dorsoventral axis', labelpad=10)
  1958. ax.set_ylabel('Rostrocaudal axis', labelpad=10)
  1960. # Index-based tick positions — find nearest bin centre to each target value
  1961. target_y = [0.0, 0.2, 0.4, 0.6, 0.8, 1.0]
  1962. target_x = [-180, -90, 0, 90, 180]
  1964. y_pos = [np.abs(pivot.index.values - t).argmin() + 0.5 for t in target_y]
  1965. x_pos = [np.abs(pivot.columns.values - t).argmin() + 0.5 for t in target_x]
  1967. ax.set_yticks(y_pos)
  1968. ax.set_yticklabels([f"{t:.1f}" for t in target_y], rotation=0)
  1969. ax.set_xticks(x_pos)
  1970. ax.set_xticklabels([str(t) for t in target_x])
  1972. # Colorbar
  1973. cbar = fig.colorbar(ax.collections[0], ax=ax, orientation='vertical', pad=0.05)
  1974. cbar.outline.set_linewidth(line_width)
  1975. cbar.ax.tick_params(width=line_width, size=6)
  1976. cbar.set_label(label, labelpad=10)
  1978. if exponent != 0:
  1979. cbar.ax.yaxis.set_major_formatter(
  1980. ticker.FuncFormatter(lambda x, pos: f'{int(round(x / multiplier))}')
  1981. )
  1982. cbar.ax.text(0.5, 1.03, f'$\\times 10^{{{exponent}}}$',
  1983. transform=cbar.ax.transAxes, ha='center', va='bottom')
  1985. # ax.set_title(f"Stage Average: {TARGET_STAGE}", pad=20)
  1987. plt.savefig(f"average_{TARGET_PROPERTY}_{TARGET_STAGE}.svg", format='svg', bbox_inches='tight')
  1988. plt.show()

06_figure_plots.ipynb at commit 3306f17, under MIT · at the source

Overview

Authors: Nimesh Chahare1, Chieko Imamura1, Nandan L. Nerurkar1
ORCID iDs: Nimesh Chahare, Nandan L. Nerurkar
  1. Department of Biomedical Engineering, Columbia University, New York, NY, USA
Institutions: Columbia University (United States)
Journal: Biophysical reports, volume 6, issue 3, article 100280
Dates: received 20 May 2026; accepted 3 August 2026; published online 5 August 2026; in print September 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1016/j.bpr.2026.100280 · PMID 42556618 · PMCID PMC13521015 · OpenAlex W7196991408
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: structural MRI / diffusion (modality), other (organism), developmental (subfield)
Methods: Connectivity, Spectral & time-frequency
MeSH: Neural Tube*, Skull*, Animals, Cell Proliferation, Chick Embryo (* major topic)
Topic: Neurogenesis and neuroplasticity mechanisms (Developmental Neuroscience, Neuroscience), according to OpenAlex
Funding: NIH (R35 GM142995)
Citations: not cited yet (Europe PMC); 67 references in the paper

Abstract

The abstract is not reproduced here: the paper's license (CC BY-NC-ND) does not allow it. Read it in the paper, at the publisher or on Europe PMC.

Repository

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

nchahare/spatchcocking

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 3306f17988f70473ab3b944a391e26828f64a028, 21 May 2026
Languages: Python (13), Jupyter (8)
Size: 64 files, 21 scripts
Software Heritage: not archived
Found in: “Data and code availability”
Holds: README, license file, CITATION.cff, environment (requirements.txt, setup.py, finite_element/requirements_fem.txt), continuous integration, documentation, 8 notebooks
Not found: tests
Tools: NumPy (15 files), Matplotlib (7 files), SciPy (5 files), pandas (4 files), seaborn (2 files), statannotations (2 files), scikit-image (1 file), tifffile (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
23 files
At the source: github.com/nchahare/spatchcocking

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;
  • 21 scripts, each with its path and the digest of its content;
  • 16 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

No dataset and no data link were found in the paper.

Code and data availability statement

The paper has a code and data availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

Read it in the paper: doi.org/10.1016/j.bpr.2026.100280.

Versions

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

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 3 authors, 5 MeSH terms, 1 funder, 64 references.

Cite

This paper

Chahare, N., Imamura, C., & Nerurkar, N. L. (2026). Morphometric analysis reveals that the chick cranial neural tube expands as an active shell. Biophysical reports, 6(3), 100280. https://doi.org/10.1016/j.bpr.2026.100280

BibTeX

@article{chahare2026morphometric,
author = {Chahare, Nimesh and Imamura, Chieko and Nerurkar, Nandan L.},
title = {{Morphometric analysis reveals that the chick cranial neural tube expands as an active shell}},
journal = {Biophysical reports},
year = {2026},
month = aug,
volume = {6},
number = {3},
pages = {100280},
publisher = {Elsevier},
issn = {2667-0747},
doi = {10.1016/j.bpr.2026.100280},
url = {https://doi.org/10.1016/j.bpr.2026.100280},
pmid = {42556618},
pmcid = {PMC13521015}
}

RIS

TY - JOUR
AU - Chahare, Nimesh
AU - Imamura, Chieko
AU - Nerurkar, Nandan L.
TI - Morphometric analysis reveals that the chick cranial neural tube expands as an active shell
T2 - Biophysical reports
J2 - Biophys Rep (N Y)
PY - 2026
DA - 2026/08/05
VL - 6
IS - 3
SP - 100280
SN - 2667-0747
PB - Elsevier
DO - 10.1016/j.bpr.2026.100280
UR - https://doi.org/10.1016/j.bpr.2026.100280
LA - en
ER -

CSL-JSON

{
"id": "10.1016/j.bpr.2026.100280",
"type": "article-journal",
"title": "Morphometric analysis reveals that the chick cranial neural tube expands as an active shell",
"container-title": "Biophysical reports",
"author": [
{
"family": "Chahare",
"given": "Nimesh"
},
{
"family": "Imamura",
"given": "Chieko"
},
{
"family": "Nerurkar",
"given": "Nandan L."
}
],
"container-title-short": "Biophys Rep (N Y)",
"volume": "6",
"issue": "3",
"page": "100280",
"DOI": "10.1016/j.bpr.2026.100280",
"PMID": "42556618",
"PMCID": "PMC13521015",
"ISSN": "2667-0747",
"publisher": "Elsevier",
"URL": "https://doi.org/10.1016/j.bpr.2026.100280",
"language": "en",
"issued": {
"date-parts": [
[
2026,
8,
5
]
]
}
}

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: [code]
Real-time closed-loop feedback system for mouse mesoscale cortical signal and movement control
Journal: eLife
In common: statannotations, tifffile, scikit-image, 5 other tools
[2] doi:10.1126/sciadv.aeb4205 [code]
Learning stochastic dynamics and cell-fate landscapes from single-cell snapshots via optimal transport.
Journal: Science advances
In common: statannotations, tifffile, scikit-image, 5 other tools
[3] doi:10.64898/2026.03.30.715222 [code]
Synthetic lumen rounding directs neural progenitor division mode
Journal: bioRxiv (preprint)
In common: tifffile, scikit-image, seaborn, 4 other tools, developmental, 1 reference
[4] doi:10.1364/boe.605322 [code]
Generalized plaque digitization framework for multi-dimensional mesoscopic images.
Journal: Biomedical optics express
In common: tifffile, scikit-image, seaborn, 4 other tools, 1 reference
[5] doi:10.1186/s12880-026-02335-x [code]
Automatic lateral ventricle and choroid plexus segmentation method in infant brain MR images.
Journal: BMC medical imaging
In common: tifffile, scikit-image, seaborn, 4 other tools, developmental, structural MRI / diffusion
[6] doi:10.1117/1.nph.13.3.035006 [code]
Characterizing developmental changes in infant habituation using functional change point detection.
Journal: Neurophotonics
In common: statannotations, scikit-image, seaborn, 4 other tools, developmental
[7] doi:10.1038/s41467-026-73770-1 [code]
Non-coding structural variants disrupt FOXG1 transcriptional regulation in early neurodevelopment.
Journal: Nature communications
In common: statannotations, scikit-image, seaborn, 4 other tools, developmental
[8] doi:10.1002/alz.71649 [code]
Postmortem brain MRI reveals differential associations of subcortical and limbic volumes with cortical thinning and neurodegenerative pathologies.
Journal: Alzheimer's & dementia : the journal of the Alzheimer's Association
In common: statannotations, scikit-image, seaborn, 4 other tools, structural MRI / diffusion
[9] doi:10.1016/j.stem.2026.05.005 [code]
Generation of human appetite-regulating neurons and tanycytes from pluripotent stem cells.
Journal: Cell stem cell
In common: seaborn, pandas, SciPy, 2 other tools, 3 references
[10] doi:10.1038/s41467-026-76569-2 [code]
Self-organization of vascularized muscle from bovine embryonic stem cells.
Journal: Nature communications
In common: tifffile, scikit-image, seaborn, 4 other tools, other

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.