def _run(self, debug=0):
for i, stack in enumerate(self._stacks):
slices = stack.get_slices()
for indices in self._slice_index_sets_of_stacks[i]:
txt = "%sSliceSet-to-Volume Registration -- " \
"Stack %d/%d -- Slices %s" % (
self._print_prefix,
i + 1, len(self._stacks),
str(indices))
if self._verbose:
ph.print_subtitle(txt)
else:
ph.print_info(txt)
image = self._get_stack_subgroup(stack, indices)
if debug:
ph.killall_itksnap()
image.show()
stack.get_slice(indices[1]).show()
self._registration_method.set_fixed(image)
self._registration_method.run()
transform_sitk = self._registration_method.\
get_registration_transform_sitk()
for j in indices:
slices[j].update_motion_correction(transform_sitk)
def _run(self):
ph.print_title("Slice-to-Volume Registration")
self._registration_method.set_moving(self._reference)
for i, stack in enumerate(self._stacks):
slices = stack.get_slices()
transforms_sitk = {}
for j, slice_j in enumerate(slices):
txt = "%sSlice-to-Volume Registration -- " \
"Stack %d/%d (%s) -- Slice %d/%d" % (
self._print_prefix,
i + 1, len(self._stacks), stack.get_filename(),
j + 1, len(slices))
if self._verbose:
ph.print_subtitle(txt)
else:
ph.print_info(txt)
self._registration_method.set_fixed(slice_j)
self._registration_method.run()
# Store information on registration transform
transform_sitk = \
self._registration_method.get_registration_transform_sitk()
transforms_sitk[slice_j.get_slice_number()] = transform_sitk
# Update position of slice
for slice in slices:
slice_number = slice.get_slice_number()
slice.update_motion_correction(transforms_sitk[slice_number])
def _run(self):
ph.print_title("Slice-to-Volume Registration")
self._registration_method.set_moving(self._reference)
for i in range(0, len(self._stacks)):
stack = self._stacks[i]
slices = stack.get_slices()
for j in range(0, len(slices)):
txt = "%sSlice-to-Volume Registration -- " \
"Stack %d/%d -- Slice %d/%d" % (
self._print_prefix,
i+1, len(self._stacks),
j+1, len(slices))
if self._verbose:
ph.print_subtitle(txt)
else:
ph.print_info(txt)
self._registration_method.set_fixed(slices[j])
self._registration_method.run()
# Update position of slice
transform_sitk = \
self._registration_method.\
get_registration_transform_sitk()
slices[j].update_motion_correction(transform_sitk)
def _print_info_text(self):
ph.print_subtitle("Tikhonov Solver:")
ph.print_info("Chosen regularization type: ", newline=False)
if self._reg_type in ["TK0"]:
print("Zeroth-order Tikhonov")
else:
print("First-order Tikhonov")
if self._deconvolution_mode in ["only_in_plane"]:
ph.print_info("(Only in-plane deconvolution is performed)")
elif self._deconvolution_mode in ["predefined_covariance"]:
ph.print_info("(Predefined covariance used: cov = %s)" %
(np.diag(self._predefined_covariance)))
if self._data_loss in ["huber"]:
ph.print_info("Loss function: %s (gamma = %g)" %
(self._data_loss, self._huber_gamma))
else:
ph.print_info("Loss function: %s" % (self._data_loss))
if self._data_loss != "linear":
ph.print_info("Loss function scale: %g" % (self._data_loss_scale))
ph.print_info("Regularization parameter: " + str(self._alpha))
ph.print_info("Minimizer: " + self._minimizer)
ph.print_info("Maximum number of iterations: " + str(self._iter_max))
def _run(self):
ph.print_title("Volume-to-Volume Registration")
for i in range(0, len(self._stacks)):
txt = "Volume-to-Volume Registration -- " \
"Stack %d/%d" % (i + 1, len(self._stacks))
if self._verbose:
ph.print_subtitle(txt)
else:
ph.print_info(txt)
if self._robust:
transform_initializer = tinit.TransformInitializer(
fixed=self._reference,
moving=self._stacks[i],
similarity_measure="NCC",
refine_pca_initializations=True,
)
transform_initializer.run()
transform_sitk = transform_initializer.get_transform_sitk()
transform_sitk = sitk.AffineTransform(
transform_sitk.GetInverse())
else:
self._registration_method.set_moving(self._reference)
self._registration_method.set_fixed(self._stacks[i])
self._registration_method.run()
transform_sitk = self._registration_method.get_registration_transform_sitk()
# Update position of stack
self._stacks[i].update_motion_correction(transform_sitk)
def _print_info_text(self):
ph.print_subtitle("ADMM Solver:")
ph.print_info("Chosen regularization type: TV")
ph.print_info("Regularization parameter alpha: " + str(self._alpha))
ph.print_info(
"Regularization parameter of augmented Lagrangian term rho: " + str(self._rho))
ph.print_info("Number of ADMM iterations: " + str(self._iterations))
ph.print_info(
"Maximum number of TK1 solver iterations: " + str(self._iter_max))
def _run(self):
ph.print_title("Multi-Component Reconstruction")
self._reconstructions = [None] * len(self._stacks)
for i in range(0, len(self._stacks)):
ph.print_subtitle("Multi-Component Reconstruction -- "
"Stack %d/%d" % (i + 1, len(self._stacks)))
stack = self._stacks[i]
self._reconstruction_method.set_stacks([stack])
self._reconstruction_method.run()
self._reconstructions[i] = st.Stack.from_stack(
self._reconstruction_method.get_reconstruction())
self._reconstructions[i].set_filename(stack.get_filename() +
self._suffix)
def _print_info_text(self):
ph.print_subtitle("Primal-Dual Solver:")
ph.print_info("Chosen regularization type: %s" % (self._reg_type),
newline=False)
if self._reg_type == "huber":
print(" (gamma = %g)" % (self._reg_huber_gamma))
else:
print("")
ph.print_info("Strategy for parameter update: %s" % (self._alg_type))
ph.print_info("Regularization parameter alpha: %g" % (self._alpha))
if self._data_loss in ["huber"]:
ph.print_info("Loss function: %s (gamma = %g)" %
(self._data_loss, self._huber_gamma))
else:
ph.print_info("Loss function: %s" % (self._data_loss))
ph.print_info("Number of Primal-Dual iterations: %d" %
(self._iterations))
ph.print_info("Minimizer: %s" % (self._minimizer))
ph.print_info("Maximum number of iterations: %d" % (self._iter_max))
def _run(self):
ph.print_title("Volume-to-Volume Registration")
self._registration_method.set_moving(self._reference)
for i in range(0, len(self._stacks)):
txt = "Volume-to-Volume Registration -- " \
"Stack %d/%d" % (i + 1, len(self._stacks))
if self._verbose:
ph.print_subtitle(txt)
else:
ph.print_info(txt)
self._registration_method.set_fixed(self._stacks[i])
self._registration_method.run()
# Update position of stack
transform_sitk = \
self._registration_method.\
get_registration_transform_sitk()
self._stacks[i].update_motion_correction(transform_sitk)
def _run(self, debug=0):
ph.print_title(
"Hierarchical SliceSet2V-Registration")
N_stacks = len(self._stacks)
self._registration_method.set_moving(self._reference)
for i_stack, stack in enumerate(self._stacks):
n_slices = stack.get_number_of_slices()
for i in range(self._interleave):
package = list(np.arange(i, n_slices, self._interleave))
if len(package) / 2 >= self._min_slices:
indices_splits = self._recursive_split(
package, [], self._min_slices)
else:
indices_splits = [package]
prefix = "Hierarchical S2V-Reg: " \
"Stack %d/%d (%s) -- Interleave %d/%d --" % (
i_stack + 1, len(self._stacks), stack.get_filename(),
i + 1, self._interleave,
)
if debug:
ph.print_subtitle(
"%s %d splits: %s" % (
prefix, len(indices_splits), indices_splits),
)
ss2vreg = SliceSetToVolumeRegistration(
print_prefix=prefix,
stack=stack,
reference=self._reference,
registration_method=self._registration_method,
slice_set_indices=indices_splits,
verbose=self._verbose,
)
ss2vreg.run()
def _run(self, debug=1):
stack = self._stacks[0]
slices = stack.get_slices()
for i, indices in enumerate(self._slice_set_indices):
txt = "%s Split %d/%d -- Slices %s" % (
self._print_prefix, i + 1,
len(self._slice_set_indices), str(indices))
if self._verbose:
ph.print_subtitle(txt)
else:
ph.print_info(txt)
image = self._get_stack_subgroup(indices)
if debug:
first = np.linalg.norm(
stack.get_slice(indices[0]).sitk.GetOrigin() -
np.array(image.sitk[:, :, 0:1].GetOrigin()))
last = np.linalg.norm(
stack.get_slice(indices[-1]).sitk.GetOrigin() -
np.array(image.sitk[:, :, -1:].GetOrigin()))
if first > 1e-6:
raise RuntimeError(
"Hierarchical S2V: first slice position flawed")
if last > 1e-6:
raise RuntimeError(
"Hierarchical S2V: last slice position flawed")
self._registration_method.set_fixed(image)
self._registration_method.run()
transform_sitk = self._registration_method.\
get_registration_transform_sitk()
for j in indices:
slices[j].update_motion_correction(transform_sitk)
def _run(self):
ph.print_title("Two-step S2V-Registration and SRR Reconstruction")
s2vreg = SliceToVolumeRegistration(
stacks=self._stacks,
reference=self._reference,
registration_method=self._registration_method,
verbose=False,
interleave=self._interleave,
)
reference = self._reference
for cycle in range(0, self._cycles):
if cycle == 0 and self._use_hierarchical_registration:
hs2vreg = HieararchicalSliceSetRegistration(
stacks=self._stacks,
reference=reference,
registration_method=self._registration_method,
interleave=self._interleave,
viewer=self._viewer,
min_slices=1,
verbose=False,
)
hs2vreg.run()
self._computational_time_registration += \
hs2vreg.get_computational_time()
else:
# Slice-to-volume registration step
s2vreg.set_reference(reference)
s2vreg.set_print_prefix("Cycle %d/%d: " %
(cycle + 1, self._cycles))
s2vreg.run()
self._computational_time_registration += \
s2vreg.get_computational_time()
# Reject misregistered slices
if self._outlier_rejection:
ph.print_subtitle("Slice Outlier Rejection (%s < %g)" % (
self._threshold_measure, self._thresholds[cycle]))
outlier_rejector = outre.OutlierRejector(
stacks=self._stacks,
reference=self._reference,
threshold=self._thresholds[cycle],
measure=self._threshold_measure,
verbose=True,
)
outlier_rejector.run()
self._reconstruction_method.set_stacks(
outlier_rejector.get_stacks())
if len(self._stacks) == 0:
raise RuntimeError(
"All slices of all stacks were rejected "
"as outliers. Volumetric reconstruction is aborted.")
# SRR step
if cycle < self._cycles - 1:
# ---------------- Perform Image Reconstruction ---------------
ph.print_subtitle("Volumetric Image Reconstruction")
if isinstance(
self._reconstruction_method,
sda.ScatteredDataApproximation
):
self._reconstruction_method.set_sigma(self._alphas[cycle])
else:
self._reconstruction_method.set_alpha(self._alphas[cycle])
self._reconstruction_method.run()
self._computational_time_reconstruction += \
self._reconstruction_method.get_computational_time()
reference = self._reconstruction_method.get_reconstruction()
# ------------------ Perform Image Mask SDA -------------------
ph.print_subtitle("Volumetric Image Mask Reconstruction")
SDA = sda.ScatteredDataApproximation(
self._stacks,
reference,
sigma=self._sigma_sda_mask,
sda_mask=True,
)
SDA.run()
# reference contains updated mask based on SDA
reference = SDA.get_reconstruction()
# -------------------- Store Reconstruction -------------------
filename = "Iter%d_%s" % (
cycle + 1,
self._reconstruction_method.get_setting_specific_filename()
)
self._reconstructions.insert(0, st.Stack.from_stack(
reference, filename=filename))
if self._verbose:
sitkh.show_stacks(self._reconstructions,
segmentation=self._reference,
viewer=self._viewer)
def _run(self):
ph.print_title("Two-step S2V-Registration and SRR Reconstruction")
# Use linear spacing for alphas excluding the last alpha reserved
# for the final SRR step
alphas = np.linspace(self._alpha_range[0], self._alpha_range[1],
self._cycles)
alphas = alphas[0:self._cycles]
thresholds = np.linspace(self._threshold_range[0],
self._threshold_range[1], self._cycles)
thresholds = thresholds[0:self._cycles]
s2vreg = SliceToVolumeRegistration(
stacks=self._stacks,
reference=self._reference,
registration_method=self._registration_method,
verbose=self._verbose,
threshold_measure=self._threshold_measure,
interleave=self._interleave,
)
reference = self._reference
for cycle in range(0, self._cycles):
# Slice-to-volume registration step
s2vreg.set_reference(reference)
s2vreg.set_print_prefix("Cycle %d/%d: " %
(cycle + 1, self._cycles))
if self._outlier_rejection:
s2vreg.set_threshold(thresholds[cycle])
if self._use_robust_registration and cycle == 0:
s2vreg.set_s2v_smoothing(self._s2v_smoothing)
else:
s2vreg.set_s2v_smoothing(None)
s2vreg.run()
self._computational_time_registration += \
s2vreg.get_computational_time()
# SRR step
if cycle < self._cycles - 1:
# ---------------- Perform Image Reconstruction ---------------
ph.print_subtitle("Volumetric Image Reconstruction")
if isinstance(self._reconstruction_method,
sda.ScatteredDataApproximation):
self._reconstruction_method.set_sigma(alphas[cycle])
else:
self._reconstruction_method.set_alpha(alphas[cycle])
self._reconstruction_method.run()
self._computational_time_reconstruction += \
self._reconstruction_method.get_computational_time()
reference = self._reconstruction_method.get_reconstruction()
# ------------------ Perform Image Mask SDA -------------------
ph.print_subtitle("Volumetric Image Mask Reconstruction")
SDA = sda.ScatteredDataApproximation(
self._stacks,
reference,
sigma=self._sigma_sda_mask,
sda_mask=True,
)
SDA.run()
# reference contains updated mask based on SDA
reference = SDA.get_reconstruction()
# -------------------- Store Reconstruction -------------------
filename = "Iter%d_%s" % (cycle + 1,
self._reconstruction_method.
get_setting_specific_filename())
self._reconstructions.insert(
0, st.Stack.from_stack(reference, filename=filename))
if self._verbose:
sitkh.show_stacks(self._reconstructions,
segmentation=self._reference,
viewer=self._viewer)
def main():
# Set print options
np.set_printoptions(precision=3)
pd.set_option('display.width', 1000)
input_parser = InputArgparser(description=".", )
input_parser.add_filenames(required=True)
input_parser.add_reference(required=True)
input_parser.add_reference_mask()
input_parser.add_dir_output(required=False)
input_parser.add_measures(
default=["PSNR", "RMSE", "MAE", "SSIM", "NCC", "NMI"])
input_parser.add_verbose(default=0)
args = input_parser.parse_args()
input_parser.print_arguments(args)
ph.print_title("Image similarity")
data_reader = dr.MultipleImagesReader(args.filenames)
data_reader.read_data()
stacks = data_reader.get_data()
reference = st.Stack.from_filename(args.reference, args.reference_mask)
for stack in stacks:
try:
stack.sitk - reference.sitk
except RuntimeError as e:
raise IOError(
"All provided images must be at the same image space")
x_ref = sitk.GetArrayFromImage(reference.sitk)
if args.reference_mask is None:
indices = np.where(x_ref != np.inf)
else:
x_ref_mask = sitk.GetArrayFromImage(reference.sitk_mask)
indices = np.where(x_ref_mask > 0)
measures_dic = {
m: lambda x, m=m: SimilarityMeasures.similarity_measures[m]
(x[indices], x_ref[indices])
# SimilarityMeasures.similarity_measures[m](x, x_ref)
for m in args.measures
}
observer = obs.Observer()
observer.set_measures(measures_dic)
for stack in stacks:
nda = sitk.GetArrayFromImage(stack.sitk)
observer.add_x(nda)
if args.verbose:
stacks_comparison = [s for s in stacks]
stacks_comparison.insert(0, reference)
sitkh.show_stacks(
stacks_comparison,
segmentation=reference,
)
observer.compute_measures()
measures = observer.get_measures()
# Store information in array
error = np.zeros((len(stacks), len(measures)))
cols = measures
rows = []
for i_stack, stack in enumerate(stacks):
error[i_stack, :] = np.array([measures[m][i_stack] for m in measures])
rows.append(stack.get_filename())
header = "# Ref: %s, Ref-Mask: %d, %s \n" % (
reference.get_filename(),
args.reference_mask is None,
ph.get_time_stamp(),
)
header += "# %s\n" % ("\t").join(measures)
path_to_file_filenames = os.path.join(args.dir_output, "filenames.txt")
path_to_file_similarities = os.path.join(args.dir_output,
"similarities.txt")
# Write to files
ph.write_to_file(path_to_file_similarities, header)
ph.write_array_to_file(path_to_file_similarities, error, verbose=False)
text = header
text += "%s\n" % "\n".join(rows)
ph.write_to_file(path_to_file_filenames, text)
# Print to screen
ph.print_subtitle("Computed Similarities")
df = pd.DataFrame(error, rows, cols)
print(df)
return 0
def _run(self):
ph.print_title("Slice-to-Volume Registration")
self._registration_method.set_moving(self._reference)
for i, stack in enumerate(self._stacks):
slices = stack.get_slices()
transforms_sitk = [None] * len(slices)
for j, slice_j in enumerate(slices):
txt = "%sSlice-to-Volume Registration -- " \
"Stack %d/%d -- Slice %d/%d" % (
self._print_prefix,
i + 1, len(self._stacks),
j + 1, len(slices))
if self._verbose:
ph.print_subtitle(txt)
else:
ph.print_info(txt)
self._registration_method.set_fixed(slice_j)
self._registration_method.run()
# Store information on registration transform
transform_sitk = \
self._registration_method.\
get_registration_transform_sitk()
transforms_sitk[j] = transform_sitk
# Avoid slice misregistrations
if self._s2v_smoothing is not None:
ph.print_subtitle("Robust slice motion estimation "
"(GP smoothing = %g, interleave = %d)" %
(self._s2v_smoothing, self._interleave))
robust_motion_estimator = rme.RobustMotionEstimator(
transforms_sitk=transforms_sitk,
interleave=self._interleave)
robust_motion_estimator.run_gaussian_process_smoothing(
self._s2v_smoothing)
transforms_sitk = \
robust_motion_estimator.get_robust_transforms_sitk()
# Export figures
# title = "%s_Stack%d%s" % (
# self._print_prefix, i, stack.get_filename())
# title = ph.replace_string_for_print(title)
# robust_motion_estimator.show_estimated_transform_parameters(
# dir_output="/tmp/fetal_brain/figs", title=title)
# dir_output = "/tmp/fetal/figs"
# motion_evaluator = me.MotionEvaluator(transforms_sitk)
# motion_evaluator.run()
# motion_evaluator.display(dir_output=dir_output, title=title)
# motion_evaluator.show(dir_output=dir_output, title=title)
# Update position of slice
for j, slice_j in enumerate(slices):
slice_j.update_motion_correction(transforms_sitk[j])
# Reject misregistered slices
if self._threshold is not None:
ph.print_subtitle("Slice Outlier Rejection (%s < %g)" %
(self._threshold_measure, self._threshold))
outlier_rejector = outre.OutlierRejector(
stacks=self._stacks,
reference=self._reference,
threshold=self._threshold,
measure=self._threshold_measure,
verbose=True,
)
outlier_rejector.run()
self._stacks = outlier_rejector.get_stacks()
if len(self._stacks) == 0:
raise RuntimeError(
"All slices of all stacks were rejected "
"as outliers. Volumetric reconstruction is aborted.")
def main():
input_parser = InputArgparser(
description="Script to export a side-by-side comparison of originally "
"acquired and simulated/projected slice given the estimated "
"volumetric reconstruction."
"This function takes the result of "
"simulate_stacks_from_reconstruction.py as input.", )
input_parser.add_filenames(required=True)
input_parser.add_dir_output(required=True)
input_parser.add_option(
option_string="--prefix-simulated",
type=str,
help="Specify the prefix of the simulated stacks to distinguish them "
"from the original data.",
default="Simulated_",
)
input_parser.add_option(
option_string="--dir-input-simulated",
type=str,
help="Specify the directory where the simulated stacks are. "
"If not given, it is assumed that they are in the same directory "
"as the original ones.",
default=None)
input_parser.add_option(
option_string="--resize",
type=float,
help="Factor to resize images (otherwise they might be very small "
"depending on the FOV)",
default=3)
args = input_parser.parse_args()
input_parser.print_arguments(args)
# --------------------------------Read Data--------------------------------
ph.print_title("Read Data")
# Read original data
filenames_original = args.filenames
data_reader = dr.MultipleImagesReader(filenames_original)
data_reader.read_data()
stacks_original = data_reader.get_data()
# Read data simulated from obtained reconstruction
if args.dir_input_simulated is None:
dir_input_simulated = os.path.dirname(filenames_original[0])
else:
dir_input_simulated = args.dir_input_simulated
filenames_simulated = [
os.path.join("%s", "%s%s") %
(dir_input_simulated, args.prefix_simulated, os.path.basename(f))
for f in filenames_original
]
data_reader = dr.MultipleImagesReader(filenames_simulated)
data_reader.read_data()
stacks_simulated = data_reader.get_data()
ph.create_directory(args.dir_output)
for i in range(len(stacks_original)):
try:
stacks_original[i].sitk - stacks_simulated[i].sitk
except:
raise IOError(
"Images '%s' and '%s' do not occupy the same space!" %
(filenames_original[i], filenames_simulated[i]))
# ---------------------Create side-by-side comparisons---------------------
ph.print_title("Create side-by-side comparisons")
intensity_max = 255
intensity_min = 0
for i in range(len(stacks_original)):
ph.print_subtitle("Stack %d/%d" % (i + 1, len(stacks_original)))
nda_3D_original = sitk.GetArrayFromImage(stacks_original[i].sitk)
nda_3D_simulated = sitk.GetArrayFromImage(stacks_simulated[i].sitk)
# Scale uniformly between 0 and 255 according to the simulated stack
# for export to png
scale = np.max(nda_3D_simulated)
nda_3D_original = intensity_max * nda_3D_original / scale
nda_3D_simulated = intensity_max * nda_3D_simulated / scale
nda_3D_simulated = np.clip(nda_3D_simulated, intensity_min,
intensity_max)
nda_3D_original = np.clip(nda_3D_original, intensity_min,
intensity_max)
filename = stacks_original[i].get_filename()
path_to_file = os.path.join(args.dir_output, "%s.pdf" % filename)
# Export side-by-side comparison of each stack to a pdf file
export_comparison_to_file(nda_3D_original,
nda_3D_simulated,
path_to_file,
resize=args.resize)
def main():
time_start = ph.start_timing()
# Read input
parser = argparse.ArgumentParser(
description="Perform rigid registration using landmarks",
prog=None,
epilog="Author: Michael Ebner ([email protected])",
)
parser.add_argument(
"-f",
"--fixed",
help="Path to fixed image landmarks.",
type=str,
required=1,
)
parser.add_argument(
"-m",
"--moving",
help="Path to moving image landmarks.",
type=str,
required=1,
)
parser.add_argument(
"-o",
"--output",
help="Path for obtained SimpleITK registration transform (.txt)",
type=str,
required=1,
)
parser.add_argument(
"-v",
"--verbose",
help="Turn on/off verbose output",
type=int,
required=0,
default=0,
)
parser.add_argument(
"--pca",
"-pca",
action="store_true",
help="If given, principal component analysis (PCA) is used "
"to test various initializations for the point based registrations.")
args = parser.parse_args()
landmarks_fixed_nda = dr.DataReader.read_landmarks(args.fixed)
landmarks_moving_nda = dr.DataReader.read_landmarks(args.moving)
if args.pca:
ph.print_subtitle("Use PCA to initialize registrations")
pca_fixed = pca.PrincipalComponentAnalysis(landmarks_fixed_nda)
pca_fixed.run()
eigvec_fixed = pca_fixed.get_eigvec()
mean_fixed = pca_fixed.get_mean()
pca_moving = pca.PrincipalComponentAnalysis(landmarks_moving_nda)
pca_moving.run()
eigvec_moving = pca_moving.get_eigvec()
mean_moving = pca_moving.get_mean()
# test different initializations based on eigenvector orientations
orientations = [
[1, 1],
[1, -1],
[-1, 1],
[-1, -1],
]
error = np.inf
for i_o, orientation in enumerate(orientations):
eigvec_moving_o = np.array(eigvec_moving)
eigvec_moving_o[:, 0] *= orientation[0]
eigvec_moving_o[:, 1] *= orientation[1]
# get right-handed coordinate system
cross = np.cross(eigvec_moving_o[:, 0], eigvec_moving_o[:, 1])
eigvec_moving_o[:, 2] = cross
# transformation to align fixed with moving eigenbasis
R = eigvec_moving_o.dot(eigvec_fixed.transpose())
t = mean_moving - R.dot(mean_fixed)
ph.print_info(
"Registration based on PCA eigenvector initialization "
"%d/%d ... " % (i_o + 1, len(orientations)),
newline=False)
reg = pycpd.rigid_registration(
**{
"Y": landmarks_fixed_nda,
"X": landmarks_moving_nda,
"max_iterations": 100,
"R": R,
"t": t,
})
reg.register()
params = reg.get_registration_parameters()
scale, R, t = params
error_o = reg.err
print("done. Error: %.2f" % error_o)
if error_o < error:
error = error_o
rotation_matrix_nda = np.array(R)
translation_nda = np.array(t)
ph.print_info("Currently best estimate")
else:
reg = pycpd.rigid_registration(
**{
"Y": landmarks_fixed_nda,
"X": landmarks_moving_nda,
"max_iterations": 100,
})
if args.verbose:
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
callback = partial(visualize, ax=ax)
else:
callback = None
ph.print_info("Registration ... ", newline=False)
reg.register(callback)
if args.verbose:
plt.show(block=False)
# reg.register()
scale, R, t = reg.get_registration_parameters()
rotation_matrix_nda = R
translation_nda = t
print("done. Error: %.2f" % reg.err)
rigid_transform_sitk = sitk.Euler3DTransform()
rigid_transform_sitk.SetMatrix(rotation_matrix_nda.flatten())
rigid_transform_sitk.SetTranslation(translation_nda)
dw.DataWriter.write_transform(rigid_transform_sitk,
args.output,
verbose=True)
elapsed_time_total = ph.stop_timing(time_start)
ph.print_info("Computational Time: %s" % elapsed_time_total)
return 0
def _run(self):
ph.print_title("Slice-to-Volume Registration")
self._registration_method.set_moving(self._reference)
for i, stack in enumerate(self._stacks):
slices = stack.get_slices()
transforms_sitk = {}
for j, slice_j in enumerate(slices):
txt = "%sSlice-to-Volume Registration -- " \
"Stack %d/%d (%s) -- Slice %d/%d" % (
self._print_prefix,
i + 1, len(self._stacks), stack.get_filename(),
j + 1, len(slices))
if self._verbose:
ph.print_subtitle(txt)
else:
ph.print_info(txt)
self._registration_method.set_fixed(slice_j)
self._registration_method.run()
# Store information on registration transform
transform_sitk = \
self._registration_method.get_registration_transform_sitk()
transforms_sitk[slice_j.get_slice_number()] = transform_sitk
# Avoid slice misregistrations
if self._s2v_smoothing is not None:
# import os
# for slice_number in transforms_sitk.keys():
# path_to_file = os.path.join(
# "/tmp/fetal_brain", "%s_slice%d.tfm" % (
# stack.get_filename(), slice_number))
# sitk.WriteTransform(
# transforms_sitk[slice_number], path_to_file)
ph.print_subtitle("Robust slice motion estimation "
"(GP smoothing = %g, interleave = %d)" %
(self._s2v_smoothing, self._interleave))
robust_motion_estimator = rme.RobustMotionEstimator(
transforms_sitk=transforms_sitk,
interleave=self._interleave)
robust_motion_estimator.run(self._s2v_smoothing)
transforms_sitk = \
robust_motion_estimator.get_robust_transforms_sitk()
# Update position of slice
for slice in slices:
slice_number = slice.get_slice_number()
slice.update_motion_correction(
transforms_sitk[slice_number])
# Run s2v-reg again
for j, slice_j in enumerate(slices):
txt = "%sSlice-to-Volume Registration -- " \
"Stack %d/%d -- Slice %d/%d (after GP init)" % (
self._print_prefix,
i + 1, len(self._stacks),
j + 1, len(slices))
if self._verbose:
ph.print_subtitle(txt)
else:
ph.print_info(txt)
self._registration_method.set_fixed(slice_j)
self._registration_method.run()
# Store information on registration transform
transform_sitk = \
self._registration_method.get_registration_transform_sitk()
transforms_sitk[
slice_j.get_slice_number()] = transform_sitk
# Export figures
# title = "%s_Stack%d%s" % (
# self._print_prefix, i, stack.get_filename())
# title = ph.replace_string_for_print(title)
# robust_motion_estimator.show_estimated_transform_parameters(
# dir_output="/tmp/fetal_brain/figs", title=title)
# dir_output = "/tmp/fetal/figs"
# motion_evaluator = me.MotionEvaluator(transforms_sitk)
# motion_evaluator.run()
# motion_evaluator.display(dir_output=dir_output, title=title)
# motion_evaluator.show(dir_output=dir_output, title=title)
# Update position of slice
for slice in slices:
slice_number = slice.get_slice_number()
slice.update_motion_correction(transforms_sitk[slice_number])
def main():
time_start = ph.start_timing()
flag_individual_cases_only = 1
flag_batch_script = 0
batch_ctr = [32]
flag_correct_bias_field = 0
# flag_correct_intensities = 0
flag_collect_segmentations = 0
flag_select_images_segmentations = 0
flag_reconstruct_volume_subject_space = 0
flag_reconstruct_volume_subject_space_irtk = 0
flag_reconstruct_volume_subject_space_show_comparison = 0
flag_register_to_template = 0
flag_register_to_template_irtk = 0
flag_show_srr_template_space = 0
flag_reconstruct_volume_template_space = 0
flag_collect_volumetric_reconstruction_results = 0
flag_show_volumetric_reconstruction_results = 0
flag_rsync_stuff = 0
# Analysis
flag_remove_failed_cases_for_analysis = 1
flag_postop = 2 # 0... preop, 1...postop, 2... pre+postop
flag_evaluate_image_similarities = 0
flag_analyse_image_similarities = 1
flag_evaluate_slice_residual_similarities = 0
flag_analyse_slice_residual_similarities = 0
flag_analyse_stacks = 0
flag_analyse_qualitative_assessment = 0
flag_collect_data_blinded_analysis = 0
flag_anonymize_data_blinded_analysis = 0
provide_comparison = 0
intensity_correction = 1
isotropic_resolution = 0.75
alpha = 0.02
outlier_rejection = 1
threshold = 0.7
threshold_first = 0.6
# metric = "ANTSNeighborhoodCorrelation"
# metric_radius = 5
# multiresolution = 0
prefix_srr = "srr_"
prefix_srr_qa = "masked_"
# ----------------------------------Set Up---------------------------------
if flag_correct_bias_field:
dir_batch = os.path.join(utils.DIR_BATCH_ROOT, "BiasFieldCorrection")
elif flag_reconstruct_volume_subject_space:
dir_batch = os.path.join(utils.DIR_BATCH_ROOT,
"VolumetricReconstructionSubjectSpace")
elif flag_register_to_template:
dir_batch = os.path.join(utils.DIR_BATCH_ROOT,
"VolumetricReconstructionRegisterToTemplate")
elif flag_reconstruct_volume_template_space:
dir_batch = os.path.join(utils.DIR_BATCH_ROOT,
"VolumetricReconstructionTemplateSpace")
else:
dir_batch = os.path.join(utils.DIR_BATCH_ROOT, "foo")
file_prefix_batch = os.path.join(dir_batch, "command")
if flag_batch_script:
verbose = 0
else:
verbose = 1
data_reader = dr.ExcelSheetDataReader(utils.EXCEL_FILE)
data_reader.read_data()
cases = data_reader.get_data()
if flag_analyse_qualitative_assessment:
data_reader = dr.ExcelSheetQualitativeAssessmentReader(utils.QA_FILE)
data_reader.read_data()
qualitative_assessment = data_reader.get_data()
statistical_evaluation = se.StatisticalEvaluation(
qualitative_assessment)
statistical_evaluation.run_tests(ref="seg_manual")
ph.exit()
cases_similarities = []
cases_stacks = []
if flag_individual_cases_only:
N_cases = len(INDIVIDUAL_CASE_IDS)
else:
N_cases = len(cases.keys())
i_case = 0
for case_id in sorted(cases.keys()):
if flag_individual_cases_only and case_id not in INDIVIDUAL_CASE_IDS:
continue
if not flag_analyse_image_similarities and \
not flag_analyse_slice_residual_similarities:
i_case += 1
ph.print_title("%d/%d: %s" % (i_case, N_cases, case_id))
if flag_rsync_stuff:
dir_output = utils.get_directory_case_recon_seg_mode(
case_id=case_id, recon_space="template_space", seg_mode="")
dir_input = re.sub("Volumes/spina/",
"Volumes/medic-volumetric_res/SpinaBifida/",
dir_output)
cmd = "rsync -avuhn --exclude 'motion_correction' %sseg_manual %s" % (
dir_input, dir_output)
ph.print_execution(cmd)
# ph.execute_command(cmd)
# -------------------------Correct Bias Field--------------------------
if flag_correct_bias_field:
filenames = utils.get_filenames_preprocessing_bias_field(case_id)
paths_to_filenames = [
os.path.join(utils.get_directory_case_original(case_id), f)
for f in filenames
]
dir_output = utils.get_directory_case_preprocessing(
case_id, stage="01_N4ITK")
# no image found matching the pattern
if len(paths_to_filenames) == 0:
continue
cmd_args = []
cmd_args.append("--filenames %s" % " ".join(paths_to_filenames))
cmd_args.append("--dir-output %s" % dir_output)
cmd_args.append("--prefix-output ''")
cmd = "niftymic_correct_bias_field %s" % (" ").join(cmd_args)
ph.execute_command(cmd,
flag_print_to_file=flag_batch_script,
path_to_file="%s%d.txt" %
(file_prefix_batch, ph.add_one(batch_ctr)))
# # Skip case in case segmentations have not been provided yet
# if not ph.directory_exists(utils.get_directory_case_segmentation(
# case_id, utils.SEGMENTATION_INIT, SEG_MODES[0])):
# continue
# ------------------------Collect Segmentations------------------------
if flag_collect_segmentations:
# Skip case in case segmentations have been collected already
if ph.directory_exists(
utils.get_directory_case_segmentation(
case_id, utils.SEGMENTATION_SELECTED, SEG_MODES[0])):
ph.print_info("skipped")
continue
filenames = utils.get_segmented_image_filenames(
case_id, subfolder=utils.SEGMENTATION_INIT)
for i_seg_mode, seg_mode in enumerate(SEG_MODES):
directory_selected = utils.get_directory_case_segmentation(
case_id, utils.SEGMENTATION_SELECTED, seg_mode)
ph.create_directory(directory_selected)
paths_to_filenames_init = [
os.path.join(
utils.get_directory_case_segmentation(
case_id, utils.SEGMENTATION_INIT, seg_mode), f)
for f in filenames
]
paths_to_filenames_selected = [
os.path.join(directory_selected, f) for f in filenames
]
for i in range(len(filenames)):
cmd = "cp -p %s %s" % (paths_to_filenames_init[i],
paths_to_filenames_selected[i])
# ph.print_execution(cmd)
ph.execute_command(cmd)
if flag_select_images_segmentations:
filenames = utils.get_segmented_image_filenames(
case_id, subfolder=utils.SEGMENTATION_SELECTED)
paths_to_filenames = [
os.path.join(
utils.get_directory_case_preprocessing(case_id,
stage="01_N4ITK"),
f) for f in filenames
]
paths_to_filenames_masks = [
os.path.join(
utils.get_directory_case_segmentation(
case_id, utils.SEGMENTATION_SELECTED, "seg_manual"), f)
for f in filenames
]
for i in range(len(filenames)):
ph.show_niftis(
[paths_to_filenames[i]],
segmentation=paths_to_filenames_masks[i],
# viewer="fsleyes",
)
ph.pause()
ph.killall_itksnap()
# # -------------------------Correct Intensities-----------------------
# if flag_correct_intensities:
# filenames = utils.get_segmented_image_filenames(case_id)
# paths_to_filenames_bias = [os.path.join(
# utils.get_directory_case_preprocessing(
# case_id, stage="01_N4ITK"), f) for f in filenames]
# print paths_to_filenames_bias
# -----------------Reconstruct Volume in Subject Space-----------------
if flag_reconstruct_volume_subject_space:
filenames = utils.get_segmented_image_filenames(
case_id, subfolder=utils.SEGMENTATION_SELECTED)
# filenames = filenames[0:2]
paths_to_filenames = [
os.path.join(
utils.get_directory_case_preprocessing(case_id,
stage="01_N4ITK"),
f) for f in filenames
]
# Estimate target stack
target_stack_index = utils.get_target_stack_index(
case_id, utils.SEGMENTATION_SELECTED, "seg_auto", filenames)
for i, seg_mode in enumerate(SEG_MODES):
# Get mask filenames
paths_to_filenames_masks = [
os.path.join(
utils.get_directory_case_segmentation(
case_id, utils.SEGMENTATION_SELECTED, seg_mode), f)
for f in filenames
]
if flag_reconstruct_volume_subject_space_irtk:
if seg_mode != "seg_manual":
continue
utils.export_irtk_call_to_workstation(
case_id=case_id,
filenames=filenames,
seg_mode=seg_mode,
isotropic_resolution=isotropic_resolution,
target_stack_index=target_stack_index,
kernel_mask_dilation=(15, 15, 4))
else:
dir_output = utils.get_directory_case_recon_seg_mode(
case_id=case_id,
recon_space="subject_space",
seg_mode=seg_mode)
# dir_output = "/tmp/foo"
cmd_args = []
cmd_args.append("--filenames %s" %
" ".join(paths_to_filenames))
cmd_args.append("--filenames-masks %s" %
" ".join(paths_to_filenames_masks))
cmd_args.append("--dir-output %s" % dir_output)
cmd_args.append("--use-masks-srr 0")
cmd_args.append("--isotropic-resolution %f" %
isotropic_resolution)
cmd_args.append("--target-stack-index %d" %
target_stack_index)
cmd_args.append("--intensity-correction %d" %
intensity_correction)
cmd_args.append("--outlier-rejection %d" %
outlier_rejection)
cmd_args.append("--threshold-first %f" % threshold_first)
cmd_args.append("--threshold %f" % threshold)
# cmd_args.append("--metric %s" % metric)
# cmd_args.append("--multiresolution %d" % multiresolution)
# cmd_args.append("--metric-radius %s" % metric_radius)
# if i > 0:
# cmd_args.append("--reconstruction-space %s" % (
# utils.get_path_to_recon(
# utils.get_directory_case_recon_seg_mode(
# case_id, "seg_manual"))))
# cmd_args.append("--two-step-cycles 0")
cmd_args.append("--verbose %d" % verbose)
cmd_args.append("--provide-comparison %d" %
provide_comparison)
# cmd_args.append("--iter-max 1")
cmd = "niftymic_reconstruct_volume %s" % (
" ").join(cmd_args)
ph.execute_command(
cmd,
flag_print_to_file=flag_batch_script,
path_to_file="%s%d.txt" %
(file_prefix_batch, ph.add_one(batch_ctr)))
if flag_reconstruct_volume_subject_space_show_comparison:
recon_paths = []
for seg_mode in SEG_MODES:
path_to_recon = utils.get_path_to_recon(
utils.get_directory_case_recon_seg_mode(
case_id=case_id,
recon_space="subject_space",
seg_mode=seg_mode))
recon_paths.append(path_to_recon)
recon_path_irtk = os.path.join(
utils.get_directory_case_recon_seg_mode(
case_id=case_id,
recon_space="subject_space",
seg_mode="IRTK"), "IRTK_SRR.nii.gz")
show_modes = list(SEG_MODES)
if ph.file_exists(recon_path_irtk):
recon_paths.append(recon_path_irtk)
show_modes.append("irtk")
ph.show_niftis(recon_paths)
ph.print_info("Sequence: %s" % (" -- ").join(show_modes))
ph.pause()
ph.killall_itksnap()
# -------------------------Register to template------------------------
if flag_register_to_template:
for seg_mode in SEG_MODES:
cmd_args = []
# register seg_auto-recon to template space
if seg_mode == "seg_auto":
path_to_recon = utils.get_path_to_recon(
utils.get_directory_case_recon_seg_mode(
case_id=case_id,
recon_space="subject_space",
seg_mode=seg_mode))
template_stack_estimator = \
tse.TemplateStackEstimator.from_mask(
ph.append_to_filename(path_to_recon, "_mask"))
path_to_reference = \
template_stack_estimator.get_path_to_template()
dir_input_motion_correction = os.path.join(
utils.get_directory_case_recon_seg_mode(
case_id=case_id,
recon_space="subject_space",
seg_mode=seg_mode), "motion_correction")
dir_output = utils.get_directory_case_recon_seg_mode(
case_id=case_id,
recon_space="template_space",
seg_mode=seg_mode)
# dir_output = "/home/mebner/tmp"
# # ------- DELETE -----
# dir_output = re.sub("data", "foo+1", dir_output)
# dir_output = re.sub(
# "volumetric_reconstruction/20180126/template_space/seg_auto",
# "", dir_output)
# # -------
# cmd_args.append("--use-fixed-mask 1")
cmd_args.append("--use-moving-mask 1")
# HACK
path_to_initial_transform = os.path.join(
utils.DIR_INPUT_ROOT_DATA, case_id,
"volumetric_reconstruction", "20180126",
"template_space", "seg_manual",
"registration_transform_sitk.txt")
cmd_args.append("--initial-transform %s" %
path_to_initial_transform)
cmd_args.append("--use-flirt 0")
cmd_args.append("--use-regaladin 1")
cmd_args.append("--test-ap-flip 0")
# register remaining recons to registered seg_auto-recon
else:
path_to_reference = utils.get_path_to_recon(
utils.get_directory_case_recon_seg_mode(
case_id=case_id,
recon_space="template_space",
seg_mode="seg_auto"),
suffix="ResamplingToTemplateSpace",
)
path_to_initial_transform = os.path.join(
utils.get_directory_case_recon_seg_mode(
case_id=case_id,
recon_space="template_space",
seg_mode="seg_auto"),
"registration_transform_sitk.txt")
path_to_recon = utils.get_path_to_recon(
utils.get_directory_case_recon_seg_mode(
case_id=case_id,
recon_space="subject_space",
seg_mode=seg_mode))
dir_input_motion_correction = os.path.join(
utils.get_directory_case_recon_seg_mode(
case_id=case_id,
recon_space="subject_space",
seg_mode=seg_mode), "motion_correction")
dir_output = utils.get_directory_case_recon_seg_mode(
case_id=case_id,
recon_space="template_space",
seg_mode=seg_mode)
cmd_args.append("--use-fixed-mask 0")
cmd_args.append("--use-moving-mask 0")
cmd_args.append("--initial-transform %s" %
path_to_initial_transform)
cmd_args.append("--use-flirt 0")
cmd_args.append("--use-regaladin 1")
cmd_args.append("--test-ap-flip 0")
cmd_args.append("--moving %s" % path_to_recon)
cmd_args.append("--fixed %s" % path_to_reference)
cmd_args.append("--dir-input %s" % dir_input_motion_correction)
cmd_args.append("--dir-output %s" % dir_output)
cmd_args.append("--write-transform 1")
cmd_args.append("--verbose %d" % verbose)
cmd = "niftymic_register_image %s" % (" ").join(cmd_args)
ph.execute_command(cmd,
flag_print_to_file=flag_batch_script,
path_to_file="%s%d.txt" %
(file_prefix_batch, ph.add_one(batch_ctr)))
if flag_register_to_template_irtk:
dir_input = utils.get_directory_case_recon_seg_mode(
case_id=case_id, recon_space="subject_space", seg_mode="IRTK")
dir_output = utils.get_directory_case_recon_seg_mode(
case_id=case_id, recon_space="template_space", seg_mode="IRTK")
path_to_recon = os.path.join(dir_input, "IRTK_SRR.nii.gz")
path_to_reference = utils.get_path_to_recon(
utils.get_directory_case_recon_seg_mode(
case_id=case_id,
recon_space="template_space",
seg_mode="seg_manual"),
suffix="ResamplingToTemplateSpace",
)
path_to_initial_transform = os.path.join(
utils.get_directory_case_recon_seg_mode(
case_id=case_id,
recon_space="template_space",
seg_mode="seg_manual"), "registration_transform_sitk.txt")
cmd_args = []
cmd_args.append("--fixed %s" % path_to_reference)
cmd_args.append("--moving %s" % path_to_recon)
cmd_args.append("--initial-transform %s" %
path_to_initial_transform)
cmd_args.append("--use-fixed-mask 0")
cmd_args.append("--use-moving-mask 0")
cmd_args.append("--use-flirt 0")
cmd_args.append("--use-regaladin 1")
cmd_args.append("--test-ap-flip 0")
cmd_args.append("--dir-output %s" % dir_output)
cmd_args.append("--verbose %d" % verbose)
cmd = "niftymic_register_image %s" % (" ").join(cmd_args)
ph.execute_command(cmd)
if flag_show_srr_template_space:
recon_paths = []
show_modes = list(SEG_MODES)
# show_modes.append("IRTK")
for seg_mode in show_modes:
dir_input = utils.get_directory_case_recon_seg_mode(
case_id=case_id,
recon_space="template_space",
seg_mode=seg_mode)
# # ------- DELETE -----
# dir_input = re.sub("data", "foo+1", dir_input)
# dir_input = re.sub(
# "volumetric_reconstruction/20180126/template_space/seg_auto",
# "", dir_input)
# # -------
path_to_recon_space = utils.get_path_to_recon(
dir_input,
suffix="ResamplingToTemplateSpace",
)
recon_paths.append(path_to_recon_space)
ph.show_niftis(recon_paths)
ph.print_info("Sequence: %s" % (" -- ").join(show_modes))
ph.pause()
ph.killall_itksnap()
# -----------------Reconstruct Volume in Template Space----------------
if flag_reconstruct_volume_template_space:
for seg_mode in SEG_MODES:
path_to_recon_space = utils.get_path_to_recon(
utils.get_directory_case_recon_seg_mode(
case_id=case_id,
recon_space="template_space",
seg_mode=seg_mode),
suffix="ResamplingToTemplateSpace",
)
dir_input = os.path.join(
utils.get_directory_case_recon_seg_mode(
case_id=case_id,
recon_space="template_space",
seg_mode=seg_mode), "motion_correction")
dir_output = utils.get_directory_case_recon_seg_mode(
case_id=case_id,
recon_space="template_space",
seg_mode=seg_mode)
# dir_output = os.path.join("/tmp/spina/template_space/%s-%s" % (
# case_id, seg_mode))
cmd_args = []
cmd_args.append("--dir-input %s" % dir_input)
cmd_args.append("--dir-output %s" % dir_output)
cmd_args.append("--reconstruction-space %s" %
path_to_recon_space)
cmd_args.append("--alpha %s" % alpha)
cmd_args.append("--verbose %s" % verbose)
cmd_args.append("--use-masks-srr 0")
# cmd_args.append("--minimizer L-BFGS-B")
# cmd_args.append("--alpha 0.006")
# cmd_args.append("--reconstruction-type HuberL2")
# cmd_args.append("--data-loss arctan")
# cmd_args.append("--iterations 5")
# cmd_args.append("--data-loss-scale 0.7")
cmd = "niftymic_reconstruct_volume_from_slices %s" % \
(" ").join(cmd_args)
ph.execute_command(cmd,
flag_print_to_file=flag_batch_script,
path_to_file="%s%d.txt" %
(file_prefix_batch, ph.add_one(batch_ctr)))
# ----------------Collect SRR results in Template Space----------------
if flag_collect_volumetric_reconstruction_results:
directory = utils.get_directory_case_recon_summary(case_id)
ph.create_directory(directory)
# clear potentially existing files
cmd = "rm -f %s/*.nii.gz" % (directory)
ph.execute_command(cmd)
# Collect SRRs
for seg_mode in SEG_MODES:
path_to_recon_src = utils.get_path_to_recon(
utils.get_directory_case_recon_seg_mode(
case_id=case_id,
recon_space="template_space",
seg_mode=seg_mode), )
path_to_recon = os.path.join(
directory, "%s%s.nii.gz" % (prefix_srr, seg_mode))
cmd = "cp -p %s %s" % (path_to_recon_src, path_to_recon)
ph.execute_command(cmd)
# Collect IRTK recon
path_to_recon_src = os.path.join(
utils.get_directory_case_recon_seg_mode(
case_id=case_id,
recon_space="template_space",
seg_mode="IRTK"),
"IRTK_SRR_LinearResamplingToTemplateSpace.nii.gz")
path_to_recon = os.path.join(directory,
"%s%s.nii.gz" % (prefix_srr, "irtk"))
cmd = "cp -p %s %s" % (path_to_recon_src, path_to_recon)
ph.execute_command(cmd)
# Collect evaluation mask
path_to_recon = utils.get_path_to_recon(
utils.get_directory_case_recon_seg_mode(
case_id=case_id,
recon_space="subject_space",
seg_mode="seg_auto"))
template_stack_estimator = \
tse.TemplateStackEstimator.from_mask(
ph.append_to_filename(path_to_recon, "_mask"))
path_to_template = \
template_stack_estimator.get_path_to_template()
path_to_template_mask_src = ph.append_to_filename(
path_to_template, "_mask_dil")
path_to_template_mask = "%s/" % directory
cmd = "cp -p %s %s" % (path_to_template_mask_src,
path_to_template_mask)
ph.execute_command(cmd)
if flag_show_volumetric_reconstruction_results:
dir_output = utils.get_directory_case_recon_summary(case_id)
paths_to_recons = []
for seg_mode in RECON_MODES:
path_to_recon = os.path.join(
dir_output, "%s%s.nii.gz" % (prefix_srr, seg_mode))
paths_to_recons.append(path_to_recon)
path_to_mask = "%s/STA*.nii.gz" % dir_output
cmd = ph.show_niftis(paths_to_recons, segmentation=path_to_mask)
sitkh.write_executable_file([cmd], dir_output=dir_output)
ph.pause()
ph.killall_itksnap()
# ---------------------Evaluate Image Similarities---------------------
if flag_evaluate_image_similarities:
dir_input = utils.get_directory_case_recon_summary(case_id)
dir_output = utils.get_directory_case_recon_similarities(case_id)
paths_to_recons = []
for seg_mode in ["seg_auto", "detect", "irtk"]:
path_to_recon = os.path.join(
dir_input, "%s%s.nii.gz" % (prefix_srr, seg_mode))
paths_to_recons.append(path_to_recon)
path_to_reference = os.path.join(
dir_input, "%s%s.nii.gz" % (prefix_srr, "seg_manual"))
path_to_reference_mask = utils.get_path_to_mask(dir_input)
cmd_args = []
cmd_args.append("--filenames %s" % " ".join(paths_to_recons))
cmd_args.append("--reference %s" % path_to_reference)
cmd_args.append("--reference-mask %s" % path_to_reference_mask)
# cmd_args.append("--verbose 1")
cmd_args.append("--dir-output %s" % dir_output)
exe = re.sub("pyc", "py",
os.path.abspath(evaluate_image_similarity.__file__))
cmd_args.insert(0, exe)
# clear potentially existing files
cmd = "rm -f %s/*.txt" % (dir_output)
ph.execute_command(cmd)
cmd = "python %s" % " ".join(cmd_args)
ph.execute_command(cmd)
# -----------------Evaluate Slice Residual Similarities----------------
if flag_evaluate_slice_residual_similarities:
path_to_reference_mask = utils.get_path_to_mask(
utils.get_directory_case_recon_summary(case_id))
dir_output_root = \
utils.get_directory_case_slice_residual_similarities(case_id)
# clear potentially existing files
# cmd = "rm -f %s/*.txt" % (dir_output_root)
# ph.execute_command(cmd)
for seg_mode in SEG_MODES:
dir_input = os.path.join(
utils.get_directory_case_recon_seg_mode(
case_id=case_id,
recon_space="template_space",
seg_mode=seg_mode,
), "motion_correction")
path_to_reference = os.path.join(
utils.get_directory_case_recon_summary(case_id),
"%s%s.nii.gz" % (prefix_srr, seg_mode))
dir_output = os.path.join(dir_output_root, seg_mode)
cmd_args = []
cmd_args.append("--dir-input %s" % dir_input)
cmd_args.append("--reference %s" % path_to_reference)
cmd_args.append("--reference-mask %s" % path_to_reference_mask)
cmd_args.append("--use-reference-mask 1")
cmd_args.append("--use-slice-masks 0")
# cmd_args.append("--verbose 1")
cmd_args.append("--dir-output %s" % dir_output)
exe = re.sub("pyc", "py", os.path.abspath(esrs.__file__))
cmd_args.insert(0, exe)
cmd = "python %s" % " ".join(cmd_args)
ph.execute_command(cmd)
# Collect data for blinded analysis
if flag_collect_data_blinded_analysis:
if flag_remove_failed_cases_for_analysis and case_id in RECON_FAILED_CASE_IDS:
continue
dir_input = utils.get_directory_case_recon_summary(case_id)
# pattern = "STA([0-9]+)[_]mask.nii.gz"
pattern = "STA([0-9]+)[_]mask_dil.nii.gz"
p = re.compile(pattern)
gw = [
p.match(f).group(1) for f in os.listdir(dir_input)
if p.match(f)
][0]
dir_output = os.path.join(
utils.get_directory_blinded_analysis(case_id, "open"), case_id)
exe = re.sub("pyc", "py", os.path.abspath(mswm.__file__))
recons = []
for seg_mode in RECON_MODES:
path_to_recon = os.path.join(
dir_input, "%s%s.nii.gz" % (prefix_srr, seg_mode))
cmd_args = []
cmd_args.append("--filename %s" % path_to_recon)
cmd_args.append("--gestational-age %s" % gw)
cmd_args.append("--dir-output %s" % dir_output)
cmd_args.append("--prefix-output %s" % prefix_srr_qa)
cmd_args.append("--verbose 0")
cmd_args.insert(0, exe)
cmd = "python %s" % " ".join(cmd_args)
# ph.execute_command(cmd)
recon = "%s%s" % (prefix_srr_qa,
os.path.basename(path_to_recon))
recons.append(recon)
ph.write_show_niftis_exe(recons, dir_output)
if flag_anonymize_data_blinded_analysis:
dir_input = os.path.join(
utils.get_directory_blinded_analysis(case_id, "open"), case_id)
dir_output_dictionaries = utils.get_directory_anonymized_dictionares(
case_id)
dir_output_anonymized_images = os.path.join(
utils.get_directory_blinded_analysis(case_id, "anonymized"),
case_id)
if not ph.directory_exists(dir_input):
continue
ph.create_directory(dir_output_dictionaries)
ph.create_directory(dir_output_anonymized_images)
data_anonymizer = da.DataAnonymizer()
# Create random dictionary (only required once)
# data_anonymizer.set_prefix_identifiers("%s_" % case_id)
# data_anonymizer.read_nifti_filenames_from_directory(dir_input)
# data_anonymizer.generate_identifiers()
# data_anonymizer.generate_randomized_dictionary()
# data_anonymizer.write_dictionary(
# dir_output_dictionaries, "dictionary_%s" % case_id)
# Read dictionary
data_anonymizer.read_dictionary(dir_output_dictionaries,
"dictionary_%s" % case_id)
# Anonymize files
if 0:
ph.clear_directory(dir_output_anonymized_images)
data_anonymizer.anonymize_files(dir_input,
dir_output_anonymized_images)
# Write executable script
filenames = [
"%s.nii.gz" % f
for f in sorted(data_anonymizer.get_identifiers())
]
ph.write_show_niftis_exe(filenames,
dir_output_anonymized_images)
# Reveal anonymized files
if 1:
filenames = data_anonymizer.reveal_anonymized_files(
dir_output_anonymized_images)
filenames = sorted(["%s" % f for f in filenames])
ph.write_show_niftis_exe(filenames,
dir_output_anonymized_images)
# Reveal additional, original files
# data_anonymizer.reveal_original_files(dir_output)
# relative_directory = re.sub(
# utils.get_directory_blinded_analysis(case_id, "anonymized"),
# ".",
# dir_output_anonymized_images)
# paths_to_filenames = [os.path.join(
# relative_directory, f) for f in filenames]
# ---------------------Analyse Image Similarities---------------------
if flag_analyse_image_similarities or \
flag_analyse_slice_residual_similarities or \
flag_analyse_stacks:
if flag_remove_failed_cases_for_analysis:
if case_id in RECON_FAILED_CASE_IDS:
continue
if cases[case_id]['postrep'] == flag_postop or flag_postop == 2:
cases_similarities.append(case_id)
cases_stacks.append(
utils.get_segmented_image_filenames(
case_id,
# subfolder=utils.SEGMENTATION_INIT,
subfolder=utils.SEGMENTATION_SELECTED,
))
dir_output_analysis = os.path.join(
# "/Users/mebner/UCL/UCL/Publications",
"/home/mebner/Dropbox/UCL/Publications",
"2018_MICCAI/brain_reconstruction_paper")
if flag_analyse_image_similarities:
dir_inputs = []
filename = "image_similarities_postop%d.txt" % flag_postop
for case_id in cases_similarities:
dir_inputs.append(
utils.get_directory_case_recon_similarities(case_id))
cmd_args = []
cmd_args.append("--dir-inputs %s" % " ".join(dir_inputs))
cmd_args.append("--dir-output %s" % dir_output_analysis)
cmd_args.append("--filename %s" % filename)
exe = re.sub("pyc", "py",
os.path.abspath(src.analyse_image_similarities.__file__))
cmd_args.insert(0, exe)
cmd = "python %s" % " ".join(cmd_args)
ph.execute_command(cmd)
if flag_analyse_slice_residual_similarities:
dir_inputs = []
filename = "slice_residuals_postop%d.txt" % flag_postop
for case_id in cases_similarities:
dir_inputs.append(
utils.get_directory_case_slice_residual_similarities(case_id))
cmd_args = []
cmd_args.append("--dir-inputs %s" % " ".join(dir_inputs))
cmd_args.append("--subfolder %s" % " ".join(SEG_MODES))
cmd_args.append("--dir-output %s" % dir_output_analysis)
cmd_args.append("--filename %s" % filename)
exe = re.sub(
"pyc", "py",
os.path.abspath(src.analyse_slice_residual_similarities.__file__))
cmd_args.insert(0, exe)
cmd = "python %s" % " ".join(cmd_args)
# print len(cases_similarities)
# print cases_similarities
ph.execute_command(cmd)
if flag_analyse_stacks:
cases_stacks_N = [len(s) for s in cases_stacks]
ph.print_subtitle("%d cases -- Number of stacks" % len(cases_stacks))
ph.print_info("min: %g" % np.min(cases_stacks_N))
ph.print_info("mean: %g" % np.mean(cases_stacks_N))
ph.print_info("median: %g" % np.median(cases_stacks_N))
ph.print_info("max: %g" % np.max(cases_stacks_N))
elapsed_time = ph.stop_timing(time_start)
ph.print_title("Summary")
print("Computational Time for Pipeline: %s" % (elapsed_time))
return 0
def main():
time_start = ph.start_timing()
# Set print options for numpy
np.set_printoptions(precision=3)
input_parser = InputArgparser(
description="Volumetric MRI reconstruction framework to reconstruct "
"an isotropic, high-resolution 3D volume from multiple stacks of 2D "
"slices with motion correction. The resolution of the computed "
"Super-Resolution Reconstruction (SRR) is given by the in-plane "
"spacing of the selected target stack. A region of interest can be "
"specified by providing a mask for the selected target stack. Only "
"this region will then be reconstructed by the SRR algorithm which "
"can substantially reduce the computational time.",
)
input_parser.add_filenames(required=True)
input_parser.add_filenames_masks()
input_parser.add_output(required=True)
input_parser.add_suffix_mask(default="_mask")
input_parser.add_target_stack(default=None)
input_parser.add_search_angle(default=45)
input_parser.add_multiresolution(default=0)
input_parser.add_shrink_factors(default=[3, 2, 1])
input_parser.add_smoothing_sigmas(default=[1.5, 1, 0])
input_parser.add_sigma(default=1)
input_parser.add_reconstruction_type(default="TK1L2")
input_parser.add_iterations(default=15)
input_parser.add_alpha(default=0.015)
input_parser.add_alpha_first(default=0.2)
input_parser.add_iter_max(default=10)
input_parser.add_iter_max_first(default=5)
input_parser.add_dilation_radius(default=3)
input_parser.add_extra_frame_target(default=10)
input_parser.add_bias_field_correction(default=0)
input_parser.add_intensity_correction(default=1)
input_parser.add_isotropic_resolution(default=1)
input_parser.add_log_config(default=1)
input_parser.add_subfolder_motion_correction()
input_parser.add_write_motion_correction(default=1)
input_parser.add_verbose(default=0)
input_parser.add_two_step_cycles(default=3)
input_parser.add_use_masks_srr(default=0)
input_parser.add_boundary_stacks(default=[10, 10, 0])
input_parser.add_metric(default="Correlation")
input_parser.add_metric_radius(default=10)
input_parser.add_reference()
input_parser.add_reference_mask()
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_interleave(default=3)
input_parser.add_slice_thicknesses(default=None)
input_parser.add_viewer(default="itksnap")
input_parser.add_v2v_method(default="RegAladin")
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_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."
)
input_parser.add_argument(
"--sda", "-sda",
action='store_true',
help="If given, the volumetric reconstructions are performed using "
"Scattered Data Approximation (Vercauteren et al., 2006). "
"'alpha' is considered the final 'sigma' for the "
"iterative adjustment. "
"Recommended value is, e.g., --alpha 0.8"
)
input_parser.add_option(
option_string="--transforms-history",
type=int,
help="Write entire history of applied slice motion correction "
"transformations to motion correction output directory",
default=0,
)
args = input_parser.parse_args()
input_parser.print_arguments(args)
rejection_measure = "NCC"
threshold_v2v = -2 # 0.3
debug = False
if args.v2v_method not in V2V_METHOD_OPTIONS:
raise ValueError("v2v-method must be in {%s}" % (
", ".join(V2V_METHOD_OPTIONS)))
if np.alltrue([not args.output.endswith(t) for t in ALLOWED_EXTENSIONS]):
raise ValueError(
"output filename invalid; allowed extensions are: %s" %
", ".join(ALLOWED_EXTENSIONS))
if args.alpha_first < args.alpha and not args.sda:
raise ValueError("It must hold alpha-first >= alpha")
if args.threshold_first > args.threshold:
raise ValueError("It must hold threshold-first <= threshold")
dir_output = os.path.dirname(args.output)
ph.create_directory(dir_output)
if args.log_config:
input_parser.log_config(os.path.abspath(__file__))
# --------------------------------Read Data--------------------------------
ph.print_title("Read Data")
data_reader = dr.MultipleImagesReader(
file_paths=args.filenames,
file_paths_masks=args.filenames_masks,
suffix_mask=args.suffix_mask,
stacks_slice_thicknesses=args.slice_thicknesses,
)
if len(args.boundary_stacks) is not 3:
raise IOError(
"Provide exactly three values for '--boundary-stacks' to define "
"cropping in i-, j-, and k-dimension of the input stacks")
data_reader.read_data()
stacks = data_reader.get_data()
ph.print_info("%d input stacks read for further processing" % len(stacks))
if all(s.is_unity_mask() is True for s in stacks):
ph.print_warning("No mask is provided! "
"Generated reconstruction space may be very big!")
ph.print_warning("Consider using a mask to speed up computations")
# args.extra_frame_target = 0
# ph.wrint_warning("Overwritten: extra-frame-target set to 0")
# Specify target stack for intensity correction and reconstruction space
if args.target_stack is None:
target_stack_index = 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")
# ---------------------------Data Preprocessing---------------------------
ph.print_title("Data Preprocessing")
segmentation_propagator = segprop.SegmentationPropagation(
# registration_method=regflirt.FLIRT(use_verbose=args.verbose),
# registration_method=niftyreg.RegAladin(use_verbose=False),
dilation_radius=args.dilation_radius,
dilation_kernel="Ball",
)
data_preprocessing = dp.DataPreprocessing(
stacks=stacks,
segmentation_propagator=segmentation_propagator,
use_cropping_to_mask=True,
use_N4BiasFieldCorrector=args.bias_field_correction,
target_stack_index=target_stack_index,
boundary_i=args.boundary_stacks[0],
boundary_j=args.boundary_stacks[1],
boundary_k=args.boundary_stacks[2],
unit="mm",
)
data_preprocessing.run()
time_data_preprocessing = data_preprocessing.get_computational_time()
# Get preprocessed stacks
stacks = data_preprocessing.get_preprocessed_stacks()
# Define reference/target stack for registration and reconstruction
if args.reference is not None:
reference = st.Stack.from_filename(
file_path=args.reference,
file_path_mask=args.reference_mask,
extract_slices=False)
else:
reference = st.Stack.from_stack(stacks[target_stack_index])
# ------------------------Volume-to-Volume Registration--------------------
if len(stacks) > 1:
if args.v2v_method == "FLIRT":
# Define search angle ranges for FLIRT in all three dimensions
search_angles = ["-searchr%s -%d %d" %
(x, args.search_angle, args.search_angle)
for x in ["x", "y", "z"]]
options = (" ").join(search_angles)
# options += " -noresample"
vol_registration = regflirt.FLIRT(
registration_type="Rigid",
use_fixed_mask=True,
use_moving_mask=True,
options=options,
use_verbose=False,
)
else:
vol_registration = niftyreg.RegAladin(
registration_type="Rigid",
use_fixed_mask=True,
use_moving_mask=True,
# options="-ln 2 -voff",
use_verbose=False,
)
v2vreg = pipeline.VolumeToVolumeRegistration(
stacks=stacks,
reference=reference,
registration_method=vol_registration,
verbose=debug,
robust=args.v2v_robust,
)
v2vreg.run()
stacks = v2vreg.get_stacks()
time_registration = v2vreg.get_computational_time()
else:
time_registration = ph.get_zero_time()
# ---------------------------Intensity Correction--------------------------
if args.intensity_correction:
ph.print_title("Intensity Correction")
intensity_corrector = ic.IntensityCorrection()
intensity_corrector.use_individual_slice_correction(False)
intensity_corrector.use_reference_mask(True)
intensity_corrector.use_stack_mask(True)
intensity_corrector.use_verbose(False)
for i, stack in enumerate(stacks):
if i == target_stack_index:
ph.print_info("Stack %d (%s): Reference image. Skipped." % (
i + 1, stack.get_filename()))
continue
else:
ph.print_info("Stack %d (%s): Intensity Correction ... " % (
i + 1, stack.get_filename()), newline=False)
intensity_corrector.set_stack(stack)
intensity_corrector.set_reference(
stacks[target_stack_index].get_resampled_stack(
resampling_grid=stack.sitk,
interpolator="NearestNeighbor",
))
intensity_corrector.run_linear_intensity_correction()
stacks[i] = intensity_corrector.get_intensity_corrected_stack()
print("done (c1 = %g) " %
intensity_corrector.get_intensity_correction_coefficients())
# ---------------------------Create first volume---------------------------
time_tmp = ph.start_timing()
# Isotropic resampling to define HR target space
ph.print_title("Reconstruction Space Generation")
HR_volume = reference.get_isotropically_resampled_stack(
resolution=args.isotropic_resolution)
ph.print_info(
"Isotropic reconstruction space with %g mm resolution is created" %
HR_volume.sitk.GetSpacing()[0])
if args.reference is None:
# Create joint image mask in target space
joint_image_mask_builder = imb.JointImageMaskBuilder(
stacks=stacks,
target=HR_volume,
dilation_radius=1,
)
joint_image_mask_builder.run()
HR_volume = joint_image_mask_builder.get_stack()
ph.print_info(
"Isotropic reconstruction space is centered around "
"joint stack masks. ")
# Crop to space defined by mask (plus extra margin)
HR_volume = HR_volume.get_cropped_stack_based_on_mask(
boundary_i=args.extra_frame_target,
boundary_j=args.extra_frame_target,
boundary_k=args.extra_frame_target,
unit="mm",
)
# Create first volume
# If outlier rejection is activated, eliminate obvious outliers early
# from stack and re-run SDA to get initial volume without them
ph.print_title("First Estimate of HR Volume")
if args.outlier_rejection and threshold_v2v > -1:
ph.print_subtitle("SDA Approximation")
SDA = sda.ScatteredDataApproximation(
stacks, HR_volume, sigma=args.sigma)
SDA.run()
HR_volume = SDA.get_reconstruction()
# Identify and reject outliers
ph.print_subtitle("Eliminate slice outliers (%s < %g)" % (
rejection_measure, threshold_v2v))
outlier_rejector = outre.OutlierRejector(
stacks=stacks,
reference=HR_volume,
threshold=threshold_v2v,
measure=rejection_measure,
verbose=True,
)
outlier_rejector.run()
stacks = outlier_rejector.get_stacks()
ph.print_subtitle("SDA Approximation Image")
SDA = sda.ScatteredDataApproximation(
stacks, HR_volume, sigma=args.sigma)
SDA.run()
HR_volume = SDA.get_reconstruction()
ph.print_subtitle("SDA Approximation Image Mask")
SDA = sda.ScatteredDataApproximation(
stacks, HR_volume, sigma=args.sigma, sda_mask=True)
SDA.run()
# HR volume contains updated mask based on SDA
HR_volume = SDA.get_reconstruction()
HR_volume.set_filename(SDA.get_setting_specific_filename())
time_reconstruction = ph.stop_timing(time_tmp)
if args.verbose:
tmp = list(stacks)
tmp.insert(0, HR_volume)
sitkh.show_stacks(tmp, segmentation=HR_volume, viewer=args.viewer)
# -----------Two-step Slice-to-Volume Registration-Reconstruction----------
if args.two_step_cycles > 0:
# Slice-to-volume registration set-up
if args.metric == "ANTSNeighborhoodCorrelation":
metric_params = {"radius": args.metric_radius}
else:
metric_params = None
registration = regsitk.SimpleItkRegistration(
moving=HR_volume,
use_fixed_mask=True,
use_moving_mask=True,
interpolator="Linear",
metric=args.metric,
metric_params=metric_params,
use_multiresolution_framework=args.multiresolution,
shrink_factors=args.shrink_factors,
smoothing_sigmas=args.smoothing_sigmas,
initializer_type="SelfGEOMETRY",
optimizer="ConjugateGradientLineSearch",
optimizer_params={
"learningRate": 1,
"numberOfIterations": 100,
"lineSearchUpperLimit": 2,
},
scales_estimator="Jacobian",
use_verbose=debug,
)
# Volumetric reconstruction set-up
if args.sda:
recon_method = sda.ScatteredDataApproximation(
stacks,
HR_volume,
sigma=args.sigma,
use_masks=args.use_masks_srr,
)
alpha_range = [args.sigma, args.alpha]
else:
recon_method = tk.TikhonovSolver(
stacks=stacks,
reconstruction=HR_volume,
reg_type="TK1",
minimizer="lsmr",
alpha=args.alpha_first,
iter_max=np.min([args.iter_max_first, args.iter_max]),
verbose=True,
use_masks=args.use_masks_srr,
)
alpha_range = [args.alpha_first, args.alpha]
# Define the regularization parameters for the individual
# reconstruction steps in the two-step cycles
alphas = np.linspace(
alpha_range[0], alpha_range[1], args.two_step_cycles)
# Define outlier rejection threshold after each S2V-reg step
thresholds = np.linspace(
args.threshold_first, args.threshold, args.two_step_cycles)
two_step_s2v_reg_recon = \
pipeline.TwoStepSliceToVolumeRegistrationReconstruction(
stacks=stacks,
reference=HR_volume,
registration_method=registration,
reconstruction_method=recon_method,
cycles=args.two_step_cycles,
alphas=alphas[0:args.two_step_cycles - 1],
outlier_rejection=args.outlier_rejection,
threshold_measure=rejection_measure,
thresholds=thresholds,
interleave=args.interleave,
viewer=args.viewer,
verbose=args.verbose,
use_hierarchical_registration=args.s2v_hierarchical,
)
two_step_s2v_reg_recon.run()
HR_volume_iterations = \
two_step_s2v_reg_recon.get_iterative_reconstructions()
time_registration += \
two_step_s2v_reg_recon.get_computational_time_registration()
time_reconstruction += \
two_step_s2v_reg_recon.get_computational_time_reconstruction()
stacks = two_step_s2v_reg_recon.get_stacks()
# no two-step s2v-registration/reconstruction iterations
else:
HR_volume_iterations = []
# Write motion-correction results
ph.print_title("Write Motion Correction Results")
if args.write_motion_correction:
dir_output_mc = os.path.join(
dir_output, args.subfolder_motion_correction)
ph.clear_directory(dir_output_mc)
for stack in stacks:
stack.write(
dir_output_mc,
write_stack=False,
write_mask=False,
write_slices=False,
write_transforms=True,
write_transforms_history=args.transforms_history,
)
if args.outlier_rejection:
deleted_slices_dic = {}
for i, stack in enumerate(stacks):
deleted_slices = stack.get_deleted_slice_numbers()
deleted_slices_dic[stack.get_filename()] = deleted_slices
# check whether any stack was removed entirely
stacks0 = data_preprocessing.get_preprocessed_stacks()
if len(stacks) != len(stacks0):
stacks_remain = [s.get_filename() for s in stacks]
for stack in stacks0:
if stack.get_filename() in stacks_remain:
continue
# add info that all slices of this stack were rejected
deleted_slices = [
slice.get_slice_number()
for slice in stack.get_slices()
]
deleted_slices_dic[stack.get_filename()] = deleted_slices
ph.print_info(
"All slices of stack '%s' were rejected entirely. "
"Information added." % stack.get_filename())
ph.write_dictionary_to_json(
deleted_slices_dic,
os.path.join(
dir_output,
args.subfolder_motion_correction,
"rejected_slices.json"
)
)
# ---------------------Final Volumetric Reconstruction---------------------
ph.print_title("Final Volumetric Reconstruction")
if args.sda:
recon_method = sda.ScatteredDataApproximation(
stacks,
HR_volume,
sigma=args.alpha,
use_masks=args.use_masks_srr,
)
else:
if args.reconstruction_type in ["TVL2", "HuberL2"]:
recon_method = pd.PrimalDualSolver(
stacks=stacks,
reconstruction=HR_volume,
reg_type="TV" if args.reconstruction_type == "TVL2" else "huber",
iterations=args.iterations,
use_masks=args.use_masks_srr,
)
else:
recon_method = tk.TikhonovSolver(
stacks=stacks,
reconstruction=HR_volume,
reg_type="TK1" if args.reconstruction_type == "TK1L2" else "TK0",
use_masks=args.use_masks_srr,
)
recon_method.set_alpha(args.alpha)
recon_method.set_iter_max(args.iter_max)
recon_method.set_verbose(True)
recon_method.run()
time_reconstruction += recon_method.get_computational_time()
HR_volume_final = recon_method.get_reconstruction()
ph.print_subtitle("Final SDA Approximation Image Mask")
SDA = sda.ScatteredDataApproximation(
stacks, HR_volume_final, sigma=args.sigma, sda_mask=True)
SDA.run()
# HR volume contains updated mask based on SDA
HR_volume_final = SDA.get_reconstruction()
time_reconstruction += SDA.get_computational_time()
elapsed_time_total = ph.stop_timing(time_start)
# Write SRR result
filename = recon_method.get_setting_specific_filename()
HR_volume_final.set_filename(filename)
dw.DataWriter.write_image(
HR_volume_final.sitk,
args.output,
description=filename)
dw.DataWriter.write_mask(
HR_volume_final.sitk_mask,
ph.append_to_filename(args.output, "_mask"),
description=SDA.get_setting_specific_filename())
HR_volume_iterations.insert(0, HR_volume_final)
for stack in stacks:
HR_volume_iterations.append(stack)
if args.verbose:
sitkh.show_stacks(
HR_volume_iterations,
segmentation=HR_volume_final,
viewer=args.viewer,
)
# Summary
ph.print_title("Summary")
exe_file_info = os.path.basename(os.path.abspath(__file__)).split(".")[0]
print("%s | Computational Time for Data Preprocessing: %s" %
(exe_file_info, time_data_preprocessing))
print("%s | Computational Time for Registrations: %s" %
(exe_file_info, time_registration))
print("%s | Computational Time for Reconstructions: %s" %
(exe_file_info, time_reconstruction))
print("%s | Computational Time for Entire Reconstruction Pipeline: %s" %
(exe_file_info, elapsed_time_total))
ph.print_line_separator()
return 0
