Struct SynthSegParams 

pub struct SynthSegParams {
    pub version: SynthSegVersion,
    pub crop: Option<usize>,
    pub flip_averaging: bool,
    pub topology_cleanup: bool,
    pub sigma_smoothing: f64,
    pub inference: SynthSegInference,
    pub head_crop: Option<usize>,
    pub posteriors: PosteriorPrecision,
}

SynthSeg inference parameters.

Fields

version: SynthSegVersion

Which generation of weights is being run — this selects the label table, so it must match the .onnx being passed in.

crop: Option<usize>

Optional cubic centre-crop, in voxels at 1 mm, applied before inference (rounded up to a multiple of 32). None — the default, and the SynthSeg CLI’s — processes the whole volume. Note that the CLI’s --crop help text claims a default of 192, but its argparse default is in fact None; matching the CLI means cropping nothing.

flip_averaging: bool

Average the posteriors with a left-right flipped second pass (SynthSeg’s default). Doubles inference time; --fast turns it off.

topology_cleanup: bool

Reset each topological class to its largest connected component (SynthSeg’s default). --fast turns it off.

sigma_smoothing: f64

Gaussian blur applied to the posteriors, in voxels (SynthSeg’s default is 0.5). Zero disables it.

inference: SynthSegInference

Whole-volume (default, the CLI’s) or sliding-window inference.

head_crop: Option<usize>

Crop the padded volume to the head before inference: the bounding box of the largest connected region brighter than 10 % of the normalised intensity range, grown by this many voxels on every side and rounded out to the pooling lattice. Everything outside it is background. None (the default, and the CLI’s) runs on the whole padded volume.

It saves memory and time only where there is empty space around the head (wide-FOV acquisitions, e.g. a 256³ field of view). When the head fills the field of view, as on typical GRE and MP2RAGE head scans (and their neck), the box plus margin is the whole padded volume and the run is identical to None, at no extra cost.

posteriors: PosteriorPrecision

How the posteriors are stored (the default, single precision, is the CLI’s).

Implementations

impl SynthSegParams

pub fn fast() -> Self

SynthSeg’s --fast: no flip averaging and no topological cleanup. Roughly halves the runtime for a small accuracy cost.

pub fn low_memory() -> Self

Memory-bounded setting for constrained hosts (e.g. 32-bit WASM): the defaults with SynthSegInference::LOW_MEMORY windows, a 16-voxel head crop and half-precision posteriors.

• The windows are what bring the network under a 4 GB heap; no whole-volume setting fits. 96³ rather than 128³ because 128³ fits only grids up to about 192×256×128.
• The head crop saves memory and time on wide-FOV scans and changes nothing (at no cost) when the head fills the field of view.
• Half-precision posteriors save 0.4 GB with no accuracy loss: peak WASM heap 2025 MB against 2418 MB at single precision on a 184×256×128 head, 2138 against 2634 MB on a 180×241×131 one.

It runs no slower than 96³ windows at a step of half a patch (the earlier browser setting): both place the same number of windows on 192×256×128 and 192×256×160 grids, and in back-to-back runs on those two grids it took 0.96–1.00× that setting’s time natively (median of 3 pairs each, 1 and 8 threads) and 0.98–1.00× in a single-threaded WASM build under Node (about 17 and 26 minutes). Converting half-precision values one at a time had made it 1–6 % slower natively; see Posterior::load.

Trait Implementations

impl Clone for SynthSegParams

fn clone(&self) -> SynthSegParams

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SynthSegParams

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

Formats the value using the given formatter.

impl Default for SynthSegParams

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for SynthSegParams

fn eq(&self, other: &SynthSegParams) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for SynthSegParams

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for SynthSegParams