Programs · ANTs and ITK
Atropos
Atropos segments an image into tissue classes by a finite mixture model with a Markov random field prior.
- Original
- ANTs 2.6.5
- Command line
larmorx ants Atropos- Python
lx.ants.atropos- Ports
- replica
larmorxApache-2.0 validated
- replica
- Evidence
- every comparison with ANTs
- Source
- made from docs/api/ants-atropos.md and the code
What it does
The method is Avants et al.'s (An open source multivariate framework for n-tissue
segmentation with evaluation on public data, Neuroinformatics 9:381-400, 2011); sMRIPrep runs it
once per subject, in its brain extraction (atropos_wf): K-means with three classes, Gaussian
likelihoods, MRF 0.1, three iterations, the fixed seed.
Command line
larmorx ants Atropos ...Everything after larmorx ants Atropos is the original’s command line: the arguments of ANTs 2.6.5’s Atropos, as ANTs takes them. LARMORX’s own options stand between larmorx and the family ants, so they never meet the original’s (below):
larmorx
[--n-threads N]
[--implementation auto|replica|clean-room]
[--upstream-defects fix|reproduce]
ants Atropos ...From the next release. In 0.1.0rc1, set the variables instead: OMP_NUM_THREADS, LARMORX_IMPLEMENTATION (original for the clean room) and LARMORX_UPSTREAM_DEFECTS.
Python
lx.ants.atropos(
images: Any | Sequence[Any],
mask: Any,
*,
classes: int = 3,
initialization: Initialization = "kmeans",
kmeans_centers: Sequence[float] | None = None,
priors: Sequence[Any] | None = None,
prior_label: Any = None,
prior_weight: float = 0.0,
prior_threshold: float | None = None,
likelihood: LikelihoodModel | None = None,
posterior_formulation: Formulation = "socrates",
use_mixture_model_proportions: bool = True,
annealing: tuple[float, float, float] = (1.0, 1.0, 0.1),
iterations: int = 5,
convergence_threshold: float = 0.001,
mrf_smoothing: Any = 0.3,
mrf_radius: int | Sequence[int] = 1,
icm: bool = True,
icm_iterations: int = 1,
use_random_seed: bool = True,
euclidean_distance: bool = False,
label_propagation: Mapping[int, tuple[float, float]] | tuple[float, float] | None = None,
minimize_memory: bool = False,
outliers: BoxPlot | GrubbsRosner | None = None,
partial_volume: Sequence[tuple[int, int]] = (),
partial_volume_likelihoods: bool = False,
adaptive_smoothing: float | Sequence[float] = 0.0,
bspline: tuple[int | Sequence[int], int | Sequence[int], int] = (6, 1, 3),
likelihood_images: bool = False,
distance_images: bool = False,
smoothed_images: bool = False,
icm_code_image: bool = False,
dimension: int | None = None,
n_threads: int = 1,
upstream_defects: UpstreamDefectsName = "fix",
) -> AtroposResultWhere Initialization is one of "kmeans", "otsu", "random", "prior-probabilities", "prior-label"; Formulation is one of "socrates", "plato", "aristotle", "sigmoid"; UpstreamDefectsName is one of "fix", "reproduce".
Atropos -d D -a image... -x mask -i <initialization> -k <likelihood> -p <formulation> -c [iterations,threshold] -m [smoothing,radius] -g ... -r ... -o [...].
Returns an AtroposResult: labels (the classified image, uint32), posteriors (one
float32 image per class, 0 outside the mask), with the arguments that ask for them
likelihoods, distances, smoothed and icm_codes, and iterations and log (the
progress lines and the filter’s settings and models). lx.ants.atropos raises
lx.ants.AtroposError with ANTs’ message where Atropos stops (a class that loses all its
voxels, a singular covariance, a missing file), and ValueError for arguments the command line
cannot express.
import larmorx as lx
# sMRIPrep's call (the defaults are Atropos': Gaussian likelihoods, MRF 0.3, 5 iterations)
seg = lx.ants.atropos("t1w_n4.nii.gz", "brain_mask.nii.gz", classes=3, mrf_smoothing=0.1,
iterations=3, convergence_threshold=0, use_random_seed=False,
n_threads=8)
seg.labels.to_filename("labels.nii.gz") # 1 = CSF, 2 = GM, 3 = WM (by intensity)
csf, gm, wm = seg.posteriors # float32 probability images
# antsCorticalThickness-style: tissue priors, weight 0.25, five iterations
seg = lx.ants.atropos(t1w, mask, initialization="prior-probabilities",
priors=["csf.nii.gz", "gm.nii.gz", "wm.nii.gz"], prior_weight=0.25,
mrf_smoothing=0.1, iterations=5, convergence_threshold=0)
# two contrasts, histogram Parzen windows, box-plot winsorizing
seg = lx.ants.atropos([t1w, t2w], mask, initialization="otsu",
likelihood=lx.ants.HistogramParzenWindows(sigma=1.0, bins=32),
outliers=lx.ants.BoxPlot())Its result, AtroposResult, holds the segmentation.
| Field | Type | What it holds |
|---|---|---|
labels |
Image |
|
posteriors |
tuple[Image, ...] |
|
likelihoods |
tuple[Image, ...] |
|
distances |
tuple[Image, ...] |
|
smoothed |
tuple[Image, ...] |
|
icm_codes |
Image | None |
|
iterations |
tuple[AtroposIteration, ...] |
|
log |
str |
Options
Each row joins an option of the original’s command line with the Python argument that does the same. The rows are checked against the code at every test run: the options Atropos accepts (crates/larmorx-ants/src/cli/atropos.rs) and the arguments of lx.ants.atropos (python/larmorx/ants/atropos.py), whose defaults and descriptions are taken from it. Under each option, in grey, ANTs’s own help for it.
| ANTs option | Python | Default | Notes |
|---|---|---|---|
-d 2/3/4, --image-dimensionality |
dimension |
None |
default: the first image’s; without -d ANTs reads every image as 3D (ANTS-99, in Upstream defects); the Python wrapper always passes itANTs: “This option forces the image to be treated as a specified-dimensional image. If not specified, Atropos tries to infer the dimensionality from the first input image.” |
-a image / -a [image,w] (repeatable), --intensity-image |
images (one or a list); adaptive_smoothing=w (one value, or one per image) |
adaptive_smoothing=0.0 |
paths, lx.Image, nibabel images or (array, affine), read as float on the first image’s grid; the weight mixes the intensity with its B-spline fit per class, for prior-based initializations only (ANTS-93)ANTs: “One or more scalar images is specified for segmentation using the -a/–intensity-image option. For segmentation scenarios with no prior information, the first scalar image encountered on the command line is used to order labelings such that the class with the smallest intensity signature is class ‘1’ through class ‘N’ which represents the voxels with the largest intensity values. The optional adaptive smoothing weight parameter is applicable only when using prior label or probability images. This scalar parameter is to be specified between [0,1] which smooths each labeled region separately and modulates the intensity measurement at each voxel in each intensity image between the original intensity and its smoothed counterpart. The smoothness parameters are governed by the -b/–bspline option.” |
-x mask, --mask-image |
mask |
required; read as unsigned int (0.6 is 0); its non-zero voxels are segmentedANTs: “The image mask (which is required) defines the region which is to be labeled by the Atropos algorithm.” |
|
-i Random[K], --initialization |
initialization="random", classes=K |
initialization="kmeans", classes=3 |
labels drawn with the filter’s generatorANTs: “To initialize the FMM parameters, one of the following options must be specified. If one does not have prior label or probability images we recommend using kmeans as it is typically faster than otsu and can be used with multivariate initialization. However, since a Euclidean distance on the inter cluster distances is used, one might have to appropriately scale the additional input images. Random initialization is meant purely for intellectual curiosity. The prior weighting (specified in the range [0,1]) is used to modulate the calculation of the posterior probabilities between the likelihoodmrfprior and the likelihoodmrfprior*prior. For specifying many prior probability images for a multi-label segmentation, we offer a minimize usage option (see -m). With that option one can specify a prior probability threshold in which only those pixels exceeding that threshold are stored in memory. ” |
-i Otsu[K] |
initialization="otsu" |
"kmeans" |
Otsu’s thresholds of the first image (200 bins)ANTs: “To initialize the FMM parameters, one of the following options must be specified. If one does not have prior label or probability images we recommend using kmeans as it is typically faster than otsu and can be used with multivariate initialization. However, since a Euclidean distance on the inter cluster distances is used, one might have to appropriately scale the additional input images. Random initialization is meant purely for intellectual curiosity. The prior weighting (specified in the range [0,1]) is used to modulate the calculation of the posterior probabilities between the likelihoodmrfprior and the likelihoodmrfprior*prior. For specifying many prior probability images for a multi-label segmentation, we offer a minimize usage option (see -m). With that option one can specify a prior probability threshold in which only those pixels exceeding that threshold are stored in memory. ” |
-i KMeans[K] / KMeans[K,c1xc2x...] |
initialization="kmeans", kmeans_centers=[...] |
initialization="kmeans", kmeans_centers=None |
k-means on the first image from centres spread over its range in the mask, or given; with several images, a second k-means on allANTs: “To initialize the FMM parameters, one of the following options must be specified. If one does not have prior label or probability images we recommend using kmeans as it is typically faster than otsu and can be used with multivariate initialization. However, since a Euclidean distance on the inter cluster distances is used, one might have to appropriately scale the additional input images. Random initialization is meant purely for intellectual curiosity. The prior weighting (specified in the range [0,1]) is used to modulate the calculation of the posterior probabilities between the likelihoodmrfprior and the likelihoodmrfprior*prior. For specifying many prior probability images for a multi-label segmentation, we offer a minimize usage option (see -m). With that option one can specify a prior probability threshold in which only those pixels exceeding that threshold are stored in memory. ” |
-i PriorProbabilityImages[K,pattern%02d,w(,t)] |
initialization="prior-probabilities", priors=[...], prior_weight=w, prior_threshold=t |
initialization="kmeans", priors=None, prior_weight=0.0, prior_threshold=None |
one image per class (paths or images; the wrapper names them as a %02d series), or one vector image on the command line; t: below it a voxel counts as without priorsANTs: “To initialize the FMM parameters, one of the following options must be specified. If one does not have prior label or probability images we recommend using kmeans as it is typically faster than otsu and can be used with multivariate initialization. However, since a Euclidean distance on the inter cluster distances is used, one might have to appropriately scale the additional input images. Random initialization is meant purely for intellectual curiosity. The prior weighting (specified in the range [0,1]) is used to modulate the calculation of the posterior probabilities between the likelihoodmrfprior and the likelihoodmrfprior*prior. For specifying many prior probability images for a multi-label segmentation, we offer a minimize usage option (see -m). With that option one can specify a prior probability threshold in which only those pixels exceeding that threshold are stored in memory. ” |
-i PriorLabelImage[K,labels,w] |
initialization="prior-label", prior_label, prior_weight |
initialization="kmeans", prior_label=None, prior_weight=0.0 |
labels 1 to K; unlabelled voxels of the mask are reached by propagationANTs: “To initialize the FMM parameters, one of the following options must be specified. If one does not have prior label or probability images we recommend using kmeans as it is typically faster than otsu and can be used with multivariate initialization. However, since a Euclidean distance on the inter cluster distances is used, one might have to appropriately scale the additional input images. Random initialization is meant purely for intellectual curiosity. The prior weighting (specified in the range [0,1]) is used to modulate the calculation of the posterior probabilities between the likelihoodmrfprior and the likelihoodmrfprior*prior. For specifying many prior probability images for a multi-label segmentation, we offer a minimize usage option (see -m). With that option one can specify a prior probability threshold in which only those pixels exceeding that threshold are stored in memory. ” |
-p Socrates[mix,T0,rate,Tmin] (Plato, Aristotle, Sigmoid), --posterior-formulation |
posterior_formulation="socrates", use_mixture_model_proportions, annealing=(T0, rate, Tmin) |
posterior_formulation="socrates", use_mixture_model_proportions=True, annealing=(1.0, 1.0, 0.1) |
see the findings; annealing applies only when T0 is not 1ANTs: “Different posterior probability formulations are possible as are different update options. To guarantee theoretical convergence properties, a proper formulation of the well-known iterated conditional modes (ICM) uses an asynchronous update step modulated by a specified annealing temperature. If one sets the AnnealingTemperature > 1 in the posterior formulation a traditional code set for a proper ICM update will be created. Otherwise, a synchronous update step will take place at each iteration. The annealing temperature, T, converts the posteriorProbability to posteriorProbability^(1/T) over the course of optimization. Options include the following: Socrates: posteriorProbability = (spatialPrior)^priorWeight*(likelihood*mrfPrior)^(1-priorWeight), Plato: posteriorProbability = 1.0, Aristotle: posteriorProbability = 1.0, Sigmoid: posteriorProbability = 1.0, ” |
-k Gaussian, --likelihood-model |
likelihood=lx.ants.GaussianLikelihood() (the default) |
None |
weighted mean and covariance per classANTs: “Both parametric and non-parametric options exist in Atropos. The Gaussian parametric option is commonly used (e.g. SPM & FAST) where the mean and standard deviation for the Gaussian of each class is calculated at each iteration. Other groups use non-parametric approaches exemplified by option 2. We recommend using options 1 or 2 as they are fairly standard and the default parameters work adequately.” |
-k HistogramParzenWindows[σ,bins] |
likelihood=lx.ants.HistogramParzenWindows(sigma, bins) |
None |
ANTs: “Both parametric and non-parametric options exist in Atropos. The Gaussian parametric option is commonly used (e.g. SPM & FAST) where the mean and standard deviation for the Gaussian of each class is calculated at each iteration. Other groups use non-parametric approaches exemplified by option 2. We recommend using options 1 or 2 as they are fairly standard and the default parameters work adequately.” |
-k ManifoldParzenWindows[σr,kEval,kCov,σk] |
likelihood=lx.ants.ManifoldParzenWindows(regularization_sigma, evaluation_k, covariance_k, kernel_sigma) |
None |
ANTS-95, ANTS-104ANTs: “Both parametric and non-parametric options exist in Atropos. The Gaussian parametric option is commonly used (e.g. SPM & FAST) where the mean and standard deviation for the Gaussian of each class is calculated at each iteration. Other groups use non-parametric approaches exemplified by option 2. We recommend using options 1 or 2 as they are fairly standard and the default parameters work adequately.” |
-k JointShapeAndOrientationProbability[σs,bs,σo,bo] |
likelihood=lx.ants.JointShapeAndOrientationProbability(...) |
None |
tensors: 6 images in 3D (xx xy xz yy yz zz); ANTS-103ANTs: “Both parametric and non-parametric options exist in Atropos. The Gaussian parametric option is commonly used (e.g. SPM & FAST) where the mean and standard deviation for the Gaussian of each class is calculated at each iteration. Other groups use non-parametric approaches exemplified by option 2. We recommend using options 1 or 2 as they are fairly standard and the default parameters work adequately.” |
-k LogEuclideanGaussian |
likelihood=lx.ants.LogEuclideanGaussian() |
None |
tensors, as aboveANTs: “Both parametric and non-parametric options exist in Atropos. The Gaussian parametric option is commonly used (e.g. SPM & FAST) where the mean and standard deviation for the Gaussian of each class is calculated at each iteration. Other groups use non-parametric approaches exemplified by option 2. We recommend using options 1 or 2 as they are fairly standard and the default parameters work adequately.” |
-c [n,threshold], --convergence |
iterations=5, convergence_threshold=0.001 |
iterations=5, convergence_threshold=0.001 |
stops when the mean largest posterior grows by less than the thresholdANTs: “Convergence is determined by calculating the mean maximum posterior probability over the region of interest at each iteration. When this value decreases or increases less than the specified threshold from the previous iteration or the maximum number of iterations is exceeded the program terminates.” |
-m [β,radius] / -m [coefficients,radius], --mrf |
mrf_smoothing=0.3 (a number or an image), mrf_radius=1 (one value or one per axis) |
mrf_smoothing=0.3, mrf_radius=1 |
ANTs: “Markov random field (MRF) theory provides a general framework for enforcing spatially contextual constraints on the segmentation solution. The default smoothing factor of 0.3 provides a moderate amount of smoothing. Increasing this number causes more smoothing whereas decreasing the number lessens the smoothing. The radius parameter specifies the mrf neighborhood. Different update schemes are possible but only the asynchronous updating has theoretical convergence properties. ” |
-g [async,iterations,codes], --icm |
icm=True, icm_iterations=1, icm_code_image=True |
icm=True, icm_iterations=1, icm_code_image=False |
the result’s icm_codes; the documented bracketed form makes ANTs abort (ANTS-102); the wrapper writes -g 1[1,n]ANTs: “Asynchronous updating requires the construction of an ICM code image which is a label image (with labels in the range {1,…,MaximumICMCode}) constructed such that no MRF neighborhood has duplicate ICM code labels. Thus, to update the voxel class labels we iterate through the code labels and, for each code label, we iterate through the image and update the voxel class label that has the corresponding ICM code label. One can print out the ICM code image by specifying an ITK-compatible image filename.” |
-r 0/1, --use-random-seed |
use_random_seed=True |
True |
ANTs seeds from the clock (1, its default) or with 19650218 (0); larmorx never reads the clock: 1 gives the seed 121212ANTs: “Initialize internal random number generator with a random seed. Otherwise, initialize with a constant seed number.” |
-e 0/1, --use-euclidean-distance |
euclidean_distance |
False |
propagate prior labels by Euclidean distance instead of fast marchingANTs: “Given prior label or probability images, the labels are propagated throughout the masked region so that every voxel in the mask is labeled. Propagation is done by using a signed distance transform of the label. Alternatively, propagation of the labels with the fast marching filter respects the distance along the shape of the mask (e.g. the sinuous sulci and gyri of the cortex).” |
-l [λ,p] / -l label[λ,p], --label-propagation |
label_propagation=(λ, p) / {label: (λ, p)} |
None |
ANTs: “The propagation of each prior label can be controlled by the lambda and boundary probability parameters. The latter parameter is the probability (in the range [0,1]) of the label on the boundary which increases linearly to a maximum value of 1.0 in the interior of the labeled region. The former parameter dictates the exponential decay of probability propagation outside the labeled region from the boundary probability, i.e. boundaryProbability*exp( -lambda * distance ).” |
-u 0/1, --minimize-memory-usage |
minimize_memory |
False |
ANTS-97, ANTS-105ANTs: “By default, memory usage is not minimized, however, if this is needed, the various probability and distance images are calculated on the fly instead of being stored in memory at each iteration. Also, if prior probability images are used, only the non-negligible pixel values are stored in memory. ” |
-w BoxPlot[l,u,w] / -w GrubbsRosner[s,w], --winsorize-outliers |
outliers=lx.ants.BoxPlot(...) / lx.ants.GrubbsRosner(...) |
None |
ANTS-94, ANTS-107, ITK-51ANTs: “To remove the effects of outliers in calculating the weighted mean and weighted covariance, the user can opt to remove the outliers through the options specified below.” |
-s 1x2 (repeatable), --partial-volume-label-set, --use-partial-volume-likelihoods |
partial_volume=[(1, 2)], partial_volume_likelihoods |
partial_volume=(), partial_volume_likelihoods=False |
partial-volume classes (labels after the tissues, in the order given); with the MRF, ANTs’ partial-volume labels hardly win a voxel and Atropos often stops (ANTS-106, corrected by default)ANTs: “The partial volume estimation option allows one to modelmixtures of classes within single voxels. Atropos currently allows the user to model two class mixtures per partial volume class. The user specifies a set of class labels per partial volume class requested. For example, suppose the user was performing a classic 3-tissue segmentation (csf, gm, wm) using kmeans initialization. Suppose the user also wanted to model the partial voluming effects between csf/gm and gm/wm. The user would specify it using -i kmeans[3] and -s 1x2 -s 2x3. So, for this example, there would be 3 tissue classes and 2 partial volume classes. Optionally,the user can limit partial volume handling to mrf considerations only whereby the output would only be the three tissues.”ANTs: “The user can specify whether or not to use the partial volume likelihoods, in which case the partial volume class is considered separate from the tissue classes. Alternatively, one can use the MRF only to handle partial volume in which case, partial volume voxels are not considered as separate classes.” |
-b [levels,mesh,order], --bspline |
bspline=(6, 1, 3) |
(6, 1, 3) |
the adaptive smoothing’s B-spline fitANTs: “If the adaptive smoothing weights are > 0, the intensity images are smoothed in calculating the likelihood values. This is to account for subtle intensity differences across the same tissue regions.” |
-o [seg,post%02d,lik%02d,dist%02d,bsp%02d], --output |
likelihood_images, distance_images, smoothed_images |
likelihood_images=False, distance_images=False, smoothed_images=False |
the result’s labels and posteriors, and with those arguments its likelihoods, distances and smoothed: the classified image as uint32, the others float32, 0 outside the maskANTs: “The output consists of a labeled image where each voxel in the masked region is assigned a label from 1, 2, …, N. Optionally, one can also output the posterior probability images specified in the same format as the prior probability images, e.g. posterior%02d.nii.gz (C-style file name formatting).” |
-v 1, --verbose |
the result | its iterations and log: the progress lines and the filter’s settings and modelsANTs: “Verbose output.” |
|
-h, --help |
(command line only) | ANTs’ short and long helpANTs: “Print the help menu (short version).”ANTs: “Print the help menu.” | |
ITK_GLOBAL_DEFAULT_NUMBER_OF_THREADS |
n_threads |
1 |
neither ANTs’ result nor larmorx’s depends on it |
LARMORX_UPSTREAM_DEFECTS |
upstream_defects |
"fix" |
fix (default) or reproduce (Upstream defects) |
LARMORX’s own options
From the next release. In 0.1.0rc1, set the variables instead: OMP_NUM_THREADS, LARMORX_IMPLEMENTATION (original for the clean room) and LARMORX_UPSTREAM_DEFECTS.
They stand between larmorx and ants on the command line (larmorx --n-threads 4 ants Atropos ...); lx.ants.atropos takes n_threads and upstream_defects as arguments, and the other is the command line’s only. Each one given wins over its environment variable, which keeps working.
| Command line, then Python | What it does |
|---|---|
--n-threads Nn_threads=1 |
Default: every logical CPU on the command line (0), 1 in Python. The variable OMP_NUM_THREADS in 0.1.0rc1. |
--implementation auto|replica|clean-room(no Python argument) |
The command line’s only: lx.ants.atropos takes no implementation. The variable LARMORX_IMPLEMENTATION in 0.1.0rc1. |
--upstream-defects fix|reproduceupstream_defects="fix" |
The variable LARMORX_UPSTREAM_DEFECTS in 0.1.0rc1. |
Examples
The tests run every example below (validation/tests/test_reference.py), each section in a new folder where these inputs are made first: t1w.nii.gz (a synthetic head of 40 × 48 × 40 voxels of 4 mm), mask.nii.gz (the synthetic head’s brain as a mask (1 inside, 0 outside)). The command lines run as python -m larmorx.
import larmorx as lx
# sMRIPrep's call: K-means with three classes, MRF 0.1, three iterations, the fixed seed.
seg = lx.ants.atropos("t1w.nii.gz", "mask.nii.gz", classes=3, mrf_smoothing=0.1,
iterations=3, convergence_threshold=0, use_random_seed=False)
seg.labels.data.dtype # -> dtype('uint32')larmorx ants Atropos -d 3 -a t1w.nii.gz -x mask.nii.gz -i KMeans[3] -k Gaussian -m [0.1,1x1x1] -c [3,0] -r 0 -o [labels.nii.gz,POSTERIOR_%02d.nii.gz]Ports
Atropos has one port: a replica.
| Port | Package | Licence | Status | Records |
|---|---|---|---|---|
| replica | larmorx (built in) |
Apache-2.0 | validated | ants-atropos |
The replica: status validated against Atropos itself (its
record, 2026-10-23, standard tier: 97 cases, 62 pass, 27
rejected by both alike, 8 expected divergences; 58 compared), on every option and failure case
on phantoms, and on sMRIPrep’s call and antsCorticalThickness-style prior-based segmentations of
the five fMRIPrep oracle runs’ T1w images:
- against the unmodified ANTs 2.6.5 binary (one thread): 27 of 58 compared cases bit-identical, the classified image identical in all 58. The others’ posteriors differ in their last bits where glibc’s functions are not correctly rounded for a value the run meets: on sMRIPrep’s call, in 11 to 4,175 of 5.9 to 17.5 million values of a posterior image (none on ds001600), by at most 1.2e-7;
- against the same binary with glibc’s
expf,logf,exp,log,pow(and the others) replaced by CORE-MATH’s correctly rounded ones (LD_PRELOAD,scripts/build_crmath_preload.sh), the arithmetic larmorx uses: 58 of 58 bit-identical, sMRIPrep’s call on the five oracle runs and two prior-based segmentations included; - ANTs’ Atropos does not depend on its thread count, and neither does larmorx’s; with the
clock’s seed (
-r 1, Atropos’ default) two ANTs runs of sMRIPrep’s options on ds000005 disagree on 306 labels (smallest Dice 0.99947) and on posteriors by up to 0.168; larmorx, with its fixed seed, is as far from them (221 and 217 labels).
On the data panel (record, 2026-10-26): sMRIPrep’s call in all fourteen finished oracle runs (the 3.5-year-old, the glioma, the stroke, strong motion, 1.5 T, 7 T and the 82-year-old among them), its inputs from each run’s working directory, and three calls fMRIPrep never makes (the stroke outside its manual lesion mask, a child’s T1w and T2w as two channels, a FLAIR of 3 mm slices): 17 of 17 compared cases bit-identical with CORE-MATH, the classified image identical in all 17 (3 bit-identical to the unmodified ANTs). Against fMRIPrep’s own files (ANTs 2.6.2, glibc’s maths): the same segmentation in every run, the posteriors different in 0 to 4,175 voxels (their last bits, as in the standard tier). The panel found a missing check, now ported: an input on another grid (the FLAIR’s mask written from its affine, 2.9e-6 mm off) makes ITK throw, as ANTs does (findings, “Inputs on another grid”).
Atropos has one port, in pip install larmorx: the replica (crates/larmorx-ants,
crates/larmorx-image; Apache-2.0; Rust larmorx_ants::atropos::Atropos, the command line
larmorx_ants::cli::atropos), translated from ANTs 2.6.5’s Atropos on ITK 5.4.5. Neither
ANTs’ result nor its result depends on the thread count.
Evidence
How each of Atropos’s ports was measured against ANTs, case by case: its evidence.
More in the repository
The API page docs/api/ants-atropos.md holds what Atropos shares with the page’s other programs: