def reveal_anonymized_files(self, directory):
ph.create_directory(directory)
filenames_revealed = []
for i in range(0, len(self._filenames)):
basename_anonymized = os.path.basename(self._filenames[i])
filename_anonymized = ph.strip_filename_extension(
basename_anonymized)[0]
try:
basename_revealed = self._dictionary[basename_anonymized]
except KeyError:
raise IOError(
"Dictionary does not match given (anonymized) filenames")
filename_revealed = "%s_%s" % (filename_anonymized,
basename_revealed)
# filename_anonymized = self._identifiers[i] + filename_extension
# filename_revealed = self._identifiers[i] + "_" + \
# self._dictionary[self._identifiers[i]] + filename_extension
# filename_revealed = re.sub("_masked_srr", "", filename_revealed)
# path_to_file_anon = os.path.join(directory, filename_anonymized)
path_to_file_reve = os.path.join(directory, filename_revealed)
# if not os.path.isfile(path_to_file_anon):
# print("%s: Nothing to reveal" % (filename_anonymized))
cmd = "cp -p "
cmd += self._filenames[i] + " "
cmd += path_to_file_reve + " "
# print(cmd)
ph.execute_command(cmd)
filenames_revealed.append(filename_revealed)
return filenames_revealed
def _resize_image(path_to_file, resize):
factor = resize * 100
cmd_args = []
cmd_args.append("%s" % path_to_file)
cmd_args.append("-resize %dx%d%%\\!" % (factor, factor))
cmd = "convert %s %s" % ((" ").join(cmd_args), path_to_file)
ph.execute_command(cmd, verbose=False)
def create_video(self, path_to_video, dir_input_slices, fps=1):
dir_output_video = os.path.dirname(path_to_video)
filename = os.path.basename(path_to_video).split(".")[0]
path_to_slices = "%s*.png" % os.path.join(dir_input_slices, filename)
path_to_video = os.path.join(dir_output_video, "%s.mp4" % filename)
path_to_video_tmp = os.path.join(
dir_output_video, "%s_tmp.mp4" % filename)
# Check that folder containing the slices exist
if not ph.directory_exists(dir_input_slices):
raise IOError("Folder '%s' meant to contain exported slices does "
"not exist" % dir_input_slices)
# Check that the folder contains exported slices as png files
# if not ph.file_exists(os.path.join(
# dir_input_slices, self._get_filename_slice(filename, 1))):
# raise IOError(
# "Slices '%s' need to be generated first using "
# "'export_slices'" % (path_to_slices))
# Create output folder for video
ph.create_directory(dir_output_video)
# ---------------Create temp video from exported slices----------------
cmd_args = []
cmd_args.append("-monitor")
cmd_args.append("-delay %d" % (100. / fps))
cmd_exe = "convert"
cmd = "%s %s %s %s" % (
cmd_exe, (" ").join(cmd_args), path_to_slices, path_to_video_tmp)
flag = ph.execute_command(cmd)
if flag != 0:
raise RuntimeError("Unable to create video from slices")
# ----------------------Use more common codec (?)----------------------
cmd_args = []
# overwrite possibly existing image
cmd_args.append("-y")
# Define input video to be converted
cmd_args.append("-i %s" % path_to_video_tmp)
# Use H.264 codec for video compression of MP4 file
cmd_args.append("-vcodec libx264")
# Define used pixel format
cmd_args.append("-pix_fmt yuv420p")
# Avoid error message associated to odd rows
# (https://stackoverflow.com/questions/20847674/ffmpeg-libx264-height-not-divisible-by-2)
cmd_args.append("-vf 'scale=trunc(iw/2)*2:trunc(ih/2)*2'")
cmd = "ffmpeg %s %s" % ((" ").join(cmd_args), path_to_video)
ph.execute_command(cmd)
# Delete temp video
os.remove(path_to_video_tmp)
def _export_pdf_from_side_by_side_images(directory, path_to_file, extension):
# Read all sidy-by-side (png) images in directory
pattern = "[a-zA-Z0-9_]+[.]%s" % extension
p = re.compile(pattern)
files = [
os.path.join(directory, f) for f in os.listdir(directory) if p.match(f)
]
# Convert consecutive sequence of images into single pdf
files = natsort.natsorted(files, key=lambda y: y.lower())
cmd = "convert %s %s" % ((" ").join(files), path_to_file)
ph.execute_command(cmd, verbose=False)
def test_reconstruct_volume_from_slices(self):
filename = "SRR_stacks3_TK1_lsmr_alpha0p02_itermax5.nii.gz"
output = os.path.join(self.dir_output, filename)
dir_reference = os.path.join(self.dir_data,
"reconstruct_volume_from_slices")
dir_input_mc = os.path.join(self.dir_data,
"reconstruct_volume_from_slices",
"motion_correction")
path_to_reference = os.path.join(dir_reference, filename)
iter_max = 5
alpha = 0.02
intensity_correction = 1
cmd_args = []
cmd_args.append("--filenames %s" % " ".join(self.filenames))
cmd_args.append("--dir-input-mc %s" % dir_input_mc)
cmd_args.append("--output %s" % output)
cmd_args.append("--iter-max %d" % iter_max)
cmd_args.append("--intensity-correction %d" % intensity_correction)
cmd_args.append("--alpha %f" % alpha)
cmd_args.append("--reconstruction-space %s" % path_to_reference)
cmd = "niftymic_reconstruct_volume_from_slices %s" % (
" ").join(cmd_args)
self.assertEqual(ph.execute_command(cmd), 0)
# Check whether identical reconstruction has been created
reconstruction_sitk = sitkh.read_nifti_image_sitk(output)
reference_sitk = sitkh.read_nifti_image_sitk(path_to_reference)
difference_sitk = reconstruction_sitk - reference_sitk
error = np.linalg.norm(sitk.GetArrayFromImage(difference_sitk))
self.assertAlmostEqual(error, 0, places=self.precision)
def test_reconstruct_volume_from_slices(self):
filename = "bold_s2v.nii.gz"
output = os.path.join(self.dir_output, filename)
dir_reference = os.path.join(
self.dir_data, "reconstruct_volume_from_slices")
dir_input_mc = os.path.join(
self.dir_data, "reconstruct_volume_from_slices", "motion_correction")
path_to_reference = os.path.join(dir_reference, filename)
iter_max = 3
alpha = 0.05
cmd_args = []
exe = os.path.abspath(rsfmri_reconstruct_volume_from_slices.__file__)
cmd_args = ["python %s" % exe]
cmd_args.append("--filename %s" % self.filename)
cmd_args.append("--filename-mask %s" % ph.append_to_filename(
self.filename, self.suffix_mask))
cmd_args.append("--dir-input-mc %s" % dir_input_mc)
cmd_args.append("--output %s" % output)
cmd_args.append("--iter-max %d" % iter_max)
cmd_args.append("--alpha %f" % alpha)
cmd = (" ").join(cmd_args)
self.assertEqual(ph.execute_command(cmd), 0)
# Check whether identical reconstruction has been created
reconstruction_sitk = sitkh.read_sitk_vector_image(output)
reference_sitk = sitkh.read_sitk_vector_image(path_to_reference)
difference_sitk = reconstruction_sitk - reference_sitk
error = np.linalg.norm(sitk.GetArrayFromImage(difference_sitk))
self.assertAlmostEqual(error, 0, places=self.precision)
def main():
pid = "49"
method = "manual" #auto, manual
input_dir = "{0:}/input".format(pid)
mask_dir = "{0:}/mask_{1:}/mask".format(pid, method)
output_dir = "{0:}/input_preprocess".format(pid)
# get input stack names
files = os.listdir(input_dir)
input_files = []
mask_files = []
for file in files:
if (("nii.gz" in file)):
input_files.append("{0:}/{1:}".format(input_dir, file))
mask_name = "{0:}/{1:}".format(mask_dir, file)
assert(os.path.isfile(mask_name))
mask_files.append(mask_name)
cmd_args = []
cmd_args.append("--filenames %s" % (" ").join(input_files))
cmd_args.append("--filenames-masks %s" % (" ").join(mask_files))
cmd_args.append("--dir-output %s" % output_dir)
cmd_args.append("--prefix-output ''")
cmd = "niftymic_correct_bias_field %s" % (" ").join(cmd_args)
time_start_bias = ph.start_timing()
exit_code = ph.execute_command(cmd)
elapsed_time_bias = ph.stop_timing(time_start_bias)
print("Computational Time for Bias Field Correction: %s" %
elapsed_time_bias)
if exit_code != 0:
raise RuntimeError("Bias field correction failed")
return 0
def test_reconstruct_volume(self):
dir_root = os.path.join(self.dir_data, "reconstruct_volume")
dir_input = os.path.join(dir_root, "input-data")
dir_reference = os.path.join(dir_root, "result-comparison")
filename_reference = "SRR_stacks3_TK1_lsmr_alpha0p02_itermax5.nii.gz"
path_to_reference = os.path.join(dir_reference, filename_reference)
two_step_cycles = 1
iter_max = 5
cmd_args = []
cmd_args.append("--dir-input %s" % dir_input)
cmd_args.append("--dir-output %s" % self.dir_output)
cmd_args.append("--two-step-cycles %s" % two_step_cycles)
cmd_args.append("--iter-max %s" % iter_max)
cmd = "niftymic_reconstruct_volume %s" % (
" ").join(cmd_args)
self.assertEqual(ph.execute_command(cmd), 0)
# Check whether identical reconstruction has been created
path_to_reconstruction = os.path.join(
self.dir_output, filename_reference)
reconstruction_sitk = sitk.ReadImage(path_to_reconstruction)
reference_sitk = sitk.ReadImage(path_to_reference)
difference_sitk = reconstruction_sitk - reference_sitk
error = np.linalg.norm(sitk.GetArrayFromImage(difference_sitk))
self.assertAlmostEqual(error, 0, places=self.precision)
def test_register_landmarks(self):
path_to_fixed_landmarks = os.path.join(
DIR_TEST, "3D_Brain_Template_landmarks.txt")
path_to_moving_landmarks = os.path.join(DIR_TEST,
"3D_Brain_AD_landmarks.txt")
path_to_reference = os.path.join(
DIR_TEST, "landmark_transform_3D_Brain_Source_to_Target_CPD.txt")
path_to_result = os.path.join(DIR_TMP, "registration_transform.txt")
exe = re.sub(".pyc", ".py",
os.path.abspath(register_landmarks.__file__))
cmd_args = ["python %s" % exe]
cmd_args.append("--output %s" % path_to_result)
cmd_args.append("--fixed %s" % path_to_fixed_landmarks)
cmd_args.append("--moving %s" % path_to_moving_landmarks)
cmd_args.append("--verbose %s" % self.verbose)
cmd = " ".join(cmd_args)
flag = ph.execute_command(cmd, verbose=self.verbose)
if flag != 0:
raise RuntimeError("Cannot execute command '%s'" % cmd)
transform_result_sitk = sitk.Euler3DTransform(
sitk.ReadTransform(path_to_result))
transform_reference_sitk = sitk.Euler3DTransform(
sitk.ReadTransform(path_to_reference))
result = np.array(transform_result_sitk.GetParameters())
reference = np.array(transform_reference_sitk.GetParameters())
self.assertAlmostEqual(np.sum(np.abs(result - reference)),
0,
places=self.precision)
def test_estimate_landmarks(self):
for image in ["3D_Brain_Template", "3D_Brain_AD"]:
path_to_image_fiducials = os.path.join(
DIR_TEST, "%s_fiducials.nii.gz" % image)
path_to_reference = os.path.join(DIR_TEST,
"%s_landmarks.txt" % image)
path_to_result = os.path.join(DIR_TMP, "%s_result.txt" % image)
exe = re.sub(".pyc", ".py",
os.path.abspath(estimate_landmarks.__file__))
cmd_args = ["python %s" % exe]
cmd_args.append("--output %s" % path_to_result)
cmd_args.append("--filename %s" % path_to_image_fiducials)
# cmd_args.append("--clusters 4")
cmd_args.append("--verbose %s" % self.verbose)
cmd = " ".join(cmd_args)
flag = ph.execute_command(cmd, verbose=self.verbose)
if flag != 0:
raise RuntimeError("Cannot execute command '%s'" % cmd)
result = np.loadtxt(path_to_result)
reference = np.loadtxt(path_to_reference)
# Find closest point
indices = [
np.argmin(np.linalg.norm(result[i, :] - reference, axis=1))
for i in range(result.shape[0])
]
reference = [reference[i, :] for i in indices]
self.assertAlmostEqual(np.sum(np.abs(result - reference)),
0,
places=self.precision)
def test_resample_oriented_gaussian_spacing_atg(self):
moving = os.path.join(DIR_DATA, "3D_SheppLoganPhantom_64.nii.gz")
fixed = os.path.join(DIR_TMP, "3D_SheppLoganPhantom_64_rotated.nii.gz")
rotation = sitk.Euler3DTransform()
rotation.SetRotation(0.3, -0.2, -0.3)
rotation.SetCenter((-40, -25, 17))
image_rotated = utils.update_image_header(sitk.ReadImage(moving),
rotation)
sitk.WriteImage(image_rotated, fixed)
reference = os.path.join(
DIR_TEST,
"3D_SheppLoganPhantom_64_OrientedGaussian_s113_atg4.nii.gz")
cmd_args = ["python simplereg_resample.py"]
cmd_args.append("-m %s" % moving)
cmd_args.append("-f %s" % fixed)
cmd_args.append("-i OrientedGaussian")
cmd_args.append("-s 1 1 3")
cmd_args.append("-atg 4")
cmd_args.append("-p -1000")
cmd_args.append("-o %s" % self.output_image)
self.assertEqual(ph.execute_command(" ".join(cmd_args)), 0)
res_sitk = sitk.ReadImage(self.output_image)
ref_sitk = sitk.ReadImage(reference)
diff_nda = sitk.GetArrayFromImage(res_sitk - ref_sitk)
self.assertAlmostEqual(np.linalg.norm(diff_nda),
0,
places=self.precision)
def test_fetal_brain_seg(self):
dir_output = os.path.join(DIR_TMP, "seg")
cmd_args = ["niftymic_segment_fetal_brains"]
cmd_args.append("--filenames %s" % self.path_to_image)
cmd_args.append("--dir-output %s" % dir_output)
# cmd_args.append("--verbose 1")
cmd = " ".join(cmd_args)
flag = ph.execute_command(cmd)
def _export_image_side_by_side(
nda_left,
nda_right,
label_left,
label_right,
path_to_file,
ctr,
resize,
extension,
border=10,
background="black",
fill_ctr="orange",
fill_label="white",
font="Arial",
pointsize=12,
):
dir_output = os.path.join(DIR_TMP, "ImageMagick", "side-by-side")
ph.clear_directory(dir_output, verbose=False)
path_to_left = os.path.join(dir_output, "left.%s" % extension)
path_to_right = os.path.join(dir_output, "right.%s" % extension)
ph.write_image(nda_left, path_to_left, verbose=False)
ph.write_image(nda_right, path_to_right, verbose=False)
_resize_image(path_to_left, resize=resize)
_resize_image(path_to_right, resize=resize)
cmd_args = []
cmd_args.append("-geometry +%d+%d" % (border, border))
cmd_args.append("-background %s" % background)
cmd_args.append("-font %s" % font)
cmd_args.append("-pointsize %s" % pointsize)
cmd_args.append("-fill %s" % fill_ctr)
cmd_args.append("-gravity SouthWest -draw \"text 0,0 '%d'\"" % ctr)
cmd_args.append("-fill %s" % fill_label)
cmd_args.append("-label '%s' %s" % (label_left, path_to_left))
cmd_args.append("-label '%s' %s" % (label_right, path_to_right))
cmd_args.append("%s" % path_to_file)
cmd = "montage %s" % (" ").join(cmd_args)
ph.execute_command(cmd, verbose=False)
def test_transform_sitk_to_regaladin(self):
cmd_args = ["python simplereg_transform.py"]
cmd_args.append("-sitk2nreg %s %s" %
(self.transform_3D_sitk, self.output_transform))
self.assertEqual(ph.execute_command(" ".join(cmd_args)), 0)
res_nda = dr.DataReader.read_transform_nreg(self.output_transform)
ref_nda = dr.DataReader.read_transform_nreg(self.transform_3D_nreg)
self.assertAlmostEqual(np.linalg.norm(ref_nda - res_nda),
0,
places=self.precision)
def test_estimate_motion(self):
filename = "SRR_reference.nii.gz"
output = os.path.join(self.dir_output, filename)
dir_reference = os.path.join(self.dir_data, "estimate_motion")
dir_reference_mc = os.path.join(dir_reference, "motion_correction")
path_to_reference = os.path.join(dir_reference, filename)
path_to_reference_mask = ph.append_to_filename(
os.path.join(dir_reference, filename), self.suffix_mask)
two_step_cycles = 1
iter_max = 5
exe = os.path.abspath(rsfmri_estimate_motion.__file__)
cmd_args = ["python %s" % exe]
cmd_args.append("--filename %s" % self.filename)
cmd_args.append("--filename-mask %s" % ph.append_to_filename(
self.filename, self.suffix_mask))
cmd_args.append("--dir-output %s" % self.dir_output)
cmd_args.append("--two-step-cycles %s" % two_step_cycles)
cmd_args.append("--iter-max %d" % iter_max)
cmd = (" ").join(cmd_args)
self.assertEqual(ph.execute_command(cmd), 0)
# Check SRR volume
res_sitk = sitkh.read_nifti_image_sitk(output)
ref_sitk = sitkh.read_nifti_image_sitk(path_to_reference)
diff_sitk = res_sitk - ref_sitk
error = np.linalg.norm(sitk.GetArrayFromImage(diff_sitk))
self.assertAlmostEqual(error, 0, places=self.precision)
# Check SRR mask volume
res_sitk = sitkh.read_nifti_image_sitk(
ph.append_to_filename(output, self.suffix_mask))
ref_sitk = sitkh.read_nifti_image_sitk(path_to_reference_mask)
diff_sitk = res_sitk - ref_sitk
error = np.linalg.norm(sitk.GetArrayFromImage(diff_sitk))
self.assertAlmostEqual(error, 0, places=self.precision)
# Check transforms
pattern = REGEX_FILENAMES + "[.]tfm"
p = re.compile(pattern)
dir_res_mc = os.path.join(self.dir_output, "motion_correction")
trafos_res = sorted(
[os.path.join(dir_res_mc, t)
for t in os.listdir(dir_res_mc) if p.match(t)])
trafos_ref = sorted(
[os.path.join(dir_reference_mc, t)
for t in os.listdir(dir_reference_mc) if p.match(t)])
self.assertEqual(len(trafos_res), len(trafos_ref))
for i in range(len(trafos_ref)):
nda_res = sitkh.read_transform_sitk(trafos_res[i]).GetParameters()
nda_ref = sitkh.read_transform_sitk(trafos_ref[i]).GetParameters()
nda_diff = np.linalg.norm(np.array(nda_res) - nda_ref)
self.assertAlmostEqual(nda_diff, 0, places=self.precision)
def test_transform_flirt_to_sitk(self):
cmd_args = ["python simplereg_transform.py"]
cmd_args.append("-flirt2sitk %s %s %s %s" %
(self.transform_3D_flirt, self.image_3D,
self.image_3D_moving, self.output_transform))
self.assertEqual(ph.execute_command(" ".join(cmd_args)), 0)
res_sitk = dr.DataReader.read_transform(self.output_transform)
ref_sitk = dr.DataReader.read_transform(self.transform_3D_sitk)
res_nda = np.array(res_sitk.GetParameters())
ref_nda = np.array(ref_sitk.GetParameters())
self.assertAlmostEqual(np.linalg.norm(ref_nda - res_nda), 0, places=2)
def test_transform_swap_sitk_nii(self):
cmd_args = ["python simplereg_transform.py"]
cmd_args.append("-sitk2nii %s %s" %
(self.landmarks_3D, self.output_landmarks))
self.assertEqual(ph.execute_command(" ".join(cmd_args)), 0)
res_nda = dr.DataReader.read_landmarks(self.output_landmarks)
ref_nda = dr.DataReader.read_landmarks(self.landmarks_3D)
ref_nda[:, 0:2] *= -1
self.assertAlmostEqual(np.linalg.norm(ref_nda - res_nda),
0,
places=self.precision)
def test_transform_nreg_to_sitk_regaladin(self):
cmd_args = ["python simplereg_transform.py"]
cmd_args.append("-nreg2sitk %s %s" %
(self.transform_3D_nreg, self.output_transform))
self.assertEqual(ph.execute_command(" ".join(cmd_args)), 0)
res_sitk = dr.DataReader.read_transform(self.output_transform)
ref_sitk = dr.DataReader.read_transform(self.transform_3D_sitk)
res_nda = np.array(res_sitk.GetParameters())
ref_nda = np.array(ref_sitk.GetParameters())
self.assertAlmostEqual(np.linalg.norm(ref_nda - res_nda),
0,
places=self.precision)
def test_transform_nreg_to_sitk_regf3d(self):
cmd_args = ["python simplereg_transform.py"]
cmd_args.append(
"-nreg2sitk %s %s" %
(self.transform_3D_nreg_disp, self.output_transform_disp))
self.assertEqual(ph.execute_command(" ".join(cmd_args)), 0)
res_sitk = sitk.ReadImage(self.output_transform_disp)
ref_sitk = sitk.ReadImage(self.transform_3D_sitk_disp)
diff_nda = sitk.GetArrayFromImage(res_sitk - ref_sitk)
self.assertAlmostEqual(np.linalg.norm(diff_nda),
0,
places=self.precision)
def anonymize_files(self, dir_output):
ph.create_directory(dir_output)
filenames_in = [os.path.basename(f) for f in self._filenames]
for i in range(0, len(self._filenames)):
filename_anonymized = self._identifiers[i]
filename_original = self._dictionary[self._identifiers[i]]
try:
index = filenames_in.index(filename_original)
except ValueError:
raise IOError(
"Given filenames (--filenames) do not match the ones given in the dictionary"
)
path_to_file_anon = os.path.join(dir_output, filename_anonymized)
cmd = "cp -p "
cmd += self._filenames[index] + " "
cmd += path_to_file_anon + " "
# print(cmd)
ph.execute_command(cmd)
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 main():
for patient_i in range(len(patients)):
for mask_i in mask_indices:
for srr_i in srr_indices:
patient = patients[patient_i]
method_mask = mask_names[mask_i]
method_srr = srr_names[srr_i]
dir_input = "{0:}/input_preprocess".format(patient)
if (not os.path.isdir(dir_input)):
dir_input = "{0:}/input".format(patient)
cmd_args = []
cmd_args.append(" --dir-input {0:}".format(dir_input))
cmd_args.append(" --dir-mask {0:}/mask_{1:}/mask".format(
patient, method_mask))
dir_output = "{0:}/mask_{1:}/reconstruct_{2:}".format(
patient, method_mask, method_srr)
cmd_args.append(" --dir-output {0:}".format(dir_output))
patient_prefix = patient
if ("_" in patient):
patient_prefix = patient.split("_")[0]
subject_space_arg = 1 if 0 in space_indices else 0
template_space_arg = 1 if 1 in space_indices else 0
cmd_args.append(" --gestational-age {0:}".format(
ages[patient_i]))
cmd_args.append(" --suffix-mask _mask")
cmd_args.append(" --alpha 0.02")
cmd_args.append(" --bias-field-correction 0")
cmd_args.append(" --run-data-vs-simulated-data 0")
cmd_args.append(" --run-recon-subject-space {0:}".format(
subject_space_arg))
cmd_args.append(" --run-recon-template-space {0:}".format(
template_space_arg))
outlier_rejct = 0
gaussian_smooth = 0
if (srr_i == 1):
outlier_rejct = 1
elif (srr_i == 2):
outlier_rejct = 1
gaussian_smooth = 1
cmd_args.append(
" --outlier-rejection {0:}".format(outlier_rejct))
cmd_args.append(
" --use-robust-registration {0:}".format(gaussian_smooth))
cmd = "python reconstruction.py {0:}".format(
' '.join(cmd_args))
exit_code = ph.execute_command(cmd)
def test_simulate_stacks_from_slices(self):
cmd_args = []
cmd_args.append("--dir-input %s" %
os.path.join(self.dir_data, "motion_correction"))
cmd_args.append("--reconstruction %s" % self.path_to_recon)
cmd_args.append("--reconstruction-mask %s" % self.path_to_recon_mask)
cmd_args.append("--copy-data 1")
cmd_args.append("--suffix-mask _brain")
# cmd_args.append("--verbose 1")
cmd_args.append("--dir-output %s" % self.dir_output)
exe = os.path.abspath(simulate_stacks_from_reconstruction.__file__)
cmd = "python %s %s" % (exe, (" ").join(cmd_args))
self.assertEqual(ph.execute_command(cmd), 0)
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 test_transform_sitk_to_regf3d(self):
cmd_args = ["python simplereg_transform.py"]
cmd_args.append(
"-sitk2nreg %s %s" %
(self.transform_3D_sitk_disp, self.output_transform_disp))
self.assertEqual(ph.execute_command(" ".join(cmd_args)), 0)
res_nib = nib.load(self.output_transform_disp)
ref_nib = nib.load(self.transform_3D_nreg_disp)
HEADERS = ['intent_p1']
for h in HEADERS:
self.assertEqual(res_nib.header[h], res_nib.header[h])
diff_nda = res_nib.get_data() - ref_nib.get_data()
self.assertAlmostEqual(np.linalg.norm(diff_nda),
0,
places=self.precision)
def test_simulate_stacks_from_slices(self):
cmd_args = []
cmd_args.append("--filenames %s" % self.path_to_file)
cmd_args.append("--dir-input-mc %s" % os.path.join(
self.dir_data, "recon_projections", "motion_correction"))
cmd_args.append("--reconstruction %s" % self.path_to_recon)
cmd_args.append("--reconstruction-mask %s" % self.path_to_recon_mask)
cmd_args.append("--copy-data 1")
cmd_args.append("--suffix-mask %s" % self.suffix_mask)
cmd_args.append("--dir-output %s" % self.dir_output)
exe = os.path.abspath(simulate_stacks_from_reconstruction.__file__)
cmd = "python %s %s" % (exe, (" ").join(cmd_args))
self.assertEqual(ph.execute_command(cmd), 0)
path_orig = os.path.join(self.dir_output, "%s.nii.gz" % self.filename)
path_sim = os.path.join(self.dir_output,
"Simulated_%s.nii.gz" % self.filename)
path_sim_mask = os.path.join(
self.dir_output,
"Simulated_%s%s.nii.gz" % (self.filename, self.suffix_mask))
path_orig_ref = os.path.join(self.dir_data, "recon_projections",
"slices", "%s.nii.gz" % self.filename)
path_sim_ref = os.path.join(self.dir_data, "recon_projections",
"slices",
"Simulated_%s.nii.gz" % self.filename)
path_sim_mask_ref = os.path.join(
self.dir_data, "recon_projections", "slices",
"Simulated_%s%s.nii.gz" % (self.filename, self.suffix_mask))
for res, ref in zip([path_orig, path_sim, path_sim_mask],
[path_orig_ref, path_sim_ref, path_sim_mask_ref]):
res_sitk = sitk.ReadImage(res)
ref_sitk = sitk.ReadImage(ref)
nda_diff = np.nan_to_num(
sitk.GetArrayFromImage(res_sitk - ref_sitk))
self.assertAlmostEqual(np.linalg.norm(nda_diff),
0,
places=self.precision)
def test_resample_bspline_spacing_atg(self):
image = os.path.join(DIR_DATA, "3D_SheppLoganPhantom_64.nii.gz")
reference = os.path.join(
DIR_TEST, "3D_SheppLoganPhantom_64_BSpline_s113_atg-4.nii.gz")
cmd_args = ["python simplereg_resample.py"]
cmd_args.append("-m %s" % image)
cmd_args.append("-f same")
cmd_args.append("-i BSpline")
cmd_args.append("-t %s" % self.transform_3D_sitk)
cmd_args.append("-s 1 1 3")
cmd_args.append("-atg -4")
cmd_args.append("-o %s" % self.output_image)
self.assertEqual(ph.execute_command(" ".join(cmd_args)), 0)
res_sitk = sitk.ReadImage(self.output_image)
ref_sitk = sitk.ReadImage(reference)
diff_nda = sitk.GetArrayFromImage(res_sitk - ref_sitk)
self.assertAlmostEqual(np.linalg.norm(diff_nda),
0,
places=self.precision)
def main():
input_parser = InputArgparser(description="Convert NIfTI to DICOM image", )
input_parser.add_filename(required=True)
input_parser.add_option(
option_string="--template",
type=str,
required=True,
help="Template DICOM to extract relevant DICOM tags.",
)
input_parser.add_dir_output(required=True)
input_parser.add_label(
help="Label used for series description of DICOM output.",
default="SRR_NiftyMIC")
input_parser.add_argument(
"--volume",
"-volume",
action='store_true',
help="If given, the output DICOM file is combined as 3D volume")
args = input_parser.parse_args()
input_parser.print_arguments(args)
# Prepare for final DICOM output
ph.create_directory(args.dir_output)
if args.volume:
dir_output_2d_slices = os.path.join(DIR_TMP, "dicom_slices")
else:
dir_output_2d_slices = os.path.join(args.dir_output, args.label)
ph.create_directory(dir_output_2d_slices, delete_files=True)
# read NiftyMIC version (if available)
data_reader = dr.ImageHeaderReader(args.filename)
data_reader.read_data()
niftymic_version = data_reader.get_niftymic_version()
if niftymic_version is None:
niftymic_version = "NiftyMIC"
else:
niftymic_version = "NiftyMIC-v%s" % niftymic_version
# Create set of 2D DICOM slices from 3D NIfTI image
# (correct image orientation!)
ph.print_title("Create set of 2D DICOM slices from 3D NIfTI image")
cmd_args = ["nifti2dicom"]
cmd_args.append("-i '%s'" % args.filename)
cmd_args.append("-o '%s'" % dir_output_2d_slices)
cmd_args.append("-d '%s'" % args.template)
cmd_args.append("--prefix ''")
cmd_args.append("--seriesdescription '%s'" % args.label)
cmd_args.append("--accessionnumber '%s'" % ACCESSION_NUMBER)
cmd_args.append("--seriesnumber '%s'" % SERIES_NUMBER)
cmd_args.append("--institutionname '%s'" % IMAGE_COMMENTS)
# Overwrite default "nifti2dicom" tags which would be added otherwise
# (no deletion/update with empty '' sufficient to overwrite them)
cmd_args.append("--manufacturersmodelname '%s'" % "NiftyMIC")
cmd_args.append("--protocolname '%s'" % niftymic_version)
cmd_args.append("-y")
ph.execute_command(" ".join(cmd_args))
if args.volume:
path_to_output = os.path.join(args.dir_output, "%s.dcm" % args.label)
# Combine set of 2D DICOM slices to form 3D DICOM image
# (image orientation stays correct)
ph.print_title("Combine set of 2D DICOM slices to form 3D DICOM image")
cmd_args = ["medcon"]
cmd_args.append("-f '%s'/*.dcm" % dir_output_2d_slices)
cmd_args.append("-o '%s'" % path_to_output)
cmd_args.append("-c dicom")
cmd_args.append("-stack3d")
cmd_args.append("-n")
cmd_args.append("-qc")
cmd_args.append("-w")
ph.execute_command(" ".join(cmd_args))
# Update all relevant DICOM tags accordingly
ph.print_title("Update all relevant DICOM tags accordingly")
print("")
dataset_template = pydicom.dcmread(args.template)
dataset = pydicom.dcmread(path_to_output)
# Copy tags from template (to guarantee grouping with original data)
update_dicom_tags = {}
for tag in COPY_DICOM_TAGS:
try:
update_dicom_tags[tag] = getattr(dataset_template, tag)
except:
update_dicom_tags[tag] = ""
# Additional tags
update_dicom_tags["SeriesDescription"] = args.label
update_dicom_tags["InstitutionName"] = institution_name
update_dicom_tags["ImageComments"] = IMAGE_COMMENTS
update_dicom_tags["AccessionNumber"] = ACCESSION_NUMBER
update_dicom_tags["SeriesNumber"] = SERIES_NUMBER
for tag in sorted(update_dicom_tags.keys()):
value = update_dicom_tags[tag]
setattr(dataset, tag, value)
ph.print_info("%s: '%s'" % (tag, value))
dataset.save_as(path_to_output)
print("")
ph.print_info("3D DICOM image written to '%s'" % path_to_output)
else:
ph.print_info("DICOM images written to '%s'" % dir_output_2d_slices)
return 0
def main():
time_start = ph.start_timing()
np.set_printoptions(precision=3)
input_parser = InputArgparser(
description="Run reconstruction pipeline including "
"(i) bias field correction, "
"(ii) volumetric reconstruction in subject space, "
"(iii) volumetric reconstruction in template space, "
"and (iv) some diagnostics to assess the obtained reconstruction.", )
input_parser.add_filenames(required=True)
input_parser.add_filenames_masks(required=True)
input_parser.add_target_stack(required=False)
input_parser.add_suffix_mask(default="")
input_parser.add_dir_output(required=True)
input_parser.add_alpha(default=0.01)
input_parser.add_verbose(default=0)
input_parser.add_gestational_age(required=False)
input_parser.add_prefix_output(default="")
input_parser.add_search_angle(default=180)
input_parser.add_multiresolution(default=0)
input_parser.add_log_config(default=1)
input_parser.add_isotropic_resolution()
input_parser.add_reference()
input_parser.add_reference_mask()
input_parser.add_bias_field_correction(default=1)
input_parser.add_intensity_correction(default=1)
input_parser.add_iter_max(default=10)
input_parser.add_two_step_cycles(default=3)
input_parser.add_slice_thicknesses(default=None)
input_parser.add_option(
option_string="--run-bias-field-correction",
type=int,
help="Turn on/off bias field correction. "
"If off, it is assumed that this step was already performed "
"if --bias-field-correction is active.",
default=1)
input_parser.add_option(
option_string="--run-recon-subject-space",
type=int,
help="Turn on/off reconstruction in subject space. "
"If off, it is assumed that this step was already performed.",
default=1)
input_parser.add_option(
option_string="--run-recon-template-space",
type=int,
help="Turn on/off reconstruction in template space. "
"If off, it is assumed that this step was already performed.",
default=1)
input_parser.add_option(
option_string="--run-diagnostics",
type=int,
help="Turn on/off diagnostics of the obtained volumetric "
"reconstruction. ",
default=0)
input_parser.add_option(
option_string="--initial-transform",
type=str,
help="Set initial transform to be used for register_image.",
default=None)
input_parser.add_outlier_rejection(default=1)
input_parser.add_threshold_first(default=0.5)
input_parser.add_threshold(default=0.8)
input_parser.add_argument(
"--sda",
"-sda",
action='store_true',
help="If given, the volume is reconstructed using "
"Scattered Data Approximation (Vercauteren et al., 2006). "
"--alpha is considered the value for the standard deviation then. "
"Recommended value is, e.g., --alpha 0.8")
input_parser.add_argument(
"--v2v-robust",
"-v2v-robust",
action='store_true',
help="If given, a more robust volume-to-volume registration step is "
"performed, i.e. four rigid registrations are performed using four "
"rigid transform initializations based on "
"principal component alignment of associated masks.")
input_parser.add_interleave(default=3)
input_parser.add_argument(
"--s2v-hierarchical",
"-s2v-hierarchical",
action='store_true',
help="If given, a hierarchical approach for the first slice-to-volume "
"registration cycle is used, i.e. sub-packages defined by the "
"specified interleave (--interleave) are registered until each "
"slice is registered independently.")
args = input_parser.parse_args()
input_parser.print_arguments(args)
if args.log_config:
input_parser.log_config(os.path.abspath(__file__))
filename_srr = "srr"
dir_output_preprocessing = os.path.join(args.dir_output,
"preprocessing_n4itk")
dir_output_recon_subject_space = os.path.join(args.dir_output,
"recon_subject_space")
dir_output_recon_template_space = os.path.join(args.dir_output,
"recon_template_space")
dir_output_diagnostics = os.path.join(args.dir_output, "diagnostics")
srr_subject = os.path.join(dir_output_recon_subject_space,
"%s_subject.nii.gz" % filename_srr)
srr_subject_mask = ph.append_to_filename(srr_subject, "_mask")
srr_template = os.path.join(dir_output_recon_template_space,
"%s_template.nii.gz" % filename_srr)
srr_template_mask = ph.append_to_filename(srr_template, "_mask")
trafo_template = os.path.join(dir_output_recon_template_space,
"registration_transform_sitk.txt")
srr_slice_coverage = os.path.join(
dir_output_diagnostics,
"%s_template_slicecoverage.nii.gz" % filename_srr)
if args.bias_field_correction and args.run_bias_field_correction:
for i, f in enumerate(args.filenames):
output = os.path.join(dir_output_preprocessing,
os.path.basename(f))
cmd_args = []
cmd_args.append("--filename '%s'" % f)
cmd_args.append("--filename-mask '%s'" % args.filenames_masks[i])
cmd_args.append("--output '%s'" % output)
# cmd_args.append("--verbose %d" % args.verbose)
cmd_args.append("--log-config %d" % args.log_config)
cmd = "niftymic_correct_bias_field %s" % (" ").join(cmd_args)
time_start_bias = ph.start_timing()
exit_code = ph.execute_command(cmd)
if exit_code != 0:
raise RuntimeError("Bias field correction failed")
elapsed_time_bias = ph.stop_timing(time_start_bias)
filenames = [
os.path.join(dir_output_preprocessing, os.path.basename(f))
for f in args.filenames
]
elif args.bias_field_correction and not args.run_bias_field_correction:
elapsed_time_bias = ph.get_zero_time()
filenames = [
os.path.join(dir_output_preprocessing, os.path.basename(f))
for f in args.filenames
]
else:
elapsed_time_bias = ph.get_zero_time()
filenames = args.filenames
# Specify target stack for intensity correction and reconstruction space
if args.target_stack is None:
target_stack = filenames[0]
else:
try:
target_stack_index = args.filenames.index(args.target_stack)
except ValueError as e:
raise ValueError(
"--target-stack must correspond to an image as provided by "
"--filenames")
target_stack = filenames[target_stack_index]
# Add single quotes around individual filenames to account for whitespaces
filenames = ["'" + f + "'" for f in filenames]
filenames_masks = ["'" + f + "'" for f in args.filenames_masks]
if args.run_recon_subject_space:
cmd_args = ["niftymic_reconstruct_volume"]
cmd_args.append("--filenames %s" % (" ").join(filenames))
cmd_args.append("--filenames-masks %s" % (" ").join(filenames_masks))
cmd_args.append("--multiresolution %d" % args.multiresolution)
cmd_args.append("--target-stack '%s'" % target_stack)
cmd_args.append("--output '%s'" % srr_subject)
cmd_args.append("--suffix-mask '%s'" % args.suffix_mask)
cmd_args.append("--intensity-correction %d" %
args.intensity_correction)
cmd_args.append("--alpha %s" % args.alpha)
cmd_args.append("--iter-max %d" % args.iter_max)
cmd_args.append("--two-step-cycles %d" % args.two_step_cycles)
cmd_args.append("--outlier-rejection %d" % args.outlier_rejection)
cmd_args.append("--threshold-first %f" % args.threshold_first)
cmd_args.append("--threshold %f" % args.threshold)
if args.slice_thicknesses is not None:
cmd_args.append("--slice-thicknesses %s" %
" ".join(map(str, args.slice_thicknesses)))
cmd_args.append("--verbose %d" % args.verbose)
cmd_args.append("--log-config %d" % args.log_config)
if args.isotropic_resolution is not None:
cmd_args.append("--isotropic-resolution %f" %
args.isotropic_resolution)
if args.reference is not None:
cmd_args.append("--reference %s" % args.reference)
if args.reference_mask is not None:
cmd_args.append("--reference-mask %s" % args.reference_mask)
if args.sda:
cmd_args.append("--sda")
if args.v2v_robust:
cmd_args.append("--v2v-robust")
if args.s2v_hierarchical:
cmd_args.append("--s2v-hierarchical")
cmd = (" ").join(cmd_args)
time_start_volrec = ph.start_timing()
exit_code = ph.execute_command(cmd)
if exit_code != 0:
raise RuntimeError("Reconstruction in subject space failed")
# Compute SRR mask in subject space
# (Approximated using SDA within reconstruct_volume)
if 0:
dir_motion_correction = os.path.join(
dir_output_recon_subject_space, "motion_correction")
cmd_args = ["niftymic_reconstruct_volume_from_slices"]
cmd_args.append("--filenames %s" % " ".join(filenames_masks))
cmd_args.append("--dir-input-mc '%s'" % dir_motion_correction)
cmd_args.append("--output '%s'" % srr_subject_mask)
cmd_args.append("--reconstruction-space '%s'" % srr_subject)
cmd_args.append("--suffix-mask '%s'" % args.suffix_mask)
cmd_args.append("--mask")
cmd_args.append("--log-config %d" % args.log_config)
if args.slice_thicknesses is not None:
cmd_args.append("--slice-thicknesses %s" %
" ".join(map(str, args.slice_thicknesses)))
if args.sda:
cmd_args.append("--sda")
cmd_args.append("--alpha 1")
else:
cmd_args.append("--alpha 0.1")
cmd_args.append("--iter-max 5")
cmd = (" ").join(cmd_args)
ph.execute_command(cmd)
elapsed_time_volrec = ph.stop_timing(time_start_volrec)
else:
elapsed_time_volrec = ph.get_zero_time()
if args.run_recon_template_space:
if args.gestational_age is None:
template_stack_estimator = \
tse.TemplateStackEstimator.from_mask(srr_subject_mask)
gestational_age = template_stack_estimator.get_estimated_gw()
ph.print_info("Estimated gestational age: %d" % gestational_age)
else:
gestational_age = args.gestational_age
template = os.path.join(DIR_TEMPLATES,
"STA%d.nii.gz" % gestational_age)
template_mask = os.path.join(DIR_TEMPLATES,
"STA%d_mask.nii.gz" % gestational_age)
# Register SRR to template space
cmd_args = ["niftymic_register_image"]
cmd_args.append("--fixed '%s'" % template)
cmd_args.append("--moving '%s'" % srr_subject)
cmd_args.append("--fixed-mask '%s'" % template_mask)
cmd_args.append("--moving-mask '%s'" % srr_subject_mask)
cmd_args.append(
"--dir-input-mc '%s'" %
os.path.join(dir_output_recon_subject_space, "motion_correction"))
cmd_args.append("--output '%s'" % trafo_template)
cmd_args.append("--verbose %s" % args.verbose)
cmd_args.append("--log-config %d" % args.log_config)
cmd_args.append("--refine-pca")
if args.initial_transform is not None:
cmd_args.append("--initial-transform '%s'" %
args.initial_transform)
cmd = (" ").join(cmd_args)
exit_code = ph.execute_command(cmd)
if exit_code != 0:
raise RuntimeError("Registration to template space failed")
# Compute SRR in template space
dir_input_mc = os.path.join(dir_output_recon_template_space,
"motion_correction")
cmd_args = ["niftymic_reconstruct_volume_from_slices"]
cmd_args.append("--filenames %s" % (" ").join(filenames))
cmd_args.append("--filenames-masks %s" % (" ").join(filenames_masks))
cmd_args.append("--dir-input-mc '%s'" % dir_input_mc)
cmd_args.append("--output '%s'" % srr_template)
cmd_args.append("--reconstruction-space '%s'" % template)
cmd_args.append("--target-stack '%s'" % target_stack)
cmd_args.append("--iter-max %d" % args.iter_max)
cmd_args.append("--alpha %s" % args.alpha)
cmd_args.append("--suffix-mask '%s'" % args.suffix_mask)
cmd_args.append("--verbose %s" % args.verbose)
cmd_args.append("--log-config %d" % args.log_config)
if args.slice_thicknesses is not None:
cmd_args.append("--slice-thicknesses %s" %
" ".join(map(str, args.slice_thicknesses)))
if args.sda:
cmd_args.append("--sda")
cmd = (" ").join(cmd_args)
exit_code = ph.execute_command(cmd)
if exit_code != 0:
raise RuntimeError("Reconstruction in template space failed")
# Compute SRR mask in template space
if 1:
dir_motion_correction = os.path.join(
dir_output_recon_template_space, "motion_correction")
cmd_args = ["niftymic_reconstruct_volume_from_slices"]
cmd_args.append("--filenames %s" % " ".join(filenames_masks))
cmd_args.append("--dir-input-mc '%s'" % dir_motion_correction)
cmd_args.append("--output '%s'" % srr_template_mask)
cmd_args.append("--reconstruction-space '%s'" % srr_template)
cmd_args.append("--suffix-mask '%s'" % args.suffix_mask)
cmd_args.append("--log-config %d" % args.log_config)
cmd_args.append("--mask")
if args.slice_thicknesses is not None:
cmd_args.append("--slice-thicknesses %s" %
" ".join(map(str, args.slice_thicknesses)))
if args.sda:
cmd_args.append("--sda")
cmd_args.append("--alpha 1")
else:
cmd_args.append("--alpha 0.1")
cmd_args.append("--iter-max 5")
cmd = (" ").join(cmd_args)
ph.execute_command(cmd)
# Copy SRR to output directory
if 0:
output = "%sSRR_Stacks%d.nii.gz" % (args.prefix_output,
len(args.filenames))
path_to_output = os.path.join(args.dir_output, output)
cmd = "cp -p '%s' '%s'" % (srr_template, path_to_output)
exit_code = ph.execute_command(cmd)
if exit_code != 0:
raise RuntimeError("Copy of SRR to output directory failed")
# Multiply template mask with reconstruction
if 0:
cmd_args = ["niftymic_multiply"]
fnames = [
srr_template,
srr_template_mask,
]
output_masked = "Masked_%s" % output
path_to_output_masked = os.path.join(args.dir_output,
output_masked)
cmd_args.append("--filenames %s" % " ".join(fnames))
cmd_args.append("--output '%s'" % path_to_output_masked)
cmd = (" ").join(cmd_args)
exit_code = ph.execute_command(cmd)
if exit_code != 0:
raise RuntimeError("SRR brain masking failed")
else:
elapsed_time_template = ph.get_zero_time()
if args.run_diagnostics:
dir_input_mc = os.path.join(dir_output_recon_template_space,
"motion_correction")
dir_output_orig_vs_proj = os.path.join(dir_output_diagnostics,
"original_vs_projected")
dir_output_selfsimilarity = os.path.join(dir_output_diagnostics,
"selfsimilarity")
dir_output_orig_vs_proj_pdf = os.path.join(dir_output_orig_vs_proj,
"pdf")
# Show slice coverage over reconstruction space
exe = os.path.abspath(show_slice_coverage.__file__)
cmd_args = ["python %s" % exe]
cmd_args.append("--filenames %s" % (" ").join(filenames))
cmd_args.append("--dir-input-mc '%s'" % dir_input_mc)
cmd_args.append("--reconstruction-space '%s'" % srr_template)
cmd_args.append("--output '%s'" % srr_slice_coverage)
cmd = (" ").join(cmd_args)
exit_code = ph.execute_command(cmd)
if exit_code != 0:
raise RuntimeError("Slice coverage visualization failed")
# Get simulated/projected slices
exe = os.path.abspath(simulate_stacks_from_reconstruction.__file__)
cmd_args = ["python %s" % exe]
cmd_args.append("--filenames %s" % (" ").join(filenames))
if args.filenames_masks is not None:
cmd_args.append("--filenames-masks %s" %
(" ").join(filenames_masks))
cmd_args.append("--dir-input-mc '%s'" % dir_input_mc)
cmd_args.append("--dir-output '%s'" % dir_output_orig_vs_proj)
cmd_args.append("--reconstruction '%s'" % srr_template)
cmd_args.append("--copy-data 1")
if args.slice_thicknesses is not None:
cmd_args.append("--slice-thicknesses %s" %
" ".join(map(str, args.slice_thicknesses)))
# cmd_args.append("--verbose %s" % args.verbose)
cmd = (" ").join(cmd_args)
exit_code = ph.execute_command(cmd)
if exit_code != 0:
raise RuntimeError("SRR slice projections failed")
filenames_simulated = [
"'%s" % os.path.join(dir_output_orig_vs_proj, os.path.basename(f))
for f in filenames
]
# Evaluate slice similarities to ground truth
exe = os.path.abspath(evaluate_simulated_stack_similarity.__file__)
cmd_args = ["python %s" % exe]
cmd_args.append("--filenames %s" % (" ").join(filenames_simulated))
if args.filenames_masks is not None:
cmd_args.append("--filenames-masks %s" %
(" ").join(filenames_masks))
cmd_args.append("--measures NCC SSIM")
cmd_args.append("--dir-output '%s'" % dir_output_selfsimilarity)
cmd = (" ").join(cmd_args)
exit_code = ph.execute_command(cmd)
if exit_code != 0:
raise RuntimeError("Evaluation of stack similarities failed")
# Generate figures showing the quantitative comparison
exe = os.path.abspath(
show_evaluated_simulated_stack_similarity.__file__)
cmd_args = ["python %s" % exe]
cmd_args.append("--dir-input '%s'" % dir_output_selfsimilarity)
cmd_args.append("--dir-output '%s'" % dir_output_selfsimilarity)
cmd = (" ").join(cmd_args)
exit_code = ph.execute_command(cmd)
if exit_code != 0:
ph.print_warning("Visualization of stack similarities failed")
# Generate pdfs showing all the side-by-side comparisons
if 0:
exe = os.path.abspath(
export_side_by_side_simulated_vs_original_slice_comparison.
__file__)
cmd_args = ["python %s" % exe]
cmd_args.append("--filenames %s" % (" ").join(filenames_simulated))
cmd_args.append("--dir-output '%s'" % dir_output_orig_vs_proj_pdf)
cmd = "python %s %s" % (exe, (" ").join(cmd_args))
cmd = (" ").join(cmd_args)
exit_code = ph.execute_command(cmd)
if exit_code != 0:
raise RuntimeError("Generation of PDF overview failed")
ph.print_title("Summary")
print("Computational Time for Bias Field Correction: %s" %
elapsed_time_bias)
print("Computational Time for Volumetric Reconstruction: %s" %
elapsed_time_volrec)
print("Computational Time for Pipeline: %s" % ph.stop_timing(time_start))
return 0
def write_function_call_to_file(function_call, path_to_file):
text = "#!/bin/zsh\n\n%s" % function_call
ph.write_to_file(path_to_file, text, verbose=False)
ph.execute_command("chmod +x %s" % path_to_file, verbose=False)