register¶

Pairwise registration of images, with an affine transformation, a nonlinear transformation, or both. It is NITorch's general-purpose registration tool: you choose how the images are compared (the loss), how they are allowed to deform (the transformation model), and how the optimisation is run. Use it when affreg does not give you enough control, for instance to register several image pairs at once, to mix intensity images and label maps, or to fit a diffeomorphic deformation.

nitorch register [-v [LEVEL]] [-o DIR] [--cpu [THREADS] | --gpu [ID]]
                 @loss [NAME] [FACTOR...] [LOSS OPTIONS]
                     @@fix FILE... [IMAGE OPTIONS]
                     @@mov FILE... [IMAGE OPTIONS]
                 [@loss ...]
                 [@affine [NAME] [FACTOR] [AFFINE OPTIONS]
                     [@@optim [NAME] [OPTIM OPTIONS]]]
                 [@nonlin [NAME] [FACTOR] [NONLIN OPTIONS]
                     [@@optim [NAME] [OPTIM OPTIONS]]]
                 [@optim [NAME] [OPTIONS]]
                 [@pyramid [NAME] [OPTIONS]]

nitorch register -h [LEVEL]

Description¶

A registration finds the transformation that makes a moving image look like a fixed image. In NITorch the transformation is a model with a handful of parameters (an affine matrix, a dense velocity field), and registering means choosing the parameters that minimise an objective function made of two parts: a matching term (the loss) that measures how different the images are once the moving image has been warped, and, for nonlinear models, a regularisation term that penalises implausible deformations. The minimisation is carried out coarse to fine, on a pyramid of progressively less smoothed and less subsampled images.

register exposes each of these ingredients as a group of options:

At least one @loss group, with both a fixed and a moving image, is required, and at least one of @affine and @nonlin. Everything else has a default. A @loss group can be repeated, and its sub-options can be combined freely, which is how you build a composite objective, for example mutual information between two T1-weighted and FLAIR scans plus a Dice term between two label maps.

When the command succeeds it writes the transformations (an affine matrix in LTA format and/or a velocity field in NIfTI format) and, by default, a copy of each input image carried to the registered space. See Outputs for the files, and Applying the transformations for how to use them with reslice.

The command-line grammar¶

Most NITorch commands take flat lists of options. register takes a nested structure, because a registration is made of several components that each have their own options, and some of those components can occur several times. Learning the grammar once makes every example below easy to read.

Two kinds of tags open a group:

• A tag starting with a single @ (@loss, @affine, @nonlin, @optim, @pyramid) opens a top-level group.
• A tag starting with @@ (@@fix, @@mov, @@optim) opens a sub-group that belongs to the top-level group written just before it.

Inside a group, things come in a fixed order: first the group's positional values (typically a model name and a numeric factor), then its options (tags starting with -, each followed by any number of values), then its sub-groups. A group ends as soon as the next word is not something it recognises, and control returns to the enclosing group.

Here is an annotated example. It registers a FLAIR image to a T1-weighted image with mutual information, using a rigid plus diffeomorphic model, and adds a Dice term on two label maps to guide the deformation:

nitorch register -v -o results --gpu \
    @loss mi 1 -b 64 \
        @@fix T1w.nii.gz -o false \
        @@mov FLAIR.nii.gz -r \
    @loss dice 0.5 \
        @@fix T1w_aseg.nii.gz -l 2 41 3 42 \
        @@mov FLAIR_aseg.nii.gz -l 2 41 3 42 \
    @affine rigid \
        @@optim gn -n 100 \
    @nonlin svf 1 -b 0.2 -m 0.001 \
        @@optim gn -n 20 \
    @optim interleaved -n 5 \
    @pyramid gaussian -l 0:4

Reading it from top to bottom:

1. -v -o results --gpu are global options. They come first, before any group.
2. @loss mi 1 -b 64 opens a loss group. mi is the loss name, 1 its weight in the global objective, and -b 64 an option specific to mutual information (the number of histogram bins). The options of a loss must precede its @@fix and @@mov sub-groups.
3. @@fix T1w.nii.gz -o false is the fixed image of this loss. -o false is an option of the @@fix sub-group: it disables the output image that would otherwise be written for this file.
4. @@mov FLAIR.nii.gz -r is the moving image. -r asks for a copy resliced onto the grid of the fixed image.
5. A second loss group: a Dice loss with weight 0.5, applied to segmentations. -l 2 41 3 42 declares that the files are label maps and that labels 2, 41, 3 and 42 should be used.
6. @affine rigid is the affine part of the model: a rigid transformation. Its @@optim gn -n 100 sub-group selects the optimiser of the affine parameters (Gauss-Newton, at most 100 iterations). A @@optim always belongs to the group written just before it.
7. @nonlin svf 1 -b 0.2 -m 0.001 is the nonlinear part: a stationary velocity field, with a global regularisation factor of 1, a bending-energy weight of 0.2 and a membrane-energy weight of 0.001. It has its own @@optim.
8. @optim interleaved -n 5 is the joint strategy: how the affine and nonlinear updates alternate.
9. @pyramid gaussian -l 0:4 is the pyramid: Gaussian smoothing, with levels 0 to 3.

A few rules follow from the grammar:

• Global options must be given before the first @ group. Once a group has been opened they are no longer recognised.
• The same short tag can mean different things in different groups: -o is the output directory globally, the output image in @@fix/@@mov, the transformation file in @affine/@nonlin, and a momentum file in @@optim. The meaning is always given by the innermost open group.
• Each @loss must contain exactly one @@fix and one @@mov, in either order.
• @affine, @nonlin, @optim and @pyramid can each appear at most once. Every group except @loss can be written with no content at all (@nonlin alone means "a stationary velocity field with default settings").
• Several filenames after @@fix or @@mov are stacked into the channels of a single multi-channel image.
• Negative numbers are values, not tags. See How options are parsed.

nitorch register -h prints a short summary of the grammar; -h 2 and -h 3 add the list of accepted names and of all sub-options. The built-in help is occasionally out of date; this page follows the code.

Matching terms: @loss¶

@loss [NAME] [FACTOR...] [-s] [-z [AXIS]] [LOSS-SPECIFIC OPTIONS]
    @@fix FILE... [IMAGE OPTIONS]
    @@mov FILE... [IMAGE OPTIONS]

Each @loss group registers one moving image to one fixed image, using one loss. The total objective is the sum of all @loss groups (weighted by their factors) plus the regularisation.

Choosing a loss¶

The choice of loss is the most important decision in a registration. It should reflect how the two images are related: are they the same contrast, or different? Is the relationship linear, or arbitrary? Is the intensity bias uniform, or does it vary smoothly across the field of view? Are they images, or segmentations?

Some practical guidance:

• Same image type, same scanner: mse is simple and fast, and its estimated noise precision means the overall scale of the data does not matter. cc and lcc additionally tolerate differences in gain.
• Different contrasts: use mi. Mutual information makes no assumption on the relationship between intensities, only that one image tells you something about the other. It is the right choice for registering a T1w scan to a FLAIR scan, or a CT to an MRI. A global histogram carries little information about local structure, so for a fine nonlinear deformation consider lgmmi, or add a Dice term on segmentations.
• Bias field: the global losses (mse, cc, mi) assume the relationship between images is the same everywhere. When it is not, the local variants lcc and lgmmi are more forgiving.
• Segmentations: dice is the natural choice for label maps. With -l each label becomes a binary channel, and the moving channels are interpolated, so the loss is smooth. cat is equivalent in spirit, but works with soft probability maps (for example the output of a tissue segmentation) and penalises confident disagreement more strongly. Combine them with an intensity loss, in separate @loss groups, to get a semi-supervised registration.
• Robust losses: mad and tuk estimate their own weight maps by iterative reweighting, so they down-weight voxels that cannot be matched.
• Multi-channel images: when several files are given after @@fix and @@mov, the loss is computed channel by channel (channel k of the moving image against channel k of the fixed image) and summed. For mi this means one joint histogram per pair of channels, not one over all pairs.

One further name, extra, is accepted but is not a loss at all: an @loss extra group contributes nothing to the objective, but its moving image is warped with the final transformation and written out like any other. It still requires a @@fix and @@mov, the former being used to define the target grid.

Options of specific losses¶

Each of these options is only accepted after the corresponding loss name, and before @@fix/@@mov.

--stride has no short tag: in every loss, -s is the symmetric flag. Because that flag takes no value, lcc -s 2 is an error: the message names the loss and the option before the stray value, and suggests --stride.

Image options (@@fix, @@mov)¶

Each @@fix and @@mov sub-group takes one or more filenames, followed by options that describe how to load, preprocess and write that image. The options are the same for both. The filenames are stacked into channels, so @@fix T1w.nii.gz T2w.nii.gz is a two-channel image; the files must share the same voxel grid.

A few of these deserve a comment.

Missing values. By default every voxel exactly equal to 0 is excluded from the loss, in addition to NaNs and infinities. This is convenient for skull-stripped or padded images, where the background carries no information. If your images have meaningful zeros (for example CT in Hounsfield units, or a quantitative map), disable it with --no-missing.

Intensity scaling. Rescaling makes losses such as mse or lcc independent of the unit of the image. The upper percentile of 95 keeps a few bright voxels from compressing the rest of the range. Rescaling is turned off automatically for label maps, for cat and dice, and for the moving image of emmi.

Initial transformations (-a). Each transformation \(T\) replaces the orientation matrix \(A\) of the image with \(T^{-1}A\). This is exactly what nitorch reslice FILE -l T does when no target is given: the voxel data are untouched and only the header changes. It is a way to feed the result of a previous registration as a starting point, or to put several images in a common space before a nonlinear registration. The output images are computed from the modified orientation matrix too.

Labels. With -l, the image is first expanded to one binary channel per label, then resampled with linear interpolation, so overlaps vary smoothly and can be differentiated. Specifying the labels explicitly (-l 2 41 3 42) keeps the number of channels, and therefore memory use, under control; with many labels, the default of using every non-zero label can be costly.

emmi. This loss changes the preprocessing of its inputs. The fixed image is discretised (into 256 bins unless -d says otherwise), and the moving image is soft-quantised into 16 bins (also adjustable with -d, set on @@mov). Intensity rescaling is disabled on the moving image, and no value is considered missing. Only single-channel moving images are supported.

Transformation models¶

A registration needs at least one of @affine and @nonlin. When both are given, the total transformation is a nonlinear deformation in the space between the two images, composed with the affine.

Affine: @affine¶

@affine [NAME] [FACTOR] [AFFINE OPTIONS]
    [@@optim [NAME] [OPTIM OPTIONS]]

The affine transformation is parametrised by its logarithm in a Lie algebra, so that composition and inversion are exact and the parameters of different types (translation, rotation, zoom, shear) are on a comparable footing. NAME chooses the number of degrees of freedom.

FACTOR is the precision of a Gaussian prior centred on the identity: it adds the penalty \(\tfrac12\lambda\lVert q\rVert^2\) to the objective, where \(q\) are the Lie parameters of the transformation and \(\lambda\) is FACTOR. It is 0 by default, meaning no prior. A small positive value keeps a poorly constrained affine registration from drifting.

Position of the affine¶

The forward model of register always maps coordinates of the fixed image to coordinates of the moving image. When the registration has both an affine and a nonlinear component, the position says where the affine sits in that composition. With \(A\) the affine (the matrix written to {name}.lta, which is always the full fixed-to-moving transformation) and \(\varphi\) the nonlinear transformation, the model is:

The position does not change where the loss is computed: the moving image is always pulled through the forward model onto the voxel grid of the fixed image, and the loss is evaluated there. The only exception is a symmetric loss (-s on a loss, see above), which also warps the fixed image into the moving space through the inverse model and adds the same loss there. This is independent of the position.

• Affine-only registration. The three positions describe the same transformation (\(A^{1/2}A^{1/2}=A\)), so they have the same optimum. They only differ in the parameterisation and in the headers of the .moved outputs (see below).
• With a nonlinear component. The position changes the model, because it changes the frame in which the nonlinear field lives, and hence how it is regularised. The results can therefore differ. It also determines the order in which the transformations must be chained when applying them with reslice (see Applying the transformations).
• sym makes the model symmetric: its inverse has the same structure, with the roles of the fixed and moving images swapped. Combined with a symmetric loss (-s), it gives a fully symmetric registration. It is the best choice when the two images play comparable roles.

The position also determines the orientation matrices written to the {base}.moved{ext} files (this concerns the output headers only, not the loss). In an affine-only registration, an image whose orientation matrix is modified receives the full affine, which carries it into the space of the other image, and an image whose orientation matrix is not modified is copied as is. With mov, the moving image is carried into the fixed space and the fixed image keeps its own header, so the two .moved files overlap. With fix, it is the other way around. With sym, both orientation matrices are modified: the moving image is carried into the fixed space and the fixed image into the moving space, so each .moved file overlaps the other input image, not the other .moved file. With a nonlinear component, each .moved image is resampled into the space of the other image whatever the position (with sym, each orientation matrix then receives half of the affine). Full reslicing (-r) is not affected by the position: the output is always on the grid of the other image.

Nonlinear: @nonlin¶

@nonlin [NAME] [FACTOR] [NONLIN OPTIONS]
    [@@optim [NAME] [OPTIM OPTIONS]]

A nonlinear transformation is a dense vector field, defined on a regular lattice (the mean space of the registered images), whose regularity is controlled by a penalty. NAME selects what the field represents.

FACTOR (default 1) is a global multiplier of the regularisation, to which the four penalties below contribute. Larger values give smoother deformations. The penalty is normalised by the number of voxels of the field, so factors are comparable across image sizes.

The regularisation is a weighted sum of four energies of the field, each with its own weight (see the options below):

Absolute shrinks the field towards zero, membrane penalises its first derivatives (it discourages stretching), bending its second derivatives (it favours smooth, locally affine deformations), and linear-elastic penalises shears and local volume changes separately, with the two weights of the --lame option.

The default lattice has the mean voxel size of the images and covers all their fields of view, so a registration between a 1 mm and a 2 mm image produces a field at about 1.5 mm.

Choosing how the warp is inverted with --inversion¶

A nonlinear registration returns a transformation in both directions, but only one of them is computed directly; the other is obtained by inverting it. Which side is direct depends on the model: svf and smalldef compute the forward warp and invert it, whereas shoot integrates the inverse warp \(\varphi\) directly and derives the forward warp \(\psi\) from it. The --inversion option, available for all three models, selects the inversion method:

What you gain depends on the model.

The cost relative to default, for a 3D image of 64³ voxels, is:

All accuracy and cost figures are approximate, and were measured on 3D benchmarks of 64³ voxels on a CPU. They concern the nonlinear update alone. A full registration spends most of its time elsewhere, so the overall slowdown is smaller.

Fast or exact shooting with --exact¶

Geodesic shooting integrates the initial velocity \(v_0\) forward in time, and the way each step is taken makes a difference. By default, shoot uses a fast scheme: every step transports the momentum by the small warp of that step only, and the steps are chained. Each transport resamples, and so blurs, the momentum, and the total blur amounts to roughly \(|v|\) voxels² however many steps you use. The scheme is cheap, but it does not converge to the true geodesic: raising --steps does not make it more accurate.

With --exact, the exact scheme transports the initial momentum along the warp integrated so far at each step. There is a single resampling per step, so the result converges to the geodesic as --steps grows. The option is long-only and takes an optional boolean (--exact, --exact true, --exact no...). It only applies to @nonlin shoot; svf and smalldef reject it.

The table shows the error on the inverse warp \(\varphi\) against a 256-step exact reference, for a 3D image of 48³ voxels with a maximum velocity of 10 voxels. Errors are in voxels, as mean / max.

The fast scheme gets slightly worse with more steps, while the exact one improves steadily. The fast scheme also loses energy along the path: the energy kept relative to the start is 0.53-0.57 after 8 steps and falls to 0.34-0.52 after 128, whereas the exact scheme keeps about 0.80, as the reference does, whatever the number of steps.

Exact shooting costs more: at 64³ voxels, a shooting call takes 1.4-1.7 times as long (1.3-1.4 times when the inverse is computed too). In a short symmetric registration of that size, the wall time rose by 14% (58 s to 66 s). In return, the forward and inverse warps were about twice as consistent (mean \(|\psi\circ\varphi - \mathrm{id}|\) from 0.083 to 0.046 voxel, maximum from 0.79 to 0.42), with a similar recovered warp. As elsewhere, these figures are approximate and were measured on a CPU.

The choice is saved in {name}.json as the fast entry (false with --exact). reslice and compose read it and shoot the velocity with the same scheme. This matters: a velocity estimated with one scheme must be shot again with the same one. In one test, shooting a velocity estimated with the fast scheme exactly moved the warp by about 3 voxels.

Optimisation¶

Each of @affine and @nonlin can contain an @@optim sub-group that selects the algorithm used to update its parameters, and the joint @optim group controls how the two alternate.

The solver: @@optim¶

@@optim [NAME] [OPTIONS]

By default, the solver is chosen from the loss. All the losses of register provide a Gauss-Newton Hessian, so the default is gn for both the affine and the nonlinear part. Gauss-Newton is a second-order method: it converges in few iterations and needs no learning rate. The other solvers are first-order methods, which are more general but need more iterations and a learning rate.

Common options:

The default number of iterations depends on the joint strategy (see below), and applies even if only one of @affine and @nonlin is used. A nonlinear registration on its own therefore runs 10 iterations per pyramid level unless you give -n or choose @optim sequential.

Options of specific solvers:

Gauss-Newton is the right choice in most cases. Powell's method is the default of affreg when it is used with mutual information.

The joint strategy: @optim¶

@optim [NAME] [OPTIONS]

When an @affine and a @nonlin are both present, the affine part is first fitted alone, from coarse to fine through the pyramid, and then the affine and nonlinear parts are optimised together, again from coarse to fine. @optim selects how the two are optimised together.

Multi-resolution: @pyramid¶

@pyramid [NAME] [OPTIONS]

Registration is run on a pyramid of images, in which each level has half the resolution of the one before. Coarse levels are cheap and have a wide basin of attraction, so they bring the images close enough that the fine levels only need to refine the result. The pyramid is used even if you do not write @pyramid: it then has three Gaussian levels.

Level 0 is the full-resolution image; level n is subsampled by \(2^n\). When the images in the registration have different resolutions, the levels are matched across images by voxel size, so a 1 mm image and a 2 mm image are compared at their closest common resolution at each level.

The level numbers in --levels count valid levels: if you give --max-size or --min-vx, level 0 is the finest level that satisfies the constraints. To spend more effort at fine scales, use more levels (-l 0:5 for a large image); to save time on a rough affine alignment, drop the finest ones (-l 2:5).

Outputs¶

Unless told otherwise, register writes the following files. Templates use the fields {dir} (a directory), {sep} (the path separator), {base} (the input filename without extension), {ext} (its extension, including .nii.gz) and {name} (the name of the model); see Output filenames.

For the transformations, {dir} is the output directory given by -o or, if there is none, the directory of the first fixed image. For images it is the output directory, or else the directory of the image itself. Note that both the fixed and moving images are written as .moved by default; give -o false to @@fix or @@mov to avoid it. Output templates are checked before the fit starts, so a malformed template is reported immediately rather than after the optimisation has run.

Minimal reslicing means that the image keeps its own voxel grid whenever possible. With a purely affine registration, the voxel data are copied unchanged and only the orientation matrix in the header is modified; a modified image can be viewed on top of the other input image, without any interpolation. If a nonlinear transformation is present, the image is resampled on its own grid. The position of the affine only decides which orientation matrices are modified: the moving image's with mov, the fixed image's with fix, and both with sym (see Position of the affine). Full reslicing (-r), in contrast, always produces an image on the grid of the other image: the moving image on the fixed grid, and the fixed image on the moving grid.

Applying the transformations¶

To resample other images (a segmentation, a different contrast, a mask) with the result of a registration, use reslice. For an affine-only registration, whatever the position:

# moving space -> fixed space
nitorch reslice aseg.nii.gz -l rigid.lta -t T1w.nii.gz -i 0 -o aseg_in_T1w.nii.gz
# fixed space -> moving space
nitorch reslice T1w.nii.gz -il rigid.lta -t FLAIR.nii.gz

(-i 0 selects nearest-neighbour interpolation, for label maps.)

When a nonlinear transformation is present, the affine is no longer sufficient and the order in which transformations are chained depends on the position of the affine. In the following table, aff is the .lta file, and vel the field. For smalldef, replace -v vel with -d disp; for shoot, the JSON file next to the field is picked up automatically.

Here -l2 applies the square root of the affine, which is what the symmetric model uses on each side of the deformation. For example, for a default registration:

nitorch reslice FLAIR.nii.gz -l2 affine.lta -v svf.nii.gz -l2 affine.lta \
    -t T1w.nii.gz -o FLAIR_in_T1w.nii.gz

A bare -- is not supported, since register has no positional inputs: it is an error. Write a file name that starts with a dash as ./-name.

Global options¶

These must precede the first group.

See Hardware for general notes on devices.

Examples¶

Rigidly register two T1-weighted scans of the same subject, with mean squared error. The transformation is written to rigid.lta next to the fixed image, and {base}.moved.nii.gz copies of both images are written:

nitorch register -v \
    @loss mse @@fix sub-01_ses-1_T1w.nii.gz @@mov sub-01_ses-2_T1w.nii.gz \
    @affine rigid

Register a FLAIR scan to a T1-weighted scan with mutual information and a full affine, initialised by aligning the centres of mass and with progressively freed degrees of freedom. The FLAIR is written resliced onto the T1w grid in the reg directory, and no .moved files are produced:

nitorch register -v -o reg \
    @loss mi @@fix T1w.nii.gz -o false @@mov FLAIR.nii.gz -o false -r \
    @affine affine -i com -g -o reg/FLAIR_to_T1w.lta

Register two brain images of a similar contrast diffeomorphically, after a rigid initialisation. lcc compares local patches of 8 % of the image size, the nonlinear part uses a bending energy of 0.5, and five pyramid levels are used. The velocity field is written to warp/svf.nii.gz:

nitorch register -v -o warp --gpu \
    @loss lcc -p 8 pct @@fix template_T1w.nii.gz @@mov sub-01_T1w.nii.gz \
    @affine rigid \
    @nonlin svf 1 -b 0.5 \
    @pyramid -l 0:5

Register with the affine and nonlinear parts fitted one after the other, and more iterations for the nonlinear solver. This is often more stable than the default interleaving when the images are initially far apart:

nitorch register -o warp \
    @loss mse @@fix fixed.nii.gz @@mov moving.nii.gz \
    @affine affine @@optim gn -n 100 \
    @nonlin svf @@optim gn -n 50 \
    @optim sequential

Register a template to a subject using two contrasts jointly, then carry the template's label map to the subject. The two files after each of @@fix and @@mov are channels of a two-channel image, so both contrasts contribute to the match. The labels are transferred with nearest-neighbour interpolation by reslice:

nitorch register -v -o reg \
    @loss mi -b 48 \
        @@fix sub-01_T1w.nii.gz sub-01_T2w.nii.gz -o false \
        @@mov template_T1w.nii.gz template_T2w.nii.gz -o false \
    @affine affine -g \
    @nonlin svf

nitorch reslice template_aseg.nii.gz \
    -l2 reg/affine.lta -v reg/svf.nii.gz -l2 reg/affine.lta \
    -t sub-01_T1w.nii.gz -i 0 -o sub-01_aseg.nii.gz

Finally, a complete affine plus nonlinear registration that combines mutual information on T1w and FLAIR scans with a Dice term on a handful of segmented structures (left and right white matter, and cortex), so that the deformation is driven by both intensities and anatomy. The Dice term has a small weight and the labels are read as 2 and 41 (white matter), 3 and 42 (cortex):

nitorch register -v -o results --gpu \
    @loss mi -b 64 \
        @@fix sub-01_T1w.nii.gz -o false \
        @@mov sub-01_FLAIR.nii.gz -o false -r \
    @loss dice 0.5 \
        @@fix sub-01_T1w_aseg.nii.gz -l 2 41 3 42 -o false \
        @@mov sub-01_FLAIR_aseg.nii.gz -l 2 41 3 42 -o false -r -n 0 \
    @affine affine -g \
    @nonlin svf 1 -b 0.2 -m 0.001 -h \
    @pyramid -l 0:4

This writes results/affine.lta, results/svf.nii.gz, results/svf_hessian.nii.gz, and the resliced FLAIR image and its label map on the T1w grid (sub-01_FLAIR.resliced.nii.gz, sub-01_FLAIR_aseg.resliced.nii.gz, in the directory of the input files). The -n 0 option writes labels with nearest-neighbour interpolation.

See also¶

• simplereg, affreg — simpler wrappers around register for affine alignment.
• optinorm — groupwise alignment of several scans, built on register.
• affopt and vopt — combine pairwise registrations into transformations to a common space; vopt uses the Hessian written by @nonlin -h.
• autoreg — the older, autograd-based registration tool.
• reslice — apply the transformations to images.
• Registering two images — a guided tutorial.