Struct RigidParams 

pub struct RigidParams {
    pub levels: usize,
    pub max_samples: usize,
    pub max_iterations: usize,
    pub max_evaluations: usize,
    pub tolerance: f64,
    pub rotation_step_deg: f64,
    pub translation_step_mm: f64,
    pub min_overlap: f64,
    pub initial: Option<[f64; 6]>,
}

Registration parameters.

Fields

levels: usize

Pyramid levels, finest included. 5 means the volume is registered at 1/16, then 1/8, 1/4, 1/2 and full resolution. Levels that would shrink any axis below 8 voxels are dropped, so a small volume quietly gets fewer and nothing has to be tuned for it.

This is the capture range, and it is the one parameter not to lower. The search starts from the identity, so for identically prescribed slabs it begins with the whole head rotation as the error to find — and 1 - NCC is not a single bowl. A brain is roughly symmetric and full of repeating structure, so the cost falls, rises as one gyrus lines up with its neighbour, and falls again; past some misalignment the coarsest level has a competing minimum of its own and the search converges into it, reporting success.

Measured on the in-vivo-sized test phantom (test_multiorient_register_capture_range), sweeping an oblique-axis rotation:

levels	converges up to
3	40°, then fails hard — 92° out, NCC 0.19
5	the whole swept range to 70°, to 0.01°

3 was the original default and is not enough: STI wants orientations spread widely over the sphere, so 45° of repositioning is ordinary and would have landed in the failure. The two extra levels cost about twice the metric evaluations but very little wall clock, because the coarse levels hold a few thousand samples each against the cap below.

max_samples: usize

Upper bound on fixed voxels sampled per metric evaluation, per level.

This, not the volume size, sets the cost of a registration: a 256³ and a 700³ volume take the same time. 6 parameters are vastly over-determined by 10⁵ samples, so lowering this buys speed long before it costs accuracy.

max_iterations: usize

Maximum Powell cycles (one pass over all six directions) per level.

max_evaluations: usize

Total metric evaluations across all levels, as a hard stop. Reached only on a cost surface that will not converge; the best parameters so far are returned either way.

tolerance: f64

Relative cost improvement per Powell cycle below which a level is considered converged.

rotation_step_deg: f64

Initial line-search step for the three rotations, at the finest level, in degrees. Coarser levels scale it up with the level’s decimation factor.

translation_step_mm: f64

Initial line-search step for the three translations, at the finest level, in mm. Coarser levels scale it up with the level’s decimation factor.

min_overlap: f64

Smallest fraction of sampled fixed voxels that must still land inside the moving volume.

NCC over a shrinking overlap is gameable — slide the volumes apart until only one well-correlated patch is left and the correlation goes up. Candidates below this floor are costed worse than any real match, with a gradient that pushes back into the valid region. Keep it low enough for a legitimately partial overlap (a thin slab against a whole head).

initial: Option<[f64; 6]>

Starting parameters, in the convention of RigidTransform::params. None starts from the identity, i.e. it trusts the two affines to place the volumes in a common world — correct both for separately prescribed slabs (where the affines differ and are truthful) and for identically prescribed ones (where they agree and only the anatomy moved).

Seed it when a previous answer is a good prior and the pyramid’s coarse search is wasted work: registering a time series to one reference, for instance, where each volume starts from where the last one landed. The parameters are defined about the fixed volume’s world centre, so they carry between pairs that share a fixed volume without conversion.

Trait Implementations

impl Clone for RigidParams

fn clone(&self) -> RigidParams

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RigidParams

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

Formats the value using the given formatter.

impl Default for RigidParams

fn default() -> Self

Returns the “default value” for a type.

impl Serialize for RigidParams

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.