ants.core package

Submodules

ants.core.ants_image module

class ants.core.ants_image.ANTsImage(pixeltype='float', dimension=3, components=1, pointer=None, is_rgb=False, label_image=None)

Bases: object

abp_n4(intensity_truncation=(0.025, 0.975, 256), mask=None, usen3=False)

abs(axis=None)

Return absolute value of image

add_noise_to_image(noise_model, noise_parameters)

anti_alias()

apply(fn)

Apply an arbitrary function to ANTsImage.

Parameters:

fn (python function or lambda) – function to apply to ENTIRE image at once

Returns:

image with function applied to it

Return type:

ANTsImage

argmax(axis=None)

Return argmax along specified axis

argmin(axis=None)

Return argmin along specified axis

argrange(axis=None)

Return argrange along specified axis

as_label_image(label_info=None)

astype(dtype)

Cast & clone an ANTsImage to a given numpy datatype.

Map:

uint8 : unsigned char uint32 : unsigned int float32 : float float64 : double

clone(pixeltype=None)

Create a copy of the given ANTsImage with the same data and info, possibly with a different data type for the image data. Only supports casting to uint8 (unsigned char), uint32 (unsigned int), float32 (float), and float64 (double)

Parameters:

dtype (string (optional)) –

if None, the dtype will be the same as the cloned ANTsImage. Otherwise, the data will be cast to this type. This can be a numpy type or an ITK type. Options:

’unsigned char’ or ‘uint8’, ‘unsigned int’ or ‘uint32’, ‘float’ or ‘float32’, ‘double’ or ‘float64’

Return type:

ANTsImage

convolve_image(kernel_image, crop=True)

copy(pixeltype=None)

Create a copy of the given ANTsImage with the same data and info, possibly with a different data type for the image data. Only supports casting to uint8 (unsigned char), uint32 (unsigned int), float32 (float), and float64 (double)

Parameters:

dtype (string (optional)) –

if None, the dtype will be the same as the cloned ANTsImage. Otherwise, the data will be cast to this type. This can be a numpy type or an ITK type. Options:

’unsigned char’ or ‘uint8’, ‘unsigned int’ or ‘uint32’, ‘float’ or ‘float32’, ‘double’ or ‘float64’

Return type:

ANTsImage

create_tiled_mosaic(rgb=None, mask=None, overlay=None, output=None, alpha=1.0, direction=0, pad_or_crop=None, slices=None, flip_slice=None, permute_axes=False)

create_warped_grid(grid_step=10, grid_width=2, grid_directions=(True, True), fixed_reference_image=None, transform=None, foreground=1, background=0)

crop_image(label_image=None, label=1)

crop_indices(lowerind, upperind)

decrop_image(full_image)

denoise_image(mask=None, shrink_factor=1, p=1, r=3, noise_model='Rician', v=0)

property direction

Get image direction

Return type:

tuple

flatten()

Flatten image data

functional_lung_segmentation(mask=None, number_of_iterations=2, number_of_atropos_iterations=5, mrf_parameters='[0.7,2x2x2]', number_of_clusters=6, cluster_centers=None, bias_correction='n4', verbose=True)

fuzzy_spatial_cmeans_segmentation(mask=None, number_of_clusters=4, m=2, p=1, q=1, radius=2, max_number_of_iterations=20, convergence_threshold=0.02, verbose=False)

get_average_of_timeseries(idx=None)

get_center_of_mass()

get_centroids(clustparam=0)

get_mask(low_thresh=None, high_thresh=None, cleanup=2)

get_neighborhood_at_voxel(center, kernel, physical_coordinates=False)

get_neighborhood_in_mask(mask, radius, physical_coordinates=False, boundary_condition=None, spatial_info=False, get_gradient=False)

get_orientation()

get_pointer_string()

histogram_equalize_image(number_of_histogram_bins=256)

iMath(operation, *args)

iMath_GC(radius=1)

iMath_GD(radius=1)

iMath_GE(radius=1)

iMath_GO(radius=1)

iMath_MC(radius=1, value=1, shape=1, parametric=False, lines=3, thickness=1, include_center=False)

iMath_MD(radius=1, value=1, shape=1, parametric=False, lines=3, thickness=1, include_center=False)

iMath_ME(radius=1, value=1, shape=1, parametric=False, lines=3, thickness=1, include_center=False)

iMath_MO(radius=1, value=1, shape=1, parametric=False, lines=3, thickness=1, include_center=False)

iMath_canny(sigma, lower, upper)

iMath_fill_holes(hole_type=2)

iMath_get_largest_component(min_size=50)

iMath_grad(sigma=0.5, normalize=False)

iMath_histogram_equalization(alpha, beta)

iMath_laplacian(sigma=0.5, normalize=False)

iMath_maurer_distance(foreground=1)

iMath_normalize()

iMath_pad(padding)

iMath_perona_malik(conductance=0.25, n_iterations=1)

iMath_propagate_labels_through_mask(labels, stopping_value=100, propagation_method=0)

iMath_sharpen()

iMath_truncate_intensity(lower_q, upper_q, n_bins=64)

image_math(operation, *args)

image_to_cluster_images(min_cluster_size=50, min_thresh=1e-06, max_thresh=1)

kmeans_segmentation(k, kmask=None, mrf=0.1)

label_clusters(min_cluster_size=50, min_thresh=1e-06, max_thresh=1, fully_connected=False)

label_image_centroids(physical=False, convex=True, verbose=False)

label_stats(label_image)

labels_to_matrix(mask, target_labels=None, missing_val=nan)

list_to_ndimage(image_list)

mask_image(mask, level=1, binarize=False)

max(axis=None)

Return max along specified axis

mean(axis=None)

Return mean along specified axis

median(axis=None)

Return median along specified axis

min(axis=None)

Return min along specified axis

morphology(operation, radius, mtype='binary', value=1, shape='ball', radius_is_parametric=False, thickness=1, lines=3, include_center=False)

motion_correction(fixed=None, type_of_transform='BOLDRigid', mask=None, fdOffset=50, outprefix='', verbose=False, **kwargs)

movie(filename=None, writer=None, fps=30)

multi_label_morphology(operation, radius, dilation_mask=None, label_list=None, force=False)

n3_bias_field_correction(downsample_factor=3)

n3_bias_field_correction2(mask=None, rescale_intensities=False, shrink_factor=4, convergence={'iters': 50, 'tol': 1e-07}, spline_param=None, number_of_fitting_levels=4, return_bias_field=False, verbose=False, weight_mask=None)

n4_bias_field_correction(mask=None, rescale_intensities=False, shrink_factor=4, convergence={'iters': [50, 50, 50, 50], 'tol': 1e-07}, spline_param=None, return_bias_field=False, verbose=False, weight_mask=None)

ndimage_to_list()

new_image_like(data)

Create a new ANTsImage with the same header information, but with a new image array.

Parameters:

data (ndarray or py::capsule) – New array or pointer for the image. It must have the same shape as the current image data.

Return type:

ANTsImage

nonzero()

Return non-zero indices of image

numpy(single_components=False)

Get a numpy array copy representing the underlying image data. Altering this ndarray will have NO effect on the underlying image data.

Parameters:

single_components (boolean (default is False)) – if True, keep the extra component dimension in returned array even if image only has one component (i.e. self.has_components == False)

Return type:

ndarray

property orientation

property origin

Get image origin

Return type:

tuple

otsu_segmentation(k, mask=None)

pad_image(shape=None, pad_width=None, value=0.0, return_padvals=False)

plot(overlay=None, blend=False, alpha=1, cmap='Greys_r', overlay_cmap='turbo', overlay_alpha=0.9, vminol=None, vmaxol=None, cbar=False, cbar_length=0.8, cbar_dx=0.0, cbar_vertical=True, axis=0, nslices=12, slices=None, ncol=None, slice_buffer=None, black_bg=True, bg_thresh_quant=0.01, bg_val_quant=0.99, domain_image_map=None, crop=False, scale=False, reverse=False, title=None, title_fontsize=20, title_dx=0.0, title_dy=0.0, filename=None, dpi=500, figsize=1.5, reorient=True, resample=True)

plot_hist(threshold=0.0, fit_line=False, normfreq=True, title=None, grid=True, xlabel=None, ylabel=None, facecolor='green', alpha=0.75)

plot_ortho(overlay=None, reorient=True, blend=False, xyz=None, xyz_lines=True, xyz_color='red', xyz_alpha=0.6, xyz_linewidth=2, xyz_pad=5, orient_labels=True, alpha=1, cmap='Greys_r', overlay_cmap='jet', overlay_alpha=0.9, cbar=False, cbar_length=0.8, cbar_dx=0.0, cbar_vertical=True, black_bg=True, bg_thresh_quant=0.01, bg_val_quant=0.99, crop=False, scale=False, domain_image_map=None, title=None, titlefontsize=24, title_dx=0, title_dy=0, text=None, textfontsize=24, textfontcolor='white', text_dx=0, text_dy=0, filename=None, dpi=500, figsize=1.0, flat=False, transparent=True, resample=False, allow_xyz_change=True)

prior_based_segmentation(priors, mask, priorweight=0.25, mrf=0.1, iterations=25)

quantile(q, nonzero=True)

range(axis=None)

Return range tuple along specified axis

reflect_image(axis=None, tx=None, metric='mattes')

reorient_image2(orientation='RAS')

resample_image(resample_params, use_voxels=False, interp_type=1)

resample_image_to_target(target, interp_type='linear', imagetype=0, verbose=False, **kwargs)

rgb_to_vector()

scalar_to_rgb(mask=None, filename=None, cmap='red', custom_colormap_file=None, min_input=None, max_input=None, min_rgb_output=None, max_rgb_output=None, vtk_lookup_table=None)

set_direction(new_direction)

Set image direction

Parameters:

new_direction (numpy.ndarray or tuple or list) – updated direction for the image. should have one value for each dimension

Return type:

None

set_origin(new_origin)

Set image origin

Parameters:

new_origin (tuple or list) – updated origin for the image. should have one value for each dimension

Return type:

None

set_spacing(new_spacing)

Set image spacing

Parameters:

new_spacing (tuple or list) – updated spacing for the image. should have one value for each dimension

Return type:

None

slice_image(axis, idx, collapse_strategy=0)

smooth_image(sigma, sigma_in_physical_coordinates=True, FWHM=False, max_kernel_width=32)

property spacing

Get image spacing

Return type:

tuple

split_channels()

std(axis=None)

Return std along specified axis

sum(axis=None, keepdims=False)

Return sum along specified axis

symmetrize_image()

threshold_image(low_thresh=None, high_thresh=None, inval=1, outval=0, binary=True)

to_file(filename)

Write the ANTsImage to file

Parameters:

filename (string) – filepath to which the image will be written

to_filename(filename)

Write the ANTsImage to file

Parameters:

filename (string) – filepath to which the image will be written

to_nibabel()

unique(sort=False)

Return unique set of values in image

vector_to_rgb()

view(single_components=False)

Geet a numpy array providing direct, shared access to the image data. IMPORTANT: If you alter the view, then the underlying image data will also be altered.

Parameters:

single_components (boolean (default is False)) – if True, keep the extra component dimension in returned array even if image only has one component (i.e. self.has_components == False)

Return type:

ndarray

weingarten_image_curvature(sigma=1.0, opt='mean')

class ants.core.ants_image.LabelImage(label_image, label_info=None, template=None)

Bases: ANTsImage

A LabelImage is a special class of ANTsImage which has discrete values and string labels or other metadata (e.g. another string label such as the “lobe” of the region) associated with each of the discrete values. A canonical example of a LabelImage is a brain label_image or parcellation.

This class provides convenient functionality for manipulating and visualizing images where you have real values associated with aggregated image regions (e.g. if you have cortical thickness values associated with brain regions)

Commonly-used functionality for LabelImage types:

• create publication-quality figures of an label_image

Nomenclature

• keya string representing the name of the associated index in the atlas image

  • e.g. if the index is 1001 and the key may be InferiorTemporalGyrus`

• value : an integer value in the atlas image

• metakeya string representing one of the possible sets of label key

  • e.g. ‘Lobes’ or ‘Regions’

Notes

• indexing works by creating a separate dict for each metakey, where

generate_data()

items(metakey)

keys(metakey=None)

metakeys()

n_values()

parentkey(key)

uniquekeys(metakey=None)

Get keys for a given metakey

values()

ants.core.ants_image.allclose(image1, image2)

Check if two images have the same array values

ants.core.ants_image.copy_image_info(reference, target)

Copy origin, direction, and spacing from one antsImage to another

ANTsR function: antsCopyImageInfo

Parameters:

• reference (ANTsImage) – Image to get values from.

• target (ANTsImAGE) – Image to copy values to

Returns:

Target image with reference header information

Return type:

ANTsImage

ants.core.ants_image.get_direction(image)

Get direction of ANTsImage

ANTsR function: antsGetDirection

ants.core.ants_image.get_origin(image)

Get origin of ANTsImage

ANTsR function: antsGetOrigin

ants.core.ants_image.get_spacing(image)

Get spacing of ANTsImage

ANTsR function: antsGetSpacing

ants.core.ants_image.image_physical_space_consistency(image1, image2, tolerance=0.01, datatype=False)

Check if two or more ANTsImage objects occupy the same physical space

ANTsR function: antsImagePhysicalSpaceConsistency

Parameters:

• *images (ANTsImages) – images to compare

• tolerance (float) – tolerance when checking origin and spacing

• data_type (boolean) – If true, also check that the image data types are the same

Returns:

true if images share same physical space, false otherwise

Return type:

boolean

ants.core.ants_image.image_type_cast(image_list, pixeltype=None)

Cast a list of images to the highest pixeltype present in the list or all to a specified type

ANTsR function: antsImageTypeCast

Parameters:

• image_list (list/tuple) – images to cast

• pixeltype (string (optional)) – pixeltype to cast to. If None, images will be cast to the highest precision pixeltype found in image_list

Returns:

given images casted to new type

Return type:

list of ANTsImages

ants.core.ants_image.set_direction(image, direction)

Set direction of ANTsImage

ANTsR function: antsSetDirection

ants.core.ants_image.set_origin(image, origin)

Set origin of ANTsImage

ANTsR function: antsSetOrigin

ants.core.ants_image.set_spacing(image, spacing)

Set spacing of ANTsImage

ANTsR function: antsSetSpacing

ants.core.ants_image_io module

Image IO

ants.core.ants_image_io.dicom_read(directory, pixeltype='float')

Read a set of dicom files in a directory into a single ANTsImage. The origin of the resulting 3D image will be the origin of the first dicom image read.

Parameters:

directory (string) – folder in which all the dicom images exist

Return type:

ANTsImage

Example

>>> import ants
>>> img = ants.dicom_read('~/desktop/dicom-subject/')

ants.core.ants_image_io.from_numpy(data, origin=None, spacing=None, direction=None, has_components=False, is_rgb=False)

Create an ANTsImage object from a numpy array

ANTsR function: as.antsImage

Parameters:

• data (ndarray) – image data array

• origin (tuple/list) – image origin

• spacing (tuple/list) – image spacing

• direction (list/ndarray) – image direction

• has_components (boolean) – whether the image has components

Returns:

image with given data and any given information

Return type:

ANTsImage

ants.core.ants_image_io.image_clone(image, pixeltype=None)

Clone an ANTsImage

ANTsR function: antsImageClone

Parameters:

• image (ANTsImage) – image to clone

• dtype (string (optional)) – new datatype for image

Return type:

ANTsImage

ants.core.ants_image_io.image_header_info(filename)

Read file info from image header

ANTsR function: antsImageHeaderInfo

Parameters:

filename (string) – name of image file from which info will be read

Return type:

dict

ants.core.ants_image_io.image_list_to_matrix(image_list, mask=None, sigma=None, epsilon=0.5)

Read images into rows of a matrix, given a mask - much faster for large datasets as it is based on C++ implementations.

ANTsR function: imagesToMatrix

Parameters:

• image_list (list of ANTsImage python:types) – images to convert to ndarray

• mask (ANTsImage (optional)) – image containing binary mask. voxels in the mask are placed in the matrix

• sigma (scaler (optional)) – smoothing factor

• epsilon (scalar) – threshold for mask

Returns:

array with a row for each image shape = (N_IMAGES, N_VOXELS)

Return type:

ndarray

Example

>>> import ants
>>> img = ants.image_read(ants.get_ants_data('r16'))
>>> img2 = ants.image_read(ants.get_ants_data('r16'))
>>> img3 = ants.image_read(ants.get_ants_data('r16'))
>>> mat = ants.image_list_to_matrix([img,img2,img3])

ants.core.ants_image_io.image_read(filename, dimension=None, pixeltype='float', reorient=False)

Read an ANTsImage from file

ANTsR function: antsImageRead

Parameters:

• filename (string) – Name of the file to read the image from.

• dimension (int) – Number of dimensions of the image read. This need not be the same as the dimensions of the image in the file. Allowed values: 2, 3, 4. If not provided, the dimension is obtained from the image file

• pixeltype (string) – C++ datatype to be used to represent the pixels read. This datatype need not be the same as the datatype used in the file. Options: unsigned char, unsigned int, float, double

• reorient (boolean | string) –

  if True, the image will be reoriented to RPI if it is 3D if False, nothing will happen if string, this should be the 3-letter orientation to which the

  input image will reoriented if 3D.

  if the image is 2D, this argument is ignored

Return type:

ANTsImage

ants.core.ants_image_io.image_write(image, filename, ri=False)

Write an ANTsImage to file

ANTsR function: antsImageWrite

Parameters:

• image (ANTsImage) – image to save to file

• filename (string) – name of file to which image will be saved

• ri (boolean) –

  if True, return image. This allows for using this function in a pipeline:

  >>> img2 = img.smooth_image(2.).image_write(file1, ri=True).threshold_image(0,20).image_write(file2, ri=True)
  

  if False, do not return image

ants.core.ants_image_io.images_from_matrix(data_matrix, mask)

Unmasks rows of a matrix and writes as images

ANTsR function: matrixToImages

Parameters:

• data_matrix (numpy.ndarray) – each row corresponds to an image array should have number of columns equal to non-zero voxels in the mask

• mask (ANTsImage) – image containing a binary mask. Rows of the matrix are unmasked and written as images. The mask defines the output image space

Return type:

list of ANTsImage types

Example

>>> import ants
>>> img = ants.image_read(ants.get_ants_data('r16'))
>>> msk = ants.get_mask( img )
>>> img2 = ants.image_read(ants.get_ants_data('r16'))
>>> img3 = ants.image_read(ants.get_ants_data('r16'))
>>> mat = ants.image_list_to_matrix([img,img2,img3], msk )
>>> ilist = ants.matrix_to_images( mat, msk )

ants.core.ants_image_io.images_to_matrix(image_list, mask=None, sigma=None, epsilon=0.5)

Read images into rows of a matrix, given a mask - much faster for large datasets as it is based on C++ implementations.

ANTsR function: imagesToMatrix

Parameters:

• image_list (list of ANTsImage python:types) – images to convert to ndarray

• mask (ANTsImage (optional)) – image containing binary mask. voxels in the mask are placed in the matrix

• sigma (scaler (optional)) – smoothing factor

• epsilon (scalar) – threshold for mask

Returns:

array with a row for each image shape = (N_IMAGES, N_VOXELS)

Return type:

ndarray

Example

>>> import ants
>>> img = ants.image_read(ants.get_ants_data('r16'))
>>> img2 = ants.image_read(ants.get_ants_data('r16'))
>>> img3 = ants.image_read(ants.get_ants_data('r16'))
>>> mat = ants.image_list_to_matrix([img,img2,img3])

ants.core.ants_image_io.make_image(imagesize, voxval=0, spacing=None, origin=None, direction=None, has_components=False, pixeltype='float')

Make an image with given size and voxel value or given a mask and vector

ANTsR function: makeImage

Parameters:

• shape (tuple/ANTsImage) – input image size or mask

• voxval (scalar) – input image value or vector, size of mask

• spacing (tuple/list) – image spatial resolution

• origin (tuple/list) – image spatial origin

• direction (list/ndarray) – direction matrix to convert from index to physical space

• components (boolean) – whether there are components per pixel or not

• pixeltype (float) – data type of image values

Return type:

ANTsImage

ants.core.ants_image_io.matrix_from_images(image_list, mask=None, sigma=None, epsilon=0.5)

Read images into rows of a matrix, given a mask - much faster for large datasets as it is based on C++ implementations.

ANTsR function: imagesToMatrix

Parameters:

• image_list (list of ANTsImage python:types) – images to convert to ndarray

• mask (ANTsImage (optional)) – image containing binary mask. voxels in the mask are placed in the matrix

• sigma (scaler (optional)) – smoothing factor

• epsilon (scalar) – threshold for mask

Returns:

array with a row for each image shape = (N_IMAGES, N_VOXELS)

Return type:

ndarray

Example

>>> import ants
>>> img = ants.image_read(ants.get_ants_data('r16'))
>>> img2 = ants.image_read(ants.get_ants_data('r16'))
>>> img3 = ants.image_read(ants.get_ants_data('r16'))
>>> mat = ants.image_list_to_matrix([img,img2,img3])

ants.core.ants_image_io.matrix_to_images(data_matrix, mask)

Unmasks rows of a matrix and writes as images

ANTsR function: matrixToImages

Parameters:

• data_matrix (numpy.ndarray) – each row corresponds to an image array should have number of columns equal to non-zero voxels in the mask

• mask (ANTsImage) – image containing a binary mask. Rows of the matrix are unmasked and written as images. The mask defines the output image space

Return type:

list of ANTsImage types

Example

>>> import ants
>>> img = ants.image_read(ants.get_ants_data('r16'))
>>> msk = ants.get_mask( img )
>>> img2 = ants.image_read(ants.get_ants_data('r16'))
>>> img3 = ants.image_read(ants.get_ants_data('r16'))
>>> mat = ants.image_list_to_matrix([img,img2,img3], msk )
>>> ilist = ants.matrix_to_images( mat, msk )

ants.core.ants_image_io.matrix_to_timeseries(image, matrix, mask=None)

converts a matrix to a ND image.

ANTsR function: matrix2timeseries

Parameters:

• image (reference ND image) –

• matrix (matrix to convert to image) –

• mask (mask image defining voxels of python:interest) –

Return type:

ANTsImage

Example

>>> import ants
>>> img = ants.make_image( (10,10,10,5 ) )
>>> mask = ants.ndimage_to_list( img )[0] * 0
>>> mask[ 4:8, 4:8, 4:8 ] = 1
>>> mat = ants.timeseries_to_matrix( img, mask = mask )
>>> img2 = ants.matrix_to_timeseries( img,  mat, mask)

ants.core.ants_image_io.timeseries_to_matrix(image, mask=None)

Convert a timeseries image into a matrix.

ANTsR function: timeseries2matrix

Parameters:

• image (image whose slices we convert to a matrix. E.g. a 3D image of size) – x by y by z will convert to a z by x*y sized matrix

• mask (ANTsImage (optional)) – image containing binary mask. voxels in the mask are placed in the matrix

Returns:

array with a row for each image shape = (N_IMAGES, N_VOXELS)

Return type:

ndarray

Example

>>> import ants
>>> img = ants.make_image( (10,10,10,5 ) )
>>> mat = ants.timeseries_to_matrix( img )

ants.core.ants_metric module

ANTs ImageToImageMetric class

ants.core.ants_metric_io module

ants.core.ants_metric_io.create_ants_metric(fixed, moving, metric_type='MeanSquares', fixed_mask=None, moving_mask=None, sampling_strategy='regular', sampling_percentage=1)

Parameters:

metric_type (string) –

which metric to use options:

MeanSquares MattesMutualInformation ANTSNeighborhoodCorrelation Correlation Demons JointHistogramMutualInformation

Example

>>> import ants
>>> fixed = ants.image_read(ants.get_ants_data('r16'))
>>> moving = ants.image_read(ants.get_ants_data('r64'))
>>> metric_type = 'Correlation'
>>> metric = ants.create_ants_metric(fixed, moving, metric_type)

ants.core.ants_metric_io.new_ants_metric(dimension=3, precision='float', metric_type='MeanSquares')

ants.core.ants_metric_io.supported_metrics()

ants.core.ants_transform module

class ants.core.ants_transform.ANTsTransform(precision='float', dimension=3, transform_type='AffineTransform', pointer=None)

Bases: object

apply(data, data_type='point', reference=None, **kwargs)

Apply transform to data

apply_to_image(image, reference=None, interpolation='linear')

Apply transform to an image

Parameters:

• image (ANTsImage) – image to which the transform will be applied

• reference (ANTsImage) – target space for transforming image

• interpolation (string) –

  type of interpolation to use. Options are:

  linear nearestneighbor multilabel gaussian bspline cosinewindowedsinc welchwindowedsinc hammingwindoweddinc lanczoswindowedsinc genericlabel

Returns:

list

Return type:

transformed vector

apply_to_point(point)

Apply transform to a point

Parameters:

point (list/tuple) – point to which the transform will be applied

Returns:

list

Return type:

transformed point

Example

>>> import ants
>>> tx = ants.new_ants_transform()
>>> params = tx.parameters
>>> tx.set_parameters(params*2)
>>> pt2 = tx.apply_to_point((1,2,3)) # should be (2,4,6)

apply_to_vector(vector)

Apply transform to a vector

Parameters:

vector (list/tuple) – vector to which the transform will be applied

Returns:

list

Return type:

transformed vector

property fixed_parameters

Get parameters of transform

invert()

Invert the transform

property parameters

Get parameters of transform

set_fixed_parameters(parameters)

Set parameters of transform

set_parameters(parameters)

Set parameters of transform

ants.core.ants_transform.apply_ants_transform(transform, data, data_type='point', reference=None, **kwargs)

Apply ANTsTransform to data

ANTsR function: applyAntsrTransform

Parameters:

• transform (ANTsTransform) – transform to apply to image

• data (ndarray/list/tuple) – data to which transform will be applied

• data_type (string) –

  type of data Options :

  ’point’ ‘vector’ ‘image’

• reference (ANTsImage) – target space for transforming image

• kwargs (kwargs) – additional options passed to apply_ants_transform_to_image

Returns:

• ANTsImage if data_type == ‘point’

• OR

• tuple if data_type == ‘point’ or data_type == ‘vector’

ants.core.ants_transform.apply_ants_transform_to_image(transform, image, reference, interpolation='linear')

Apply transform to an image

ANTsR function: applyAntsrTransformToImage

Parameters:

• image (ANTsImage) – image to which the transform will be applied

• reference (ANTsImage) – reference image

• interpolation (string) – type of interpolation to use. Options are: linear nearestneighbor multilabel gaussian bspline cosinewindowedsinc welchwindowedsinc hammingwindoweddinc lanczoswindowedsinc genericlabel

Returns:

list

Return type:

transformed vector

Example

>>> import ants
>>> img = ants.image_read(ants.get_ants_data("r16")).clone('float')
>>> tx = ants.new_ants_transform(dimension=2)
>>> tx.set_parameters((0.9,0,0,1.1,10,11))
>>> img2 = tx.apply_to_image(img, img)

ants.core.ants_transform.apply_ants_transform_to_point(transform, point)

Apply transform to a point

ANTsR function: applyAntsrTransformToPoint

Parameters:

point (list/tuple) – point to which the transform will be applied

Returns:

tuple

Return type:

transformed point

Example

>>> import ants
>>> tx = ants.new_ants_transform()
>>> params = tx.parameters
>>> tx.set_parameters(params*2)
>>> pt2 = tx.apply_to_point((1,2,3)) # should be (2,4,6)

ants.core.ants_transform.apply_ants_transform_to_vector(transform, vector)

Apply transform to a vector

ANTsR function: applyAntsrTransformToVector

Parameters:

vector (list/tuple) – vector to which the transform will be applied

Returns:

tuple

Return type:

transformed vector

ants.core.ants_transform.compose_ants_transforms(transform_list)

Compose multiple ANTsTransform’s together

ANTsR function: composeAntsrTransforms

Parameters:

transform_list (list/tuple of ANTsTransform object) – list of transforms to compose together

Returns:

one transform that contains all given transforms

Return type:

ANTsTransform

Example

>>> import ants
>>> img = ants.image_read(ants.get_ants_data("r16")).clone('float')
>>> tx = ants.new_ants_transform(dimension=2)
>>> tx.set_parameters((0.9,0,0,1.1,10,11))
>>> inv_tx = tx.invert()
>>> single_tx = ants.compose_ants_transforms([tx, inv_tx])
>>> img_orig = single_tx.apply_to_image(img, img)
>>> rRotGenerator = ants.contrib.RandomRotate2D( ( 0, 40 ), reference=img )
>>> rShearGenerator=ants.contrib.RandomShear2D( (0,50), reference=img )
>>> tx1 = rRotGenerator.transform()
>>> tx2 = rShearGenerator.transform()
>>> rSrR = ants.compose_ants_transforms([tx1, tx2])
>>> rSrR.apply_to_image( img )

ants.core.ants_transform.get_ants_transform_fixed_parameters(transform)

Get fixed parameters of an ANTsTransform

ANTsR function: getAntsrTransformFixedParameters

ants.core.ants_transform.get_ants_transform_parameters(transform)

Get parameters of an ANTsTransform

ANTsR function: getAntsrTransformParameters

ants.core.ants_transform.invert_ants_transform(transform)

Invert ANTsTransform

ANTsR function: invertAntsrTransform

Example

>>> import ants
>>> img = ants.image_read(ants.get_ants_data("r16")).clone('float')
>>> tx = ants.new_ants_transform(dimension=2)
>>> tx.set_parameters((0.9,0,0,1.1,10,11))
>>> img_transformed = tx.apply_to_image(img, img)
>>> inv_tx = tx.invert()
>>> img_orig = inv_tx.apply_to_image(img_transformed, img_transformed)

ants.core.ants_transform.set_ants_transform_fixed_parameters(transform, parameters)

Set fixed parameters of an ANTsTransform

ANTsR function: setAntsrTransformFixedParameters

ants.core.ants_transform.set_ants_transform_parameters(transform, parameters)

Set parameters of an ANTsTransform

ANTsR function: setAntsrTransformParameters

ants.core.ants_transform.transform_index_to_physical_point(image, index)

Get spatial point from index of an image.

ANTsR function: antsTransformIndexToPhysicalPoint

Parameters:

• img (ANTsImage) – image to get values from

• index (list or tuple or numpy.ndarray) – location in image

Return type:

tuple

Example

>>> import ants
>>> import numpy as np
>>> img = ants.make_image((10,10),np.random.randn(100))
>>> pt = ants.transform_index_to_physical_point(img, (2,2))

ants.core.ants_transform.transform_physical_point_to_index(image, point)

Get index from spatial point of an image.

ANTsR function: antsTransformPhysicalPointToIndex

Parameters:

• image (ANTsImage) – image to get values from

• point (list or tuple or numpy.ndarray) – point in image

Return type:

tuple

Example

>>> import ants
>>> import numpy as np
>>> img = ants.make_image((10,10),np.random.randn(100))
>>> idx = ants.transform_physical_point_to_index(img, (2,2))
>>> img.set_spacing((2,2))
>>> idx2 = ants.transform_physical_point_to_index(img, (4,4))

ants.core.ants_transform_io module

ants.core.ants_transform_io.create_ants_transform(transform_type='AffineTransform', precision='float', dimension=3, matrix=None, offset=None, center=None, translation=None, parameters=None, fixed_parameters=None, displacement_field=None, supported_types=False)

Create and initialize an ANTsTransform

ANTsR function: createAntsrTransform

Parameters:

• transform_type (string) – type of transform(s)

• precision (string) – numerical precision

• dimension (python:integer) – spatial dimension of transform

• matrix (ndarray) – matrix for linear transforms

• offset (tuple/list) – offset for linear transforms

• center (tuple/list) – center for linear transforms

• translation (tuple/list) – translation for linear transforms

• parameters (ndarray/list) – array of parameters

• fixed_parameters (ndarray/list) – array of fixed parameters

• displacement_field (ANTsImage) – multichannel ANTsImage for non-linear transform

• supported_types (boolean) – flag that returns array of possible transforms types

Return type:

ANTsTransform or list of ANTsTransform types

Example

>>> import ants
>>> translation = (3,4,5)
>>> tx = ants.create_ants_transform( type='Euler3DTransform', translation=translation )

ants.core.ants_transform_io.new_ants_transform(precision='float', dimension=3, transform_type='AffineTransform', parameters=None, fixed_parameters=None)

Create a new ANTsTransform

ANTsR function: None

This is a simplified method for creating an ANTsTransform, mostly used internally. See create_ants_transform for more options.

Example

>>> import ants
>>> tx = ants.new_ants_transform()

ants.core.ants_transform_io.read_transform(filename, precision='float')

Read a transform from file

ANTsR function: readAntsrTransform

Parameters:

• filename (string) – filename of transform

• precision (string) – numerical precision of transform

Return type:

ANTsTransform

Example

>>> import ants
>>> tx = ants.new_ants_transform(dimension=2)
>>> tx.set_parameters((0.9,0,0,1.1,10,11))
>>> ants.write_transform(tx, '~/desktop/tx.mat')
>>> tx2 = ants.read_transform('~/desktop/tx.mat')

ants.core.ants_transform_io.transform_from_displacement_field(field)

Convert deformation field (multiChannel image) to ANTsTransform

ANTsR function: antsrTransformFromDisplacementField

Parameters:

field (ANTsImage) – deformation field as multi-channel ANTsImage

Return type:

ANTsImage

Example

>>> import ants
>>> fi = ants.image_read(ants.get_ants_data('r16') )
>>> mi = ants.image_read(ants.get_ants_data('r64') )
>>> fi = ants.resample_image(fi,(60,60),1,0)
>>> mi = ants.resample_image(mi,(60,60),1,0) # speed up
>>> mytx = ants.registration(fixed=fi, moving=mi, type_of_transform = ('SyN') )
>>> vec = ants.image_read( mytx['fwdtransforms'][0] )
>>> atx = ants.transform_from_displacement_field( vec )

ants.core.ants_transform_io.transform_to_displacement_field(xfrm, ref)

Convert displacement field ANTsTransform to displacement field

ANTsR function: antsrTransformToDisplacementField

Parameters:

• xfrm (displacement field ANTsTransform) – displacement field ANTsTransform

• ref (ANTs Image) –

Return type:

ANTsVectorImage

Example

>>> import ants
>>> fi = ants.image_read(ants.get_ants_data('r16') )
>>> mi = ants.image_read(ants.get_ants_data('r64') )
>>> fi = ants.resample_image(fi,(60,60),1,0)
>>> mi = ants.resample_image(mi,(60,60),1,0) # speed up
>>> mytx = ants.registration(fixed=fi, moving=mi, type_of_transform = ('SyN') )
>>> vec = ants.image_read( mytx['fwdtransforms'][0] )
>>> atx = ants.transform_from_displacement_field( vec )
>>> field = ants.transform_to_displacement_field( atx, fi )

ants.core.ants_transform_io.write_transform(transform, filename)

Write ANTsTransform to file

ANTsR function: writeAntsrTransform

Parameters:

• transform (ANTsTransform) – transform to save

• filename (string) – filename of transform (file extension is “.mat” for affine transforms)

Return type:

N/A

Example

>>> import ants
>>> tx = ants.new_ants_transform(dimension=2)
>>> tx.set_parameters((0.9,0,0,1.1,10,11))
>>> ants.write_transform(tx, '~/desktop/tx.mat')
>>> tx2 = ants.read_transform('~/desktop/tx.mat')

Module contents