def evalute(self, validGenerator):
self.model.eval()
losses = []
recalls = []
mrrs = []
with torch.no_grad():
batchSize = validGenerator.batchSize
hidden = self.model.initHidden(batchSize)
for ii, (input, target, finishedMask,
validMask) in tqdm(enumerate(validGenerator),
total=validGenerator.totalIters,
miniters=1000,
position=0,
leave=True):
input = input.to(self.device)
target = target.to(self.device)
hidden = self.model.resetHidden(hidden, finishedMask,
validMask)
logit, hidden = self.model(input, hidden)
if (self.lossFunc is not None):
loss = self.lossFunc(logit, target)
if (~np.isnan(loss.item())):
losses.append(loss.item())
recall, mrr = Metrics.calc(logit, target, k=self.topk)
recalls.append(recall)
mrrs.append(mrr.cpu().numpy())
if (len(losses)):
meanLoss = np.mean(losses)
else:
meanLoss = 0
meanRecall = np.mean(recalls)
meanMrr = np.mean(mrrs)
return meanLoss, meanRecall, meanMrr
def metrics_computation(input_channels, seq_len, features_order, kernel_size=[5, 5], strides=[1, 1], conv_paddings=[0, 0],
gpu=True, gpu_device="cuda:0", gen_path=P.GenDataDir(), alpha_=P.Alpha, lambda_=P.Lambda,
train_id="train", test_id="test", epoch=P.Epoch, addParamFn=P.ParamFunction, seed=42,
verbose=False):
"""
"""
# Add restarting mechanism.
metrics = Me.Metrics(input_channels=input_channels, seq_len=seq_len, kernel_sizes=kernel_size,
strides=strides, conv_paddings=conv_paddings, gpu=gpu, distance_metric=P.DistanceMetric,
gpu_device=gpu_device, prep_included=P.PreprocessingIncluded,
prep_excluded=P.PreprocessingExcluded, scale=P.Scale,
features_ordering=features_order, seed=seed, verbose=verbose,
data_fmt_class="MotionSenseDataset", window_overlap=P.Window_overlap)
results = R.Results(resultDir=P.ResultsDir())
sr = R.StopRestart(resultDir=P.ResultsDir())
# Read data and compute metrics,
# Baseline
metric_epochs = 200
metric_batch = 256
def shaping(path):
# Set the data as the same for all, the generated ones and the original ones such that we have the same
# computation graph.
data = D.MotionSenseDataset(path, window_overlap=P.Window_overlap)
return data.__inverse_transform_conv__(sensor_tensor=data.sensor, phy=data.phy_data,
act_tensor=data.activities, sens_tensor=data.sensitive,
user_id_tensor=data.users_id, trials=data.trials, cpu_device=CPU_DEVICE)
o_test = shaping(P.TestPath)
if not sr.computed(epoch=0, alpha_=np.NaN, lambda_=np.NaN, Attribute="act") or \
not sr.computed(epoch=0, alpha_=np.NaN, lambda_=np.NaN, Attribute="gender"):
o_train = shaping(P.TrainPath)
sp = metrics.sensitive_attribute(train_set=o_train, test_set=o_test,
use_accuracy=False, act_name="act", drop=[], sens_name="gender", ms_act_name="act",
ms_sens_name="sens", sklearn_data_process=None, use_phys=True, physNodes=3,
phys_names=["height", "weight", "age"], ms_phys_name="phy", epoch=metric_epochs,
batch_size=metric_batch, loss_fn=None)
tp = metrics.task(train_set=o_train, test_set=o_test,
act_name="act", drop=[], sens_name="gender", ms_act_name="act", ms_sens_name="sens",
sklearn_data_process=None, use_phys=True, physNodes=3, phys_names=["height", "weight", "age"],
ms_phys_name="phy", epoch=metric_epochs, batch_size=metric_batch, loss_fn=None)
di = metrics.distance(o_test, o_test)
# Add and save results
results.add_result(distance=di, s_acc=sp[0], s_ber=sp[1], t_acc=tp[0], t_ber=tp[1], sens_name="gender",
act_name="act", epoch=0, alpha_=np.NaN, lambda_=np.NaN)
# Sanitization
name = lambda n, e: "{}/{}_{}.csv".format(gen_path, n, addParamFn(e))
for epoch in tqdm.tqdm(range(1, epoch+1)):
if not sr.computed(epoch=epoch, alpha_=alpha_, lambda_=lambda_, Attribute="act") or \
not sr.computed(epoch=epoch, alpha_=alpha_, lambda_=lambda_, Attribute="gender"):
train = shaping(name(train_id, epoch))
test = shaping(name(test_id, epoch))
sp = metrics.sensitive_attribute(train_set=train, test_set=test,
use_accuracy=False, act_name="act", drop=[], sens_name="gender", ms_act_name="act",
ms_sens_name="sens", sklearn_data_process=None, use_phys=True, physNodes=3,
phys_names=["height", "weight", "age"], ms_phys_name="phy", epoch=metric_epochs,
batch_size=metric_batch, loss_fn=None, learning_rate=5e-4, weight_decay=0)
tp = metrics.task(train_set=train, test_set=test,
act_name="act", drop=[], sens_name="gender", ms_act_name="act", ms_sens_name="sens",
sklearn_data_process=None, use_phys=True, physNodes=3, phys_names=["height", "weight", "age"],
ms_phys_name="phy", epoch=metric_epochs, batch_size=metric_batch, loss_fn=None,
learning_rate=5e-4, weight_decay=0)
di = metrics.distance(o_test_set=o_test, test_set=test)
# Add and save results
results.add_result(distance=di, s_acc=sp[0], s_ber=sp[1], t_acc=tp[0], t_ber=tp[1], sens_name="gender",
act_name="act", epoch=epoch, alpha_=alpha_, lambda_=lambda_)
xTestBrute = testBrute.loc[:, 'rotationRate.x':'userAcceleration.z']
xTestBrute = xTestBrute.as_matrix()
tempDistance = []
for j in range(len(xTestBrute[0])):
tempDistance.append(Di.euclidean(xTestOriginal[:, j], xTestBrute[:,
j]))
distance.append(np.mean(tempDistance))
epoch.append(e)
for i in range(numberClass):
clf = tc[i]
clf.fit(xTrain, yTrain1)
predictions = clf.predict(xTest)
accuAct[i].append(Me.Metrics().accuracy(predictions, yTest1))
clf = tc[i]
clf.fit(xTrain, yTrain2)
predictions = clf.predict(xTest)
accuGender[i].append(Me.Metrics().accuracy(predictions, yTest2))
train_prep = D.Preprocessing(adressTrain,
prep_excluded=P.PreprocessingExcluded,
scale=P.Scale,
prep_included=P.PreprocessingIncluded,
numeric_as_categoric_max_thr=0)
train_prep.set_features_ordering(None)
test_prep = D.Preprocessing(adressTest,
prep_excluded=P.PreprocessingExcluded,
scale=P.Scale,
prep_included=P.PreprocessingIncluded)
test_prep.set_features_ordering(None)
test_prep.fit_transform()
train_ds = D.MotionSenseDataset(train_prep)
test_ds = D.MotionSenseDataset(test_prep)
# build data loaders
batch_size = 256
# Defining model Predicting activities.
activities = np.unique(train_ds.activities)
phys_shape = train_ds.phy_data.shape[1]
metrics = Me.Metrics(input_channels=train_ds.input_channels, seq_len=train_ds.seq_len, kernel_sizes=[5,5],
strides=[1, 1], conv_paddings=[0, 0], gpu=True,
gpu_device="cuda:0", prep_included=P.PreprocessingIncluded, prep_excluded=P.PreprocessingExcluded,
scale=P.Scale, features_ordering=None, seed=42, verbose=True)
# sp = metrics.sensitive_attribute(train_set=pd.read_csv("../" + P.TrainPath), test_set=pd.read_csv("../" + P.TestPath),
# use_accuracy=False, drop=[], sens_name="sens", phys_names="phy", epoch=200, batch_size=batch_size,
# loss_fn=None, verbose=False)
# tp = metrics.sensitive_attribute(train_set="../" + P.TrainPath, test_set="../" + P.TestPath, use_accuracy=False,
# drop=[], sens_name="sens", phys_names="phy", epoch=200, batch_size=batch_size, loss_fn=Cl.AccuracyLoss(),
# verbose=False)
tp = metrics.sensitive_attribute(train_set=pd.read_csv("../" + P.TrainPath), test_set=pd.read_csv("../" + P.TestPath),
use_accuracy=False, act_name="act", drop=[], sens_name="gender", ms_act_name="act",
ms_sens_name="sens", sklearn_data_process=None, use_phys=True, physNodes=3,
phys_names=["height", "weight", "age"], ms_phys_name="phy", epoch=200, batch_size=256,
loss_fn=None)
sp = metrics.task(train_set=pd.read_csv("../" + P.TrainPath), test_set=pd.read_csv("../" + P.TestPath),
def model_test(use_existing):
cm.mkdir(cm.workingPath.testingResults_path)
# Loading test data:
filename = cm.filename
modelname = cm.modellist[0]
# Single CT:
originFile_list = sorted(
glob(cm.workingPath.originTestingSet_path + filename))
maskAortaFile_list = sorted(
glob(cm.workingPath.aortaTestingSet_path + filename))
maskPulFile_list = sorted(
glob(cm.workingPath.pulTestingSet_path + filename))
# Zahra CTs:
# originFile_list = sorted(glob(cm.workingPath.originTestingSet_path + "vol*.dcm"))
# maskAortaFile_list = sorted(glob(cm.workingPath.aortaTestingSet_path + "vol*.dcm"))
# maskPulFile_list = sorted(glob(cm.workingPath.pulTestingSet_path + "vol*.dcm"))
# Lidia CTs:
# originFile_list = sorted(glob(cm.workingPath.originLidiaTestingSet_path + "vol*.dcm"))[61:]
# maskAortaFile_list = sorted(glob(cm.workingPath.originLidiaTestingSet_path + "vol*.dcm"))[61:]
# maskPulFile_list = sorted(glob(cm.workingPath.originLidiaTestingSet_path + "vol*.dcm"))[61:]
# Abnormal CTs:
# originFile_list = sorted(glob(cm.workingPath.originAbnormalTestingSet_path + "vol126*.dcm"))
# maskAortaFile_list = sorted(glob(cm.workingPath.originAbnormalTestingSet_path + "vol126*.dcm"))
# maskPulFile_list = sorted(glob(cm.workingPath.originAbnormalTestingSet_path + "vol126*.dcm"))
for i in range(len(originFile_list)):
# Show runtime:
starttime = datetime.datetime.now()
vol_slices = []
out_test_images = []
out_test_masks = []
current_file = originFile_list[i].split('/')[-1]
current_dir = cm.workingPath.testingResults_path + str(
current_file[:-17])
cm.mkdir(current_dir)
cm.mkdir(current_dir + '/Plots/')
cm.mkdir(current_dir + '/Surface_Distance/')
cm.mkdir(current_dir + '/DICOM/')
cm.mkdir(current_dir + '/mhd/')
stdout_backup = sys.stdout
log_file = open(current_dir + "/logs.txt", "w")
sys.stdout = log_file
print('-' * 30)
print('Loading test data %04d/%04d...' % (i + 1, len(originFile_list)))
originVol, originVol_num, originVolwidth, originVolheight = dp.loadFile(
originFile_list[i])
maskAortaVol, maskAortaVol_num, maskAortaVolwidth, maskAortaVolheight = dp.loadFile(
maskAortaFile_list[i])
maskPulVol, maskPulVol_num, maskPulVolwidth, maskPulVolheight = dp.loadFile(
maskPulFile_list[i])
maskVol = maskAortaVol
for j in range(len(maskAortaVol)):
maskAortaVol[j] = np.where(maskAortaVol[j] != 0, 1, 0)
for j in range(len(maskPulVol)):
maskPulVol[j] = np.where(maskPulVol[j] != 0, 2, 0)
maskVol = maskVol + maskPulVol
for j in range(len(maskVol)):
maskVol[j] = np.where(maskVol[j] > 2, 0, maskVol[j])
# maskVol[j] = np.where(maskVol[j] != 0, 0, maskVol[j])
# Make the Vessel class
for j in range(len(maskVol)):
maskVol[j] = np.where(maskVol[j] != 0, 1, 0)
for i in range(originVol.shape[0]):
img = originVol[i, :, :]
out_test_images.append(img)
for i in range(maskVol.shape[0]):
img = maskVol[i, :, :]
out_test_masks.append(img)
vol_slices.append(originVol.shape[0])
maskAortaVol = None
maskPulVol = None
maskVol = None
originVol = None
nb_class = 2
outmasks_onehot = to_categorical(out_test_masks, num_classes=nb_class)
final_test_images = np.ndarray([sum(vol_slices), 512, 512, 1],
dtype=np.int16)
final_test_masks = np.ndarray([sum(vol_slices), 512, 512, nb_class],
dtype=np.int8)
for i in range(len(out_test_images)):
final_test_images[i, :, :, 0] = out_test_images[i]
final_test_masks[i, :, :, :] = outmasks_onehot[i]
outmasks_onehot = None
out_test_masks = None
out_test_images = None
row = cm.img_rows_3d
col = cm.img_cols_3d
row_1 = int((512 - row) / 2)
row_2 = int(512 - (512 - row) / 2)
col_1 = int((512 - col) / 2)
col_2 = int(512 - (512 - col) / 2)
slices = cm.slices_3d
gaps = cm.gaps_3d
final_images_crop = final_test_images[:, row_1:row_2, col_1:col_2, :]
final_masks_crop = final_test_masks[:, row_1:row_2, col_1:col_2, :]
sitk.WriteImage(
sitk.GetImageFromArray(np.uint16(final_test_masks[:, :, :, 1])),
current_dir + '/DICOM/masksAortaGroundTruth.dcm')
# sitk.WriteImage(sitk.GetImageFromArray(np.uint16(final_test_masks[:, :, :, 2])), current_dir + '/DICOM/masksPulGroundTruth.dcm')
sitk.WriteImage(
sitk.GetImageFromArray(np.uint16(final_test_masks[:, :, :, 1])),
current_dir + '/mhd/masksAortaGroundTruth.mhd')
# sitk.WriteImage(sitk.GetImageFromArray(np.uint16(final_test_masks[:, :, :, 2])), current_dir + '/mhd/masksPulGroundTruth.mhd')
# clear the masks for the final step:
final_test_masks = np.where(final_test_masks == 0, 0, 0)
num_patches = int((sum(vol_slices) - slices) / gaps)
test_image = np.ndarray([1, slices, row, col, 1], dtype=np.int16)
predicted_mask_volume = np.ndarray(
[sum(vol_slices), row, col, nb_class], dtype=np.float32)
# model = DenseUNet_3D.get_3d_denseunet()
# model = UNet_3D.get_3d_unet_bn()
# model = RSUNet_3D.get_3d_rsunet(opti)
# model = UNet_3D.get_3d_wnet(opti)
model = UNet_3D.get_3d_unet()
# model = RSUNet_3D_Gerda.get_3d_rsunet_Gerdafeature(opti)
using_start_end = 1
start_slice = cm.start_slice
end_slice = -1
if use_existing:
model.load_weights(modelname)
for i in range(num_patches):
count1 = i * gaps
count2 = i * gaps + slices
test_image[0] = final_images_crop[count1:count2]
predicted_mask = model.predict(test_image)
if i == int(num_patches * 0.63):
vs.visualize_activation_in_layer_one_plot(
model, test_image, current_dir)
else:
pass
predicted_mask_volume[count1:count2] += predicted_mask[
0, :, :, :, :]
t = len(predicted_mask_volume)
for i in range(0, slices, gaps):
predicted_mask_volume[i:(
i +
gaps)] = predicted_mask_volume[i:(i + gaps)] / (i / gaps + 1)
for i in range(0, slices, gaps):
predicted_mask_volume[(t - i -
gaps):(t - i)] = predicted_mask_volume[
(t - i - gaps):(t - i)] / (i / gaps + 1)
for i in range(slices, (len(predicted_mask_volume) - slices)):
predicted_mask_volume[i] = predicted_mask_volume[i] / (slices /
gaps)
np.save(cm.workingPath.testingSet_path + 'testImages.npy',
final_images_crop)
np.save(cm.workingPath.testingSet_path + 'testMasks.npy',
final_masks_crop)
np.save(cm.workingPath.testingSet_path + 'masksTestPredicted.npy',
predicted_mask_volume)
final_images_crop = None
final_masks_crop = None
predicted_mask_volume = None
imgs_origin = np.load(cm.workingPath.testingSet_path +
'testImages.npy').astype(np.int16)
imgs_true = np.load(cm.workingPath.testingSet_path +
'testMasks.npy').astype(np.int8)
imgs_predict = np.load(cm.workingPath.testingSet_path +
'masksTestPredicted.npy').astype(np.float32)
imgs_predict_threshold = np.load(cm.workingPath.testingSet_path +
'masksTestPredicted.npy').astype(
np.float32)
########## ROC curve aorta
actual = imgs_true[:, :, :, 1].reshape(-1)
predictions = imgs_predict[:, :, :, 1].reshape(-1)
# predictions = np.where(predictions < (0.7), 0, 1)
false_positive_rate_aorta, true_positive_rate_aorta, thresholds_aorta = roc_curve(
actual, predictions, pos_label=1)
roc_auc_aorta = auc(false_positive_rate_aorta,
true_positive_rate_aorta)
plt.figure(1, figsize=(6, 6))
plt.figure(1)
plt.title('ROC of Aorta')
plt.plot(false_positive_rate_aorta, true_positive_rate_aorta, 'b')
label = 'AUC = %0.2f' % roc_auc_aorta
plt.legend(loc='lower right')
plt.plot([0, 1], [0, 1], 'r--')
plt.xlim([-0.0, 1.0])
plt.ylim([-0.0, 1.0])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
# plt.show()
saveName = '/Plots/ROC_Aorta_curve.png'
plt.savefig(current_dir + saveName)
plt.close()
########## ROC curve pul
# actual = imgs_true[:, :, :, 2].reshape(-1)
# predictions = imgs_predict[:, :, :, 2].reshape(-1)
#
# false_positive_rate_pul, true_positive_rate_pul, thresholds_pul = roc_curve(actual, predictions, pos_label=1)
# roc_auc_pul = auc(false_positive_rate_pul, true_positive_rate_pul)
# plt.figure(2, figsize=(6, 6))
# plt.figure(2)
# plt.title('ROC of pul')
# plt.plot(false_positive_rate_pul, true_positive_rate_pul, 'b')
# label = 'AUC = %0.2f' % roc_auc_pul
# plt.legend(loc='lower right')
# plt.plot([0, 1], [0, 1], 'r--')
# plt.xlim([-0.0, 1.0])
# plt.ylim([-0.0, 1.0])
# plt.xlabel('False Positive Rate')
# plt.ylabel('True Positive Rate')
# # plt.show()
# saveName = '/Plots/ROC_Pul_curve.png'
# plt.savefig(current_dir + saveName)
# plt.close()
false_positive_rate_aorta = None
true_positive_rate_aorta = None
false_positive_rate_pul = None
true_positive_rate_pul = None
imgs_predict_threshold = np.where(imgs_predict_threshold < (0.5), 0, 1)
if using_start_end == 1:
aortaMean = lf.dice_coef_np(
imgs_predict_threshold[start_slice:end_slice, :, :, 1],
imgs_true[start_slice:end_slice, :, :, 1])
# pulMean = lf.dice_coef_np(imgs_predict_threshold[start_slice:end_slice, :, :, 2],
# imgs_true[start_slice:end_slice, :, :, 2])
else:
aortaMean = lf.dice_coef_np(imgs_predict_threshold[:, :, :, 1],
imgs_true[:, :, :, 1])
# pulMean = lf.dice_coef_np(imgs_predict_threshold[:, :, :, 2], imgs_true[:, :, :, 2])
np.savetxt(current_dir + '/Plots/AortaDicemean.txt',
np.array(aortaMean).reshape(1, ),
fmt='%.5f')
# np.savetxt(current_dir + '/Plots/PulDicemean.txt', np.array(pulMean).reshape(1, ), fmt='%.5f')
print('Model file:', modelname)
print('-' * 30)
print('Aorta Dice Coeff', aortaMean)
# print('Pul Dice Coeff', pulMean)
print('-' * 30)
# Draw the subplots of figures:
color1 = 'gray' # ***
color2 = 'viridis' # ******
# color = 'plasma' # **
# color = 'magma' # ***
# color2 = 'RdPu' # ***
# color = 'gray' # ***
# color = 'gray' # ***
transparent1 = 1.0
transparent2 = 0.5
# Slice parameters:
#################################### Aorta
# Automatically:
steps = 40
slice = range(0, len(imgs_origin), steps)
plt_row = 3
plt_col = int(len(imgs_origin) / steps)
plt.figure(3, figsize=(25, 12))
plt.figure(3)
for i in slice:
if i == 0:
plt_num = int(i / steps) + 1
else:
plt_num = int(i / steps)
if plt_num <= plt_col:
ax1 = plt.subplot(plt_row, plt_col, plt_num)
title = 'slice=' + str(i)
plt.title(title)
ax1.imshow(imgs_origin[i, :, :, 0],
cmap=color1,
alpha=transparent1)
ax1.imshow(imgs_true[i, :, :, 1],
cmap=color2,
alpha=transparent2)
ax2 = plt.subplot(plt_row, plt_col, plt_num + plt_col)
title = 'slice=' + str(i)
plt.title(title)
ax2.imshow(imgs_origin[i, :, :, 0],
cmap=color1,
alpha=transparent1)
ax2.imshow(imgs_predict[i, :, :, 1],
cmap=color2,
alpha=transparent2)
ax3 = plt.subplot(plt_row, plt_col, plt_num + 2 * plt_col)
title = 'slice=' + str(i)
plt.title(title)
ax3.imshow(imgs_origin[i, :, :, 0],
cmap=color1,
alpha=transparent1)
ax3.imshow(imgs_predict_threshold[i, :, :, 1],
cmap=color2,
alpha=transparent2)
else:
pass
modelname = cm.modellist[0]
imageName = re.findall(r'\d+\.?\d*', modelname)
epoch_num = int(imageName[0]) + 1
accuracy = float(
np.loadtxt(current_dir + '/Plots/AortaDicemean.txt', float))
# saveName = 'epoch_' + str(epoch_num) + '_dice_' +str(accuracy) + '.png'
saveName = '/Plots/epoch_Aorta_%02d_dice_%.3f.png' % (epoch_num - 1,
accuracy)
plt.subplots_adjust(left=0.0,
bottom=0.05,
right=1.0,
top=0.95,
hspace=0.3,
wspace=0.3)
plt.savefig(current_dir + saveName)
plt.close()
# plt.show()
################################ Pulmonary
# steps = 40
# slice = range(0, len(imgs_origin), steps)
# plt_row = 3
# plt_col = int(len(imgs_origin) / steps)
#
# plt.figure(4, figsize=(25, 12))
# plt.figure(4)
# for i in slice:
# if i == 0:
# plt_num = int(i / steps) + 1
# else:
# plt_num = int(i / steps)
#
# if plt_num <= plt_col:
#
# ax1 = plt.subplot(plt_row, plt_col, plt_num)
# title = 'slice=' + str(i)
# plt.title(title)
# ax1.imshow(imgs_origin[i, :, :, 0], cmap=color1, alpha=transparent1)
# ax1.imshow(imgs_true[i, :, :, 2], cmap=color2, alpha=transparent2)
#
# ax2 = plt.subplot(plt_row, plt_col, plt_num + plt_col)
# title = 'slice=' + str(i)
# plt.title(title)
# ax2.imshow(imgs_origin[i, :, :, 0], cmap=color1, alpha=transparent1)
# ax2.imshow(imgs_predict[i, :, :, 2], cmap=color2, alpha=transparent2)
#
# ax3 = plt.subplot(plt_row, plt_col, plt_num + 2 * plt_col)
# title = 'slice=' + str(i)
# plt.title(title)
# ax3.imshow(imgs_origin[i, :, :, 0], cmap=color1, alpha=transparent1)
# ax3.imshow(imgs_predict_threshold[i, :, :, 2], cmap=color2, alpha=transparent2)
# else:
# pass
#
# modelname = cm.modellist[0]
#
# imageName = re.findall(r'\d+\.?\d*', modelname)
# epoch_num = int(imageName[0]) + 1
# accuracy = float(np.loadtxt(current_dir + '/Plots/PulDicemean.txt', float))
#
# # saveName = 'epoch_' + str(epoch_num) + '_dice_' +str(accuracy) + '.png'
# saveName = '/Plots/epoch_Pul_%02d_dice_%.3f.png' % (epoch_num - 1, accuracy)
#
# plt.subplots_adjust(left=0.0, bottom=0.05, right=1.0, top=0.95, hspace=0.3, wspace=0.3)
# plt.savefig(current_dir + saveName)
# plt.close()
# # plt.show()
print('Images saved')
# Save npy as dcm files:
final_test_aorta_predicted_threshold = final_test_masks[:, :, :, 1]
# final_test_pul_predicted_threshold = final_test_masks[:, :, :, 2]
final_test_aorta_predicted_threshold[:, row_1:row_2, col_1:
col_2] = imgs_predict_threshold[:, :, :,
1]
# final_test_pul_predicted_threshold[:, row_1:row_2, col_1:col_2] = imgs_predict_threshold[:, :, :, 2]
new_imgs_dcm = sitk.GetImageFromArray(
np.uint16(final_test_images + 4000))
new_imgs_aorta_predict_dcm = sitk.GetImageFromArray(
np.uint16(final_test_aorta_predicted_threshold))
# new_imgs_pul_predict_dcm = sitk.GetImageFromArray(np.uint16(final_test_pul_predicted_threshold))
sitk.WriteImage(new_imgs_dcm,
current_dir + '/DICOM/imagesPredicted.dcm')
sitk.WriteImage(new_imgs_aorta_predict_dcm,
current_dir + '/DICOM/masksAortaPredicted.dcm')
# sitk.WriteImage(new_imgs_pul_predict_dcm, current_dir + '/DICOM/masksPulPredicted.dcm')
sitk.WriteImage(new_imgs_dcm, current_dir + '/mhd/imagesPredicted.mhd')
sitk.WriteImage(new_imgs_aorta_predict_dcm,
current_dir + '/mhd/masksAortaPredicted.mhd')
# sitk.WriteImage(new_imgs_pul_predict_dcm, current_dir + '/mhd/masksPulPredicted.mhd')
mt.SegmentDist(current_dir + '/mhd/masksAortaPredicted.mhd',
current_dir + '/mhd/masksAortaGroundTruth.mhd',
current_dir + '/Surface_Distance/Aorta')
# mt.SegmentDist(current_dir + '/mhd/masksPulPredicted.mhd',current_dir + '/mhd/masksPulGroundTruth.mhd', current_dir + '/Surface_Distance/Pul')
# ds1 = dicom.read_file(maskAortaFile_list[0])
# ds2 = dicom.read_file(cm.workingPath.testingSet_path + 'masksAortaPredicted.dcm')
# ds1.PixelData = ds2.PixelData
# ds1.pop('pixel_array')
# ds1["pixel_array"] = ds2["pixel_array"]
# ds1.save_as(cm.workingPath.testingSet_path + 'masksAortaPredicted.dcm')
# ds1.save_as(cm.workingPath.testingSet_path + 'masksAortaPredicted.mhd')
#
# ds1 = dicom.read_file(maskPulFile_list[0])
# ds2 = dicom.read_file(cm.workingPath.testingSet_path + 'masksPulPredicted.dcm')
# ds1.PixelData = ds2.PixelData
# ds1["pixelarray"] = ds2["pixelarray"]
# ds1.save_as(cm.workingPath.testingSet_path + 'masksPulPredicted.dcm')
# ds1.save_as(cm.workingPath.testingSet_path + 'masksPulPredicted.mhd')
print('DICOM saved')
# Clear memory for the next testing sample:
final_test_aorta_predicted_threshold = None
final_test_pul_predicted_threshold = None
imgs_predict_threshold = None
new_imgs_dcm = None
new_imgs_aorta_predict_dcm = None
new_imgs_pul_predict_dcm = None
final_test_images = None
final_test_masks = None
imgs_origin = None
imgs_predict = None
imgs_true = None
predicted_mask = None
predictions = None
endtime = datetime.datetime.now()
print('-' * 30)
print('running time:', endtime - starttime)
log_file.close()
sys.stdout = stdout_backup