API reference

Subpackages

icon_registration.pretrained_models

Submodules

icon_registration.data

icon_registration.data.get_cartilage_dataset()[source]

icon_registration.data.get_copdgene_dataset(data_folder, cache_folder='./data_cache', lung_only=True, downscale=2)[source]: This function load the preprocessed COPDGene train set.

icon_registration.data.get_dataset_1d(data_size=128, samples=6000, batch_size=128)[source]

icon_registration.data.get_dataset_mnist(split, number=5, do_spin_augment=False)[source]

icon_registration.data.get_dataset_retina(extra_deformation=False, downsample_factor=4, blur_sigma=None, warps_per_pair=20, fixed_vertical_offset=None, include_boundary=False)[source]

icon_registration.data.get_dataset_sunnyside(split, scale=1)[source]

icon_registration.data.get_dataset_triangles(split=None, data_size=128, hollow=False, samples=6000, batch_size=128)[source]

icon_registration.data.get_knees_dataset()[source]

icon_registration.data.get_learn2reg_AbdomenCTCT_dataset(data_folder, cache_folder='./data_cache', clamp=[-1000, 0], downscale=1)[source]: This function will return the training dataset of AbdomenCTCT registration task in learn2reg.

icon_registration.data.get_learn2reg_lungCT_dataset(data_folder, cache_folder='./data_cache', lung_only=True, clamp=[-1000, 0], downscale=1)[source]: This function will return the training dataset of LungCT registration task in learn2reg.

icon_registration.data.make_batch(data, BATCH_SIZE, SCALE)[source]

icon_registration.data.spin_augment(image_A)[source]

icon_registration.itk_wrapper

icon_registration.itk_wrapper.create_itk_transform(phi, ident, image_A, image_B) → <itkTemplate itk::CompositeTransform>[source]

icon_registration.itk_wrapper.finetune_execute(model, image_A, image_B, steps, learning_rate)[source]

icon_registration.itk_wrapper.finetune_execute_mask(model, image_A, image_B, mask_A, mask_B, steps, learning_rate)[source]

icon_registration.itk_wrapper.register_pair(model, image_A, image_B, finetune_steps=None, return_artifacts=False, learning_rate=2e-05)[source]

icon_registration.itk_wrapper.register_pair_with_mask(model, image_A, image_B, mask_A, mask_B, finetune_steps=None, return_artifacts=False, learning_rate=2e-05)[source]

icon_registration.itk_wrapper.register_pair_with_multimodalities(model, image_A: list, image_B: list, finetune_steps=None, return_artifacts=False, learning_rate=2e-05)[source]

icon_registration.itk_wrapper.resampling_transform(image, shape)[source]

icon_registration.losses

class icon_registration.losses.AdaptiveNCC(level=4, threshold=0.1, gamma=1.5, sigma=2)[source]

Bases: SimilarityBase

blur(tensor)

class icon_registration.losses.BendingEnergyNet(network, similarity, lmbda)[source]

Bases: RegistrationModule

compute_bending_energy_loss(phi_AB_vectorfield)

compute_similarity_measure(phi_AB_vectorfield, image_A, image_B)

forward(image_A, image_B) → ICONLoss

prepare_for_viz(image_A, image_B)

class icon_registration.losses.BendingLoss(all_loss, bending_energy_loss, similarity_loss, transform_magnitude, flips)[source]

Bases: tuple

all_loss: Alias for field number 0

bending_energy_loss: Alias for field number 1

flips: Alias for field number 4

similarity_loss: Alias for field number 2

transform_magnitude: Alias for field number 3

class icon_registration.losses.BlurredSSD(sigma)[source]

Bases: SimilarityBase

blur(tensor)

class icon_registration.losses.DiffusionRegularizedNet(network, similarity, lmbda)[source]

Bases: BendingEnergyNet

compute_bending_energy_loss(phi_AB_vectorfield)

class icon_registration.losses.GradientICON(network, similarity, lmbda)[source]

Bases: RegistrationModule

compute_gradient_icon_loss(phi_AB, phi_BA)

compute_similarity_measure(phi_AB, phi_BA, image_A, image_B)

forward(image_A, image_B) → ICONLoss

class icon_registration.losses.GradientICONSparse(network, similarity, lmbda)[source]

Bases: RegistrationModule

forward(image_A, image_B)

class icon_registration.losses.ICONLoss(all_loss, inverse_consistency_loss, similarity_loss, transform_magnitude, flips)[source]

Bases: tuple

all_loss: Alias for field number 0

flips: Alias for field number 4

inverse_consistency_loss: Alias for field number 1

similarity_loss: Alias for field number 2

transform_magnitude: Alias for field number 3

class icon_registration.losses.InverseConsistentNet(network, similarity, lmbda)[source]

Bases: RegistrationModule

forward(image_A, image_B)

class icon_registration.losses.LNCC(sigma)[source]

Bases: SimilarityBase

blur(tensor)

calculate_lncc(I, J)

class icon_registration.losses.LNCCOnlyInterpolated(sigma)[source]

Bases: SimilarityBase

blur(tensor)

class icon_registration.losses.MINDSSC(radius, dilation)[source]

Bases: SimilarityBase

compute_mindssc(img)

pdist_squared(x)

class icon_registration.losses.NCC[source]: Bases: SimilarityBase

class icon_registration.losses.SSD[source]: Bases: SimilarityBase

class icon_registration.losses.SSDOnlyInterpolated[source]: Bases: SimilarityBase

class icon_registration.losses.SimilarityBase(isInterpolated=False)[source]: Bases: object

class icon_registration.losses.SquaredLNCC(sigma)[source]: Bases: LNCC

icon_registration.losses.flips(phi, in_percentage=False)[source]

icon_registration.losses.gaussian_blur(tensor, kernel_size, sigma, padding='same')[source]

icon_registration.losses.normalize(image)[source]

icon_registration.losses.to_floats(stats)[source]

icon_registration.monai_wrapper

class icon_registration.monai_wrapper.ConcatInputs(net)[source]

Bases: Module

forward(image_A, image_B)

class icon_registration.monai_wrapper.FirstChannelInputs(net)[source]

Bases: Module

forward(image_A, image_B)

icon_registration.monai_wrapper.make_ddf_from_icon_transform(transform, identity_map)[source]: Compute A deformation field compatible with monai’s Warp using an ICON transform. The assosciated ICON identity_map is also required

icon_registration.monai_wrapper.make_ddf_using_icon_module(module: RegistrationModule, image_A, image_B)[source]: Compute A deformation field compatible with monai’s Warp using and ICON RegistrationModule. If the RegistrationModule returns a transform, this function returns the monai version of that transform. If the RegistrationModule returns a loss, this function returns a monai version of the internal transform as well as the loss.

icon_registration.network_wrappers

icon_registration.network_wrappers.DoubleNet[source]: alias of TwoStepRegistration

icon_registration.network_wrappers.DownsampleNet[source]: alias of DownsampleRegistration

class icon_registration.network_wrappers.DownsampleRegistration(net, dimension)[source]

Bases: RegistrationModule

Perform registration using the wrapped RegistrationModule net at half input resolution.

forward(image_A, image_B)

class icon_registration.network_wrappers.FunctionFromMatrix(net)[source]

Bases: RegistrationModule

wrap an inner neural network net that returns an N x N+1 matrix representing an affine transform, into a RegistrationModule that returns a function that transforms a tensor of coordinates.

forward(image_A, image_B)

class icon_registration.network_wrappers.FunctionFromVectorField(net)[source]

Bases: RegistrationModule

Wrap an inner neural network ‘net’ that returns a tensor of displacements [B x N x H x W (x D)], into a RegistrationModule that returns a function that transforms a tensor of coordinates

forward(image_A, image_B)

class icon_registration.network_wrappers.RandomShift(stddev)[source]

Bases: RegistrationModule

forward(image_A, image_B)

class icon_registration.network_wrappers.RegistrationModule[source]

Bases: Module

Base class for icon modules that perform registration.

A subclass of RegistrationModule should have a forward method that takes as input two images image_A and image_B, and returns a python function phi_AB that transforms a tensor of coordinates.

RegistrationModule provides a method as_function that turns a tensor representing an image into a python function mapping a tensor of coordinates into a tensor of intensities \(\mathbb{R}^N \rightarrow \mathbb{R}\) . Mathematically, this is what an image is anyway.

After this class is constructed, but before it is used, you _must_ call assign_identity_map on it or on one of its parents to define the coordinate system associated with input images.

The contract that a successful registration fulfils is: for a tensor of coordinates X, self.as_function(image_A)(phi_AB(X)) ~= self.as_function(image_B)(X)

ie

\[I^A \circ \Phi^{AB} \simeq I^B\]

In particular, self.as_function(image_A)(phi_AB(self.identity_map)) ~= image_B

adjust_batch_size(size)

as_function(image): image is a tensor with shape self.input_shape. Returns a python function that maps a tensor of coordinates [batch x N_dimensions x …] into a tensor of intensities.

assign_identity_map(input_shape, parents_identity_map=None)

forward(image_B)

Register a pair of images: return a python function phi_AB that warps a tensor of coordinates such that

self.as_function(image_A)(phi_AB(self.identity_map)) ~= image_B

\[I^A \circ \Phi^{AB} \simeq I^B\]

Parameters:

image_A – the moving image
image_B – the fixed image

Returns:

\(\Phi^{AB}\)

class icon_registration.network_wrappers.SquaringVelocityField(net)[source]

Bases: RegistrationModule

forward(image_A, image_B)

class icon_registration.network_wrappers.TwoStepRegistration(netPhi, netPsi)[source]

Bases: RegistrationModule

Combine two RegistrationModules.

First netPhi is called on the input images, then image_A is warped with the resulting field, and then netPsi is called on warped A and image_B in order to find a residual warping. Finally, the composition of the two transforms is returned.

forward(image_A, image_B)

icon_registration.network_wrappers.adjust_batch_size(net, N)[source]

icon_registration.network_wrappers.assignIdentityMap(net, size)[source]

icon_registration.network_wrappers.multiply_matrix_vectorfield(matrix, vectorfield)[source]

icon_registration.network_wrappers.warninfo(message)[source]

icon_registration.networks

class icon_registration.networks.Autoencoder(num_layers, channels)[source]

Bases: Module

forward(x, y)

class icon_registration.networks.ConvNet(dimension=2, output_dim=100)[source]

Bases: Module

forward(x, y)

class icon_registration.networks.ConvolutionalMatrixNet(dimension=2)[source]

Bases: Module

forward(x, y)

class icon_registration.networks.DenseMatrixNet(size=28, dimension=2)[source]

Bases: Module

forward(x, y)

class icon_registration.networks.FCNet(size=28)[source]

Bases: Module

forward(x, y)

class icon_registration.networks.FCNet1D(size=28)[source]

Bases: Module

forward(x, y)

class icon_registration.networks.FCNet3D(shape, bottleneck=128)[source]

Bases: Module

forward(x, y)

class icon_registration.networks.RegisNet[source]

Bases: Module

forward(x, y)

class icon_registration.networks.Residual(features)[source]

Bases: Module

forward(x)

class icon_registration.networks.StumpyConvolutionalMatrixNet(dimension=2)[source]

Bases: Module

forward(x, y)

class icon_registration.networks.UNet(num_layers, channels, dimension)[source]

Bases: Module

forward(x, y)

class icon_registration.networks.UNet2(num_layers, channels, dimension)[source]

Bases: Module

forward(x, y)

class icon_registration.networks.UNet2ChunkyMiddle(num_layers, channels, dimension)[source]

Bases: Module

forward(x, y)

class icon_registration.networks.UNet3(num_layers, channels, dimension, normalization)[source]

Bases: Module

forward(x, y)

icon_registration.networks.pad_or_crop(x, shape, dimension)[source]

icon_registration.networks.tallAE()[source]

icon_registration.networks.tallUNet(unet=<class 'icon_registration.networks.UNet'>, dimension=2)[source]

icon_registration.networks.tallUNet2(dimension=2, input_channels=1)[source]

icon_registration.networks.tallUNet3(normalization='batchnorm', dimension=2)[source]

icon_registration.networks.tallerUNet2(dimension=2)[source]

icon_registration.networks.tallishUNet2(dimension=2)[source]

icon_registration.test_utils

icon_registration.test_utils.download_test_data()[source]

icon_registration.test_utils.read_copd_pointset(f_path)[source]

Points are deliminated by ‘ ‘ and X,Y,Z of each point are deliminated by ‘ ‘.

param f_path:

the path to the file containing the position of points from copdgene dataset.

return:

numpy array of points in physical coordinates

icon_registration.train

icon_registration.train.train2d(net, optimizer, d1, d2, epochs=400)[source]: A training function for quick experiments

icon_registration.train.train_batchfunction(net, optimizer, make_batch, steps=100000, step_callback=<function <lambda>>, unwrapped_net=None)[source]: A training function intended for long running experiments, with tensorboard logging and model checkpoints. Use for medical registration training

icon_registration.train.train_datasets(net, optimizer, d1, d2, epochs=400)[source]: A training function for quick experiments

icon_registration.train.write_stats(writer, stats: ICONLoss, ite)[source]

icon_registration.visualize

icon_registration.visualize.show_as_grid(phi, linewidth=1)[source]

icon_registration.visualize.visualizeRegistration(net, image_A, image_B, N, path, linewidth=1)[source]

icon_registration.visualize.visualizeRegistrationCompact(net, image_A, image_B, N)[source]