def test_itk_registration(self):
import os
os.environ["FOOTSTEPS_NAME"] = "test"
import footsteps
icon_registration.test_utils.download_test_data()
model = icon_registration.pretrained_models.OAI_knees_registration_model(
pretrained=True)
image_A = itk.imread(
str(icon_registration.test_utils.TEST_DATA_DIR /
"knees_diverse_sizes" /
#"9126260_20060921_SAG_3D_DESS_LEFT_11309302_image.nii.gz")
"9487462_20081003_SAG_3D_DESS_RIGHT_11495603_image.nii.gz"))
image_B = itk.imread(
str(icon_registration.test_utils.TEST_DATA_DIR /
"knees_diverse_sizes" /
"9225063_20090413_SAG_3D_DESS_RIGHT_12784112_image.nii.gz"))
print(image_A.GetLargestPossibleRegion().GetSize())
print(image_B.GetLargestPossibleRegion().GetSize())
print(image_A.GetSpacing())
print(image_B.GetSpacing())
phi_AB, phi_BA = icon_registration.itk_wrapper.register_pair(
model, image_A, image_B)
assert (isinstance(phi_AB, itk.CompositeTransform))
interpolator = itk.LinearInterpolateImageFunction.New(image_A)
warped_image_A = itk.resample_image_filter(
image_A,
transform=phi_AB,
interpolator=interpolator,
size=itk.size(image_B),
output_spacing=itk.spacing(image_B),
output_direction=image_B.GetDirection(),
output_origin=image_B.GetOrigin())
plt.imshow(
np.array(itk.checker_board_image_filter(warped_image_A,
image_B))[40])
plt.colorbar()
plt.savefig(footsteps.output_dir + "grid.png")
plt.clf()
plt.imshow(np.array(warped_image_A)[40])
plt.savefig(footsteps.output_dir + "warped.png")
plt.clf()
reference = np.load(icon_registration.test_utils.TEST_DATA_DIR /
"warped.npy")
np.save(footsteps.output_dir + "warped.npy",
itk.array_from_image(warped_image_A)[40])
self.assertLess(
np.mean(
np.abs(reference - itk.array_from_image(warped_image_A)[40])),
1e-6)
def downsample_images(images:list, ratio:float) -> list:
assert(ratio > 1.0)
downsampled_image_list = list()
for image in images:
new_spacing = [spacing * ratio for spacing in itk.spacing(image)]
new_size = [int(size / ratio) for size in itk.size(image)]
downsampled_image = itk.resample_image_filter(image,
size=new_size,
output_origin=itk.origin(image),
output_spacing=new_spacing)
downsampled_image_list.append(downsampled_image)
return downsampled_image_list
def spine_slice(image, params):
"""
image is the ITK image to slice from
params is a SliceParams object"""
output_spacing = [params.height / params.px, params.width / params.px, 1]
output_origin = [
val + params.direction[j, 0] * -params.height / 2 +
params.direction[j, 1] * -params.width / 2
for j, val in enumerate(params.origin)
]
#print(output_origin)
#print(output_spacing)
return itk.resample_image_filter(image,
output_origin=output_origin,
output_spacing=output_spacing,
OutputDirection=itk.matrix_from_array(
np.ascontiguousarray(
params.direction)),
size=[params.px, params.px, 1])
fixed_landmarks.push_back(fixed_point)
moving_landmarks.push_back(moving_point)
fixed_point[0] = 20
fixed_point[1] = 20
moving_point[0] = 60
moving_point[1] = 60
fixed_landmarks.push_back(fixed_point)
moving_landmarks.push_back(moving_point)
TransformInitializerType = itk.LandmarkBasedTransformInitializer[itk.Transform[
itk.D, Dimension, Dimension]]
transform_initializer = TransformInitializerType.New()
transform_initializer.SetFixedLandmarks(fixed_landmarks)
transform_initializer.SetMovingLandmarks(moving_landmarks)
transform = itk.Rigid2DTransform[itk.D].New()
transform_initializer.SetTransform(transform)
transform_initializer.InitializeTransform()
output = itk.resample_image_filter(
moving_image,
transform=transform,
use_reference_image=True,
reference_image=fixed_image,
default_pixel_value=200,
)
itk.imwrite(output, "outputPython.png")
parser = argparse.ArgumentParser(description="Resample A Scalar Image.")
parser.add_argument("input_image")
parser.add_argument("output_image")
parser.add_argument("size_x", type=int)
parser.add_argument("size_y", type=int)
args = parser.parse_args()
output_size = [args.size_x, args.size_y]
input_image = itk.imread(args.input_image)
input_spacing = itk.spacing(input_image)
input_size = itk.size(input_image)
dimension = input_image.GetImageDimension()
output_spacing = [
input_spacing[dim] * input_size[dim] / output_size[dim]
for dim in range(dimension)
]
transform = itk.IdentityTransform[itk.D, dimension].New()
output_image = itk.resample_image_filter(
input_image,
size=output_size,
output_spacing=output_spacing,
output_origin=itk.origin(input_image),
transform=transform,
)
itk.imwrite(output_image, args.output_image)
import itk
import argparse
parser = argparse.ArgumentParser(description="Resample A Vector Image.")
parser.add_argument("input_image")
parser.add_argument("output_image")
args = parser.parse_args()
PixelType = itk.RGBPixel[itk.UC]
input_image = itk.imread(args.input_image, pixel_type=PixelType)
ImageType = type(input_image)
interpolator = itk.LinearInterpolateImageFunction[ImageType, itk.D].New()
Dimension = input_image.GetImageDimension()
transform = itk.IdentityTransform[itk.D, Dimension].New()
output_image = itk.resample_image_filter(
input_image,
interpolator=interpolator,
transform=transform,
default_pixel_value=[50, 50, 50],
output_spacing=[0.5, 0.5],
output_origin=[30, 40],
size=[300, 300],
)
itk.imwrite(output_image, args.output_image)
expected_point = itk.Point[itk.D,2]([-22.7057, 13.4688])
point = image.TransformContinuousIndexToPhysicalPoint(continuous_index)
print(f'Expected point: Transformed point: {point}')
assert all([abs(el1 - el2) < 1e-3 for el1, el2 in zip(list(point), list(expected_point))]), f'Output point {point} differs from expectation {expected_point}'
transformed_continuous_index = image.TransformPhysicalPointToContinuousIndex(point)
print(f'Transformed continuous index: {continuous_index}')
assert transformed_continuous_index == continuous_index, f'Output {transformed_continuous_index} differs from expectation {continuous_index}'
# Try transforming last index [2047, 240]
continuous_index[0] = 2047
continuous_index[1] = 240
print(f'Continuous index: {continuous_index}')
expected_point = itk.Point[itk.D,2]([113.099, 67.0891])
point = image.TransformContinuousIndexToPhysicalPoint(continuous_index)
print(f'Transformed point: {point}')
assert all([abs(el1 - el2) < 1e-3 for el1, el2 in zip(list(point), list(expected_point))]), f'Output point {point} differs from expectation {expected_point}'
transformed_continuous_index = image.TransformPhysicalPointToContinuousIndex(point)
print(f'Transformed continuous index: {continuous_index}')
assert transformed_continuous_index == continuous_index, f'Output {transformed_continuous_index} differs from expectation {continuous_index}'
# Verify resampling works with curvilinear image input
output_size = [800] * dimension
output_spacing = [0.15] * dimension
output_origin = [output_size[0] * output_spacing[0] / -2.0,
radius_start * math.cos(math.pi / 4.0)]
_ = itk.resample_image_filter(image, size=output_size, output_spacing=output_spacing, output_origin=output_origin)
# objects in the image, omit the transform and instead supply:
#
# output_size = [int(input_size[d] * scale) for d in range(Dimension)]
# output_spacing = [input_spacing[d] / scale for d in range(Dimension)]
# output_origin = [input_origin[d] + 0.5 * (output_spacing[d] - input_spacing[d])
# for d in range(Dimension)]
output_size = input_size
output_spacing = input_spacing
output_origin = input_origin
scale_transform = itk.ScaleTransform[itk.D, Dimension].New()
scale_transform_parameters = scale_transform.GetParameters()
for i in range(len(scale_transform_parameters)):
scale_transform_parameters[i] = scale
scale_transform_center = [float(int(s / 2)) for s in input_size]
scale_transform.SetParameters(scale_transform_parameters)
scale_transform.SetCenter(scale_transform_center)
interpolator = itk.LinearInterpolateImageFunction.New(input_image)
resampled = itk.resample_image_filter(
input_image,
transform=scale_transform,
interpolator=interpolator,
size=output_size,
output_spacing=output_spacing,
output_origin=output_origin,
)
itk.imwrite(resampled, output_file_name)
#
# Get the final parameters of the transformation
#
final_parameters = registration.GetOutput().Get().GetParameters()
print("\nFinal Registration Parameters: ")
print(f"Translation X = {final_parameters[0]:f}")
print(f"Translation Y = {final_parameters[1]:f}")
#
# Now, we use the final transform for resampling the
# moving image.
#
resampled_moving = itk.resample_image_filter(
moving_image,
transform=registration.GetTransform(),
use_reference_image=True,
reference_image=fixed_image,
default_pixel_value=100)
#
# Cast to 8-bit unsigned integer pixels, supported by the PNG file format
#
OutputPixelType = itk.ctype('unsigned char')
resampled_cast = resampled_moving.astype(OutputPixelType)
#
# Write the resampled image
#
itk.imwrite(resampled_cast, output_image_file)
