Struct RigidTransform 

pub struct RigidTransform {
    pub matrix: [f64; 16],
    pub params: [f64; 6],
    pub fixed_dims: (usize, usize, usize),
    pub fixed_affine: [f64; 16],
    pub moving_dims: (usize, usize, usize),
    pub moving_affine: [f64; 16],
    pub ncc: f64,
    pub overlap: f64,
    pub evaluations: usize,
}

A recovered rigid transform, together with everything needed to use it.

Which way it points

Self::matrix maps fixed world → moving world: it answers “where in the moving acquisition is the anatomy that the fixed volume has here”, which is the direction resampling needs (for each output voxel, find where to read). The inverse direction is one Self::inverse away, and it is worth being pedantic about this: applying the rotation the wrong way round produces a plausible-looking, wrong susceptibility map rather than an error.

Fields

matrix: [f64; 16]

Row-major 4×4 rigid transform, fixed world → moving world. Pure rotation plus translation; no scaling or shear.

params: [f64; 6]

The six parameters matrix was built from: [rx, ry, rz, tx, ty, tz], rotations in radians composed as Rz(rz)·Ry(ry)·Rx(rx) about the fixed volume’s world centre, translations in mm of world space.

fixed_dims: (usize, usize, usize)

Dimensions and voxel→world affine of the fixed volume — the common grid.

fixed_affine: [f64; 16]

moving_dims: (usize, usize, usize)

Dimensions and original voxel→world affine of the moving volume, as handed in.

moving_affine: [f64; 16]

ncc: f64

Normalised cross-correlation at the solution, on [-1, 1]. Same-subject magnitude volumes that genuinely align land above ~0.9; below ~0.5 something is wrong.

overlap: f64

Fraction of sampled fixed voxels that found a moving sample at the solution. Well under 1.0 means the volumes only partially overlap, which may be correct (a slab inside a head) or may mean the search wandered.

evaluations: usize

Metric evaluations used, summed over pyramid levels. Diagnostic.

Implementations

impl RigidTransform

pub fn identity( fixed_dims: (usize, usize, usize), fixed_affine: &[f64; 16], moving_dims: (usize, usize, usize), moving_affine: &[f64; 16], ) -> Self

The identity transform between two grids — the “already registered” answer, for callers that skip estimation but still want one uniform type to resample and read directions through.

pub fn rotation_degrees(&self) -> [f64; 3]

The three rotation angles in degrees, in the order Self::params stores them.

pub fn translation_mm(&self) -> [f64; 3]

The translation in mm of world space.

pub fn rotation_magnitude_deg(&self) -> f64

Total rotation angle in degrees, regardless of axis — the single number to eyeball when deciding whether a registration did anything.

pub fn aligned_affine(&self) -> [f64; 16]

The moving volume’s voxel→world affine after alignment: re-tag the moving volume with this and its world coordinates agree with the fixed volume’s anatomy, with no interpolation at all.

Do not then read B0 off it. This affine describes the volume in the reference anatomy’s world, where “world +z” is the reference orientation’s B0 and not this orientation’s, so b0_direction_from_affine applied to it is meaningless. Use Self::b0_direction_in_fixed.

pub fn b0_direction_in_fixed( &self, declared_moving_b0: Option<(f64, f64, f64)>, ) -> (f64, f64, f64)

The moving acquisition’s B0 direction expressed in the fixed grid’s voxel frame — exactly the bdirs entry [crate::inversion::cosmos] and [crate::inversion::sti] want for this orientation.

declared_moving_b0 is a sidecar-declared B0 direction in the moving volume’s own voxel frame, in the convention b0_direction_from_affine returns (the world B0 resolved onto the volume’s normalised voxel axes). Pass None to read it off the moving affine, which is right whenever that affine is the scanner’s own.

The chain is: lift the direction into the moving volume’s world, rotate it into the fixed volume’s world with the inverse of Self::matrix (a free vector carries no translation), then resolve it onto the fixed grid’s normalised voxel axes. With no rotation it reduces to b0_direction_from_affine(fixed_affine), as it must.

pub fn resample(&self, moving: &[f64]) -> Option<Vec<f64>>

Resample continuous moving data (magnitude, an unwrapped field map, χ) onto the fixed grid. Not for wrapped phase — use Self::resample_complex.

pub fn resample_mask(&self, mask: &[u8]) -> Option<Vec<u8>>

Resample a moving binary mask or label volume onto the fixed grid (nearest neighbour).

pub fn resample_complex( &self, magnitude: &[f64], phase: &[f64], ) -> Option<(Vec<f64>, Vec<f64>)>

Resample magnitude and wrapped phase onto the fixed grid together, interpolating mag·e^{iφ} so the wraps survive. Returns (magnitude, phase).

pub fn inverse(&self) -> Self

The same alignment with the roles swapped: the transform taking the old moving volume as fixed and vice versa. Lets a chain of pairwise registrations be re-referenced without re-estimating anything — what intra-run motion correction needs when the volume it registered against is not the one it wants to output on.

Trait Implementations

impl Clone for RigidTransform

fn clone(&self) -> RigidTransform

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RigidTransform

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.