def get_deformed_image_sitk(self, fixed_sitk, moving_sitk,
interpolation_order):
# REMARK:
# Not possible to write registration transform that way since
# some header information gets lost! Therefore, read again the one
# which was the output of NiftyReg (and hope that file is not been
# deleted)
# Create and delete all possibly existing files in the directory
# ph.create_directory(self._dir_tmp, delete_files=True)
# sitkh.write_nifti_image_sitk(self.get_registration_transform_sitk(),
# self._registration_control_point_grid_str)
sitkh.write_nifti_image_sitk(fixed_sitk, self._fixed_str)
sitkh.write_nifti_image_sitk(moving_sitk, self._moving_str)
nreg = nipype.interfaces.niftyreg.RegResample()
nreg.inputs.ref_file = self._fixed_str
nreg.inputs.flo_file = self._moving_str
nreg.inputs.trans_file = self._registration_control_point_grid_str
nreg.inputs.out_file = self._warped_moving_str
nreg.inputs.omp_core_val = self._omp
nreg.inputs.args = "-inter " + str(interpolation_order)
# Execute registration
if self._verbose:
ph.print_execution(nreg.cmdline)
nreg.run()
return sitkh.read_nifti_image_sitk(self._warped_moving_str,
moving_sitk.GetPixelIDValue())
def split_labels(path_to_labels, dimension, path_to_output):
if dimension == 4:
labels_nib = nib.load(path_to_labels)
nda = labels_nib.get_data().astype(np.uint8)
else:
labels_sitk = sitk.ReadImage(path_to_labels)
nda = sitk.GetArrayFromImage(labels_sitk).astype(np.uint8)
# split labels into separate components
n_labels = nda.max()
shape = nda.shape + (n_labels, )
nda_4d = np.zeros((shape), dtype=np.uint8)
for label in range(n_labels):
indices = np.where(nda == label + 1)
indices += (label * np.ones(len(indices[0]), dtype=np.uint8), )
nda_4d[indices] = 1
if dimension == 4:
labels_4d_nib = nib.Nifti1Image(nda_4d,
affine=labels_nib.affine,
header=labels_nib.header)
labels_4d_nib.set_data_dtype(np.uint8)
ph.create_directory(os.path.dirname(path_to_output))
nib.save(labels_4d_nib, path_to_output)
else:
labels_5d_sitk = sitk.GetImageFromArray(nda_4d)
labels_5d_sitk.SetOrigin(labels_sitk.GetOrigin())
labels_5d_sitk.SetSpacing(labels_sitk.GetSpacing())
labels_5d_sitk.SetDirection(labels_sitk.GetDirection())
sitkh.write_nifti_image_sitk(labels_5d_sitk, path_to_output)
def test_read_write_nifti_image_sitk(self):
image_sitk = sitk.ReadImage(os.path.join(
self.dir_test_data, self.filename + ".nii.gz"))
foo = os.path.join(DIR_TMP, "foo.nii.gz")
sitkh.write_nifti_image_sitk(image_sitk, foo)
foo_sitk = sitkh.read_nifti_image_sitk(foo)
nda = sitk.GetArrayFromImage(image_sitk - foo_sitk)
error = np.linalg.norm(nda)
self.assertAlmostEqual(error, 0, places=self.accuracy)
def write_mask(mask_sitk, path_to_file, compress=True, verbose=True):
info = "Write mask to %s" % path_to_file
if compress:
mask_sitk = sitk.Cast(mask_sitk, sitk.sitkUInt8)
info += " (uint8)"
if verbose:
ph.print_info("%s ... " % info, newline=False)
sitkh.write_nifti_image_sitk(mask_sitk, path_to_file)
if verbose:
print("done")
def write_image(image_sitk, path_to_file, compress=True, verbose=True):
info = "Write image to %s" % path_to_file
if compress:
image_sitk = sitk.Cast(image_sitk, sitk.sitkFloat32)
info += " (float32)"
if verbose:
ph.print_info("%s ... " % info, newline=False)
sitkh.write_nifti_image_sitk(image_sitk, path_to_file)
if verbose:
print("done")
def save_landmarks_to_image(self, path_to_file):
if self._landmarks_image_space is None:
raise RuntimeError("Execute 'run' first to estimate landmarks")
ph.print_info("Save landmarks to image '%s' ... " % path_to_file,
newline=False)
# read original image
image_label_sitk = sitk.ReadImage(self._path_to_image_label)
image_label_nda = sitk.GetArrayFromImage(image_label_sitk) * 0
# convert to integer voxels
image_label_nda = self._get_array_with_landmarks(
image_label_sitk.GetSize()[::-1], self._landmarks_voxel_space)
# landmarks_voxel_space = self._landmarks_voxel_space.astype('int')
# for i in range(landmarks_voxel_space.shape[0]):
# image_label_nda[landmarks_voxel_space[i, 2],
# landmarks_voxel_space[i, 1],
# landmarks_voxel_space[i, 0]] = 1
image_landmarks_sitk = sitk.GetImageFromArray(image_label_nda)
image_landmarks_sitk.CopyInformation(image_label_sitk)
sitkh.write_nifti_image_sitk(image_landmarks_sitk, path_to_file)
print("done")
# show landmark estimate
if self._verbose:
# find bounding box for "zoomed in" visualization
ran_x, ran_y, ran_z = self._get_bounding_box(image_label_nda)
# get zoomed-in image mask
image_label_nda_show = image_label_nda[ran_x[0]:ran_x[1],
ran_y[0]:ran_y[1],
ran_z[0]:ran_z[1]]
landmarks_nda = self._get_array_with_landmarks(
image_label_nda.shape, self._landmarks_voxel_space)
show_mask_sitk = sitk.GetImageFromArray(image_label_nda_show)
# get zoomed-in landmark estimate (dilated for visualization)
landmarks_nda_show = landmarks_nda[ran_x[0]:ran_x[1],
ran_y[0]:ran_y[1],
ran_z[0]:ran_z[1]]
landmarks_nda_show += scipy.ndimage.morphology.binary_dilation(
landmarks_nda_show, iterations=10)
show_landmarks_sitk = sitk.GetImageFromArray(landmarks_nda_show)
sitkh.show_sitk_image(show_mask_sitk,
segmentation=show_landmarks_sitk,
label=os.path.basename(
ph.strip_filename_extension(
self._path_to_image_label)[0]))
def write_image(image_sitk, path_to_file, verbose=0):
extension = ph.strip_filename_extension(path_to_file)[1]
if extension not in ALLOWED_IMAGES:
raise IOError("Image file extension must be of type %s " %
", or ".join(ALLOWED_IMAGES))
if isinstance(image_sitk, sitk.Image):
sitkh.write_nifti_image_sitk(image_sitk=image_sitk,
path_to_file=path_to_file,
verbose=verbose)
else:
sitkh.write_nifti_image_itk(image_itk=image_sitk,
path_to_file=path_to_file,
verbose=verbose)
def write_transform(transform_sitk, path_to_file, verbose=0):
extension = ph.strip_filename_extension(path_to_file)[1]
if extension not in ALLOWED_TRANSFORMS and \
extension not in ALLOWED_TRANSFORMS_DISPLACEMENTS:
raise IOError("Transform file extension must be of type "
"%s (transformation) or %s (displacements)" %
(", ".join(ALLOWED_TRANSFORMS),
", ".join(ALLOWED_TRANSFORMS_DISPLACEMENTS)))
if extension in ALLOWED_TRANSFORMS:
if isinstance(transform_sitk, sitk.Image):
raise IOError("Cannot convert displacement field (%s) to "
"transform (%s)" % (
", ".join(ALLOWED_TRANSFORMS_DISPLACEMENTS),
", ".join(ALLOWED_TRANSFORMS),
))
if isinstance(transform_sitk, sitk.Transform):
ph.create_directory(os.path.dirname(path_to_file))
sitk.WriteTransform(transform_sitk, path_to_file)
if verbose:
ph.print_info("Transform written to '%s'" % path_to_file)
elif isinstance(transform_sitk, np.ndarray):
ph.write_array_to_file(path_to_file,
transform_sitk,
delimiter=" ",
access_mode="w",
verbose=verbose)
else:
raise IOError("Transform must be of type "
"sitk.Transform or np.ndarray")
else:
if isinstance(transform_sitk, sitk.Transform):
raise IOError("Cannot convert transform (%s) to "
"displacement field (%s)" % (
", ".join(ALLOWED_TRANSFORMS),
", ".join(ALLOWED_TRANSFORMS_DISPLACEMENTS),
))
elif isinstance(transform_sitk, sitk.Image):
sitkh.write_nifti_image_sitk(image_sitk=transform_sitk,
path_to_file=path_to_file,
verbose=verbose)
elif isinstance(transform_sitk, nib.nifti1.Nifti1Image):
ph.create_directory(os.path.dirname(path_to_file))
nib.save(transform_sitk, path_to_file)
else:
raise IOError("Transform must be of type "
"sitk.Image or nibabel.nifti1.Nifti1Image")
def _run_bet_for_brain_stripping(self, debug=0):
filename_out = "image"
self._dir_tmp = ph.create_directory(self._dir_tmp, delete_files=True)
path_to_image = os.path.join(self._dir_tmp, filename_out + ".nii.gz")
path_to_res = os.path.join(self._dir_tmp, filename_out + "_bet.nii.gz")
path_to_res_mask = os.path.join(self._dir_tmp,
filename_out + "_bet_mask.nii.gz")
path_to_res_skull = os.path.join(self._dir_tmp,
filename_out + "_bet_skull.nii.gz")
sitkh.write_nifti_image_sitk(self._sitk, path_to_image)
bet = nipype.interfaces.fsl.BET()
bet.inputs.in_file = path_to_image
bet.inputs.out_file = path_to_res
options = ""
if not self._compute_brain_image:
options += "-n "
if self._compute_brain_mask:
options += "-m "
if self._compute_skull_image:
options += "-s "
options += self._bet_options
bet.inputs.args = options
if debug:
print(bet.cmdline)
bet.run()
if self._compute_brain_image:
self._sitk_brain_image = sitkh.read_nifti_image_sitk(
path_to_res, sitk.sitkFloat64)
if self._compute_brain_mask:
self._sitk_brain_mask = sitkh.read_nifti_image_sitk(
path_to_res_mask, sitk.sitkUInt8)
if self._compute_skull_image:
self._sitk_skull_image = sitkh.read_nifti_image_sitk(
path_to_res_skull)
def test_affine_transform_reg_aladin(self):
# Read data
filename_fixed = "stack1_rotated_angle_z_is_pi_over_10.nii.gz"
filename_moving = "FetalBrain_reconstruction_3stacks_myAlg.nii.gz"
diff_ref = os.path.join(
DIR_TEST, "stack1_rotated_angle_z_is_pi_over_10_nreg_diff.nii.gz")
moving = st.Stack.from_filename(
os.path.join(self.dir_test_data, filename_moving), )
fixed = st.Stack.from_filename(
os.path.join(self.dir_test_data, filename_fixed))
# Set up NiftyReg
nifty_reg = nreg.RegAladin()
nifty_reg.set_fixed(fixed)
nifty_reg.set_moving(moving)
nifty_reg.set_registration_type("Rigid")
nifty_reg.use_verbose(False)
# Register via NiftyReg
nifty_reg.run()
# Get associated results
affine_transform_sitk = nifty_reg.get_registration_transform_sitk()
moving_warped = nifty_reg.get_warped_moving()
# Get SimpleITK result with "similar" interpolator (NiftyReg does not
# state what interpolator is used but it seems to be BSpline)
moving_warped_sitk = sitk.Resample(moving.sitk, fixed.sitk,
affine_transform_sitk,
sitk.sitkBSpline, 0.0,
moving.sitk.GetPixelIDValue())
diff_res_sitk = moving_warped.sitk - moving_warped_sitk
sitkh.write_nifti_image_sitk(diff_res_sitk, diff_ref)
diff_ref_sitk = sitk.ReadImage(diff_ref)
res_diff_nda = sitk.GetArrayFromImage(diff_res_sitk - diff_ref_sitk)
self.assertAlmostEqual(np.linalg.norm(res_diff_nda),
0,
places=self.accuracy)
def write_mask(
mask_sitk,
path_to_file,
compress=True,
verbose=True,
description=None,
):
info = "Write mask to %s" % path_to_file
if compress:
mask_sitk = sitk.Cast(mask_sitk, sitk.sitkUInt8)
info += " (uint8)"
if verbose:
ph.print_info("%s ... " % info, newline=False)
header_update = DataWriter._get_header_update(description=description)
sitkh.write_nifti_image_sitk(mask_sitk,
path_to_file,
header_update=header_update)
if verbose:
print("done")
def run(self):
ph.create_directory(dir_tmp, delete_files=True)
# Write images
sitkh.write_nifti_image_sitk(
self._stack1.sitk,
self._dir_tmp + self._stack1.get_filename() + ".nii.gz")
sitkh.write_nifti_image_sitk(
self._stack2.sitk,
self._dir_tmp + self._stack2.get_filename() + ".nii.gz")
cmd = "siena "
cmd += self._dir_tmp + self._stack1.get_filename() + ".nii.gz "
cmd += self._dir_tmp + self._stack2.get_filename() + ".nii.gz "
cmd += "-o " + self._dir_output + " "
cmd += self._options
time_start = ph.start_timing()
ph.execute_command(cmd)
self._elapsed_time = ph.stop_timing(time_start)
# Extract measures from report
self._extract_percentage_brain_volume_change()
def write(self,
directory,
filename=None,
write_transform=False,
suffix_mask="_mask",
prefix_slice="_slice"):
# Create directory if not existing
ph.create_directory(directory)
# Construct filename
if filename is None:
filename_out = self._filename + \
prefix_slice + str(self._slice_number)
else:
filename_out = filename + prefix_slice + str(self._slice_number)
full_file_name = os.path.join(directory, filename_out)
# Write slice and affine transform
sitkh.write_nifti_image_sitk(self.sitk, full_file_name + ".nii.gz")
if write_transform:
sitk.WriteTransform(
# self.get_affine_transform(),
self.get_motion_correction_transform(),
full_file_name + ".tfm")
# Write mask to specified location if given
if self.sitk_mask is not None:
nda = sitk.GetArrayFromImage(self.sitk_mask)
# Write mask if it does not consist of only ones
if not np.all(nda):
sitkh.write_nifti_image_sitk(
self.sitk_mask,
full_file_name + "%s.nii.gz" % (suffix_mask))
def _run_registrations(self, transformations):
path_to_fixed = os.path.join(DIR_TMP, "fixed.nii.gz")
path_to_moving = os.path.join(DIR_TMP, "moving.nii.gz")
path_to_fixed_mask = os.path.join(DIR_TMP, "fixed_mask.nii.gz")
path_to_moving_mask = os.path.join(DIR_TMP, "moving_mask.nii.gz")
path_to_tmp_output = os.path.join(DIR_TMP, "foo.nii.gz")
path_to_transform_regaladin = os.path.join(DIR_TMP,
"transform_regaladin.txt")
path_to_transform_sitk = os.path.join(DIR_TMP, "transform_sitk.txt")
sitkh.write_nifti_image_sitk(self._fixed.sitk, path_to_fixed)
sitkh.write_nifti_image_sitk(self._moving.sitk, path_to_moving)
sitkh.write_nifti_image_sitk(self._fixed.sitk_mask, path_to_fixed_mask)
# sitkh.write_nifti_image_sitk(
# self._moving.sitk_mask, path_to_moving_mask)
for i in range(len(transformations)):
sitk.WriteTransform(transformations[i], path_to_transform_sitk)
# Convert SimpleITK to RegAladin transform
cmd = "simplereg_transform -sitk2nreg %s %s" % (
path_to_transform_sitk, path_to_transform_regaladin)
ph.execute_command(cmd, verbose=False)
# Run NiftyReg
cmd_args = ["reg_aladin"]
cmd_args.append("-ref %s" % path_to_fixed)
cmd_args.append("-flo %s" % path_to_moving)
cmd_args.append("-res %s" % path_to_tmp_output)
cmd_args.append("-inaff %s" % path_to_transform_regaladin)
cmd_args.append("-aff %s" % path_to_transform_regaladin)
cmd_args.append("-rigOnly")
cmd_args.append("-ln 2")
cmd_args.append("-voff")
cmd_args.append("-rmask %s" % path_to_fixed_mask)
# To avoid error "0 correspondences between blocks were found" that can
# occur for some cases. Also, disable moving mask, as this would be ignored
# anyway
cmd_args.append("-noSym")
ph.print_info(
"Run Registration (RegAladin) based on PCA-init %d ... " %
(i + 1))
ph.execute_command(" ".join(cmd_args), verbose=False)
# Convert RegAladin to SimpleITK transform
cmd = "simplereg_transform -nreg2sitk %s %s" % (
path_to_transform_regaladin, path_to_transform_sitk)
ph.execute_command(cmd, verbose=False)
transformations[i] = sitkh.read_transform_sitk(
path_to_transform_sitk)
return transformations
def _run(self):
# Create and delete all possibly existing files in the directory
ph.create_directory(self._dir_tmp, delete_files=True)
sitkh.write_nifti_image_sitk(self._fixed_sitk, self._fixed_str)
sitkh.write_nifti_image_sitk(self._moving_sitk, self._moving_str)
if self._fixed_sitk_mask is not None:
sitkh.write_nifti_image_sitk(
self._fixed_sitk_mask, self._fixed_mask_str)
if self._moving_sitk_mask is not None:
sitkh.write_nifti_image_sitk(
self._moving_sitk_mask, self._moving_mask_str)
if self._transform_init is not None:
ph.write_array_to_file(
self._transform_init_str,
self._transform_init,
access_mode="a",
verbose=0)
def _run(self):
# Create and delete all possibly existing files in the directory
ph.create_directory(self._dir_tmp, delete_files=True)
sitkh.write_nifti_image_sitk(self._fixed_sitk, self._fixed_str)
sitkh.write_nifti_image_sitk(self._moving_sitk, self._moving_str)
flt = nipype.interfaces.fsl.FLIRT()
flt.inputs.in_file = self._moving_str
flt.inputs.reference = self._fixed_str
flt.inputs.out_file = self._warped_moving_str
flt.inputs.out_matrix_file = self._registration_transform_str
flt.inputs.output_type = "NIFTI_GZ"
if self._fixed_sitk_mask is not None:
sitkh.write_nifti_image_sitk(self._fixed_sitk_mask,
self._fixed_mask_str)
flt.inputs.ref_weight = self._fixed_mask_str
if self._moving_sitk_mask is not None:
sitkh.write_nifti_image_sitk(self._moving_sitk_mask,
self._moving_mask_str)
flt.inputs.in_weight = self._moving_mask_str
flt.inputs.args = self._options
# Execute registration
if self._verbose:
ph.print_execution(flt.cmdline)
flt.run()
# Read warped image
self._warped_moving_sitk = sitkh.read_nifti_image_sitk(
self._warped_moving_str)
# Convert to sitk affine transform
self._registration_transform_sitk = self._convert_to_sitk_transform()
def _run_registration_inplane_similarity_3D(self, id, endl=" \\\n"):
if self._fixed is None or self._moving is None:
raise ValueError("Error: Fixed and moving image not specified")
if self._use_verbose:
verbose = "1"
else:
verbose = "0"
# Clean output directory first
os.system("rm -rf " + self._dir_tmp + "*")
moving_str = "RegistrationITK_moving_" + id + self._moving.get_filename(
)
fixed_str = "RegistrationITK_fixed_" + id + self._fixed.get_filename()
moving_mask_str = "RegistrationITK_moving_mask_" + id + self._moving.get_filename(
)
fixed_mask_str = "RegistrationITK_fixed_mask_" + id + self._fixed.get_filename(
)
registration_transform_str = "RegistrationITK_transform_" + id + \
self._fixed.get_filename() + "_" + self._moving.get_filename()
# Write images to HDD
# if not os.path.isfile(self._dir_tmp + moving_str + ".nii.gz"):
sitkh.write_nifti_image_sitk(self._moving.sitk,
self._dir_tmp + moving_str + ".nii.gz")
# if not os.path.isfile(self._dir_tmp + fixed_str + ".nii.gz"):
sitkh.write_nifti_image_sitk(self._fixed.sitk,
self._dir_tmp + fixed_str + ".nii.gz")
# if not os.path.isfile(self._dir_tmp + moving_mask_str + ".nii.gz")
# and self._use_moving_mask:
sitkh.write_nifti_image_sitk(
self._moving.sitk_mask,
self._dir_tmp + moving_mask_str + ".nii.gz")
# if not os.path.isfile(self._dir_tmp + fixed_mask_str + ".nii.gz") and
# self._use_fixed_mask:
sitkh.write_nifti_image_sitk(
self._fixed.sitk_mask, self._dir_tmp + fixed_mask_str + ".nii.gz")
# Prepare command for execution
cmd = DIR_CPP_BUILD + "/bin/itkInplaneSimilarity3DReg" + endl
cmd += "--f " + self._dir_tmp + fixed_str + ".nii.gz" + endl
cmd += "--m " + self._dir_tmp + moving_str + ".nii.gz" + endl
if self._use_fixed_mask:
cmd += "--fmask " + self._dir_tmp + fixed_mask_str + ".nii.gz" + endl
if self._use_moving_mask:
cmd += "--mmask " + self._dir_tmp + moving_mask_str + ".nii.gz" + endl
cmd += "--tout " + self._dir_tmp + registration_transform_str + ".txt" + endl
cmd += "--useAffine " + \
str(int(self._registration_type is "Affine")) + endl
cmd += "--useMultires " + \
str(int(self._use_multiresolution_framework)) + endl
cmd += "--metric " + self._metric + endl
cmd += "--scalesEst " + self._scales_estimator + endl
cmd += "--interpolator " + self._interpolator + endl
cmd += "--ANTSrad " + str(self._ANTSradius) + endl
# cmd += "--translationScale " + str(self._translation_scale) + endl
cmd += "--verbose " + verbose + endl
# Compute oriented Gaussian PSF if desired
if self._interpolator in ["OrientedGaussian"]:
if self._cov is None:
# Get oriented Gaussian covariance matrix
cov_HR_coord = psf.PSF().\
get_covariance_matrix_in_reconstruction_space(
self._moving, self._fixed).flatten()
else:
cov_HR_coord = self._cov.flatten()
cmd += "--cov " + "'" + ' '.join(cov_HR_coord.astype("|S12")) + "'"
# if self._use_verbose:
ph.execute_command(cmd)
# Read transformation file
params_all = np.loadtxt(self._dir_tmp + registration_transform_str +
".txt")
## (center_x, center_y, center_z, direction_fixed_image_flattened_0, ..., direction_fixed_image_flattened_8)
self._parameters_fixed = params_all[0:-7]
## (versor_0, versor_1, versor_2, translation_x, translation_y, translation_z, scale)
self._parameters = params_all[-7:]
# Get affine registration transform T(x) = R D Lambda D^{-1} (x-c) + t
# + c
self._registration_transform_sitk = self._get_affine_transform_from_similarity_registration(
)
def _run_registration_rigid_affine(self, id, endl=" \\\n"):
if self._fixed is None or self._moving is None:
raise ValueError("Error: Fixed and moving image not specified")
if self._use_verbose:
verbose = "1"
else:
verbose = "0"
moving_str = "RegistrationITK_moving_" + id + self._moving.get_filename(
)
fixed_str = "RegistrationITK_fixed_" + id + self._fixed.get_filename()
moving_mask_str = "RegistrationITK_moving_mask_" + id + self._moving.get_filename(
)
fixed_mask_str = "RegistrationITK_fixed_mask_" + id + self._fixed.get_filename(
)
registration_transform_str = "RegistrationITK_transform_" + id + \
self._fixed.get_filename() + "_" + self._moving.get_filename()
# Write images to HDD
# if not os.path.isfile(self._dir_tmp + moving_str + ".nii.gz"):
sitkh.write_nifti_image_sitk(self._moving.sitk,
self._dir_tmp + moving_str + ".nii.gz")
# if not os.path.isfile(self._dir_tmp + fixed_str + ".nii.gz"):
sitkh.write_nifti_image_sitk(self._fixed.sitk,
self._dir_tmp + fixed_str + ".nii.gz")
# if not os.path.isfile(self._dir_tmp + moving_mask_str + ".nii.gz")
# and self._use_moving_mask:
sitkh.write_nifti_image_sitk(
self._moving.sitk_mask,
self._dir_tmp + moving_mask_str + ".nii.gz")
# if not os.path.isfile(self._dir_tmp + fixed_mask_str + ".nii.gz") and
# self._use_fixed_mask:
sitkh.write_nifti_image_sitk(
self._fixed.sitk_mask, self._dir_tmp + fixed_mask_str + ".nii.gz")
# Prepare command for execution
# cmd = "/Users/mebner/UCL/UCL/Software/Volumetric\ Reconstruction/build/cpp/bin/itkReg "
cmd = DIR_CPP_BUILD + "/bin/itkReg" + endl
cmd += "--f " + self._dir_tmp + fixed_str + ".nii.gz" + endl
cmd += "--m " + self._dir_tmp + moving_str + ".nii.gz" + endl
if self._use_fixed_mask:
cmd += "--fmask " + self._dir_tmp + fixed_mask_str + ".nii.gz" + endl
if self._use_moving_mask:
cmd += "--mmask " + self._dir_tmp + moving_mask_str + ".nii.gz" + endl
cmd += "--tout " + self._dir_tmp + registration_transform_str + ".txt" + endl
cmd += "--useAffine " + \
str(int(self._registration_type is "Affine")) + endl
cmd += "--useMultires " + \
str(int(self._use_multiresolution_framework)) + endl
cmd += "--metric " + self._metric + endl
cmd += "--scalesEst " + self._scales_estimator + endl
cmd += "--interpolator " + self._interpolator + endl
cmd += "--ANTSrad " + str(self._ANTSradius) + endl
cmd += "--verbose " + verbose + endl
# Compute oriented Gaussian PSF if desired
if self._interpolator in ["OrientedGaussian"]:
if self._cov is None:
# Get oriented Gaussian covariance matrix
cov_HR_coord = psf.PSF().\
get_covariance_matrix_in_reconstruction_space(
self._moving, self._fixed).flatten()
else:
cov_HR_coord = self._cov.flatten()
cmd += "--cov " + "'" + ' '.join(cov_HR_coord.astype("|S12")) + "'"
ph.execute_command(cmd, verbose=0)
# Read transformation file
params_all = np.loadtxt(self._dir_tmp + registration_transform_str +
".txt")
if self._registration_type in ["Rigid"]:
self._parameters_fixed = params_all[0:4]
self._parameters = params_all[4:]
self._registration_transform_sitk = sitk.Euler3DTransform()
else:
self._parameters_fixed = params_all[0:3]
self._parameters = params_all[3:]
self._registration_transform_sitk = sitk.AffineTransform(3)
self._registration_transform_sitk.SetParameters(self._parameters)
self._registration_transform_sitk.SetFixedParameters(
self._parameters_fixed)
def write(self, directory, filename=None, write_mask=False, write_slices=False, write_transforms=False, suffix_mask="_mask"):
# Create directory if not existing
ph.create_directory(directory)
# Construct filename
if filename is None:
filename = self._filename
full_file_name = os.path.join(directory, filename)
# Write file to specified location
ph.print_info("Write image stack to %s.nii.gz ... " %
(full_file_name), newline=False)
sitkh.write_nifti_image_sitk(self.sitk, full_file_name + ".nii.gz")
print("done")
# Write mask to specified location if given
if self.sitk_mask is not None:
# nda = sitk.GetArrayFromImage(self.sitk_mask)
# Write mask if it does not consist of only ones
if not self._is_unity_mask and write_mask:
ph.print_info("Write image stack mask to %s%s.nii.gz ... " % (
full_file_name, suffix_mask), newline=False)
sitkh.write_nifti_image_sitk(
self.sitk_mask, full_file_name + "%s.nii.gz" % (
suffix_mask))
print("done")
# print("Stack was successfully written to %s.nii.gz"
# %(full_file_name))
# Write each separate Slice of stack (if they exist)
if write_slices:
try:
# Check whether variable exists
# if 'self._slices' not in locals() or all(i is None for i in
# self._slices):
if not hasattr(self, '_slices'):
raise ValueError(
"Error occurred in attempt to write %s.nii.gz: "
"No separate slices of object Slice are found" %
full_file_name)
# Write slices
else:
if write_transforms:
ph.print_info(
"Write image slices + transforms to %s ... " %
directory, newline=False)
else:
ph.print_info(
"Write image slices to %s ... " %
directory, newline=False)
for slice in self.get_slices():
slice.write(
directory=directory,
filename=filename,
write_transform=write_transforms,
suffix_mask=suffix_mask)
print("done")
except ValueError as err:
print(err.message)
