def main():
parser = argparse.ArgumentParser()
parser.add_argument("-i", "--input", help="Input folder with all scans to segment")
parser.add_argument("-o", "--output", help="Output folder for the SCT GM masks")
args = parser.parse_args()
file_tree = dm.load_files(args.input)
total_slices = 0
start_time = time.time()
for site in file_tree.keys():
print("Stating GM segmentation for "+site+" images")
sc_nbr = len(file_tree[site].keys())
k=1
for sc in file_tree[site].keys():
print("Segmenting scan "+str(k)+" out of "+str(sc_nbr))
total_slices += file_tree[site][sc]['slice_nbr']
sct.make_gm_seg(file_tree[site][sc], args.output)
k+=1
end_time = time.time()
dur = end_time-start_time
print("All done !")
print("Total duration : "+str(int(dur//60))+"min and "+str(int(dur%60))+"s")
print(str(total_slices)+" slices segmented")
print("Average segmentation time per slice : "+str(int(dur//total_slices))+"s")
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"-gt",
"--gt_folder",
help="Input folder with all scans and ground truth masks")
parser.add_argument("-sct",
"--sct_folder",
help="Input folder with all SCT generated masks")
parser.add_argument("-o",
"--output",
help="Output folder for the SCT GM mask scores")
args = parser.parse_args()
file_tree = dm.load_files(args.gt_folder, args.sct_folder)
score_tree = {'maskr1': {}, 'maskr2': {}, 'maskr3': {}, 'maskr4': {}}
masks = list(score_tree.keys())
ds = []
hs = []
start_time = time.time()
for i in range(len(masks)):
print("Getting scores for " + masks[i])
for site in file_tree.keys():
print("Getting scores for " + site + " images")
score_tree[masks[i]][site] = {}
sc_nbr = len(file_tree[site].keys())
k = 1
for sc in file_tree[site].keys():
score_tree[masks[i]][site][sc] = {}
print("Scoring segmentation of scan " + str(k) + " out of " +
str(sc_nbr))
dice_scores = gma.dice_score(file_tree[site][sc], i)
n = sum(x > 0 for x in dice_scores)
haus_scores = gma.hausdorff_score(file_tree[site][sc], i)
avg_dice_score = sum(dice_scores) / n
avg_haus_score = sum(haus_scores) / n
score_tree[masks[i]][site][sc]['dice_score'] = avg_dice_score
score_tree[masks[i]][site][sc]['haus_score'] = avg_haus_score
ds.append(avg_dice_score)
hs.append(avg_haus_score)
k += 1
end_time = time.time()
dur = end_time - start_time
output_file = open(args.output + "sct_seg_scores.pkl", "wb")
pickle.dump(score_tree, output_file)
output_file.close()
print("All done !")
print("Total duration : " + str(int(dur // 60)) + "min and " +
str(int(dur % 60)) + "s")
print("Average dice score : " + str(sum(ds) / len(ds)))
print("Average hausdorff distance : " + str(sum(hs) / len(hs)))
print("Saved scores at : " + args.output + "sct_seg_scores.pkl")
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"-gt",
"--gt_folder",
help="Input folder with all scans and ground truth masks")
parser.add_argument("-o",
"--output",
help="Output folder for the SCT GM mask scores")
args = parser.parse_args()
sct_tree = dm.load_files(args.gt_folder)
CROP_SIZE = (50, 50)
avg_masks = {
'site1': np.zeros(CROP_SIZE),
'site2': np.zeros(CROP_SIZE),
'site3': np.zeros(CROP_SIZE),
'site4': np.zeros(CROP_SIZE),
'average': np.zeros(CROP_SIZE),
}
start_time = time.time()
for site in sct_tree.keys():
print("Getting skeleton for " + site + " images")
sc_nbr = len(sct_tree[site].keys())
k = 1
for sc in sct_tree[site].keys():
print("Getting skeletons of scan " + str(k) + " out of " +
str(sc_nbr))
for sl in range(sct_tree[site][sc]['slice_nbr']):
cropped_mask = gma.get_cropped_gm_mask(sct_tree[site][sc], sl,
2, CROP_SIZE)
if len(cropped_mask) > 1:
avg_masks[site] = np.where(cropped_mask == 1., 1,
avg_masks[site])
k += 1
avg_masks['average'] = np.where(avg_masks[site] == 1., 1,
avg_masks['average'])
avg_masks[site] = skeletonize(avg_masks[site])
avg_masks['average'] = skeletonize(avg_masks['average'])
end_time = time.time()
dur = end_time - start_time
output_file = open(args.output + "average_masks.pkl", "wb")
pickle.dump(avg_masks, output_file)
output_file.close()
print("All done !")
print("Total duration : " + str(int(dur // 60)) + "min and " +
str(int(dur % 60)) + "s")
print("Saved tempaltes at : " + args.output + "average_masks.pkl")
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"-gt",
"--gt_folder",
help="Input folder with all scans and ground truth masks")
parser.add_argument("-sct",
"--sct_folder",
help="Input folder with all SCT generated masks")
parser.add_argument("-mt",
"--mask_tempaltes",
help="Pickle file with template file")
parser.add_argument("-o",
"--output",
help="Output folder for the SCT GM mask scores")
args = parser.parse_args()
train_file_tree = dm.load_files(args.gt_folder, args.sct_folder)
avg_mask_file = open(args.mask_tempaltes, "rb")
avg_masks = pkl.load(avg_mask_file)
avg_mask_file.close()
crop_size = avg_masks['site1'].shape[:1]
donnees = {
'SITE': [],
'SCAN': [],
'SLICE': [],
'LEVEL': [],
'DENSITY': [],
'TEXTURE': [],
'SHAPE': [],
}
stats = {
'site1': {},
'site2': {},
'site3': {},
'site4': {},
}
start_time = time.time()
for site in train_file_tree.keys():
dens = []
text = []
shap = []
for sc in train_file_tree[site].keys():
slice_densities = gma.get_sct_gm_densities(
train_file_tree[site][sc])
for sl in range(train_file_tree[site][sc]['slice_nbr']):
sct_gm_skeleton = gma.get_cropped_sct_gm_skeleton(
train_file_tree[site][sc], sl, crop_size)
if len(sct_gm_skeleton) > 1:
donnees['SITE'].append(int(site[-1]))
donnees['SCAN'].append(int(sc[-2:]))
donnees['SLICE'].append(sl)
try:
donnees['LEVEL'].append(
int(train_file_tree[site][sc]['levels'][sl][0]))
except:
donnees['LEVEL'].append(0)
donnees['DENSITY'].append(np.mean(slice_densities[sl]))
dens.append(donnees['DENSITY'][-1])
donnees['TEXTURE'].append(np.std(slice_densities[sl]))
text.append(donnees['TEXTURE'][-1])
donnees['SHAPE'].append(
gma.general_hausdorff_distance(sct_gm_skeleton,
avg_masks[site]))
shap.append(donnees['SHAPE'][-1])
stats[site] = {
'density': {
'mean': np.mean(dens),
'std': np.std(dens)
},
'texture': {
'mean': np.mean(text),
'std': np.std(text)
},
'shape': {
'mean': np.mean(shap),
'std': np.std(shap)
}
}
df = pd.DataFrame(donnees, columns=list(donnees.keys()))
df.to_pickle(args.output + "GM_features.pkl")
end_time = time.time()
dur = end_time - start_time
output_file = open(args.output + "GM_feature_stats.pkl", "wb")
pkl.dump(stats, output_file)
output_file.close()
print("All done !")
print("Total duration : " + str(int(dur // 60)) + "min and " +
str(int(dur % 60)) + "s")
print("Saved feature data at : " + args.output + "GM_features.pkl")
print("Saved feature stats at : " + args.output + "GM_feature_stats.pkl")