Heart alignment varying thickness

Heart alignment varying thickness#

The same heart pairing, on sections cut at different thicknesses – so the two differ in density as well as in shape, and the intensity regression inside the solver has to absorb the difference before the deformation can be read. Upstream caps this one at niter=1000, which is not enough: the two sections start 1742 um apart and at the default translation step that budget only closes it to 1587. Leaving niter alone – squidpy’s default is 5000, and so is upstream’s LDDMM’s – gets it to 238 um. Nothing else needed tuning; it was an iteration budget, not a parameter.

Upstream’s equivalent is heart-alignment-varying-thickness. One call does the alignment: stalign_align_obs fits a diffeomorphism straight between two point clouds, rasterizing both sides itself.

STalign’s own version of this analysis: heart-alignment-varying-thickness.

Inputs#

import anndata as ad, numpy as np, pandas as pd

def read_xy(path, x, y, *, skip_first=False):
    df = pd.read_csv(path)
    xy = np.c_[np.asarray(df[x])[1:] if skip_first else df[x],
               np.asarray(df[y])[1:] if skip_first else df[y]].astype(float)
    return ad.AnnData(X=np.zeros((len(xy), 1)), obsm={'spatial': xy})

ref = read_xy('heart_data/4_CN73_C2.csv.gz', 'x', 'y')
query = read_xy('heart_data/3_CN73_D2.csv.gz', 'x', 'y')
print(f'{ref.n_obs} reference cells, {query.n_obs} query cells')
3388 reference cells, 3605 query cells

The fit#

Upstream’s own solver values, and squidpy’s defaults for everything else.

from squidpy.experimental.tl import stalign_align_obs

fit = stalign_align_obs(
    ref, query, spatial_key='spatial',
    dx=100.0, blur=1.0, epV=1000, sigmaB=0.1,
)
print(f'{fit.n_iter} iterations, objective '
      f'{float(fit.energies[0]):.0f} -> {float(fit.energies[-1]):.0f}')
5000 iterations, objective 499 -> 256

Where the cells land#

StalignFit.transform writes the mapped coordinates straight back into the query’s obsm, so the alignment ends up on the object rather than in a local variable. It evaluates the fitted map at each point, so a cell lands where it lands rather than at the nearest raster cell.

import matplotlib.pyplot as plt
from matplotlib.lines import Line2D
from scipy.spatial import cKDTree

fit.transform(query, key_added='aligned')
moved = query.obsm['aligned']

# Whether the fit worked, in the units of the data rather than of the objective. The energy
# can halve while the sections stay as far apart as they started -- that is what an iteration
# budget that ran out looks like, and it is invisible in the energy alone.
tree = cKDTree(ref.obsm['spatial'])
before = tree.query(query.obsm['spatial'])[0]
after = tree.query(moved)[0]
print(f"centroid offset {np.linalg.norm(query.obsm['spatial'].mean(0) - ref.obsm['spatial'].mean(0)):.0f}"
      f" -> {np.linalg.norm(moved.mean(0) - ref.obsm['spatial'].mean(0)):.0f}")
print(f'distance to the nearest reference cell: median {np.median(before):.0f} -> '
      f'{np.median(after):.0f}, 90th percentile {np.percentile(before, 90):.0f} -> '
      f'{np.percentile(after, 90):.0f}')

fig, ax = plt.subplots(1, 2, figsize=(12, 5.5))
for a, (pts, title) in zip(ax, [(query.obsm['spatial'], 'before'),
                                (moved, 'after the fit')], strict=True):
    a.scatter(*ref.obsm['spatial'].T, s=0.12, alpha=0.3, label='reference')
    a.scatter(*pts.T, s=0.12, alpha=0.3, label='query')
    a.set_title(title); a.set_aspect('equal'); a.invert_yaxis()
    a.set_xticks([]); a.set_yticks([])
ax[0].legend(handles=[Line2D([], [], marker='o', ls='', ms=5, color=c, label=l)
                     for c, l in (('tab:blue', 'reference'), ('tab:orange', 'query'))],
             loc='lower left', fontsize=8)
centroid offset 830 -> 222
distance to the nearest reference cell: median 44 -> 34, 90th percentile 242 -> 75
<matplotlib.legend.Legend at 0x7f083718f0e0>
../../_images/ac9534bdc713322d970a54697b602e23e40a6a3de2c80793e6d639c6c2789f5f.png

Convergence#

energies = np.asarray(fit.energies)[: fit.n_iter]
plt.figure(figsize=(5, 3))
plt.plot(energies, lw=0.8)
plt.xlabel('iteration'); plt.ylabel('objective'); plt.grid(alpha=0.3)
../../_images/7bf2deff64d466fbba9b0de934c5690da4e332f373426dec56411ce56e3813e3.png