def calculate_metrics(self, output_image, bart_test, sample_truth):
cs_psnr = []
cs_nrmse = []
cs_ssim = []
output_psnr = []
output_nrmse = []
output_ssim = []
complex_truth = tf_util.channels_to_complex(sample_truth)
complex_truth = self.sess.run(complex_truth)
psnr, nrmse, ssim = metrics.compute_all(complex_truth,
bart_test,
sos_axis=-1)
cs_psnr.append(psnr)
cs_nrmse.append(nrmse)
cs_ssim.append(ssim)
psnr, nrmse, ssim = metrics.compute_all(complex_truth,
output_image,
sos_axis=-1)
output_psnr.append(psnr)
output_nrmse.append(nrmse)
output_ssim.append(ssim)
return output_psnr, output_nrmse, output_ssim
def calculate_metrics(output, bart_test, truth):
cs_psnr = []
cs_nrmse = []
cs_ssim = []
output_psnr = []
output_nrmse = []
output_ssim = []
psnr, nrmse, ssim = metrics.compute_all(truth, output, sos_axis=-1)
output_psnr.append(psnr)
output_nrmse.append(nrmse)
output_ssim.append(ssim)
print("cs psnr, nrmse, ssim")
print(
np.mean(cs_psnr),
np.std(cs_psnr),
np.mean(cs_nrmse),
np.std(cs_nrmse),
np.mean(cs_ssim),
np.std(cs_ssim),
)
print(output_psnr)
print("output psnr, nrmse, ssim")
print(
np.mean(output_psnr),
np.std(output_psnr),
np.mean(output_nrmse),
np.std(output_nrmse),
np.mean(output_ssim),
np.std(output_ssim),
)
def calculate_metrics(output, bart_test, truth):
cs_psnr = []
cs_nrmse = []
cs_ssim = []
output_psnr = []
output_nrmse = []
output_ssim = []
psnr, nrmse, ssim = metrics.compute_all(truth, output, sos_axis=-1)
output_psnr.append(psnr)
output_nrmse.append(nrmse)
output_ssim.append(ssim)
def calculate_metrics(output, bart_test, truth):
cs_psnr = []
cs_nrmse = []
cs_ssim = []
output_psnr = []
output_nrmse = []
output_ssim = []
# complex_truth = tf_util.channels_to_complex(sample_truth)
# complex_truth = sess.run(complex_truth)
# psnr, nrmse, ssim = metrics.compute_all(complex_truth, bart_test, sos_axis=-1)
# cs_psnr.append(psnr)
# cs_nrmse.append(nrmse)
# cs_ssim.append(ssim)
# print("truth", truth.shape)
# print("output", output.shape)
psnr, nrmse, ssim = metrics.compute_all(truth, output, sos_axis=-1)
output_psnr.append(psnr)
output_nrmse.append(nrmse)
output_ssim.append(ssim)
print("cs psnr, nrmse, ssim")
print(
np.mean(cs_psnr),
np.std(cs_psnr),
np.mean(cs_nrmse),
np.std(cs_nrmse),
np.mean(cs_ssim),
np.std(cs_ssim),
)
print(output_psnr)
print("output psnr, nrmse, ssim")
print(
np.mean(output_psnr),
np.std(output_psnr),
np.mean(output_nrmse),
np.std(output_nrmse),
np.mean(output_ssim),
np.std(output_ssim),
)
def main(_):
if FLAGS.batch_size is not 1:
print("Error: to test images, batch size must be 1")
exit()
model_dir = os.path.join(FLAGS.log_root, FLAGS.train_dir)
if not os.path.exists(FLAGS.log_root):
os.makedirs(FLAGS.log_root)
if not os.path.exists(model_dir):
os.makedirs(model_dir)
bart_dir = os.path.join(model_dir, "bart_recon")
if not os.path.exists(bart_dir):
os.makedirs(bart_dir)
run_config = tf.ConfigProto()
run_config.gpu_options.allow_growth = True
with tf.Session(config=run_config) as sess:
"""Execute main function."""
os.environ["CUDA_VISIBLE_DEVICES"] = FLAGS.device
if not FLAGS.dataset_dir:
raise ValueError("You must supply the dataset directory with " +
"--dataset_dir")
if FLAGS.random_seed >= 0:
random.seed(FLAGS.random_seed)
np.random.seed(FLAGS.random_seed)
tf.logging.set_verbosity(tf.logging.INFO)
print("Preparing dataset...")
out_shape = [FLAGS.shape_z, FLAGS.shape_y]
test_dataset, num_files = mri_data.create_dataset(
os.path.join(FLAGS.dataset_dir, "test"),
FLAGS.mask_path,
num_channels=FLAGS.num_channels,
num_emaps=FLAGS.num_emaps,
batch_size=FLAGS.batch_size,
out_shape=out_shape,
)
# channels first: (batch, channels, z, y)
# placeholders
ks_shape = [None, FLAGS.shape_z, FLAGS.shape_y, FLAGS.num_channels]
ks_place = tf.placeholder(tf.complex64, ks_shape)
sense_shape = [
None, FLAGS.shape_z, FLAGS.shape_y, 1, FLAGS.num_channels
]
sense_place = tf.placeholder(tf.complex64, sense_shape)
im_shape = [None, FLAGS.shape_z, FLAGS.shape_y, 1]
im_truth_place = tf.placeholder(tf.complex64, im_shape)
# run through unrolled
im_out_place = mri_model.unroll_fista(
ks_place,
sense_place,
is_training=True,
verbose=True,
do_hardproj=FLAGS.do_hard_proj,
num_summary_image=FLAGS.num_summary_image,
resblock_num_features=FLAGS.feat_map,
num_grad_steps=FLAGS.num_grad_steps,
conv=FLAGS.conv,
do_conjugate=FLAGS.do_conjugate,
)
saver = tf.train.Saver()
summary_writer = tf.summary.FileWriter(model_dir, sess.graph)
# initialize model
print("[*] initializing network...")
if not load(model_dir, saver, sess):
sess.run(tf.global_variables_initializer())
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess, coord)
# See how many parameters are in model
total_parameters = 0
for variable in tf.trainable_variables():
variable_parameters = 1
for dim in variable.get_shape():
variable_parameters *= dim.value
total_parameters += variable_parameters
print("Total number of trainable parameters: %d" % total_parameters)
test_iterator = test_dataset.make_one_shot_iterator()
features, labels = test_iterator.get_next()
ks_truth = labels
ks_in = features["ks_input"]
sense_in = features["sensemap"]
mask_recon = features["mask_recon"]
im_truth = tf_util.model_transpose(ks_truth * mask_recon, sense_in)
total_summary = tf.summary.merge_all()
output_psnr = []
output_nrmse = []
output_ssim = []
cs_psnr = []
cs_nrmse = []
cs_ssim = []
for test_file in range(num_files):
ks_in_run, sense_in_run, im_truth_run = sess.run(
[ks_in, sense_in, im_truth])
im_out, total_summary_run = sess.run(
[im_out_place, total_summary],
feed_dict={
ks_place: ks_in_run,
sense_place: sense_in_run,
im_truth_place: im_truth_run,
},
)
# CS recon
bart_test = bart_cs(bart_dir, ks_in_run, sense_in_run, l1=0.007)
# bart_test = None
# handle batch dimension
for b in range(FLAGS.batch_size):
truth = im_truth_run[b, :, :, :]
out = im_out[b, :, :, :]
psnr, nrmse, ssim = metrics.compute_all(truth,
out,
sos_axis=-1)
output_psnr.append(psnr)
output_nrmse.append(nrmse)
output_ssim.append(ssim)
print("output mean +/ standard deviation psnr, nrmse, ssim")
print(
np.mean(output_psnr),
np.std(output_psnr),
np.mean(output_nrmse),
np.std(output_nrmse),
np.mean(output_ssim),
np.std(output_ssim),
)
psnr, nrmse, ssim = metrics.compute_all(im_truth_run,
bart_test,
sos_axis=-1)
cs_psnr.append(psnr)
cs_nrmse.append(nrmse)
cs_ssim.append(ssim)
print("cs mean +/ standard deviation psnr, nrmse, ssim")
print(
np.mean(cs_psnr),
np.std(cs_psnr),
np.mean(cs_nrmse),
np.std(cs_nrmse),
np.mean(cs_ssim),
np.std(cs_ssim),
)
print("End of testing loop")
txt_path = os.path.join(model_dir, "metrics.txt")
f = open(txt_path, "w")
f.write("parameters = " + str(total_parameters) + "\n" +
"output psnr = " + str(np.mean(output_psnr)) + " +\- " +
str(np.std(output_psnr)) + "\n" + "output nrmse = " +
str(np.mean(output_nrmse)) + " +\- " +
str(np.std(output_nrmse)) + "\n" + "output ssim = " +
str(np.mean(output_ssim)) + " +\- " +
str(np.std(output_ssim)) + "\n"
"cs psnr = " + str(np.mean(cs_psnr)) + " +\- " +
str(np.std(cs_psnr)) + "\n" + "output nrmse = " +
str(np.mean(cs_nrmse)) + " +\- " + str(np.std(cs_nrmse)) +
"\n" + "output ssim = " + str(np.mean(cs_ssim)) + " +\- " +
str(np.std(cs_ssim)))
f.close()
def main(_):
model_dir = os.path.join(FLAGS.log_root, FLAGS.train_dir)
if not os.path.exists(FLAGS.log_root):
os.makedirs(FLAGS.log_root)
if not os.path.exists(model_dir):
os.makedirs(model_dir)
bart_dir = os.path.join(model_dir, "bart_recon")
if not os.path.exists(bart_dir):
os.makedirs(bart_dir)
# im_head = "/home/ekcole/Workspace/mfast_combined/"
# im_dir = os.path.join(im_head, FLAGS.train_dir)
image_dir = os.path.join(model_dir, "images")
if not os.path.exists(image_dir):
os.makedirs(image_dir)
run_config = tf.ConfigProto()
run_config.gpu_options.allow_growth = True
with tf.Session(config=run_config) as sess:
"""Execute main function."""
os.environ["CUDA_VISIBLE_DEVICES"] = FLAGS.device
if not FLAGS.dataset_dir:
raise ValueError("You must supply the dataset directory with " +
"--dataset_dir")
if FLAGS.random_seed >= 0:
random.seed(FLAGS.random_seed)
np.random.seed(FLAGS.random_seed)
tf.logging.set_verbosity(tf.logging.INFO)
print("Preparing dataset...")
out_shape = [FLAGS.shape_z, FLAGS.shape_y]
test_dataset, num_files = mri_data.create_dataset(
os.path.join(FLAGS.dataset_dir, "test_images"),
FLAGS.mask_path,
num_channels=FLAGS.num_channels,
num_maps=FLAGS.num_emaps,
batch_size=FLAGS.batch_size,
out_shape=out_shape,
)
# channels first: (batch, channels, z, y)
# placeholders
ks_shape = [None, FLAGS.shape_z, FLAGS.shape_y, FLAGS.num_channels]
ks_place = tf.placeholder(tf.complex64, ks_shape)
sense_shape = [
None, FLAGS.shape_z, FLAGS.shape_y, 1, FLAGS.num_channels
]
sense_place = tf.placeholder(tf.complex64, sense_shape)
im_shape = [None, FLAGS.shape_z, FLAGS.shape_y, 1]
im_truth_place = tf.placeholder(tf.complex64, im_shape)
# run through unrolled
im_out_place = mri_model.unroll_fista(
ks_place,
sense_place,
is_training=True,
verbose=True,
do_hardproj=FLAGS.do_hard_proj,
num_summary_image=FLAGS.num_summary_image,
resblock_num_features=FLAGS.feat_map,
num_grad_steps=FLAGS.num_grad_steps,
conv=FLAGS.conv,
)
saver = tf.train.Saver()
summary_writer = tf.summary.FileWriter(model_dir, sess.graph)
# initialize model
print("[*] initializing network...")
if not load(model_dir, saver, sess):
sess.run(tf.global_variables_initializer())
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess, coord)
# See how many parameters are in model
total_parameters = 0
for variable in tf.trainable_variables():
variable_parameters = 1
for dim in variable.get_shape():
variable_parameters *= dim.value
total_parameters += variable_parameters
print("Total number of trainable parameters: %d" % total_parameters)
tf.summary.scalar("parameters/parameters", total_parameters)
test_iterator = test_dataset.make_one_shot_iterator()
features, labels = test_iterator.get_next()
ks_truth = labels
ks_in = features["ks_input"]
sense_in = features["sensemap"]
mask_recon = features["mask_recon"]
im_in = tf_util.model_transpose(ks_in * mask_recon, sense_in)
im_truth = tf_util.model_transpose(ks_truth * mask_recon, sense_in)
total_summary = tf.summary.merge_all()
output_psnr = []
output_nrmse = []
output_ssim = []
cs_psnr = []
cs_nrmse = []
cs_ssim = []
for test_file in range(num_files):
ks_in_run, sense_in_run, im_truth_run, im_in_run = sess.run(
[ks_in, sense_in, im_truth, im_in])
im_out, total_summary_run = sess.run(
[im_out_place, total_summary],
feed_dict={
ks_place: ks_in_run,
sense_place: sense_in_run,
im_truth_place: im_truth_run,
},
)
# CS recon
bart_test = bart_cs(bart_dir, ks_in_run, sense_in_run, l1=FLAGS.l1)
# print("rotating")
# im_in_run = np.rot90(np.squeeze(im_in_run), k=3)
# im_out = np.rot90(np.squeeze(im_out), k=3)
# bart_test = np.rot90(np.squeeze(bart_test), k=3)
# im_truth_run = np.rot90(np.squeeze(im_truth_run), k=3)
# save magnitude input, output, cs, truth as .png
# complex
if FLAGS.conv == "complex":
mag_images = np.squeeze(
np.absolute(
np.concatenate((im_out, bart_test, im_truth_run),
axis=2)))
phase_images = np.squeeze(
np.angle(
np.concatenate((im_out, bart_test, im_truth_run),
axis=2)))
diff_out = im_truth_run - im_out
diff_cs = im_truth_run - bart_test
diff_mag = np.squeeze(
np.absolute(np.concatenate((diff_out, diff_cs), axis=2)))
diff_phase = np.squeeze(
np.angle(np.concatenate((diff_out, diff_cs), axis=2)))
if FLAGS.conv == "real":
mag_images = np.squeeze(
np.absolute(np.concatenate((im_in_run, im_out), axis=2)))
phase_images = np.squeeze(
np.angle(np.concatenate((im_in_run, im_out), axis=2)))
diff_in = im_truth_run - im_in_run
diff_out = im_truth_run - im_out
diff_mag = np.squeeze(
np.absolute(np.concatenate((diff_in, diff_out), axis=2)))
diff_phase = np.squeeze(
np.angle(np.concatenate((diff_in, diff_out), axis=2)))
filename = image_dir + "/mag_" + str(test_file) + ".png"
scipy.misc.imsave(filename, mag_images)
# filename = image_dir + "/diff_mag_" + str(test_file) + ".png"
# scipy.misc.imsave(filename, diff_mag)
filename = image_dir + "/phase_" + str(test_file) + ".png"
scipy.misc.imsave(filename, phase_images)
# filename = image_dir + "/diff_phase_" + str(test_file) + ".png"
# scipy.misc.imsave(filename, diff_phase)
filename = image_dir + "/diff_phase_" + str(test_file) + ".npy"
np.save(filename, diff_phase)
filename = image_dir + "/diff_mag_" + str(test_file) + ".npy"
np.save(filename, diff_mag)
psnr, nrmse, ssim = metrics.compute_all(im_truth_run,
im_out,
sos_axis=-1)
output_psnr.append(psnr)
output_nrmse.append(nrmse)
output_ssim.append(ssim)
print("output psnr, nrmse, ssim")
print(
np.mean(output_psnr),
np.std(output_psnr),
np.mean(output_nrmse),
np.std(output_nrmse),
np.mean(output_ssim),
np.std(output_ssim),
)
psnr, nrmse, ssim = metrics.compute_all(im_truth_run,
bart_test,
sos_axis=-1)
cs_psnr.append(psnr)
cs_nrmse.append(nrmse)
cs_ssim.append(ssim)
print("cs psnr, nrmse, ssim")
print(
np.mean(cs_psnr),
np.std(cs_psnr),
np.mean(cs_nrmse),
np.std(cs_nrmse),
np.mean(cs_ssim),
np.std(cs_ssim),
)
print("End of testing loop")
txt_path = os.path.join(model_dir, "metrics.txt")
f = open(txt_path, "w")
f.write("parameters = " + str(total_parameters) + "\n"
"output psnr = " + str(np.mean(output_psnr)) + " +\- " +
str(np.std(output_psnr)) + "\n" + "output nrmse = " +
str(np.mean(output_nrmse)) + " +\- " +
str(np.std(output_nrmse)) + "\n" + "output ssim = " +
str(np.mean(output_ssim)) + " +\- " +
str(np.std(output_ssim)) + "\n"
"cs psnr = " + str(np.mean(cs_psnr)) + " +\- " +
str(np.std(cs_psnr)) + "\n" + "output nrmse = " +
str(np.mean(cs_nrmse)) + " +\- " + str(np.std(cs_nrmse)) +
"\n" + "output ssim = " + str(np.mean(cs_ssim)) + " +\- " +
str(np.std(cs_ssim)))
f.close()
def test(self):
print("testing")
# read in a correct test dicom file to change it later
# dicom_filename = get_testdata_files("MR_small.dcm")[0]
# self.ds = pydicom.dcmread(dicom_filename)
# 18 time frames in each DICOM
max_frame = self.max_frames
frame = 1
case = 1
gif = []
print("number of test cases", self.input_files)
total_acc = []
mask_input = tf_util.kspace_mask(self.ks, dtype=tf.complex64)
numel = tf.cast(tf.size(mask_input), tf.float32)
acc = numel / tf.reduce_sum(tf.abs(mask_input))
output_psnr = []
output_nrmse = []
output_ssim = []
cs_psnr = []
cs_nrmse = []
cs_ssim = []
for step in range(self.input_files):
# whenever you do a lot of TF operations or sess.run(-c) in a loop, cpu memory builds up
print("test file #", step)
acc_run = self.sess.run(acc)
# acc = np.round(acc, decimals=2)
# print("acceleration", acc_run)
total_acc.append(acc_run)
print(
"total test acc:",
np.round(np.mean(total_acc), decimals=2),
np.round(np.std(total_acc), decimals=2),
)
# if (step < select*max_frame) or (step > (select+1)*max_frame):
# continue
if self.data_type is "knee":
# l1 = 0.015
l1 = 0.02
if self.data_type is "DCE":
l1 = 0.05
if self.data_type is "DCE_2D":
l1 = 0.07
# bart_test = self.bart_cs(sample_ks, sample_sensemap, l1=l1)
# im_in = tf_util.model_transpose(self.ks, self.sensemap)
# output_image, input_image, complex_truth = self.sess.run([self.im_out, im_in, self.complex_truth])
output_image, complex_truth = self.sess.run(
[self.im_out, self.complex_truth])
if self.data_type is "knee":
# input_image = np.squeeze(input_image)
output_image = np.squeeze(output_image)
truth_image = np.squeeze(complex_truth)
psnr, nrmse, ssim = metrics.compute_all(truth_image,
output_image,
sos_axis=-1)
# psnr, nrmse, ssim = metrics.compute_all(
# truth_image, input_image, sos_axis=-1
# )
# psnr = np.round(psnr, decimals=2)
# nrmse = np.round(nrmse, decimals=2)
# ssim = np.round(ssim, decimals=2)
output_psnr.append(psnr)
output_nrmse.append(nrmse)
output_ssim.append(ssim)
print("output psnr, nrmse, ssim")
print(
np.round(np.mean(output_psnr), decimals=2),
np.round(np.mean(output_nrmse), decimals=2),
np.round(np.mean(output_ssim), decimals=2),
)
# psnr, nrmse, ssim = metrics.compute_all(
# complex_truth, bart_test, sos_axis=-1
# )
# psnr = np.round(psnr, decimals=2)
# nrmse = np.round(nrmse, decimals=2)
# ssim = np.round(ssim, decimals=2)
# cs_psnr.append(psnr)
# cs_nrmse.append(nrmse)
# cs_ssim.append(ssim)
# print("cs psnr, nrmse, ssim")
# print(
# np.mean(psnr), np.mean(nrmse), np.mean(ssim),
# )
# mag_input = np.squeeze(np.absolute(input_image))
# mag_cs = np.squeeze(np.absolute(bart_test))
# mag_output = np.squeeze(np.absolute(output_image))
# if self.data_type is "knee":
# # save as png
# mag_input = np.rot90(mag_input, k=3)
# # norm_max = np.amax(mag_input)
# mag_cs = np.rot90(mag_cs, k=3)
# mag_output = np.rot90(mag_output, k=3)
# mag_images = np.concatenate((mag_input, mag_cs, mag_output), axis=1)
# filename = self.image_dir + "/mag_" + str(step) + ".png"
# scipy.misc.imsave(filename, mag_images)
if self.data_type is "DCE":
gif = []
for f in range(max_frame):
frame_input = mag_input[:, :, f]
frame_output = mag_output[:, :, f]
frame_cs = mag_cs[:, :, f]
rotated_input = np.rot90(frame_input, 1)
rotated_output = np.rot90(frame_output, 1)
rotated_cs = np.rot90(frame_cs, 1)
# normalize to help the CS brightness
newMax = np.max(rotated_input)
newMin = np.min(rotated_input)
oldMax = np.max(rotated_cs)
oldMin = np.min(rotated_cs)
rotated_cs = (rotated_cs - oldMin) * (newMax - newMin) / (
oldMax - oldMin) + newMin
full_images = np.concatenate(
(rotated_input, rotated_output, rotated_cs), axis=1)
# filename = self.log_dir + '/images/case' + str(step) + '_f' + str(f) + '.png'
# scipy.misc.imsave(filename, full_images)
new_filename = (self.log_dir + "/dicoms/" + str(step) +
"_f" + str(f) + ".dcm")
self.write_dicom(full_images, new_filename, step, f)
# add each frame to a gif
gif.append(full_images)
print("Saving gif")
gif_path = self.log_dir + "/gifs/slice_" + str(step) + ".gif"
imageio.mimsave(gif_path, gif, duration=0.2)
# Save as PNG
# filename = self.log_dir + '/images/case' + str(case) + '_f' + str(frame) + '.png'
# scipy.misc.imsave(filename, saved)
# Save as DICOM
if self.data_type is "DCE_2D":
rotated_input = np.rot90(mag_input, 1)
rotated_output = np.rot90(mag_output, 1)
rotated_cs = np.rot90(mag_cs, 1)
full_images = np.concatenate(
(rotated_input, rotated_output, rotated_cs), axis=1)
full_images = full_images * 10.0
new_filename = (self.log_dir + "/dicoms/" + str(case) + "_f" +
str(frame) + ".dcm")
dicom_output = np.squeeze(np.abs(full_images))
self.write_dicom(dicom_output, new_filename, case, frame)
# Save as PNG
filename = (self.log_dir + "/images/case" + str(case) + "_f" +
str(frame) + ".png")
scipy.misc.imsave(filename, full_images)
if frame <= max_frame:
gif.append(full_images)
frame = frame + 1
if frame > max_frame:
print("Max frame")
gif.append(full_images)
# gif = gif+100
# gif = gif.astype('uint8')
# timeMax = np.max(gif, axis=-1)
# gif = gif/np.max(gif)
# if self.shuffle == "False":
print("Saving gif")
gif_path = self.log_dir + \
"/gifs/new_gif" + str(case) + ".gif"
imageio.mimsave(gif_path, gif, "GIF", duration=0.2)
# return back to next case
frame = 1
case = case + 1
gif = []
# Create a gif
if frame <= max_frame:
mypath = self.log_dir + "/images/case" + str(case)
search_str = "*.png"
filenames = sorted(glob.glob(mypath + search_str))
# make and save gif
gif_path = self.log_dir + \
"/gifs/case_" + str(case) + ".gif"
images = []
for f in filenames:
image = scipy.misc.imread(f)
images.append(image)
filename_gif = mypath + "/case.gif"
imageio.mimsave(gif_path, images, duration=0.3)
txt_path = os.path.join(self.log_dir, "output_metrics.txt")
f = open(txt_path, "w")
f.write("output psnr = " + str(np.mean(output_psnr)) + " +\- " +
str(np.std(output_psnr)) + "\n" + "output nrmse = " +
str(np.mean(output_nrmse)) + " +\- " +
str(np.std(output_nrmse)) + "\n" + "output ssim = " +
str(np.mean(output_ssim)) + " +\- " +
str(np.std(output_ssim)) + "\n" + "test acc = " +
str(np.mean(total_acc)) + " +\-" + str(np.std(total_acc)))
f.close()
def test(self):
print("testing")
# read in a correct test dicom file to change it later
dicom_filename = pydicom.data.get_testdata_files("MR_small.dcm")[0]
self.ds = pydicom.dcmread(dicom_filename)
# 18 time frames in each DICOM
max_frame = self.max_frames
frame = 0
x_slice = 0
case = 1
gif = []
print("number of test cases", self.input_files)
total_acc = []
mask_input = tf_util.kspace_mask(self.ks, dtype=tf.complex64)
numel = tf.cast(tf.size(mask_input), tf.float32)
acc = numel / tf.reduce_sum(tf.abs(mask_input))
input_psnr = []
input_nrmse = []
input_ssim = []
output_psnr = []
output_nrmse = []
output_ssim = []
cs_psnr = []
cs_nrmse = []
cs_ssim = []
input_volume = np.zeros((self.max_frames, 192, 80, 180))
output_volume = np.zeros((self.max_frames, 192, 80, 180))
cs_volume = np.zeros((self.max_frames, 192, 80, 180))
model_time = []
cs_time = []
for step in range(self.input_files // 2):
# for step in range(20):
# DCE_2D: iterator will see each slice followed by 18 time frames
# then the next slice
print("test file #", step)
acc_run = self.sess.run(acc)
total_acc.append(acc_run)
print(
"total test acc:",
np.round(np.mean(total_acc), decimals=2),
np.round(np.std(total_acc), decimals=2),
)
if self.data_type is "knee":
# l1 = 0.015
l1 = 0.0035
if self.data_type is "DCE":
# l1 = 0.05
l1 = 0.01
if self.data_type is "DCE_2D":
l1 = 0.05
model_start_time = time.time()
(
input_image,
output_image,
complex_truth,
ks_run,
sensemap_run,
) = self.sess.run([
self.im_in,
self.output_image,
self.complex_truth,
self.ks,
self.sensemap,
])
runtime = time.time() - model_start_time
if step is not 1:
model_time.append(runtime)
print("GAN: %s seconds" % np.mean(model_time),
"+/- %s" % np.std(model_time))
# bart_test = np.zeros_like(output_image)
cs_start_time = time.time()
bart_test = self.bart_cs(ks_run, sensemap_run, l1=l1)
runtime = time.time() - cs_start_time
if step is not 1:
cs_time.append(runtime)
print("CS: %s seconds" % np.mean(cs_time),
"+/- %s" % np.std(cs_time))
if self.data_type is "knee":
input_image = np.squeeze(input_image)
output_image = np.squeeze(output_image)
truth_image = np.squeeze(complex_truth)
cs_image = np.squeeze(bart_test)
psnr, nrmse, ssim = metrics.compute_all(truth_image,
cs_image,
sos_axis=-1)
cs_psnr.append(psnr)
cs_nrmse.append(nrmse)
cs_ssim.append(ssim)
print("cs psnr, nrmse, ssim")
print(
np.round(np.mean(cs_psnr), decimals=2),
np.round(np.mean(cs_nrmse), decimals=2),
np.round(np.mean(cs_ssim), decimals=2),
)
psnr, nrmse, ssim = metrics.compute_all(truth_image,
output_image,
sos_axis=-1)
output_psnr.append(psnr)
output_nrmse.append(nrmse)
output_ssim.append(ssim)
print("output psnr, nrmse, ssim")
print(
np.round(np.mean(output_psnr), decimals=2),
np.round(np.mean(output_nrmse), decimals=2),
np.round(np.mean(output_ssim), decimals=2),
)
psnr, nrmse, ssim = metrics.compute_all(truth_image,
input_image,
sos_axis=-1)
input_psnr.append(psnr)
input_nrmse.append(nrmse)
input_ssim.append(ssim)
print("input psnr, nrmse, ssim")
print(
np.round(np.mean(input_psnr), decimals=2),
np.round(np.mean(input_nrmse), decimals=2),
np.round(np.mean(input_ssim), decimals=2),
)
def rotate_image(img):
img = np.squeeze(np.absolute(img))
if self.data_type is "DCE":
img = np.transpose(img, axes=(1, 0, 2))
img = np.flip(img, axis=2) # flip the time
if self.data_type is "DCE_2D":
img = np.transpose(img, axes=(1, 0))
return img
mag_input = rotate_image(input_image)
mag_output = rotate_image(output_image)
mag_cs = rotate_image(bart_test)
# x, y, z, time
if self.data_type is "DCE":
input_volume[step, :, :, :] = mag_input
output_volume[step, :, :, :] = mag_output
cs_volume[step, :, :, :] = mag_cs
if self.data_type is "DCE_2D":
input_volume[frame, x_slice, :, :] = mag_input
output_volume[frame, x_slice, :, :] = mag_output
cs_volume[frame, x_slice, :, :] = mag_cs
new_filename = (self.log_dir + "/dicoms/" + "output_slice_" +
str(x_slice) + "_f" + str(frame) + ".dcm")
self.write_dicom(mag_input, new_filename, x_slice, frame)
# increment frame
# if frame is 17, go back to next slice
if frame == self.max_frames - 1:
frame = 0
x_slice += 1
else:
frame += 1
print("slice", x_slice, "time frame", frame)
in_sl = np.abs(input_volume[2, 0, :, :])
filename = os.path.join(self.log_dir,
os.path.basename(self.search_str[:-11]))
input_dir = filename + "_input" + ".npy"
output_dir = filename + "_output" + ".npy"
cs_dir = filename + "_cs" + ".npy"
print("saving numpy volumes")
np.save(input_dir, input_volume)
np.save(output_dir, output_volume)
np.save(cs_dir, cs_volume)
print(output_dir)
print("saving cfl volumes")
cfl.write(input_dir, input_volume, "R")
cfl.write(output_dir, output_volume, "R")
cfl.write(cs_dir, cs_volume, "R")
if self.data_type is "knee":
print("output psnr = " + str(np.mean(output_psnr)) + " +\- " +
str(np.std(output_psnr)) + "\n" + "output nrmse = " +
str(np.mean(output_nrmse)) + " +\- " +
str(np.std(output_nrmse)) + "\n" + "output ssim = " +
str(np.mean(output_ssim)) + " +\- " +
str(np.std(output_ssim)) + "\n" + "test acc = " +
str(np.mean(total_acc)) + " +\-" + str(np.std(total_acc)))
txt_path = os.path.join(self.log_dir, "output_metrics.txt")
f = open(txt_path, "w")
f.write("output psnr = " + str(np.mean(output_psnr)) + " +\- " +
str(np.std(output_psnr)) + "\n" + "output nrmse = " +
str(np.mean(output_nrmse)) + " +\- " +
str(np.std(output_nrmse)) + "\n" + "output ssim = " +
str(np.mean(output_ssim)) + " +\- " +
str(np.std(output_ssim)) + "\n" + "input psnr = " +
str(np.mean(input_psnr)) + " +\- " +
str(np.std(input_psnr)) + "\n" + "input nrmse = " +
str(np.mean(input_nrmse)) + " +\- " +
str(np.std(input_nrmse)) + "\n" + "input ssim = " +
str(np.mean(input_ssim)) + " +\- " +
str(np.std(input_ssim)) + "\n" + "test acc = " +
str(np.mean(total_acc)) + " +\-" + str(np.std(total_acc)))
f.close()
txt_path = os.path.join(self.log_dir, "cs_metrics.txt")
f = open(txt_path, "w")
f.write("cs psnr = " + str(np.mean(cs_psnr)) + " +\- " +
str(np.std(cs_psnr)) + "\n" + "output nrmse = " +
str(np.mean(cs_nrmse)) + " +\- " + str(np.std(cs_nrmse)) +
"\n" + "output ssim = " + str(np.mean(cs_ssim)) + " +\- " +
str(np.std(cs_ssim)))
f.close()
