def image_standardize(img, mask, img_std):
print("\n standardization ...")
c3 = C3d()
c3.inputs.in_file = img
c3.inputs.args = "%s -nlw 25x25x25 %s -times -replace nan 0" % (mask, mask)
c3.inputs.out_file = img_std
c3.run()
def trim_like(in_img_file, ref_img_file, out_img_file, interp=0):
print("\n cropping ...")
c3 = C3d()
c3.inputs.in_file = ref_img_file
c3.inputs.args = "-int %s %s -reslice-identity" % (interp, in_img_file)
c3.inputs.out_file = out_img_file
c3.run()
def image_mask(img, mask, img_masked):
print("\n skull stripping ...")
c3 = C3d()
c3.inputs.in_file = img
c3.inputs.args = "%s -multiply" % mask
c3.inputs.out_file = img_masked
c3.run()
def copy_orient(in_img_file, ref_img_file, out_img_file):
print("\n copy orientation ...")
c3 = C3d()
c3.inputs.in_file = ref_img_file
c3.inputs.args = "%s -copy-transform -type uchar" % in_img_file
c3.inputs.out_file = out_img_file
c3.run()
def resample(img, x, y, z, out, interp=0):
print("\n resmapling ...")
c3 = C3d()
c3.inputs.in_file = img
c3.inputs.args = "-int %s -resample %sx%sx%s" % (interp, x, y, z)
c3.inputs.out_file = out
c3.run()
def trim(in_img_file, out_img_file, voxels=1):
print("\n cropping ...")
c3 = C3d()
c3.inputs.in_file = in_img_file
c3.inputs.args = "-trim %svox" % voxels
c3.inputs.out_file = out_img_file
c3.run()
def trim(img, out, voxels=1):
c3 = C3d()
c3.inputs.in_file = img
c3.inputs.args = "-trim %svox" % voxels
c3.inputs.out_file = out
if not os.path.exists(out):
print("\n cropping")
c3.run()
def trim_like(img, ref, out, interp=0):
c3 = C3d()
c3.inputs.in_file = ref
c3.inputs.args = "-int %s %s -reslice-identity" % (interp, img)
c3.inputs.out_file = out
if not os.path.exists(out):
print("\n cropping like")
c3.run()
def orient_img(in_img_file, orient_tag, out_img_file):
c3 = C3d()
c3.inputs.in_file = in_img_file
c3.inputs.args = "-orient %s" % orient_tag
c3.inputs.out_file = out_img_file
if os.path.exists(out_img_file):
print("\n %s already exists" % out_img_file)
else:
c3.run()
def trim_img_to_size(in_img, trimmed_img):
"""
Trim image to specific size (112x112x64mm)
:param in_img: input image
:param trimmed_img: trimmed image
"""
c3 = C3d()
c3.inputs.in_file = in_img
c3.inputs.args = "-trim-to-size 112x112x64mm"
c3.inputs.out_file = trimmed_img
if not os.path.exists(trimmed_img):
print("\n extracting hippocampus region")
c3.run()
def standard_img(in_file, std_file):
"""
Orient image in standard orientation
:param in_file: input image
:param std_file: output oriented image
"""
c3 = C3d()
c3.inputs.in_file = in_file
file_shape = nib.load(in_file).shape
nx = int(file_shape[0] / 2.2)
ny = int(file_shape[1] / 2.2)
nz = int(file_shape[2] / 2.2)
c3.inputs.args = "-binarize -as m %s -push m -nlw %sx%sx%s -push m -times -replace nan 0" % (in_file, nx, ny, nz)
c3.inputs.out_file = std_file
if not os.path.exists(std_file):
c3.run()
def trim_img_to_size(in_img, trimmed_img):
"""
Trim image to specific size (112x112x64mm)
:param in_img: input image
:param trimmed_img: trimmed image
"""
# trim(in_img, trimmed_img, voxels=20)
# file_shape = nib.load(trimmed_img).shape
# print(file_shape)
c3 = C3d()
c3.inputs.in_file = in_img
c3.inputs.args = "-trim-to-size 112x112x64vox"
# c3.inputs.args = "-trim-to-size %sx%sx%svox" % (file_shape[0], file_shape[0], int(file_shape[0]/2))
c3.inputs.out_file = trimmed_img
# if not os.path.exists(trimmed_img):
# print("\n extracting hippocampus region")
c3.run()
def reslice_like(in_img, ref_img, trimmed_img):
c3 = C3d()
c3.inputs.in_file = ref_img
c3.inputs.args = "%s -reslice-identity -interpolation Cubic" % in_img
c3.inputs.out_file = trimmed_img
c3.run()
def orient_img(in_img_file, orient_tag, out_img_file):
c3 = C3d()
c3.inputs.in_file = in_img_file
c3.inputs.args = "-orient %s" % orient_tag
c3.inputs.out_file = out_img_file
c3.run()
def main(args):
parser = parsefn()
subj_dir, img, seg, gap, tile, alpha, ax, roi, flip, min_sl, out = parse_inputs(
parser, args)
# pred preprocess dir
pred_dir = '%s/pred_process' % os.path.abspath(subj_dir)
if not os.path.exists(pred_dir):
os.mkdir(pred_dir)
# trim seg to focus
c3 = C3d()
mosaic_slicer = CreateTiledMosaic()
if seg:
c3.inputs.in_file = seg
c3.inputs.args = "-trim %sx%sx%svox" % (roi, roi, roi)
seg_trim_file = "%s/%s_trim_mosaic.nii.gz" % (
pred_dir, os.path.basename(seg).split('.')[0])
# seg_trim_file = "seg_trim.nii.gz"
c3.inputs.out_file = seg_trim_file
c3.run()
# trim struct like seg
c3.inputs.in_file = seg_trim_file
c3.inputs.args = "%s -reslice-identity" % img
struct_trim_file = "%s/%s_trim_mosaic.nii.gz" % (
pred_dir, os.path.basename(img).split('.')[0])
# struct_trim_file = "struct_trim.nii.gz"
c3.inputs.out_file = struct_trim_file
c3.run()
# create rgb image from seg
converter = ConvertScalarImageToRGB()
converter.inputs.dimension = 3
converter.inputs.input_image = seg_trim_file
converter.inputs.colormap = 'jet'
converter.inputs.minimum_input = 0
converter.inputs.maximum_input = 10
out_rgb = "%s/%s_trim_rgb.nii.gz" % (
pred_dir, os.path.basename(seg).split('.')[0])
converter.inputs.output_image = out_rgb
converter.run()
mosaic_slicer.inputs.rgb_image = out_rgb
mosaic_slicer.inputs.mask_image = seg_trim_file
mosaic_slicer.inputs.alpha_value = alpha
else:
struct_trim_file = img
mosaic_slicer.inputs.rgb_image = struct_trim_file
# stretch and clip intensities
c3.inputs.in_file = struct_trim_file
c3.inputs.args = "-stretch 2% 98% 0 255 -clip 0 255"
c3.inputs.out_file = struct_trim_file
c3.run()
# slices to show
if gap == 1:
max_sl = 100
elif gap == 2:
max_sl = 220
elif gap == 5:
max_sl = 275
else:
max_sl = 300
slices = '[%s,%s,%s]' % (gap, min_sl, max_sl)
mosaic_slicer.inputs.input_image = struct_trim_file
mosaic_slicer.inputs.output_image = out
mosaic_slicer.inputs.direction = ax
# mosaic_slicer.inputs.pad_or_crop = '[ -15x -50 , -15x -30 ,0]'
mosaic_slicer.inputs.tile_geometry = tile
mosaic_slicer.inputs.slices = slices
mosaic_slicer.inputs.flip_slice = flip
mosaic_slicer.terminal_output = "none"
mosaic_slicer.run()
def main(args):
parser = parsefn()
subj_dir, subj, t1, fl, t2, woc, out, bias, num_mc, thresh, ign_ort, force = parse_inputs(
parser, args)
cp_orient = False
if out is None:
prediction = '%s/%s_T1acq_nu_HfB_pred.nii.gz' % (subj_dir, subj) \
# if bias is True else '%s/%s_T1acq_HfB_pred.nii.gz' % (subj_dir, subj)
prediction_std_orient = '%s/%s_T1acq_nu_HfB_pred_std_orient.nii.gz' % (
subj_dir, subj)
else:
prediction = out
prediction_std_orient = "%s/%s_std_orient.nii.gz" % (
subj_dir, os.path.basename(out).split('.')[0])
if os.path.exists(prediction) and force is False:
print("\n %s already exists" % prediction)
else:
start_time = datetime.now()
hfb = os.path.realpath(__file__)
hyper_dir = Path(hfb).parents[2]
if fl is None and t2 is None:
test_seqs = [t1]
training_mods = ["t1"]
model_name = 'hfb_t1only_mcdp'
model_name_woc = 'hfb_t1'
print("\n found only t1-w, using the %s model" % model_name)
elif t2 is None and fl:
test_seqs = [t1, fl]
training_mods = ["t1", "flair"]
model_name = 'hfb_t1fl_mcdp'
model_name_woc = 'hfb_t1fl'
print("\n found t1 and fl sequences, using the %s model" %
model_name)
elif fl is None and t2:
test_seqs = [t1, t2]
training_mods = ["t1", "t2"]
model_name = 'hfb_t1t2_mcdp'
model_name_woc = 'hfb_t1t2'
print("\n found t1 and t2 sequences, using the %s model" %
model_name)
else:
test_seqs = [t1, fl, t2]
training_mods = ["t1", "flair", "t2"]
model_name = 'hfb_multi_mcdp'
model_name_woc = 'hfb'
print("\n found all 3 sequences, using the full %s model" %
model_name)
model_json = '%s/models/%s_model.json' % (hyper_dir, model_name)
model_weights = '%s/models/%s_model_weights.h5' % (hyper_dir,
model_name)
assert os.path.exists(
model_json
), "%s does not exist ... please download and rerun script" % model_json
assert os.path.exists(
model_weights
), "%s does not exist ... please download and rerun script" % model_weights
# pred preprocess dir
print(
colored("\n pre-processing %s..." % os.path.abspath(subj_dir),
'green'))
pred_dir = "%s/pred_process" % os.path.abspath(subj_dir)
if not os.path.exists(pred_dir):
os.mkdir(pred_dir)
#############
# bias correction if requested
if bias is True:
t1_bias = os.path.join(subj_dir, "%s_T1_nu.nii.gz" % subj)
biascorr.main(["-i", "%s" % t1, "-o", "%s" % t1_bias])
in_ort = t1_bias
else:
in_ort = t1
# std orientations
r_orient = 'RPI'
l_orient = 'LPI'
# check orientation
t1_ort = "%s/%s_std_orient.nii.gz" % (
subj_dir, os.path.basename(t1).split('.')[0])
if ign_ort is False:
cp_orient = check_orient(in_ort, r_orient, l_orient, t1_ort)
# loading t1
in_t1 = t1_ort if os.path.exists(t1_ort) else in_ort
t1_img = nib.load(in_t1)
###########
c3 = C3d()
pred_shape = [128, 128, 128]
test_data = np.zeros((1, len(training_mods), pred_shape[0],
pred_shape[1], pred_shape[2]),
dtype=t1_img.get_data_dtype())
for s, seq in enumerate(test_seqs):
print(
colored(
"\n pre-processing %s" %
os.path.basename(seq).split('.')[0], 'green'))
seq_ort = "%s/%s_std_orient.nii.gz" % (
subj_dir, os.path.basename(seq).split('.')[0])
if training_mods[s] != 't1':
if training_mods[s] == 'flair':
seq_bias = os.path.join(subj_dir,
"%s_T1acq_nu_FL.nii.gz" % subj)
else:
seq_bias = os.path.join(subj_dir,
"%s_T1acq_nu_T2.nii.gz" % subj)
# bias correction if requested
if bias is True:
biascorr.main(["-i", "%s" % seq, "-o", "%s" % seq_bias])
seq = seq_bias if os.path.exists(seq_bias) else seq
# check orientation
if ign_ort is False:
cp_orient_seq = check_orient(seq, r_orient, l_orient,
seq_ort)
in_seq = seq_ort if os.path.exists(seq_ort) else seq
image = nib.load(in_seq)
img = image.get_data()
# standardize intensity for data
print("\n standardizing ...")
std_img = (img - img.mean()) / img.std()
std_file = '%s/%s_standardized.nii.gz' % (
pred_dir, os.path.basename(seq).split('.')[0])
nib.save(nib.Nifti1Image(std_img, t1_img.affine), std_file)
# cropping
if training_mods[s] == 't1':
crop_file = '%s/%s_standardized_cropped.nii.gz' % (
pred_dir, os.path.basename(seq).split('.')[0])
trim(std_file, crop_file, voxels=1)
else:
crop_file = '%s/%s_standardized_cropped.nii.gz' % (
pred_dir, os.path.basename(seq).split('.')[0])
ref_file = '%s/%s_standardized_cropped.nii.gz' % (
pred_dir, os.path.basename(t1).split('.')[0])
trim_like(std_file, ref_file, crop_file, interp=1)
#resampling
# img = nib.load(crop_file)
# res = resample(img, [pred_shape[0], pred_shape[1], pred_shape[2]])
# res_file = '%s/%s_resampled.nii.gz' % (pred_dir, os.path.basename(seq).split('.')[0])
# nib.save(res, res_file)
res_file = '%s/%s_resampled.nii.gz' % (
pred_dir, os.path.basename(seq).split('.')[0])
resample(crop_file,
pred_shape[0],
pred_shape[1],
pred_shape[2],
res_file,
interp=1)
if not os.path.exists(res_file):
print("\n pre-processing %s" % training_mods[s])
c3.run()
res_data = nib.load(res_file)
test_data[0, s, :, :, :] = res_data.get_data()
print(
colored(
"\n predicting hfb segmentation using MC Dropout with %s samples"
% num_mc, 'green'))
res_t1_file = '%s/%s_resampled.nii.gz' % (
pred_dir, os.path.basename(t1).split('.')[0])
res = nib.load(res_t1_file)
pred_s = np.zeros(
(num_mc, pred_shape[0], pred_shape[1], pred_shape[2]),
dtype=res.get_data_dtype())
for sample_id in range(num_mc):
print("MC sample # %s" % sample_id)
pred = run_test_case(test_data=test_data,
model_json=model_json,
model_weights=model_weights,
affine=res.affine,
output_label_map=True,
labels=1)
pred_s[sample_id, :, :, :] = pred.get_data()
# computing mean
pred_mean = pred_s.mean(axis=0)
pred = nib.Nifti1Image(pred_mean, res.affine)
pred_prob = os.path.join(pred_dir, "hfb_prob.nii.gz")
nib.save(pred, pred_prob)
pred_th_name = os.path.join(pred_dir, "hfb_pred.nii.gz")
pred_th = math_img('img > %s' % thresh, img=pred)
nib.save(pred_th, pred_th_name)
# resample back
pred_res = resample_to_img(pred_prob, t1_img)
pred_prob_name = os.path.join(
pred_dir, "%s_%s_pred_prob.nii.gz" % (subj, model_name))
nib.save(pred_res, pred_prob_name)
# sm
pred_sm = smooth_img(pred_res, fwhm=3)
pred_res_th = math_img('img > %s' % thresh, img=pred_sm)
# conn comp
pred_comp = largest_connected_component_img(pred_res_th)
pred_name = os.path.join(pred_dir,
"%s_%s_pred.nii.gz" % (subj, model_name))
nib.save(pred_comp, pred_name)
# copy original orientation to final prediction
if ign_ort is False and cp_orient:
nib.save(pred_comp, prediction_std_orient)
fill_holes(prediction_std_orient, prediction_std_orient)
copy_orient(pred_name, in_ort, prediction)
fill_holes(prediction, prediction)
else:
nib.save(pred_comp, prediction)
fill_holes(prediction, prediction)
# mask
t1_masked_name = '%s/%s_T1_nu_masked.nii.gz' % (subj_dir, subj) \
if bias is True else '%s/%s_masked.nii.gz' % (subj_dir, os.path.basename(t1).split('.')[0])
masked_t1 = math_img("img1 * img2",
img1=nib.load(in_ort),
img2=nib.load(prediction))
nib.save(masked_t1, t1_masked_name)
if ign_ort is False and cp_orient:
t1_masked_name_std = '%s/%s_T1_nu_masked_std_orient.nii.gz' % (subj_dir, subj) \
if bias is True else '%s/%s_masked_std_orient.nii.gz' % (subj_dir, os.path.basename(t1).split('.')[0])
masked_t1_std = math_img("img1 * img2",
img1=t1_img,
img2=nib.load(prediction_std_orient))
nib.save(masked_t1_std, t1_masked_name_std)
# predict cerebellum
if woc == 1 and model_name_woc == 'hfb':
print("\n predicting approximate cerebellar mask")
cereb_prediction = '%s/%s_T1acq_nu_cerebellum_pred.nii.gz' % (subj_dir, subj) \
if bias is True else '%s/%s_T1acq_cerebellum_pred.nii.gz' % (subj_dir, subj)
model_json_woc = '%s/models/%s_model.json' % (hyper_dir,
model_name_woc)
cereb_weights = '%s/models/cereb_model_weights.h5' % hyper_dir
cereb_pred = run_test_case(test_data=test_data,
model_json=model_json_woc,
model_weights=cereb_weights,
affine=res.affine,
output_label_map=True,
labels=1)
# resample back
cereb_pred_res = resample_to_img(cereb_pred, t1_img)
cereb_pred_name = os.path.join("%s/%s_hfb_cereb_pred_prob.nii.gz" %
(pred_dir, subj))
nib.save(cereb_pred_res, cereb_pred_name)
cereb_sm = smooth_img(cereb_pred_res, fwhm=2)
cereb_th = math_img('img > 0.25', img=cereb_sm)
nib.save(cereb_th, cereb_prediction)
# remove cerebellum
woc_img = pred_comp.get_data() - cereb_th.get_data()
woc_nii = nib.Nifti1Image(woc_img, t1_img.affine)
# conn comp
woc_th = math_img('img > 0', img=woc_nii)
woc_comp = largest_connected_component_img(woc_th)
woc_name = os.path.join(
pred_dir, "%s_%s_woc_pred.nii.gz" % (subj, model_name))
nib.save(woc_comp, woc_name)
woc_pred = '%s/%s_T1acq_nu_HfB_woc_pred.nii.gz' % (subj_dir, subj) \
if bias is True else '%s/%s_T1acq_HfB_woc_pred.nii.gz' % (subj_dir, subj)
woc_pred_std_orient = '%s/%s_T1acq_nu_HfB_woc_pred_std_orient.nii.gz' % (
subj_dir, subj)
if ign_ort is False and cp_orient:
nib.save(woc_comp, woc_pred_std_orient)
fill_holes(woc_pred_std_orient, woc_pred_std_orient)
copy_orient(woc_name, in_ort, woc_pred)
fill_holes(woc_pred, woc_pred)
else:
nib.save(woc_comp, woc_pred)
fill_holes(woc_pred, woc_pred)
# mask
t1_woc_name = '%s/%s_T1_nu_masked_woc.nii.gz' % (subj_dir, subj) \
if bias is True else '%s/%s_masked_woc.nii.gz' % (subj_dir, os.path.basename(t1).split('.')[0])
woc_t1 = math_img("img1 * img2",
img1=nib.load(in_ort),
img2=nib.load(woc_pred))
nib.save(woc_t1, t1_woc_name)
if ign_ort is False and cp_orient:
t1_woc_name = '%s/%s_T1_nu_masked_woc_std_orient.nii.gz' % (subj_dir, subj) \
if bias is True else '%s/%s_masked_woc_std_orient.nii.gz' % (subj_dir, os.path.basename(t1).split('.')[0])
woc_t1 = math_img("img1 * img2",
img1=t1_img,
img2=nib.load(woc_pred_std_orient))
nib.save(woc_t1, t1_woc_name)
else:
print(
'Removing cerebellum is available only when all 3 sequence t1, flair, and t2 have existed.'
)
print("\n generating mosaic image for qc")
seg_qc.main(
["-i",
"%s" % t1, "-s",
"%s" % prediction, "-g", "5", "-m", "75"])
endstatement.main('Brain extraction and mosaic generation',
'%s' % (datetime.now() - start_time))
def fill_holes(in_img_file, out_img_file):
c3 = C3d()
c3.inputs.in_file = in_img_file
c3.inputs.args = "-holefill 1 0 -type uchar"
c3.inputs.out_file = out_img_file
c3.run()
def main(args):
parser = parsefn()
subj_dir, subj, t1, fl, t2, mask, out, force = parse_inputs(parser, args)
cp_orient = False
if out is None:
prediction = '%s/%s_T1acq_nu_ventricles_pred.nii.gz' % (subj_dir, subj)
prediction_std_orient = '%s/%s_T1acq_nu_ventricles_pred_std_orient.nii.gz' % (
subj_dir, subj)
else:
prediction = out
prediction_std_orient = "%s/%s_std_orient.nii.gz" % (
subj_dir, os.path.basename(out).split('.')[0])
if os.path.exists(prediction) and force is False:
print("\n %s already exists" % prediction)
else:
start_time = datetime.now()
file_path = os.path.realpath(__file__)
hyper_dir = Path(file_path).parents[2]
# if fl is None or t2 is None:
if fl is None and t2 is None:
test_seqs = [t1]
training_mods = ["t1"]
model_name = 'vent_t1only'
print("\n found only t1-w, using the %s model" % model_name)
elif t2 is None and fl:
test_seqs = [t1, fl]
training_mods = ["t1", "flair"]
model_name = 'vent_t1fl'
print("\n found the t1-w and FLAIR, using the t1-flair model")
else:
test_seqs = [t1, fl, t2]
training_mods = ["t1", "flair", "t2"]
model_name = 'vent_multi'
print(
"\n found all 3 sequences, using the model with all 3 sequences"
)
model_json = '%s/models/%s_model.json' % (hyper_dir, model_name)
model_weights = '%s/models/%s_model_weights.h5' % (hyper_dir,
model_name)
assert os.path.exists(
model_json
), "%s does not exist ... please download and rerun script" % model_json
assert os.path.exists(model_weights), \
"%s model does not exist ... please download and rerun script" % model_weights
# pred preprocess dir
print(colored("\n pre-processing ...", 'green'))
pred_dir = '%s/pred_process' % os.path.abspath(subj_dir)
if not os.path.exists(pred_dir):
os.mkdir(pred_dir)
# standardize intensity and mask data
c3 = C3d()
pred_shape = [128, 128, 128]
# std orientations
r_orient = 'RPI'
l_orient = 'LPI'
# check orientation t1 and mask
t1_ort = "%s/%s_std_orient.nii.gz" % (
subj_dir, os.path.basename(t1).split('.')[0])
cp_orient = check_orient(t1, r_orient, l_orient, t1_ort)
mask_ort = "%s/%s_std_orient.nii.gz" % (
subj_dir, os.path.basename(mask).split('.')[0])
cp_orient_m = check_orient(mask, r_orient, l_orient, mask_ort)
in_mask = mask_ort if os.path.exists(mask_ort) else mask
# loading t1
in_t1 = t1_ort if os.path.exists(t1_ort) else t1
t1_img = nib.load(in_t1)
test_data = np.zeros((1, len(training_mods), pred_shape[0],
pred_shape[1], pred_shape[2]),
dtype=t1_img.get_data_dtype())
for s, seq in enumerate(test_seqs):
print(
colored(
"\n pre-processing %s" %
os.path.basename(seq).split('.')[0], 'green'))
seq_ort = "%s/%s_std_orient.nii.gz" % (
subj_dir, os.path.basename(seq).split('.')[0])
if training_mods[s] != 't1':
# check orientation
cp_orient_seq = check_orient(seq, r_orient, l_orient, seq_ort)
in_seq = seq_ort if os.path.exists(seq_ort) else seq
# masked
seq_masked = "%s/%s_masked.nii.gz" % (
pred_dir, os.path.basename(seq).split('.')[0])
image_mask(in_seq, in_mask, seq_masked)
# standardized
seq_std = "%s/%s_masked_standardized.nii.gz" % (
pred_dir, os.path.basename(seq).split('.')[0])
image_standardize(seq_masked, in_mask, seq_std)
# cropping
if training_mods[s] == 't1':
seq_crop = '%s/%s_masked_standardized_cropped.nii.gz' % (
pred_dir, os.path.basename(seq).split('.')[0])
trim(seq_std, seq_crop, voxels=1)
else:
seq_crop = '%s/%s_masked_standardized_cropped.nii.gz' % (
pred_dir, os.path.basename(seq).split('.')[0])
ref_file = '%s/%s_masked_standardized_cropped.nii.gz' % (
pred_dir, os.path.basename(t1).split('.')[0])
trim_like(seq_std, ref_file, seq_crop, interp=1)
# resampling
img = nib.load(seq_crop)
res = resample(img, [pred_shape[0], pred_shape[1], pred_shape[2]])
seq_res = '%s/%s_resampled.nii.gz' % (
pred_dir, os.path.basename(seq).split('.')[0])
nib.save(res, seq_res)
if not os.path.exists(seq_res):
print("\n pre-processing %s" % training_mods[s])
c3.run()
res_data = nib.load(seq_res)
test_data[0, s, :, :, :] = res_data.get_data()
print(colored("\n generating ventricle segmentation", 'green'))
res_t1_file = '%s/%s_resampled.nii.gz' % (
pred_dir, os.path.basename(t1).split('.')[0])
res = nib.load(res_t1_file)
pred = run_test_case(test_data=test_data,
model_json=model_json,
model_weights=model_weights,
affine=res.affine,
output_label_map=True,
labels=1)
# resample back
pred_res = resample_to_img(pred, t1_img)
pred_prob_name = os.path.join(
pred_dir, "%s_%s_pred_prob.nii.gz" % (subj, model_name))
nib.save(pred_res, pred_prob_name)
pred_res_th = math_img('img > 0.5', img=pred_res)
pred_name = os.path.join(pred_dir,
"%s_%s_pred.nii.gz" % (subj, model_name))
nib.save(pred_res_th, pred_name)
# copy original orientation to final prediction
if cp_orient:
nib.save(pred_res_th, prediction_std_orient)
copy_orient(pred_name, t1, prediction)
else:
nib.save(pred_res_th, prediction)
print("\n generating mosaic image for qc")
seg_qc.main(
['-i',
'%s' % t1, '-s',
'%s' % prediction, '-g', '2', '-m', '40'])
endstatement.main('Ventricles prediction and mosaic generation',
'%s' % (datetime.now() - start_time))