def A(self, reconstruction, stack_slice, interpolator_mask="Linear"):
simulated_itk = self.A_itk(reconstruction.itk, stack_slice.itk)
simulated_sitk = sitkh.get_sitk_from_itk_image(simulated_itk)
# Update stack/slice mask, in case provided for reconstruction
if not reconstruction.is_unity_mask():
slice_tmp = reconstruction.get_resampled_stack(
stack_slice.sitk, interpolator=interpolator_mask)
simulated_sitk_mask = slice_tmp.sitk_mask
# PSF-aware resampling omitted as results less plausible for mask
# simulated_itk_mask = self.A_itk(
# reconstruction.itk_mask, stack_slice.itk_mask)
# simulated_sitk_mask = sitkh.get_sitk_from_itk_image(
# simulated_itk_mask)
else:
simulated_sitk_mask = None
if isinstance(stack_slice, sl.Slice):
simulated = sl.Slice.from_sitk_image(
slice_sitk=simulated_sitk,
slice_number=stack_slice.get_slice_number(),
filename=stack_slice.get_filename(),
slice_sitk_mask=simulated_sitk_mask,
)
elif isinstance(stack_slice, st.Stack):
simulated = st.Stack.from_sitk_image(
image_sitk=simulated_sitk,
image_sitk_mask=simulated_sitk_mask,
filename=stack_slice.get_filename(),
)
return simulated
def _run(self):
solver = self.get_solver()
self._print_info_text()
# Run reconstruction
solver.run()
# Get computational time
self._computational_time = solver.get_computational_time()
# Update volume
self._reconstruction.itk = self._get_itk_image_from_array_vec(
solver.get_x(), self._reconstruction.itk)
self._reconstruction.sitk = sitkh.get_sitk_from_itk_image(
self._reconstruction.itk)
def A(self, reconstruction, stack_slice, interpolator_mask="Linear"):
# Get slice spacing relevant for Gaussian blurring estimate
in_plane_res = stack_slice.get_inplane_resolution()
slice_thickness = stack_slice.get_slice_thickness()
slice_spacing = np.array([in_plane_res, in_plane_res, slice_thickness])
simulated_itk = self.A_itk(
reconstruction_itk=reconstruction.itk,
slice_itk=stack_slice.itk,
slice_spacing=slice_spacing,
)
simulated_sitk = sitkh.get_sitk_from_itk_image(simulated_itk)
# Update stack/slice mask, in case provided for reconstruction
if not reconstruction.is_unity_mask():
slice_tmp = reconstruction.get_resampled_stack(
stack_slice.sitk, interpolator=interpolator_mask)
simulated_sitk_mask = slice_tmp.sitk_mask
# PSF-aware resampling omitted as results less plausible for mask
# simulated_itk_mask = self.A_itk(
# reconstruction.itk_mask, stack_slice.itk_mask)
# simulated_sitk_mask = sitkh.get_sitk_from_itk_image(
# simulated_itk_mask)
else:
simulated_sitk_mask = None
if isinstance(stack_slice, sl.Slice):
simulated = sl.Slice.from_sitk_image(
slice_sitk=simulated_sitk,
slice_number=stack_slice.get_slice_number(),
filename=stack_slice.get_filename(),
slice_sitk_mask=simulated_sitk_mask,
slice_thickness=stack_slice.get_slice_thickness(),
)
elif isinstance(stack_slice, st.Stack):
simulated = st.Stack.from_sitk_image(
image_sitk=simulated_sitk,
image_sitk_mask=simulated_sitk_mask,
filename=stack_slice.get_filename(),
slice_thickness=stack_slice.get_slice_thickness(),
)
return simulated
def _run(self):
resampler_itk = itk.ResampleImageFilter[self._image_type,
self._image_type].New()
resampler_itk.SetOutputParametersFromImage(self._stack_slice.itk)
resampler_itk.SetInterpolator(self._get_interpolator(
self._stack_slice))
resampler_itk.SetInput(self._reference.itk)
resampler_itk.UpdateLargestPossibleRegion()
resampler_itk.Update()
output_itk = resampler_itk.GetOutput()
output_itk.DisconnectPipeline()
output_sitk = sitkh.get_sitk_from_itk_image(output_itk)
self._output = st.Stack.from_sitk_image(
image_sitk=output_sitk,
image_sitk_mask=self._stack_slice.sitk_mask,
filename=self._stack_slice.get_filename())
def test_run_simulation_view(self):
filename_HR_volume = "HR_volume_postmortem"
HR_volume = st.Stack.from_filename(
os.path.join(self.dir_test_data, filename_HR_volume + ".nii.gz"),
os.path.join(self.dir_test_data,
filename_HR_volume + "_mask.nii.gz"))
# 1) Test for Nearest Neighbor Interpolator
slice_acquistion = sa.SliceAcqusition(HR_volume)
slice_acquistion.set_interpolator_type("NearestNeighbor")
slice_acquistion.set_motion_type("NoMotion")
slice_acquistion.run_simulation_view_1()
slice_acquistion.run_simulation_view_2()
slice_acquistion.run_simulation_view_3()
stacks_simulated = slice_acquistion.get_simulated_stacks()
for i in range(0, len(stacks_simulated)):
HR_volume_resampled_sitk = sitk.Resample(
HR_volume.sitk, stacks_simulated[i].sitk,
sitk.Euler3DTransform(), sitk.sitkNearestNeighbor, 0.0,
stacks_simulated[i].sitk.GetPixelIDValue())
self.assertEqual(
np.round(np.linalg.norm(
sitk.GetArrayFromImage(stacks_simulated[i].sitk -
HR_volume_resampled_sitk)),
decimals=self.accuracy), 0)
# 2) Test for Linear Interpolator
slice_acquistion = sa.SliceAcqusition(HR_volume)
slice_acquistion.set_interpolator_type("Linear")
slice_acquistion.set_motion_type("NoMotion")
slice_acquistion.run_simulation_view_1()
slice_acquistion.run_simulation_view_2()
slice_acquistion.run_simulation_view_3()
stacks_simulated = slice_acquistion.get_simulated_stacks()
for i in range(0, len(stacks_simulated)):
HR_volume_resampled_sitk = sitk.Resample(
HR_volume.sitk, stacks_simulated[i].sitk,
sitk.Euler3DTransform(), sitk.sitkLinear, 0.0,
stacks_simulated[i].sitk.GetPixelIDValue())
self.assertEqual(
np.round(np.linalg.norm(
sitk.GetArrayFromImage(stacks_simulated[i].sitk -
HR_volume_resampled_sitk)),
decimals=self.accuracy), 0)
# 3) Test for Oriented Gaussian Interpolator
alpha_cut = 3
slice_acquistion = sa.SliceAcqusition(HR_volume)
slice_acquistion.set_interpolator_type("OrientedGaussian")
slice_acquistion.set_motion_type("NoMotion")
slice_acquistion.set_alpha_cut(alpha_cut)
slice_acquistion.run_simulation_view_1()
slice_acquistion.run_simulation_view_2()
slice_acquistion.run_simulation_view_3()
stacks_simulated = slice_acquistion.get_simulated_stacks()
resampler = itk.ResampleImageFilter[image_type, image_type].New()
resampler.SetDefaultPixelValue(0.0)
resampler.SetInput(HR_volume.itk)
interpolator = itk.OrientedGaussianInterpolateImageFunction[
image_type, pixel_type].New()
interpolator.SetAlpha(alpha_cut)
resampler.SetInterpolator(interpolator)
PSF = psf.PSF()
for i in range(0, len(stacks_simulated)):
resampler.SetOutputParametersFromImage(stacks_simulated[i].itk)
# Set covariance based on oblique PSF
Cov_HR_coord = PSF.get_covariance_matrix_in_reconstruction_space(
stacks_simulated[i], HR_volume)
interpolator.SetCovariance(Cov_HR_coord.flatten())
resampler.UpdateLargestPossibleRegion()
resampler.Update()
HR_volume_resampled_itk = resampler.GetOutput()
HR_volume_resampled_sitk = sitkh.get_sitk_from_itk_image(
HR_volume_resampled_itk)
self.assertEqual(
np.round(np.linalg.norm(
sitk.GetArrayFromImage(stacks_simulated[i].sitk -
HR_volume_resampled_sitk)),
decimals=self.accuracy), 0)
def test_ground_truth_affine_transforms_with_motion_OrientedGaussian(self):
filename_HR_volume = "HR_volume_postmortem"
HR_volume = st.Stack.from_filename(
os.path.join(self.dir_test_data, filename_HR_volume + ".nii.gz"),
os.path.join(self.dir_test_data,
filename_HR_volume + "_mask.nii.gz"))
alpha_cut = 3
# Run simulation for Oriented Gaussian interpolation, hence more
# "realistic" case
slice_acquistion = sa.SliceAcqusition(HR_volume)
slice_acquistion.set_interpolator_type("OrientedGaussian")
# slice_acquistion.set_interpolator_type("NearestNeighbor")
# slice_acquistion.set_interpolator_type("Linear")
slice_acquistion.set_motion_type("Random")
# slice_acquistion.set_motion_type("NoMotion")
slice_acquistion.set_alpha_cut(alpha_cut)
slice_acquistion.run_simulation_view_1()
slice_acquistion.run_simulation_view_2()
slice_acquistion.run_simulation_view_3()
# Get simulated stack of slices + corresponding ground truth affine
# transforms indicating the correct acquisition of the slice
# within the volume
stacks_simulated = slice_acquistion.get_simulated_stacks()
affine_transforms_ground_truth, rigid_motion_transforms_ground_truth = slice_acquistion.get_ground_truth_data(
)
resampler = itk.ResampleImageFilter[image_type, image_type].New()
resampler.SetDefaultPixelValue(0.0)
resampler.SetInput(HR_volume.itk)
interpolator = itk.OrientedGaussianInterpolateImageFunction[
image_type, pixel_type].New()
interpolator.SetAlpha(alpha_cut)
# interpolator = itk.LinearInterpolateImageFunction[image_type, pixel_type].New()
# interpolator = itk.NearestNeighborInterpolateImageFunction[image_type, pixel_type].New()
resampler.SetInterpolator(interpolator)
PSF = psf.PSF()
for i in range(0, len(stacks_simulated)):
stack = stacks_simulated[i]
slices = stack.get_slices()
N_slices = stack.get_number_of_slices()
for j in range(0, N_slices):
# print("Stack %s: Slice %s/%s" %(i,j,N_slices-1))
slice = slices[j]
slice.update_motion_correction(
rigid_motion_transforms_ground_truth[i][j])
# Get covariance based on oblique PSF
Cov_HR_coord = PSF.get_covariance_matrix_in_reconstruction_space(
slice, HR_volume)
# Update resampler
interpolator.SetCovariance(Cov_HR_coord.flatten())
resampler.SetOutputParametersFromImage(slice.itk)
resampler.UpdateLargestPossibleRegion()
resampler.Update()
HR_volume_resampled_slice_itk = resampler.GetOutput()
HR_volume_resampled_slice_sitk = sitkh.get_sitk_from_itk_image(
HR_volume_resampled_slice_itk)
# HR_volume_resampled_slice_sitk = sitk.Resample(
# HR_volume.sitk, slice.sitk, sitk.Euler3DTransform(), sitk.sitkNearestNeighbor, 0.0, slice.sitk.GetPixelIDValue()
# )
norm_diff = np.linalg.norm(
sitk.GetArrayFromImage(slice.sitk -
HR_volume_resampled_slice_sitk))
# try:
self.assertEqual(np.round(norm_diff, decimals=self.accuracy),
0)
def _run(self):
if self._use_fixed_mask:
fixed_sitk_mask = self._fixed.sitk_mask
else:
fixed_sitk_mask = None
if self._use_moving_mask:
moving_sitk_mask = self._moving.sitk_mask
else:
moving_sitk_mask = None
# Blur moving image with oriented Gaussian prior to the registration
if self._use_oriented_psf:
# Get oriented Gaussian covariance matrix
cov_HR_coord = psf.PSF(
).get_covariance_matrix_in_reconstruction_space(
self._fixed, self._moving)
# Create recursive YVV Gaussianfilter
image_type = itk.Image[itk.D, self._fixed.sitk.GetDimension()]
gaussian_yvv = itk.SmoothingRecursiveYvvGaussianImageFilter[
image_type, image_type].New()
# Feed Gaussian filter with axis aligned covariance matrix
sigma_axis_aligned = np.sqrt(np.diagonal(cov_HR_coord))
print("Oriented PSF blurring with (axis aligned) sigma = " +
str(sigma_axis_aligned))
print("\t(Based on computed covariance matrix = ")
for i in range(0, 3):
print("\t\t" + str(cov_HR_coord[i, :]))
print("\twith square root of diagonal " +
str(np.diagonal(cov_HR_coord)) + ")")
gaussian_yvv.SetInput(self._moving.itk)
gaussian_yvv.SetSigmaArray(sigma_axis_aligned)
gaussian_yvv.Update()
moving_itk = gaussian_yvv.GetOutput()
moving_itk.DisconnectPipeline()
moving_sitk = sitkh.get_sitk_from_itk_image(moving_itk)
else:
moving_sitk = self._moving.sitk
self._registration_method = \
simplereg.simple_itk_registration.SimpleItkRegistration(
fixed_sitk=self._fixed.sitk,
moving_sitk=moving_sitk,
fixed_sitk_mask=fixed_sitk_mask,
moving_sitk_mask=moving_sitk_mask,
registration_type=self._registration_type,
interpolator=self._interpolator,
metric=self._metric,
metric_params=self._metric_params,
optimizer=self._optimizer,
optimizer_params=self._optimizer_params,
initializer_type=self._initializer_type,
use_multiresolution_framework=self._use_multiresolution_framework,
optimizer_scales=self._scales_estimator,
shrink_factors=self._shrink_factors,
smoothing_sigmas=self._smoothing_sigmas,
verbose=self._use_verbose,
)
self._registration_method.run()
self._registration_transform_sitk = \
self._registration_method.get_registration_transform_sitk()
