def objective_function(optimise_array, static_image, dynamic_path, dvf_path,
weighted_normalise, dynamic_data_magnitude):
static_image.fill(
np.reshape(optimise_array,
static_image.as_array().astype(np.double).shape))
objective_value = 0.0
for i in range(len(dynamic_path)):
dynamic_image = reg.NiftiImageData(dynamic_path[i])
dvf_image = reg.NiftiImageData3DDeformation(dvf_path[i])
resampler = reg.NiftyResample()
resampler.set_reference_image(static_image)
resampler.set_floating_image(dynamic_image)
resampler.add_transformation(dvf_image)
resampler.set_interpolation_type_to_cubic_spline()
objective_value = objective_value + (np.nansum(
np.square(dynamic_image.as_array().astype(np.double) -
((np.nansum(dynamic_image.as_array().astype(np.double),
dtype=np.double) / dynamic_data_magnitude) *
warp_image_forward(resampler, static_image)),
dtype=np.double),
dtype=np.double) * weighted_normalise[i])
print("Objective function value: {0}".format(str(objective_value)))
return objective_value
def try_stirtonifti(nifti_filename):
time.sleep(0.5)
sys.stderr.write('\n# --------------------------------------------------------------------------------- #\n')
sys.stderr.write('# Starting STIR to Nifti test...\n')
sys.stderr.write('# --------------------------------------------------------------------------------- #\n')
time.sleep(0.5)
# Load the image as a NiftiImageData3D
image_nifti = reg.NiftiImageData3D(nifti_filename)
# Read as STIRImageData, convert to NiftiImageData3D and save to file
image_stir = pet.ImageData(nifti_filename)
image_nifti_from_stir = reg.NiftiImageData3D(image_stir)
image_nifti_from_stir.write('results/stir_to_nifti.nii',image_nifti.get_original_datatype())
# Compare the two
if image_nifti != image_nifti_from_stir:
raise AssertionError("Conversion from STIR to Nifti failed.")
# Resample and then check that voxel values match
resample = reg.NiftyResample()
resample.set_floating_image(image_stir)
resample.set_reference_image(image_nifti)
resample.set_interpolation_type_to_nearest_neighbour()
resample.process()
# as_array() of both original images should match
if not numpy.array_equal(image_nifti.as_array(),resample.get_output().as_array()):
raise AssertionError("as_array() of sirf.Reg.NiftiImageData and resampled sirf.STIR.ImageData are different.")
time.sleep(0.5)
sys.stderr.write('\n# --------------------------------------------------------------------------------- #\n')
sys.stderr.write('# Finished STIR to Nifti test.\n')
sys.stderr.write('# --------------------------------------------------------------------------------- #\n')
time.sleep(0.5)
def get_resamplers(static_image, dynamic_array, dvf_array, output_path):
resamplers = []
static_image_path = "{0}/temp_static.nii".format(output_path)
dynamic_array_path = "{0}/temp_dynamic.nii".format(output_path)
dvf_array_path = "{0}/temp_dvf.nii".format(output_path)
for j in range(len(dynamic_array)):
resampler = reg.NiftyResample()
static_image.write(static_image_path)
dynamic_array[j].write(dynamic_array_path)
dvf_array[j].write(dvf_array_path)
temp_static = reg.NiftiImageData(static_image_path)
temp_dynamic = reg.NiftiImageData(dynamic_array_path)
temp_dvf = reg.NiftiImageData3DDeformation(dvf_array_path)
resampler.set_reference_image(temp_static)
resampler.set_floating_image(temp_dynamic)
resampler.add_transformation(temp_dvf)
resampler.set_interpolation_type_to_linear()
resamplers.append(resampler)
return resamplers
def op_test(static_image, output_path):
static_image_path = "{0}/temp_static.nii".format(output_path)
static_image.write(static_image_path)
temp_static = reg.NiftiImageData(static_image_path)
temp_at = reg.AffineTransformation()
temp_at_array = temp_at.as_array()
temp_at_array[0][0] = 1.25
temp_at_array[1][1] = 1.25
temp_at_array[2][2] = 1.25
temp_at_array[3][3] = 1.25
temp_at = reg.AffineTransformation(temp_at_array)
resampler = reg.NiftyResample()
resampler.set_reference_image(temp_static)
resampler.set_floating_image(temp_static)
resampler.add_transformation(temp_at)
resampler.set_interpolation_type_to_linear()
warp = warp_image_forward(resampler, temp_static)
warped_image = static_image.clone()
warped_image.fill(warp)
warped_image.write("{0}/op_test_warp_forward.nii".format(output_path))
difference = temp_static.as_array().astype(np.double) - warp
difference_image = temp_static.clone()
difference_image.fill(difference)
difference_image.write(
"{0}/op_test_warp_forward_difference.nii".format(output_path))
warp = warp_image_adjoint(resampler, temp_static)
warped_image = temp_static.clone()
warped_image.fill(warp)
warped_image.write("{0}/op_test_warp_adjoint.nii".format(output_path))
difference = temp_static.as_array().astype(np.double) - warp
difference_image = temp_static.clone()
difference_image.fill(difference)
difference_image.write(
"{0}/warp_adjoint_difference.nii".format(output_path))
return True
def get_resampler_from_tm(tm, image):
"""returns a NiftyResample object for the specified transform matrix and image"""
resampler = reg.NiftyResample()
resampler.set_reference_image(image)
resampler.set_floating_image(image)
resampler.add_transformation(tm)
resampler.set_padding_value(0)
resampler.set_interpolation_type_to_linear()
return resampler
def get_resampler(image, ref=None, trans=None):
"""returns a NiftyResample object for the specified transform and image"""
if ref is None:
ref = image
resampler = reg.NiftyResample()
resampler.set_reference_image(ref)
resampler.set_floating_image(image)
resampler.set_padding_value(0)
resampler.set_interpolation_type_to_linear()
if trans is not None:
resampler.add_transformation(trans)
return resampler
def test_for_adj(static_image, dvf_array, output_path):
static_image_path = "{0}/temp_static.nii".format(output_path)
dvf_array_path = "{0}/temp_dvf.nii".format(output_path)
for i in range(len(dvf_array)):
static_image.write(static_image_path)
dvf_array[i].write(dvf_array_path)
temp_static = reg.NiftiImageData(static_image_path)
temp_dvf = reg.NiftiImageData3DDeformation(dvf_array_path)
resampler = reg.NiftyResample()
resampler.set_reference_image(temp_static)
resampler.set_floating_image(temp_static)
resampler.add_transformation(temp_dvf)
resampler.set_interpolation_type_to_linear()
warp = warp_image_forward(resampler, temp_static)
warped_image = static_image.clone()
warped_image.fill(warp)
warped_image.write("{0}/warp_forward_{1}.nii".format(
output_path, str(i)))
difference = temp_static.as_array().astype(np.double) - warp
difference_image = temp_static.clone()
difference_image.fill(difference)
difference_image.write("{0}/warp_forward_difference_{1}.nii".format(
output_path, str(i)))
warp = warp_image_adjoint(resampler, temp_static)
warped_image = temp_static.clone()
warped_image.fill(warp)
warped_image.write("{0}/warp_adjoint_{1}.nii".format(
output_path, str(i)))
difference = temp_static.as_array().astype(np.double) - warp
difference_image = temp_static.clone()
difference_image.fill(difference)
difference_image.write("{0}/warp_adjoint_difference_{1}.nii".format(
output_path, str(i)))
return True
def gradient_function(optimise_array, static_image, dynamic_path, dvf_path,
weighted_normalise, dynamic_data_magnitude):
static_image.fill(
np.reshape(optimise_array,
static_image.as_array().astype(np.double).shape))
gradient_value = static_image.clone()
gradient_value.fill(0.0)
adjoint_image = static_image.clone()
for i in range(len(dynamic_path)):
dynamic_image = reg.NiftiImageData(dynamic_path[i])
dvf_image = reg.NiftiImageData3DDeformation(dvf_path[i])
resampler = reg.NiftyResample()
resampler.set_reference_image(static_image)
resampler.set_floating_image(dynamic_image)
resampler.add_transformation(dvf_image)
resampler.set_interpolation_type_to_cubic_spline()
adjoint_image.fill((
(np.nansum(dynamic_image.as_array().astype(np.double),
dtype=np.double) / dynamic_data_magnitude) *
warp_image_forward(resampler, static_image)) -
dynamic_image.as_array().astype(np.double))
gradient_value.fill((gradient_value.as_array().astype(np.double) +
(warp_image_adjoint(resampler, adjoint_image) *
weighted_normalise[i])))
# gradient_value.write("{0}/gradient.nii".format(output_path))
print(
"Max gradient value: {0}, Mean gradient value: {1}, Gradient norm: {2}"
.format(
str(np.amax(gradient_value.as_array().astype(np.double))),
str(
np.nanmean(
np.abs(gradient_value.as_array().astype(np.double),
dtype=np.double))),
str(np.linalg.norm(gradient_value.as_array().astype(np.double)))))
return np.ravel(gradient_value.as_array().astype(np.double)).astype(
np.double)
def test_for_adj(static_image, dvf_path, output_path):
for i in range(len(dvf_path)):
dvf_image = reg.NiftiImageData3DDeformation(dvf_path[i])
resampler = reg.NiftyResample()
resampler.set_reference_image(static_image)
resampler.set_floating_image(static_image)
resampler.add_transformation(dvf_image)
resampler.set_interpolation_type_to_cubic_spline()
warp = warp_image_forward(resampler, static_image)
warped_image = static_image.clone()
warped_image.fill(warp)
warped_image.write("{0}/warp_forward_{1}.nii".format(
output_path, str(i)))
difference = static_image.as_array().astype(np.double) - warp
difference_image = static_image.clone()
difference_image.fill(difference)
difference_image.write("{0}/warp_forward_difference_{1}.nii".format(
output_path, str(i)))
warp = warp_image_adjoint(resampler, static_image)
warped_image = static_image.clone()
warped_image.fill(warp)
warped_image.write("{0}/warp_adjoint_{1}.nii".format(
output_path, str(i)))
difference = static_image.as_array().astype(np.double) - warp
difference_image = static_image.clone()
difference_image.fill(difference)
difference_image.write("{0}/warp_adjoint_difference_{1}.nii".format(
output_path, str(i)))
return True
def get_resamplers(static_image, dynamic_array, dvf_array):
resamplers = []
for j in range(len(dynamic_array)):
dynamic_image = dynamic_array[j]
dvf_image = dvf_array[j]
resampler = reg.NiftyResample()
resampler.set_reference_image(static_image)
resampler.set_floating_image(dynamic_image)
resampler.add_transformation(dvf_image)
resampler.set_interpolation_type_to_cubic_spline()
resamplers.append(resampler)
return resamplers
def resample_attn_image(image):
"""Resample the attenuation image."""
if trans_type == 'tm':
transformation = reg.AffineTransformation(trans)
elif trans_type == 'disp':
transformation = reg.NiftiImageData3DDisplacement(trans)
elif trans_type == 'def':
transformation = reg.NiftiImageData3DDeformation(trans)
else:
raise ValueError("Unknown transformation type.")
resampler = reg.NiftyResample()
resampler.set_reference_image(image)
resampler.set_floating_image(image)
resampler.set_interpolation_type_to_linear()
resampler.set_padding_value(0.0)
resampler.add_transformation(transformation)
return resampler.forward(image)
def back_warp(static_path, dvf_path, output_path):
if not os.path.exists(output_path):
os.makedirs(output_path, mode=0o770)
for i in range(len(dvf_path)):
static_image = reg.NiftiImageData(static_path)
dvf_image = reg.NiftiImageData3DDeformation(dvf_path[i])
resampler = reg.NiftyResample()
resampler.set_reference_image(static_image)
resampler.set_floating_image(static_image)
resampler.add_transformation(dvf_image)
resampler.set_interpolation_type_to_cubic_spline()
warped_static_image = warp_image_forward(resampler, static_image)
static_image.fill(warped_static_image)
static_image.write("{0}/back_warped_{1}.nii".format(
output_path, str(i)))
return True
max_ring_diff=16,
view_mash_factor=1)
template_acq_data.write('template.hs')
#%% resample mu-Map into correct space and transform via invers tm
tprint('Start Resampling')
attn_image = Pet.ImageData(attn_file)
template_image = template_acq_data.create_uniform_image(1.0)
# define space matrices
tm_fwd = numpy.loadtxt(py_path + '/UKL_data/tm_epi/reg_NAC_EPI.txt')
tm_inv = numpy.loadtxt(py_path + '/UKL_data/tm_epi/reg_NAC_EPI_inv.txt')
# settings for attn resampler
resamplers_attn = Reg.NiftyResample()
resamplers_attn.set_reference_image(template_image)
resamplers_attn.set_floating_image(attn_image)
resamplers_attn.set_padding_value(0)
resamplers_attn.set_interpolation_type_to_linear()
i = 0
for num in num_tm:
print('Begin resampling mu-Maps: {}'.format(path_EPI + 'tm_epi_inv_' +
str(num) + '.txt'))
# read tm-matrix as numpy array
matrix = numpy.loadtxt(path_EPI + 'tm_epi_inv_' + str(num) + '.txt')
# tm space transformation: EPI -> NAC
# transform tm into PET space: T_nac = R⁻1 * T_epi * R
#%% resample the float images back to reference
# list of all NACs
list_NACs = [f for f in os.listdir(path_NAC) if f.endswith(".nii")]
# list of all ACs
list_ACs = [f for f in os.listdir(path_AC) if f.endswith(".nii")]
# define reference image and float-path
ref_file = path_AC + 'AC_0.nii'
ref = Eng_ref.ImageData(ref_file)
flo_path = path_AC
# settings for image resampler
resampler_im = Reg.NiftyResample()
resampler_im.set_reference_image(ref)
resampler_im.set_padding_value(0)
resampler_im.set_interpolation_type_to_linear()
tprint('Start Resampling')
# for loop, simultaneous matrices and images
for num, image in zip(range(len(list_ACs)), sorted_alphanumeric(list_ACs)):
print('TM: {}, Float-Image: {}'.format('tm_nac_' + str(num) + '.txt', image))
flo = Eng_flo.ImageData(path_AC + image)
# read tm-matrix as numpy array
matrix = numpy.loadtxt(path_tm + 'tm_nac_' + str(num) + '.txt')
#%% create listmode-to-sinograms converter object
lm2sino = Pet.ListmodeToSinograms()
# set input, output and template files
lm2sino.set_input(list_file)
lm2sino.set_output_prefix(sino_file)
lm2sino.set_template('template.hs')
#%% from template sinogram, ensure that mu-map has spacing/offset
# that matches the reconstructed image
attn_image = Pet.ImageData(attn_file)
template_image = template_acq_data.create_uniform_image(1.0)
resampler = Reg.NiftyResample()
resampler.set_reference_image(template_image)
resampler.set_floating_image(attn_image)
resampler.set_padding_value(0)
resampler.set_interpolation_type_to_linear()
attn_image = resampler.forward(attn_image)
attn_image.write(working_folder + '/stir_mu_map_in_recon_space')
#%% create folders for results
path_sino = working_folder + '/sino'
path_rando = working_folder + '/rando'
path_recon = working_folder + '/recon'
if not os.path.exists(path_sino):
os.makedirs(path_sino, mode=0o770)
print('Create Folder: {}'.format(path_sino))
def try_complex_resample(raw_mr_filename):
time.sleep(0.5)
sys.stderr.write('\n# --------------------------------------------------------------------------------- #\n')
sys.stderr.write('# Starting complex resampling test...\n')
sys.stderr.write('# --------------------------------------------------------------------------------- #\n')
time.sleep(0.5)
raw_mr = mr.AcquisitionData(raw_mr_filename)
recon_gadgets = ['NoiseAdjustGadget',
'AsymmetricEchoAdjustROGadget',
'RemoveROOversamplingGadget',
'AcquisitionAccumulateTriggerGadget(trigger_dimension=repetition)',
'BucketToBufferGadget(split_slices=true, verbose=false)',
'SimpleReconGadget',
'ImageArraySplitGadget']
recon = mr.Reconstructor(recon_gadgets)
recon.set_input(raw_mr)
recon.process()
ismrmrd_im = recon.get_output()
if ismrmrd_im.is_real():
raise AssertionError("Expected output of reconstruction to be complex")
# Complex component may be empty, so use imag = real / 2
image_data_arr = ismrmrd_im.as_array()
image_data_arr.imag = image_data_arr.real / 2
ismrmrd_im.fill(image_data_arr)
# Convert the complex image to two niftis
[real, imag] = reg.ImageData.construct_from_complex_image(ismrmrd_im)
real.write("results/real")
imag.write("results/imag")
# Create affine transformation
tm = reg.AffineTransformation()
tm_ = tm.as_array()
tm_[0][3] = 2.
tm = reg.AffineTransformation(tm_)
# Resample the complex data
res_complex = reg.NiftyResample()
res_complex.set_reference_image(ismrmrd_im)
res_complex.set_floating_image(ismrmrd_im)
res_complex.set_interpolation_type_to_linear()
res_complex.add_transformation(tm)
forward_cplx_sptr = res_complex.forward(ismrmrd_im)
adjoint_cplx_sptr = res_complex.adjoint(ismrmrd_im)
# Get the output
[forward_cplx_real, forward_cplx_imag] = \
reg.ImageData.construct_from_complex_image(forward_cplx_sptr)
[adjoint_cplx_real, adjoint_cplx_imag] = \
reg.ImageData.construct_from_complex_image(adjoint_cplx_sptr)
forward_cplx_real.write("results/forward_cplx_real")
forward_cplx_imag.write("results/forward_cplx_imag")
adjoint_cplx_real.write("results/adjoint_cplx_real")
adjoint_cplx_imag.write("results/adjoint_cplx_imag")
# Now resample each of the components individually
res_real = reg.NiftyResample()
res_real.set_reference_image(real)
res_real.set_floating_image(real)
res_real.set_interpolation_type_to_linear()
res_real.add_transformation(tm)
forward_real = res_real.forward(real)
adjoint_real = res_real.adjoint(real)
res_imag = reg.NiftyResample()
res_imag.set_reference_image(imag)
res_imag.set_floating_image(imag)
res_imag.set_interpolation_type_to_linear()
res_imag.add_transformation(tm)
forward_imag = res_imag.forward(imag)
adjoint_imag = res_imag.adjoint(imag)
forward_real.write("results/forward_real")
forward_imag.write("results/forward_imag")
adjoint_real.write("results/adjoint_real")
adjoint_imag.write("results/adjoint_imag")
# Compare that the real and imaginary parts match regardless
# of whether they were resampled separately or together.
if forward_real != forward_cplx_real or forward_imag != forward_cplx_imag:
raise AssertionError("NiftyResample::forward failed for complex data")
if adjoint_real != adjoint_cplx_real or adjoint_imag != adjoint_cplx_imag:
raise AssertionError("NiftyResample::adjoint failed for complex data")
time.sleep(0.5)
sys.stderr.write('\n# --------------------------------------------------------------------------------- #\n')
sys.stderr.write('# Finished complex resampling test.\n')
sys.stderr.write('# --------------------------------------------------------------------------------- #\n')
time.sleep(0.5)