Slice-timing correction representation

[effigies]

I haven't had the time to sit down and really understand this, but nipy has STC implemented as part of realign4d. It uses affine transforms, so I suspect we can find a compact serializable representation of STC for nitransforms.

https://github.com/nipy/nipy/blob/d16d268938dcd5c15748ca051532c21f57cf8a22/nipy/algorithms/registration/groupwise_registration.py

This is brought up in the context of attempting to reduce the outputs of preprocessing to a minimum while preserving flexibility for downstream uses. In the absence of an STC transform, the ST-corrected BOLD series would be a required output, if calculated.

[effigies]

Having read the paper and looked through the code a bit, it turns out the affine is a constraint on the spatial transform, but the final representation of the space-time realign is a cubic spline. I don't know if it would make sense to come up with our own representation of a temporal realignment, or figure out how to degenerate the spline representation to one that is constant over time and has no spatial component.

[effigies]

Other algorithms:

• FMRIB's TIGER: https://www.sciencedirect.com/science/article/pii/S0262885606000345 (I'm not sure if the tool is distributed...)
• SPM STC: https://github.com/spm/spm12/blob/3085dac00ac804adb190a7e82c6ef11866c8af02/spm_slice_timing.m
• AFNI 3dTshift: https://github.com/afni/afni/blob/25e77d564f2c67ff480fa99a7b8e48ec2d9a89fc/src/3dTshift.c

[oesteban]

The limitation to this is that scipy only supports up to 3D cubic B-Spline interpolation. The extension to 4D is not trivial but not hard (esp. reusing the 3D implementation on scipy).

The rest of it is dealing with the additional dimension when converting from IJK+L to RAS+t and viceversa.

[oesteban]

Adding on the above - that works for volume (gridded) data.

For surfaced-sampled data, we need to finish #106, and add the t-axis interpolator basis. I'm not sure how computationally heavy this will be (probably affordable for fsaverage5 resolution and <1k timesteps, but probably excessively slow for fsaverage6).

[oesteban]

Scipy now interpolates ND grids, so technically this would be easy. Also, after #247, this should be relatively easy to implement. Here:

nitransforms/nitransforms/resampling.py

Lines 321 to 331 in a03c51f

	if xfm_nvols > 1:
	assert targets.ndim == 3
	n_time, n_dim, n_vox = targets.shape
	# Reshape to (3, n_time x n_vox)
	ijk_targets = np.rollaxis(targets, 0, 2).reshape((n_dim, -1))
	time_row = np.repeat(np.arange(n_time), n_vox)[None, :]
	# Now targets is (4, n_vox x n_time), with indexes (t, i, j, k)
	# t is the slowest-changing axis, so we put it first
	targets = np.vstack((time_row, ijk_targets))
	data = np.rollaxis(data, data.ndim - 1, 0)

the coordinates are made 4D with t being the first one. Instead of generating only on-grid points for t, here we could write the appropriate timing for each slice (it may become a bit tedious, but should be doable).

The bigger problem, in this case, is to divide the problem, as we will need some sliding window on time (or space) to interpolate large images.