def test_matrix_to_images(self):
# def matrix_to_images(data_matrix, mask):
for img in self.imgs:
imgmask = img > img.mean()
data = img[imgmask]
dataflat = data.reshape(1, -1)
mat = np.vstack([dataflat, dataflat]).astype('float32')
imglist = ants.matrix_to_images(mat, imgmask)
nptest.assert_allclose((img * imgmask).numpy(), imglist[0].numpy())
nptest.assert_allclose((img * imgmask).numpy(), imglist[1].numpy())
self.assertTrue(
ants.image_physical_space_consistency(img, imglist[0]))
self.assertTrue(
ants.image_physical_space_consistency(img, imglist[1]))
# go back to matrix
mat2 = ants.images_to_matrix(imglist, imgmask)
nptest.assert_allclose(mat, mat2)
# test with matrix.ndim > 2
img = img.clone()
img.set_direction(img.direction * 2)
imgmask = img > img.mean()
arr = (img * imgmask).numpy()
arr = arr[arr > 0.5]
arr2 = arr.copy()
mat = np.stack([arr, arr2])
imglist = ants.matrix_to_images(mat, imgmask)
for im in imglist:
self.assertTrue(ants.allclose(im, imgmask * img))
self.assertTrue(
ants.image_physical_space_consistency(im, imgmask))
def test_image_read_write(self):
# def image_read(filename, dimension=None, pixeltype='float'):
# def image_write(image, filename):
# test scalar images
for img in self.imgs:
img = (img - img.min()) / (img.max() - img.min())
img = img * 255.
img = img.clone('unsigned char')
for ptype in self.pixeltypes:
img = img.clone(ptype)
tmpfile = mktemp(suffix='.nii.gz')
ants.image_write(img, tmpfile)
img2 = ants.image_read(tmpfile)
self.assertTrue(ants.image_physical_space_consistency(img,img2))
self.assertEqual(img2.components, img.components)
nptest.assert_allclose(img.numpy(), img2.numpy())
# unsupported ptype
with self.assertRaises(Exception):
ants.image_read(tmpfile, pixeltype='not-suppoted-ptype')
# test vector images
for img in self.vecimgs:
img = (img - img.min()) / (img.max() - img.min())
img = img * 255.
img = img.clone('unsigned char')
for ptype in self.pixeltypes:
img = img.clone(ptype)
tmpfile = mktemp(suffix='.nii.gz')
ants.image_write(img, tmpfile)
img2 = ants.image_read(tmpfile)
self.assertTrue(ants.image_physical_space_consistency(img,img2))
self.assertEqual(img2.components, img.components)
nptest.assert_allclose(img.numpy(), img2.numpy())
# test saving/loading as npy
for img in self.imgs:
tmpfile = mktemp(suffix='.npy')
ants.image_write(img, tmpfile)
img2 = ants.image_read(tmpfile)
self.assertTrue(ants.image_physical_space_consistency(img,img2))
self.assertEqual(img2.components, img.components)
nptest.assert_allclose(img.numpy(), img2.numpy())
# with no json header
arr = img.numpy()
tmpfile = mktemp(suffix='.npy')
np.save(tmpfile, arr)
img2 = ants.image_read(tmpfile)
nptest.assert_allclose(img.numpy(), img2.numpy())
# non-existant file
with self.assertRaises(Exception):
tmpfile = mktemp(suffix='.nii.gz')
ants.image_read(tmpfile)
def test_copy_image_info(self):
for img in self.imgs:
img2 = img.clone()
img2.set_spacing([6.9]*img.dimension)
img2.set_origin([6.9]*img.dimension)
self.assertTrue(not ants.image_physical_space_consistency(img,img2))
img3 = ants.copy_image_info(reference=img, target=img2)
self.assertTrue(ants.image_physical_space_consistency(img,img3))
def test_make_image(self):
self.setUp()
for arr in self.arrs:
voxval = 6.
img = ants.make_image(arr.shape, voxval=voxval)
self.assertTrue(img.dimension, arr.ndim)
self.assertTrue(img.shape, arr.shape)
nptest.assert_allclose(img.mean(), voxval)
new_origin = tuple([6.9] * arr.ndim)
new_spacing = tuple([3.6] * arr.ndim)
new_direction = np.eye(arr.ndim) * 9.6
img2 = ants.make_image(arr.shape,
voxval=voxval,
origin=new_origin,
spacing=new_spacing,
direction=new_direction)
self.assertTrue(img2.dimension, arr.ndim)
self.assertTrue(img2.shape, arr.shape)
nptest.assert_allclose(img2.mean(), voxval)
self.assertEqual(img2.origin, new_origin)
self.assertEqual(img2.spacing, new_spacing)
nptest.assert_allclose(img2.direction, new_direction)
for ptype in self.pixeltypes:
img = ants.make_image(arr.shape, voxval=1., pixeltype=ptype)
self.assertEqual(img.pixeltype, ptype)
# test with components
img = ants.make_image((69, 70, 4), has_components=True)
self.assertEqual(img.components, 4)
self.assertEqual(img.dimension, 2)
nptest.assert_allclose(img.mean(), 0.)
img = ants.make_image((69, 70, 71, 4), has_components=True)
self.assertEqual(img.components, 4)
self.assertEqual(img.dimension, 3)
nptest.assert_allclose(img.mean(), 0.)
# set from image
for img in self.imgs:
mask = img > img.mean()
arr = img[mask]
img2 = ants.make_image(mask, voxval=arr)
nptest.assert_allclose(img2.numpy(), (img * mask).numpy())
self.assertTrue(ants.image_physical_space_consistency(img2, mask))
# set with arr.ndim > 1
img2 = ants.make_image(mask, voxval=np.expand_dims(arr, -1))
nptest.assert_allclose(img2.numpy(), (img * mask).numpy())
self.assertTrue(ants.image_physical_space_consistency(img2, mask))
def test_images_to_matrix(self):
# def images_to_matrix(image_list, mask=None, sigma=None, epsilon=0):
for img in self.imgs:
mask = img > img.mean()
imglist = [img.clone(), img.clone(), img.clone()]
imgmat = ants.images_to_matrix(imglist, mask=mask)
self.assertTrue(imgmat.shape[0] == len(imglist))
self.assertTrue(imgmat.shape[1] == (mask > 0).sum())
# go back to images
imglist2 = ants.matrix_to_images(imgmat, mask)
for i1, i2 in zip(imglist, imglist2):
self.assertTrue(ants.image_physical_space_consistency(i1, i2))
nptest.assert_allclose(i1.numpy() * mask.numpy(), i2.numpy())
if img.dimension == 2:
# with sigma
mask = img > img.mean()
imglist = [img.clone(), img.clone(), img.clone()]
imgmat = ants.images_to_matrix(imglist, mask=mask, sigma=2.)
# with no mask
mask = img > img.mean()
imglist = [img.clone(), img.clone(), img.clone()]
imgmat = ants.images_to_matrix(imglist)
# with mask of different shape
s = [65] * img.dimension
mask2 = ants.from_numpy(np.random.randn(*s))
mask2 = mask2 > mask2.mean()
imgmat = ants.images_to_matrix(imglist, mask=mask2)
def test_new_image_like(self):
#self.setUp()
for img in self.imgs:
myarray = img.numpy()
myarray *= 6.9
imgnew = img.new_image_like(myarray)
# test physical space consistency
self.assertTrue(ants.image_physical_space_consistency(img, imgnew))
# test data
nptest.assert_allclose(myarray, imgnew.numpy())
nptest.assert_allclose(myarray, img.numpy()*6.9)
# test exceptions
with self.assertRaises(Exception):
# not ndarray
new_data = img.clone()
img.new_image_like(new_data)
with self.assertRaises(Exception):
# wrong shape
new_data = np.random.randn(69,12,21).astype('float32')
img.new_image_like(new_data)
with self.assertRaises(Exception):
# wrong shape with components
vecimg = ants.from_numpy(np.random.randn(69,12,3).astype('float32'), has_components=True)
new_data = np.random.randn(69,12,4).astype('float32')
vecimg.new_image_like(new_data)
def test_nibabel(self):
fn = ants.get_ants_data('mni')
ants_img = ants.image_read(fn)
nii_mni = nib.load(fn)
ants_mni = ants_img.to_nibabel()
self.assertTrue((ants_mni.get_qform() == nii_mni.get_qform()).all())
temp = ants.from_nibabel(nii_mni)
self.assertTrue(ants.image_physical_space_consistency(ants_img, temp))
def test__ne__(self):
#self.setUp()
for img in self.imgs:
img2 = (img != 6.9)
self.assertTrue(ants.image_physical_space_consistency(img, img2))
nptest.assert_allclose(img2.numpy(), (img.numpy()!=6.9).astype('int'))
# op on another image
img2 = img != img.clone()
self.assertTrue(ants.image_physical_space_consistency(img, img2))
nptest.assert_allclose(img2.numpy(), img.numpy()!=img.numpy())
with self.assertRaises(Exception):
# different physical space
img2 = img.clone()
img2.set_spacing([2.31]*img.dimension)
img3 = img != img2
def test__pow__(self):
#self.setUp()
for img in self.imgs:
# op on constant
img2 = img ** 6.9
self.assertTrue(ants.image_physical_space_consistency(img, img2))
nptest.assert_allclose(img2.numpy(), img.numpy()**6.9)
# op on another image
img2 = img ** img.clone()
self.assertTrue(ants.image_physical_space_consistency(img, img2))
nptest.assert_allclose(img2.numpy(), img.numpy()**img.numpy())
with self.assertRaises(Exception):
# different physical space
img2 = img.clone()
img2.set_spacing([2.31]*img.dimension)
img3 = img ** img2
def test_Rotate3D(self):
for img in self.imgs_3d:
imgclone = img.clone()
tx = ants.contrib.Rotate3D((10, -5, 12))
img_zoom = tx.transform(img)
# physical space shouldnt change .. ?
self.assertTrue(
ants.image_physical_space_consistency(img, img_zoom))
# assert no unintended changes to passed-in img
self.assertTrue(
ants.image_physical_space_consistency(img, imgclone))
self.assertTrue(ants.allclose(img, imgclone))
# apply to cloned image to ensure deterministic nature
img_zoom2 = tx.transform(imgclone)
self.assertTrue(
ants.image_physical_space_consistency(img_zoom, img_zoom2))
self.assertTrue(ants.allclose(img_zoom, img_zoom2))
def test_image_clone(self):
for img in self.imgs:
img = ants.image_clone(img, 'unsigned char')
orig_ptype = img.pixeltype
for ptype in self.pixeltypes:
imgcloned = ants.image_clone(img, ptype)
self.assertTrue(ants.image_physical_space_consistency(img,imgcloned))
nptest.assert_allclose(img.numpy(), imgcloned.numpy())
self.assertEqual(imgcloned.pixeltype, ptype)
self.assertEqual(img.pixeltype, orig_ptype)
for img in self.vecimgs:
img = img.clone('unsigned char')
orig_ptype = img.pixeltype
for ptype in self.pixeltypes:
imgcloned = ants.image_clone(img, ptype)
self.assertTrue(ants.image_physical_space_consistency(img,imgcloned))
self.assertEqual(imgcloned.components, img.components)
nptest.assert_allclose(img.numpy(), imgcloned.numpy())
self.assertEqual(imgcloned.pixeltype, ptype)
self.assertEqual(img.pixeltype, orig_ptype)
def test_to_file(self):
#self.setUp()
for img in self.imgs:
filename = mktemp(suffix='.nii.gz')
img.to_file(filename)
# test that file now exists
self.assertTrue(os.path.exists(filename))
img2 = ants.image_read(filename)
# test physical space and data
self.assertTrue(ants.image_physical_space_consistency(img, img2))
nptest.assert_allclose(img.numpy(), img2.numpy())
try:
os.remove(filename)
except:
pass
def test_clone(self):
#self.setUp()
for img in self.imgs:
orig_ptype = img.pixeltype
for ptype in self.pixeltypes:
imgclone = img.clone(ptype)
self.assertEqual(imgclone.pixeltype, ptype)
self.assertEqual(img.pixeltype, orig_ptype)
# test physical space consistency
self.assertTrue(ants.image_physical_space_consistency(img, imgclone))
if ptype == orig_ptype:
# test that they dont share image pointer
view1 = img.view()
view1 *= 6.9
nptest.assert_allclose(view1, imgclone.numpy()*6.9)
def randomly_transform_image_data(
reference_image,
input_image_list,
segmentation_image_list=None,
number_of_simulations=10,
transform_type='affine',
sd_affine=0.02,
deformation_transform_type="bspline",
number_of_random_points=1000,
sd_noise=10.0,
number_of_fitting_levels=4,
mesh_size=1,
sd_smoothing=4.0,
input_image_interpolator='linear',
segmentation_image_interpolator='nearestNeighbor'):
"""
Randomly transform image data (optional: with corresponding segmentations).
Apply rigid, affine and/or deformable maps to an input set of training
images. The reference image domain defines the space in which this
happens.
Arguments
---------
reference_image : ANTsImage
Defines the spatial domain for all output images. If the input images do
not match the spatial domain of the reference image, we internally
resample the target to the reference image. This could have unexpected
consequences. Resampling to the reference domain is performed by testing
using ants.image_physical_space_consistency then calling
ants.resample_image_to_target with failure.
input_image_list : list of lists of ANTsImages
List of lists of input images to warp. The internal list sets contain one
or more images (per subject) which are assumed to be mutually aligned. The
outer list contains multiple subject lists which are randomly sampled to
produce output image list.
segmentation_image_list : list of ANTsImages
List of segmentation images corresponding to the input image list (optional).
number_of_simulations : integer
Number of output images.
transform_type : string
One of the following options: "translation", "rigid", "scaleShear", "affine",
"deformation", "affineAndDeformation".
sd_affine : float
Parameter dictating deviation amount from identity for random linear
transformations.
deformation_transform_type : string
"bspline" or "exponential".
number_of_random_points : integer
Number of displacement points for the deformation field.
sd_noise : float
Standard deviation of the displacement field.
number_of_fitting_levels : integer
Number of fitting levels (bspline deformation only).
mesh_size : int or n-D tuple
Determines fitting resolution (bspline deformation only).
sd_smoothing : float
Standard deviation of the Gaussian smoothing in mm (exponential field only).
input_image_interpolator : string
One of the following options "linear", "gaussian", "bspline".
segmentation_image_interpolator : string
One of the following options "nearestNeighbor" or "genericLabel".
Returns
-------
list of lists of transformed images
Example
-------
>>> import ants
>>> image1_list = list()
>>> image1_list.append(ants.image_read(ants.get_ants_data("r16")))
>>> image2_list = list()
>>> image2_list.append(ants.image_read(ants.get_ants_data("r64")))
>>> input_segmentations = list()
>>> input_segmentations.append(ants.threshold_image(image1, "Otsu", 3))
>>> input_segmentations.append(ants.threshold_image(image2, "Otsu", 3))
>>> input_images = list()
>>> input_images.append(image1_list)
>>> input_images.append(image2_list)
>>> data = antspynet.randomly_transform_image_data(image1,
>>> input_images, input_segmentations, sd_affine=0.02,
>>> transform_type = "affineAndDeformation" )
"""
def polar_decomposition(X):
U, d, V = np.linalg.svd(X, full_matrices=False)
P = np.matmul(U, np.matmul(np.diag(d), np.transpose(U)))
Z = np.matmul(U, np.transpose(V))
if np.linalg.det(Z) < 0:
Z = -Z
return ({"P": P, "Z": Z, "Xtilde": np.matmul(P, Z)})
def create_random_linear_transform(image,
fixed_parameters,
transform_type='affine',
sd_affine=1.0):
transform = ants.create_ants_transform(
transform_type="AffineTransform",
precision='float',
dimension=image.dimension)
ants.set_ants_transform_fixed_parameters(transform, fixed_parameters)
identity_parameters = ants.get_ants_transform_parameters(transform)
random_epsilon = np.random.normal(loc=0,
scale=sd_affine,
size=len(identity_parameters))
if transform_type == 'translation':
random_epsilon[:(len(identity_parameters) - image.dimension)] = 0
random_parameters = identity_parameters + random_epsilon
random_matrix = np.reshape(
random_parameters[:(len(identity_parameters) - image.dimension)],
newshape=(image.dimension, image.dimension))
decomposition = polar_decomposition(random_matrix)
if transform_type == "rigid":
random_matrix = decomposition['Z']
elif transform_type == "affine":
random_matrix = decomposition['Xtilde']
elif transform_type == "scaleShear":
random_matrix = decomposition['P']
random_parameters[:(len(identity_parameters) - image.dimension)] = \
np.reshape(random_matrix, newshape=(len(identity_parameters) - image.dimension))
ants.set_ants_transform_parameters(transform, random_parameters)
return (transform)
def create_random_displacement_field_transform(
image,
field_type="bspline",
number_of_random_points=1000,
sd_noise=10.0,
number_of_fitting_levels=4,
mesh_size=1,
sd_smoothing=4.0):
displacement_field = ants.simulate_displacement_field(
image,
field_type=field_type,
number_of_random_points=number_of_random_points,
sd_noise=sd_noise,
enforce_stationary_boundary=True,
number_of_fitting_levels=number_of_fitting_levels,
mesh_size=mesh_size,
sd_smoothing=sd_smoothing)
return (ants.transform_from_displacement_field(displacement_field))
admissible_transforms = ("translation", "rigid", "scaleShear", "affine",
"affineAndDeformation", "deformation")
if not transform_type in admissible_transforms:
raise ValueError(
"The specified transform is not a possible option. Please see help menu."
)
# Get the fixed parameters from the reference image.
fixed_parameters = ants.get_center_of_mass(reference_image)
number_of_subjects = len(input_image_list)
random_indices = np.random.choice(number_of_subjects,
size=number_of_simulations,
replace=True)
simulated_image_list = list()
simulated_segmentation_image_list = list()
simulated_transforms = list()
for i in range(number_of_simulations):
single_subject_image_list = input_image_list[random_indices[i]]
single_subject_segmentation_image = None
if segmentation_image_list is not None:
single_subject_segmentation_image = segmentation_image_list[
random_indices[i]]
if ants.image_physical_space_consistency(
reference_image, single_subject_image_list[0]) is False:
for j in range(len(single_subject_image_list)):
single_subject_image_list.append(
ants.resample_image_to_target(
single_subject_image_list[j],
reference_image,
interp_type=input_image_interpolator))
if single_subject_segmentation_image is not None:
single_subject_segmentation_image = \
ants.resample_image_to_target(single_subject_segmentation_image, reference_image,
interp_type=segmentation_image_interpolator)
transforms = list()
if transform_type == 'deformation':
deformable_transform = create_random_displacement_field_transform(
reference_image, deformation_transform_type,
number_of_random_points, sd_noise, number_of_fitting_levels,
mesh_size, sd_smoothing)
transforms.append(deformable_transform)
elif transform_type == 'affineAndDeformation':
deformable_transform = create_random_displacement_field_transform(
reference_image, deformation_transform_type,
number_of_random_points, sd_noise, number_of_fitting_levels,
mesh_size, sd_smoothing)
linear_transform = create_random_linear_transform(
reference_image, fixed_parameters, 'affine', sd_affine)
transforms.append(deformable_transform)
transforms.append(linear_transform)
else:
linear_transform = create_random_linear_transform(
reference_image, fixed_parameters, transform_type, sd_affine)
transforms.append(linear_transform)
simulated_transforms.append(ants.compose_ants_transforms(transforms))
single_subject_simulated_image_list = list()
for j in range(len(single_subject_image_list)):
single_subject_simulated_image_list.append(
ants.apply_ants_transform_to_image(
simulated_transforms[i],
single_subject_image_list[j],
reference=reference_image))
simulated_image_list.append(single_subject_simulated_image_list)
if single_subject_segmentation_image is not None:
simulated_segmentation_image_list.append(
ants.apply_ants_transform_to_image(
simulated_transforms[i],
single_subject_segmentation_image,
reference=reference_image))
if segmentation_image_list is None:
return ({
'simulated_images': simulated_image_list,
'simulated_transforms': simulated_transforms
})
else:
return ({
'simulated_images': simulated_image_list,
'simulated_segmentation_images': simulated_segmentation_image_list,
'simulated_transforms': simulated_transforms
})
def test_image_physical_spacing_consistency(self):
for img in self.imgs:
self.assertTrue(ants.image_physical_space_consistency(img,img))
self.assertTrue(ants.image_physical_space_consistency(img,img,datatype=True))
clonetype = 'float' if img.pixeltype != 'float' else 'unsigned int'
img2 = img.clone(clonetype)
self.assertTrue(ants.image_physical_space_consistency(img,img2))
self.assertTrue(not ants.image_physical_space_consistency(img,img2,datatype=True))
# test incorrectness #
# bad spacing
img2 = img.clone()
img2.set_spacing([6.96]*img.dimension)
self.assertTrue(not ants.image_physical_space_consistency(img,img2))
# bad origin
img2 = img.clone()
img2.set_origin([6.96]*img.dimension)
self.assertTrue(not ants.image_physical_space_consistency(img,img2))
# bad direction
img2 = img.clone()
img2.set_direction(img.direction*2)
self.assertTrue(not ants.image_physical_space_consistency(img,img2))
# bad dimension
ndim = img.dimension
img2 = ants.from_numpy(np.random.randn(*tuple([69]*(ndim+1))).astype('float32'))
self.assertTrue(not ants.image_physical_space_consistency(img,img2))
# only one image
with self.assertRaises(Exception):
ants.image_physical_space_consistency(img)
# not an ANTsImage
with self.assertRaises(Exception):
ants.image_physical_space_consistency(img, 12)
# false because of components
vecimg = ants.from_numpy(np.random.randn(69,70,3), has_components=True)
vecimg2 = ants.from_numpy(np.random.randn(69,70,4), has_components=True)
self.assertTrue(not ants.image_physical_space_consistency(vecimg, vecimg2, datatype=True))
def test_apply(self):
#self.setUp()
for img in self.imgs:
img2 = img.apply(lambda x: x*6.9)
self.assertTrue(ants.image_physical_space_consistency(img, img2))
nptest.assert_allclose(img2.numpy(), img.numpy()*6.9)
