def run_ckpt(databin_path, ckpt, output_dir, scorer_type, gold_m2_file,
ori_path, ori_bpe_path, gen_subset, remove_unk_edits,
remove_error_type_lst, apply_rerank, preserve_spell, max_edits):
logging.info(f"[Run-ckpt] working on {ckpt}")
os.makedirs(output_dir, exist_ok=True)
ckpt_lst = ckpt.split(":")
ckpt_basename = ''
for c in ckpt_lst:
b = util.get_basename(c, include_path=False, include_extension=False)
ckpt_basename += b
data_basename = util.get_basename(ori_path,
include_path=False,
include_extension=False)
system_out_basename = os.path.join(output_dir,
f"{ckpt_basename}.{data_basename}")
system_out = f"{system_out_basename}.out"
if not os.path.isfile(system_out):
logging.info(f"[Run-ckpt] 1. generate into {system_out}")
generate(databin_path,
ckpt,
system_out,
ori_path=ori_bpe_path,
gen_subset=gen_subset)
cor_path = util.get_cor_path(system_out, remove_unk_edits,
remove_error_type_lst, apply_rerank,
preserve_spell, max_edits)
if not os.path.isfile(cor_path):
logging.info(f"[Run-ckpt] 2. postprocess into {cor_path}")
postprocess(ori_path, system_out, cor_path, remove_unk_edits,
remove_error_type_lst, apply_rerank, preserve_spell,
max_edits)
report_path = f"{util.get_basename(cor_path, include_extension=False)}.report"
if not os.path.isfile(report_path):
logging.info(f"[Run-ckpt] 3. evaluation into {report_path}")
if scorer_type is not None and gold_m2_file is not None:
evaluate(scorer_type, ori_path, cor_path, gold_m2_file,
report_path)
def save_transform_to_database(data_transforms):
""" Save data transforms to database"""
# pylint: disable= too-many-locals, bare-except
conn = sqlite3.connect(util.DB_PATH)
conn.text_factory = str
for img in data_transforms:
cursor = conn.execute('''SELECT pid from Images where id = ? ''', (img.image_id,))
pid = cursor.fetchone()[0]
folder = util.DATA_FOLDER + str(pid) + "/registration_transforms/"
util.mkdir_p(folder)
transform_paths = ""
print(img.get_transforms())
for _transform in img.get_transforms():
print(_transform)
dst_file = folder + util.get_basename(_transform) + '.h5.gz'
if os.path.exists(dst_file):
os.remove(dst_file)
with open(_transform, 'rb') as f_in, gzip.open(dst_file, 'wb') as f_out:
shutil.copyfileobj(f_in, f_out)
transform_paths += str(pid) + "/registration_transforms/" +\
basename(_transform) + '.h5.gz' + ", "
transform_paths = transform_paths[:-2]
cursor2 = conn.execute('''UPDATE Images SET transform = ? WHERE id = ?''',
(transform_paths, img.image_id))
cursor2 = conn.execute('''UPDATE Images SET fixed_image = ? WHERE id = ?''',
(img.fixed_image, img.image_id))
folder = util.DATA_FOLDER + str(pid) + "/reg_volumes_labels/"
util.mkdir_p(folder)
vol_path = util.compress_vol(img.processed_filepath)
shutil.copy(vol_path, folder)
volume_db = str(pid) + "/reg_volumes_labels/" + basename(vol_path)
cursor2 = conn.execute('''UPDATE Images SET filepath_reg = ? WHERE id = ?''',
(volume_db, img.image_id))
cursor = conn.execute('''SELECT filepath, id from Labels where image_id = ? ''',
(img.image_id,))
for (row, label_id) in cursor:
temp = util.compress_vol(move_vol(util.DATA_FOLDER + row,
img.get_transforms(), True))
shutil.copy(temp, folder)
label_db = str(pid) + "/reg_volumes_labels/" + basename(temp)
cursor2 = conn.execute('''UPDATE Labels SET filepath_reg = ? WHERE id = ?''',
(label_db, label_id))
conn.commit()
cursor.close()
cursor2.close()
# cursor = conn.execute('''VACUUM; ''')
conn.close()
def execute(self):
# Ejecutar el comando mmls sobre un fichero
Comandos.log.info('Execute mmls')
destination_file = self.destination_folder + os.sep + util.get_basename(
self.file_name)
command = ['mmls']
command.append(destination_file)
(output, err) = util.execute_shell(util.join_list(' ', command))
print(output)
Comandos.log.info('Mmls finished')
def postprocess(ori_path,
system_out,
cor_path,
remove_unk_edits=True,
remove_error_type_lst=[],
apply_rerank=False,
preserve_spell=False,
max_edits=None):
pred = f"{system_out}.pred"
m2_file_tmp = f"{system_out}._m2"
try:
logging.info("[Postprocess] 1. get pred file")
m2.sys_to_cor(system_out, pred)
logging.info("[Postprocess] 2. convert pred into m2")
m2.parallel_to_m2(ori_path, pred, m2_file_tmp)
logging.info("[Postprocess] 3. adjust m2")
m2_entries = m2.get_m2_entries(m2_file_tmp)
if remove_unk_edits:
logging.info("[Postprocess] 3-1. removing <unk> edits")
m2_entries = m2.remove_m2(m2_entries, None, '<unk>')
if len(remove_error_type_lst) > 0:
logging.info("[Postprocess] 3-2. remove error types")
m2_entries = m2.remove_m2(m2_entries, remove_error_type_lst, None)
if apply_rerank:
logging.info("[Postprocess] 3-3. apply rerank")
lm_scorer = load_lm()
m2_entries = m2.apply_lm_rerank(m2_entries, preserve_spell,
max_edits, lm_scorer)
logging.info("[Postprocess] 4. get pred again")
logging.info("[Postprocess] 4-1. write m2 file")
cor_basename = util.get_basename(cor_path, include_extension=False)
m2_file = f"{cor_basename}.m2"
m2.write_m2_entries(m2_entries, m2_file)
logging.info("[Postprocess] 4-2. write cor file")
m2.m2_to_parallel([m2_file], None, cor_path, False, True)
except:
logging.error("[Postprocess] error occurred")
def _get_ckpt_dir_basename(train_mode, model, lr, dropout, seed,
prev_model_dir):
basenames = []
if prev_model_dir is not None:
prev_model_basename = util.get_basename(
prev_model_dir,
include_path=False,
include_extension=False)
basenames.append(prev_model_basename)
basename = f"{train_mode}-{model}-lr{lr}-dr{dropout}"
if seed is not None:
basename += f"-s{seed}"
basenames.append(basename)
return "_".join(basenames)
def _get_output_dir_from_ckpt_fpath(ckpt_fpath):
ckpts = ckpt_fpath.split(':')
# not ensemble
if len(ckpts) == 1:
ckpt_dir = os.path.dirname(ckpt_fpath)
return _get_output_dir_from_ckpt_dir(ckpt_dir)
# ensemble
else:
dirname_lst = []
for ckpt in ckpts:
ckpt_dir = os.path.dirname(ckpt)
ckpt_dir_basename = util.get_basename(ckpt_dir,
include_path=False)
dirname_lst.append(ckpt_dir_basename)
return f"{self.TRACK_PATH}/outputs/" + ":".join(dirname_lst)
def move_vol(moving, transform, label_img=False):
""" Move data with transform """
if label_img:
# resample volume to 1 mm slices
target_affine_3x3 = np.eye(3) * 1
img_3d_affine = resample_img(moving, target_affine=target_affine_3x3,
interpolation='nearest')
resampled_file = util.TEMP_FOLDER_PATH + util.get_basename(moving) + '_resample.nii.gz'
# pylint: disable= no-member
img_3d_affine.to_filename(resampled_file)
else:
img = img_data(-1, util.DATA_FOLDER, util.TEMP_FOLDER_PATH)
img.set_img_filepath(moving)
resampled_file = pre_process(img, False).pre_processed_filepath
result = util.transform_volume(moving, transform, label_img)
util.generate_image(result, util.TEMPLATE_VOLUME)
return result
def post_calculations(moving_dataset_image_ids, result=None):
""" Transform images and calculate avg"""
if result is None:
result = {}
for _id in moving_dataset_image_ids:
img = img_data(_id, util.DATA_FOLDER, util.TEMP_FOLDER_PATH)
img.load_db_transforms()
img_pre = img_data(img.fixed_image, util.DATA_FOLDER,
util.TEMP_FOLDER_PATH)
img_pre.load_db_transforms()
reg_vol = util.transform_volume(img.reg_img_filepath,
img_pre.get_transforms())
vol = util.TEMP_FOLDER_PATH + util.get_basename(
basename(reg_vol)) + '_BE.nii.gz'
mult = ants.MultiplyImages()
mult.inputs.dimension = 3
mult.inputs.first_input = reg_vol
mult.inputs.second_input = util.TEMPLATE_MASK
mult.inputs.output_product_image = vol
mult.run()
label = "img"
if label in result:
result[label].append(vol)
else:
result[label] = [vol]
for (segmentation, label) in util.find_reg_label_images(_id):
segmentation = util.transform_volume(segmentation,
img_pre.get_transforms(),
label_img=True)
if label in result:
result[label].append(segmentation)
else:
result[label] = [segmentation]
return result
def move_vol(moving, transform, label_img=False, slice_size=1, ref_img=None):
""" Move data with transform """
if label_img:
# resample volume to 1 mm slices
target_affine_3x3 = np.eye(3) * slice_size
img_3d_affine = resample_img(moving,
target_affine=target_affine_3x3,
interpolation='nearest')
resampled_file = util.TEMP_FOLDER_PATH + util.get_basename(
moving) + '_resample.nii.gz'
# pylint: disable= no-member
img_3d_affine.to_filename(resampled_file)
del img_3d_affine
else:
img = img_data(-1, util.DATA_FOLDER, util.TEMP_FOLDER_PATH)
img.set_img_filepath(moving)
resampled_file = pre_process(img, False).pre_processed_filepath
result = util.transform_volume(resampled_file,
transform,
label_img,
ref_img=ref_img)
util.generate_image(result, util.TEMPLATE_VOLUME)
return result
def pre_process(img, do_bet=True, slice_size=1, reg_type=None, be_method=None):
# pylint: disable= too-many-statements, too-many-locals, too-many-branches
""" Pre process the data"""
path = img.temp_data_path
input_file = img.img_filepath
n4_file = path + util.get_basename(input_file) + '_n4.nii.gz'
norm_file = path + util.get_basename(n4_file) + '_norm.nii.gz'
resampled_file = path + util.get_basename(norm_file) + '_resample.nii.gz'
name = util.get_basename(resampled_file) + "_be"
img.pre_processed_filepath = path + name + '.nii.gz'
n4bias = ants.N4BiasFieldCorrection()
n4bias.inputs.dimension = 3
n4bias.inputs.num_threads = NUM_THREADS_ANTS
n4bias.inputs.input_image = input_file
n4bias.inputs.output_image = n4_file
n4bias.run()
# normalization [0,100], same as template
normalize_img = nib.load(n4_file)
temp_data = normalize_img.get_data()
temp_img = nib.Nifti1Image(temp_data / np.amax(temp_data) * 100,
normalize_img.affine, normalize_img.header)
temp_img.to_filename(norm_file)
del temp_img
# resample volume to 1 mm slices
target_affine_3x3 = np.eye(3) * slice_size
img_3d_affine = resample_img(norm_file, target_affine=target_affine_3x3)
nib.save(img_3d_affine, resampled_file)
if not do_bet:
img.pre_processed_filepath = resampled_file
return img
if be_method == 0:
img.init_transform = path + name + '_InitRegTo' + str(
img.fixed_image) + '.h5'
reg = ants.Registration()
# reg.inputs.args = "--verbose 1"
reg.inputs.collapse_output_transforms = True
reg.inputs.fixed_image = resampled_file
reg.inputs.moving_image = util.TEMPLATE_VOLUME
reg.inputs.fixed_image_mask = img.label_inv_filepath
reg.inputs.num_threads = NUM_THREADS_ANTS
reg.inputs.initial_moving_transform_com = True
if reg_type == RIGID:
reg.inputs.transforms = ['Rigid', 'Rigid']
elif reg_type == COMPOSITEAFFINE:
reg.inputs.transforms = ['Rigid', 'CompositeAffine']
elif reg_type == SIMILARITY:
reg.inputs.transforms = ['Rigid', 'Similarity']
else:
reg.inputs.transforms = ['Rigid', 'Affine']
reg.inputs.metric = ['MI', 'MI']
reg.inputs.radius_or_number_of_bins = [32, 32]
reg.inputs.metric_weight = [1, 1]
reg.inputs.convergence_window_size = [5, 5]
reg.inputs.number_of_iterations = ([[
15000, 12000, 10000, 10000, 10000, 5000, 5000
], [10000, 10000, 5000, 5000]])
reg.inputs.shrink_factors = [[19, 16, 12, 9, 5, 3, 1], [9, 5, 3, 1]]
reg.inputs.smoothing_sigmas = [[10, 10, 10, 8, 4, 1, 0], [8, 4, 1, 0]]
reg.inputs.convergence_threshold = [1.e-6] * 2
reg.inputs.transform_parameters = [(0.25, ), (0.25, )]
reg.inputs.sigma_units = ['vox'] * 2
reg.inputs.use_estimate_learning_rate_once = [True, True]
reg.inputs.write_composite_transform = True
reg.inputs.output_transform_prefix = path + name
reg.inputs.output_warped_image = path + name + '_beReg.nii.gz'
transform = path + name + 'InverseComposite.h5'
util.LOGGER.info("starting be registration")
reg.run()
util.LOGGER.info("Finished be registration")
reg_volume = util.transform_volume(resampled_file, transform)
shutil.copy(transform, img.init_transform)
mult = ants.MultiplyImages()
mult.inputs.dimension = 3
mult.inputs.first_input = reg_volume
mult.inputs.second_input = util.TEMPLATE_MASK
mult.inputs.output_product_image = img.pre_processed_filepath
mult.run()
util.generate_image(img.pre_processed_filepath, reg_volume)
elif be_method == 1:
# http://fsl.fmrib.ox.ac.uk/fsl/fslwiki/BET/UserGuide#Main_bet2_options:
bet = fsl.BET(command=BET_COMMAND)
bet.inputs.in_file = resampled_file
# pylint: disable= pointless-string-statement
""" fractional intensity threshold (0->1); default=0.5;
smaller values give larger brain outline estimates"""
bet.inputs.frac = 0.25
""" vertical gradient in fractional intensity threshold (-1->1);
default=0; positive values give larger brain outline at bottom,
smaller at top """
bet.inputs.vertical_gradient = 0
""" This attempts to reduce image bias, and residual neck voxels.
This can be useful when running SIENA or SIENAX, for example.
Various stages involving FAST segmentation-based bias field removal
and standard-space masking are combined to produce a result which
can often give better results than just running bet2."""
# bet.inputs.reduce_bias = True
bet.inputs.mask = True
bet.inputs.out_file = img.pre_processed_filepath
bet.run()
util.generate_image(img.pre_processed_filepath, resampled_file)
elif be_method == 2:
if BET_FRAC > 0:
name = util.get_basename(resampled_file) + "_bet"
# http://fsl.fmrib.ox.ac.uk/fsl/fslwiki/BET/UserGuide#Main_bet2_options:
bet = fsl.BET(command=BET_COMMAND)
bet.inputs.in_file = resampled_file
# pylint: disable= pointless-string-statement
""" fractional intensity threshold (0->1); default=0.5;
smaller values give larger brain outline estimates"""
bet.inputs.frac = BET_FRAC
""" vertical gradient in fractional intensity threshold (-1->1);
default=0; positive values give larger brain outline at bottom,
smaller at top """
bet.inputs.vertical_gradient = 0
""" This attempts to reduce image bias, and residual neck voxels.
This can be useful when running SIENA or SIENAX, for example.
Various stages involving FAST segmentation-based bias field removal
and standard-space masking are combined to produce a result which
can often give better results than just running bet2."""
bet.inputs.reduce_bias = True
bet.inputs.mask = True
bet.inputs.out_file = path + name + '.nii.gz'
util.LOGGER.info("starting bet registration")
start_time = datetime.datetime.now()
util.LOGGER.info(bet.cmdline)
if not os.path.exists(bet.inputs.out_file):
bet.run()
util.LOGGER.info("Finished bet registration 0: ")
util.LOGGER.info(datetime.datetime.now() - start_time)
name += "_be"
print('OR HERE 3??????')
moving_image = util.TEMPLATE_MASKED_VOLUME
print(moving_image)
fixed_image = bet.inputs.out_file
else:
name = util.get_basename(resampled_file) + "_be"
moving_image = util.TEMPLATE_VOLUME
fixed_image = resampled_file
img.init_transform = path + name + '_InitRegTo' + str(
img.fixed_image) + '.h5'
img.pre_processed_filepath = path + name + '.nii.gz'
print('DO I GET HERE??????')
reg = ants.Registration()
# reg.inputs.args = "--verbose 1"
reg.inputs.collapse_output_transforms = True
reg.inputs.fixed_image = fixed_image
print('OR HERE 1??????')
print(moving_image)
reg.inputs.moving_image = moving_image
print('OR HERE 2??????')
reg.inputs.fixed_image_mask = img.label_inv_filepath
reg.inputs.num_threads = NUM_THREADS_ANTS
reg.inputs.initial_moving_transform_com = True
if reg_type == RIGID:
reg.inputs.transforms = ['Rigid', 'Rigid']
elif reg_type == COMPOSITEAFFINE:
reg.inputs.transforms = ['Rigid', 'CompositeAffine']
elif reg_type == SIMILARITY:
reg.inputs.transforms = ['Rigid', 'Similarity']
elif reg_type == AFFINE:
reg.inputs.transforms = ['Rigid', 'Affine']
reg.inputs.metric = ['MI', 'MI']
reg.inputs.radius_or_number_of_bins = [32, 32]
reg.inputs.metric_weight = [1, 1]
reg.inputs.convergence_window_size = [5, 5]
reg.inputs.sampling_strategy = ['Regular'] * 2
reg.inputs.sampling_percentage = [0.5] * 2
reg.inputs.number_of_iterations = ([[10000, 10000, 5000, 5000],
[10000, 10000, 5000, 5000]])
reg.inputs.shrink_factors = [[9, 5, 3, 1], [9, 5, 3, 1]]
reg.inputs.smoothing_sigmas = [[8, 4, 1, 0], [8, 4, 1, 0]]
reg.inputs.transform_parameters = [(0.25, ), (0.25, )]
reg.inputs.convergence_threshold = [1.e-6] * 2
reg.inputs.sigma_units = ['vox'] * 2
reg.inputs.use_estimate_learning_rate_once = [True, True]
reg.inputs.write_composite_transform = True
reg.inputs.output_transform_prefix = path + name
reg.inputs.output_warped_image = path + name + '_TemplateReg.nii.gz'
print('FINISHED SETTING UP ALL reg.inputs')
transform = path + name + 'InverseComposite.h5'
util.LOGGER.info("starting be registration")
util.LOGGER.info(reg.cmdline)
start_time = datetime.datetime.now()
if not os.path.exists(reg.inputs.output_warped_image):
reg.run()
util.LOGGER.info("Finished be registration: ")
util.LOGGER.info(datetime.datetime.now() - start_time)
reg_volume = util.transform_volume(resampled_file, transform)
shutil.copy(transform, img.init_transform)
brain_mask = util.TEMPLATE_MASK
#brain_mask = img.reg_brainmask_filepath
if not brain_mask:
brain_mask = util.TEMPLATE_MASK
print("Using brain mask " + brain_mask)
mult = ants.MultiplyImages()
mult.inputs.dimension = 3
mult.inputs.first_input = reg_volume
mult.inputs.second_input = brain_mask
mult.inputs.output_product_image = img.pre_processed_filepath
mult.run()
util.generate_image(img.pre_processed_filepath, reg_volume)
else:
util.LOGGER.error(" INVALID BE METHOD!!!!")
util.LOGGER.info("---BET " + img.pre_processed_filepath)
return img
def save_transform_to_database(imgs):
""" Save data transforms to database"""
# pylint: disable= too-many-locals, bare-except
conn = sqlite3.connect(util.DB_PATH, timeout=900)
conn.text_factory = str
try:
conn.execute(
"alter table Images add column 'registration_date' 'TEXT'")
except sqlite3.OperationalError:
pass
for img in imgs:
cursor = conn.execute('''SELECT pid from Images where id = ? ''',
(img.image_id, ))
pid = cursor.fetchone()[0]
folder = util.DATA_FOLDER + str(pid) + "/registration_transforms/"
if os.path.exists(folder):
shutil.rmtree(folder)
os.makedirs(folder)
transform_paths = ""
util.LOGGER.info(img.get_transforms())
for _transform in img.get_transforms():
util.LOGGER.info(_transform)
dst_file = folder + util.get_basename(_transform) + '.h5.gz'
with open(_transform, 'rb') as f_in, gzip.open(dst_file,
'wb') as f_out:
shutil.copyfileobj(f_in, f_out)
transform_paths += str(pid) + "/registration_transforms/" +\
util.get_basename(_transform) + '.h5.gz' + ", "
transform_paths = transform_paths[:-2]
cursor2 = conn.execute(
'''UPDATE Images SET transform = ? WHERE id = ?''',
(transform_paths, img.image_id))
cursor2 = conn.execute(
'''UPDATE Images SET fixed_image = ? WHERE id = ?''',
(img.fixed_image, img.image_id))
cursor2 = conn.execute(
'''UPDATE Images SET registration_date = ? WHERE id = ?''',
(datetime.datetime.now().strftime("%Y-%m-%d"), img.image_id))
folder = util.DATA_FOLDER + str(pid) + "/reg_volumes_labels/"
if os.path.exists(folder):
shutil.rmtree(folder)
os.makedirs(folder)
vol_path = util.compress_vol(img.processed_filepath)
shutil.copy(vol_path, folder)
volume_db = str(pid) + "/reg_volumes_labels/" + basename(vol_path)
cursor2 = conn.execute(
'''UPDATE Images SET filepath_reg = ? WHERE id = ?''',
(volume_db, img.image_id))
cursor = conn.execute(
'''SELECT filepath, id from Labels where image_id = ? ''',
(img.image_id, ))
for (filepath, label_id) in cursor:
temp = util.compress_vol(
move_vol(util.DATA_FOLDER + filepath, img.get_transforms(),
True))
shutil.copy(temp, folder)
label_db = str(pid) + "/reg_volumes_labels/" + basename(temp)
cursor2 = conn.execute(
'''UPDATE Labels SET filepath_reg = ? WHERE id = ?''',
(label_db, label_id))
conn.commit()
cursor.close()
cursor2.close()
def registration(moving_img, fixed, reg_type):
# pylint: disable= too-many-statements, too-many-branches
"""Image2Image registration """
reg = ants.Registration()
path = moving_img.temp_data_path
name = util.get_basename(
moving_img.pre_processed_filepath) + '_' + reg_type
moving_img.processed_filepath = path + name + '_RegTo' + str(
moving_img.fixed_image) + '.nii.gz'
moving_img.transform = path + name + '_RegTo' + str(
moving_img.fixed_image) + '.h5'
init_moving_transform = moving_img.init_transform
if init_moving_transform is not None and os.path.exists(
init_moving_transform):
util.LOGGER.info("Found initial transform")
# reg.inputs.initial_moving_transform = init_moving_transform
reg.inputs.initial_moving_transform_com = False
mask = util.transform_volume(moving_img.label_inv_filepath,
moving_img.init_transform,
label_img=True)
else:
reg.inputs.initial_moving_transform_com = True
mask = moving_img.label_inv_filepath
reg.inputs.collapse_output_transforms = True
reg.inputs.fixed_image = moving_img.pre_processed_filepath
reg.inputs.fixed_image_mask = mask
reg.inputs.moving_image = fixed
reg.inputs.num_threads = NUM_THREADS_ANTS
if reg_type == RIGID:
reg.inputs.transforms = ['Rigid', 'Rigid', 'Rigid']
reg.inputs.metric = ['MI', 'MI', 'MI']
reg.inputs.metric_weight = [1] * 2 + [1]
reg.inputs.radius_or_number_of_bins = [32, 32, 32]
reg.inputs.convergence_window_size = [5, 5, 5]
reg.inputs.sampling_strategy = ['Regular'] * 2 + [None]
reg.inputs.sampling_percentage = [0.5] * 2 + [None]
if reg.inputs.initial_moving_transform_com:
reg.inputs.number_of_iterations = ([[
10000, 10000, 10000, 1000, 1000, 1000
], [10000, 10000, 1000, 1000, 1000], [75, 50, 50]])
reg.inputs.shrink_factors = [[12, 9, 5, 3, 2, 1], [5, 4, 3, 2, 1],
[3, 2, 1]]
reg.inputs.smoothing_sigmas = [[9, 8, 4, 2, 1, 0], [4, 3, 2, 1, 0],
[2, 1, 0]]
else:
reg.inputs.number_of_iterations = ([[5000, 5000, 1000, 500],
[5000, 5000, 1000, 500],
[75, 50]])
reg.inputs.shrink_factors = [[7, 5, 2, 1], [4, 3, 2, 1], [2, 1]]
reg.inputs.smoothing_sigmas = [[6, 4, 1, 0], [3, 2, 1, 0],
[0.5, 0]]
reg.inputs.convergence_threshold = [1.e-6] * 3
reg.inputs.sigma_units = ['vox'] * 3
reg.inputs.transform_parameters = [(0.25, ), (0.25, ), (0.25, )]
reg.inputs.use_estimate_learning_rate_once = [True] * 3
reg.inputs.use_histogram_matching = [False, False, True]
elif reg_type == AFFINE or reg_type == COMPOSITEAFFINE or reg_type == SIMILARITY:
if reg_type == AFFINE:
reg.inputs.transforms = ['Rigid', 'Affine', 'Affine']
elif reg_type == SIMILARITY:
reg.inputs.transforms = ['Rigid', 'Similarity', 'Similarity']
else:
reg.inputs.transforms = [
'Rigid', 'CompositeAffine', 'CompositeAffine'
]
reg.inputs.metric = ['MI', 'MI', 'MI']
reg.inputs.metric_weight = [1] * 2 + [1]
reg.inputs.radius_or_number_of_bins = [32, 32, 32]
reg.inputs.convergence_window_size = [5, 5, 5]
reg.inputs.sampling_strategy = ['Regular'] * 2 + [None]
reg.inputs.sampling_percentage = [0.5] * 2 + [None]
if reg.inputs.initial_moving_transform_com:
reg.inputs.number_of_iterations = ([[
10000, 10000, 1000, 1000, 1000
], [10000, 10000, 1000, 1000, 1000], [75, 50, 50]])
reg.inputs.shrink_factors = [[9, 5, 3, 2, 1], [5, 4, 3, 2, 1],
[3, 2, 1]]
reg.inputs.smoothing_sigmas = [[8, 4, 2, 1, 0], [4, 3, 2, 1, 0],
[2, 1, 0]]
else:
reg.inputs.number_of_iterations = ([[5000, 5000, 1000, 500],
[5000, 5000, 1000, 500],
[75, 50]])
reg.inputs.shrink_factors = [[7, 5, 2, 1], [4, 3, 2, 1], [2, 1]]
reg.inputs.smoothing_sigmas = [[6, 4, 1, 0], [3, 2, 1, 0],
[0.5, 0]]
reg.inputs.convergence_threshold = [1.e-6] * 3
reg.inputs.sigma_units = ['vox'] * 3
reg.inputs.transform_parameters = [(0.25, ), (0.25, ), (0.25, )]
reg.inputs.use_estimate_learning_rate_once = [True] * 3
reg.inputs.use_histogram_matching = [False, False, True]
elif reg_type == SYN:
reg.inputs.transforms = ['Rigid', 'Affine', 'SyN']
reg.inputs.metric = ['MI', 'MI', ['MI', 'CC']]
reg.inputs.metric_weight = [1] * 2 + [[0.5, 0.5]]
reg.inputs.radius_or_number_of_bins = [32, 32, [32, 4]]
reg.inputs.convergence_window_size = [5, 5, 5]
reg.inputs.sampling_strategy = ['Regular'] * 2 + [[None, None]]
reg.inputs.sampling_percentage = [0.5] * 2 + [[None, None]]
if reg.inputs.initial_moving_transform_com:
reg.inputs.number_of_iterations = ([[
10000, 10000, 1000, 1000, 1000
], [10000, 10000, 1000, 1000, 1000], [100, 75, 75, 75]])
reg.inputs.shrink_factors = [[9, 5, 3, 2, 1], [5, 4, 3, 2, 1],
[5, 3, 2, 1]]
reg.inputs.smoothing_sigmas = [[8, 4, 2, 1, 0], [4, 3, 2, 1, 0],
[4, 2, 1, 0]]
else:
reg.inputs.number_of_iterations = ([[5000, 5000, 1000, 500],
[5000, 5000, 1000, 500],
[100, 90, 75]])
reg.inputs.shrink_factors = [[7, 5, 2, 1], [4, 3, 2, 1], [4, 2, 1]]
reg.inputs.smoothing_sigmas = [[6, 4, 1, 0], [3, 2, 1, 0],
[1, 0.5, 0]]
reg.inputs.convergence_threshold = [1.e-6] * 2 + [-0.01]
reg.inputs.sigma_units = ['vox'] * 3
reg.inputs.transform_parameters = [(0.25, ), (0.25, ), (0.2, 3.0, 0.0)]
reg.inputs.use_estimate_learning_rate_once = [True] * 3
reg.inputs.use_histogram_matching = [False, False, True]
else:
raise Exception("Wrong registration format " + reg_type)
reg.inputs.winsorize_lower_quantile = 0.005
reg.inputs.winsorize_upper_quantile = 0.995
reg.inputs.write_composite_transform = True
reg.inputs.output_transform_prefix = path + name
transform = path + name + 'InverseComposite.h5'
if os.path.exists(moving_img.processed_filepath) and\
os.path.exists(moving_img.transform):
# generate_image(reg.inputs.output_warped_image, fixed)
return moving_img
util.LOGGER.info("starting registration")
start_time = datetime.datetime.now()
util.LOGGER.info(reg.cmdline)
reg.run()
util.LOGGER.info("Finished registration: ")
util.LOGGER.info(datetime.datetime.now() - start_time)
util.transform_volume(moving_img.pre_processed_filepath,
transform,
outputpath=moving_img.processed_filepath)
shutil.copy(transform, moving_img.transform)
util.generate_image(moving_img.processed_filepath, fixed)
return moving_img
def pre_process(img, do_bet=True):
# pylint: disable= too-many-statements, too-many-locals
""" Pre process the data"""
path = img.temp_data_path
input_file = img.img_filepath
n4_file = path + util.get_basename(input_file) + '_n4.nii.gz'
norm_file = path + util.get_basename(n4_file) + '_norm.nii.gz'
resampled_file = path + util.get_basename(norm_file) + '_resample.nii.gz'
name = util.get_basename(resampled_file) + "_be"
img.pre_processed_filepath = path + name + '.nii.gz'
if os.path.exists(img.pre_processed_filepath) and\
(os.path.exists(path + name + 'Composite.h5') or BE_METHOD == 1):
if BE_METHOD == 0:
img.init_transform = path + name + 'Composite.h5'
util.generate_image(img.pre_processed_filepath, util.TEMPLATE_VOLUME)
return img
n4bias = ants.N4BiasFieldCorrection()
n4bias.inputs.dimension = 3
n4bias.inputs.input_image = input_file
n4bias.inputs.output_image = n4_file
n4bias.run()
# normalization [0,100], same as template
normalize_img = nib.load(n4_file)
temp_data = normalize_img.get_data()
temp_img = nib.Nifti1Image(temp_data/np.amax(temp_data)*100,
normalize_img.affine, normalize_img.header)
temp_img.to_filename(norm_file)
# resample volume to 1 mm slices
target_affine_3x3 = np.eye(3) * 1
img_3d_affine = resample_img(norm_file, target_affine=target_affine_3x3)
nib.save(img_3d_affine, resampled_file)
if not do_bet:
img.pre_processed_filepath = resampled_file
return img
if BE_METHOD == 0:
img.init_transform = path + name + '_InitRegTo' + str(img.fixed_image) + '.h5'
reg = ants.Registration()
# reg.inputs.args = "--verbose 1"
reg.inputs.collapse_output_transforms = True
reg.inputs.fixed_image = resampled_file
reg.inputs.moving_image = util.TEMPLATE_VOLUME
reg.inputs.fixed_image_mask = img.label_inv_filepath
reg.inputs.num_threads = 1
reg.inputs.initial_moving_transform_com = True
reg.inputs.transforms = ['Rigid', 'Affine']
reg.inputs.metric = ['MI', 'MI']
reg.inputs.radius_or_number_of_bins = [32, 32]
reg.inputs.metric_weight = [1, 1]
reg.inputs.convergence_window_size = [5, 5]
reg.inputs.number_of_iterations = ([[10000, 10000, 10000, 10000],
[10000, 10000, 10000, 10000]])
reg.inputs.convergence_threshold = [1.e-6]*2
reg.inputs.shrink_factors = [[9, 5, 3, 1], [9, 5, 3, 1]]
reg.inputs.smoothing_sigmas = [[8, 4, 1, 0], [8, 4, 1, 0]]
reg.inputs.transform_parameters = [(0.25,), (0.25,)]
reg.inputs.sigma_units = ['vox']*2
reg.inputs.use_estimate_learning_rate_once = [True, True]
reg.inputs.write_composite_transform = True
reg.inputs.output_transform_prefix = path + name
reg.inputs.output_warped_image = path + name + '_beReg.nii.gz'
transform = path + name + 'InverseComposite.h5'
print("starting be registration")
reg.run()
print("Finished be registration")
reg_volume = util.transform_volume(resampled_file, transform)
shutil.copy(transform, img.init_transform)
mult = ants.MultiplyImages()
mult.inputs.dimension = 3
mult.inputs.first_input = reg_volume
mult.inputs.second_input = util.TEMPLATE_MASK
mult.inputs.output_product_image = img.pre_processed_filepath
mult.run()
util.generate_image(img.pre_processed_filepath, reg_volume)
elif BE_METHOD == 1:
# http://fsl.fmrib.ox.ac.uk/fsl/fslwiki/BET/UserGuide#Main_bet2_options:
bet = fsl.BET(command="fsl5.0-bet")
bet.inputs.in_file = resampled_file
# pylint: disable= pointless-string-statement
""" fractional intensity threshold (0->1); default=0.5;
smaller values give larger brain outline estimates"""
bet.inputs.frac = 0.25
""" vertical gradient in fractional intensity threshold (-1->1);
default=0; positive values give larger brain outline at bottom,
smaller at top """
bet.inputs.vertical_gradient = 0
""" This attempts to reduce image bias, and residual neck voxels.
This can be useful when running SIENA or SIENAX, for example.
Various stages involving FAST segmentation-based bias field removal
and standard-space masking are combined to produce a result which
can often give better results than just running bet2."""
# bet.inputs.reduce_bias = True
bet.inputs.mask = True
bet.inputs.out_file = img.pre_processed_filepath
bet.run()
util.generate_image(img.pre_processed_filepath, resampled_file)
elif BE_METHOD == 2:
name = util.get_basename(resampled_file) + "_bet"
# http://fsl.fmrib.ox.ac.uk/fsl/fslwiki/BET/UserGuide#Main_bet2_options:
bet = fsl.BET(command="fsl5.0-bet")
bet.inputs.in_file = resampled_file
# pylint: disable= pointless-string-statement
""" fractional intensity threshold (0->1); default=0.5;
smaller values give larger brain outline estimates"""
bet.inputs.frac = 0.1
""" vertical gradient in fractional intensity threshold (-1->1);
default=0; positive values give larger brain outline at bottom,
smaller at top """
bet.inputs.vertical_gradient = 0
""" This attempts to reduce image bias, and residual neck voxels.
This can be useful when running SIENA or SIENAX, for example.
Various stages involving FAST segmentation-based bias field removal
and standard-space masking are combined to produce a result which
can often give better results than just running bet2."""
bet.inputs.reduce_bias = True
bet.inputs.mask = True
bet.inputs.out_file = path + name + '.nii.gz'
print("starting bet registration")
start_time = datetime.datetime.now()
if not os.path.exists(bet.inputs.out_file):
bet.run()
print("Finished bet registration 0: ")
print(datetime.datetime.now() - start_time)
name = name + "_be"
img.pre_processed_filepath = path + name + '.nii.gz'
img.init_transform = path + name + '_InitRegTo' + str(img.fixed_image) + '.h5'
reg = ants.Registration()
# reg.inputs.args = "--verbose 1"
reg.inputs.collapse_output_transforms = True
reg.inputs.fixed_image = bet.inputs.out_file
reg.inputs.moving_image = util.TEMPLATE_MASKED_VOLUME
reg.inputs.fixed_image_mask = img.label_inv_filepath
reg.inputs.num_threads = 8
reg.inputs.initial_moving_transform_com = True
reg.inputs.transforms = ['Rigid', 'Affine']
reg.inputs.metric = ['MI', 'MI']
reg.inputs.radius_or_number_of_bins = [32, 32]
reg.inputs.metric_weight = [1, 1]
reg.inputs.convergence_window_size = [5, 5]
reg.inputs.sampling_strategy = ['Regular'] * 2
reg.inputs.sampling_percentage = [0.5] * 2
reg.inputs.number_of_iterations = ([[10000, 10000, 5000, 5000],
[10000, 10000, 5000, 5000]])
reg.inputs.shrink_factors = [[9, 5, 3, 1], [9, 5, 3, 1]]
reg.inputs.smoothing_sigmas = [[8, 4, 1, 0], [8, 4, 1, 0]]
reg.inputs.transform_parameters = [(0.25,), (0.25,)]
reg.inputs.convergence_threshold = [1.e-6]*2
reg.inputs.sigma_units = ['vox']*2
reg.inputs.use_estimate_learning_rate_once = [True, True]
reg.inputs.write_composite_transform = True
reg.inputs.output_transform_prefix = path + name
reg.inputs.output_warped_image = path + name + '_TemplateReg.nii.gz'
transform = path + name + 'InverseComposite.h5'
print("starting be registration")
start_time = datetime.datetime.now()
if not os.path.exists(reg.inputs.output_warped_image):
reg.run()
print("Finished be registration: ")
print(datetime.datetime.now() - start_time)
reg_volume = util.transform_volume(resampled_file, transform)
shutil.copy(transform, img.init_transform)
mult = ants.MultiplyImages()
mult.inputs.dimension = 3
mult.inputs.first_input = reg_volume
mult.inputs.second_input = util.TEMPLATE_MASK
mult.inputs.output_product_image = img.pre_processed_filepath
mult.run()
util.generate_image(img.pre_processed_filepath, reg_volume)
print("---BET", img.pre_processed_filepath)
return img
def execute(self):
# Copiar datos de carpeta incoming a carpeta destino con integridad de datos
# Para verificar la integridad se cogera cada fichero y se le calculara el md5. Cuando se copie al destino se calculara
# tambien el md5 para verificar que la copia se ha realizado correctamente
Comandos.log.info('Copy files')
# Filtrar todos los ficheros que hay en incoming para quedarse solo con los que se necesitan copiar (estan en files)
incomingFiles = os.listdir(self.incomingFolder)
if self.files != None:
incomingFilesFiltered = list(
filter(lambda f: f in self.files, incomingFiles))
else:
incomingFilesFiltered = incomingFiles
# Si no hay ficheros que copiar el proceso ha finalizado
if len(incomingFilesFiltered) == 0:
Comandos.log.info('No files to process')
return
# Crear carpeta destino si no existe
util.create_folder_if_not_exist(self.destinationFolder)
# Copiar solo los ficheros filtrados
incomingFilesFullPath = list()
for file in incomingFilesFiltered:
incomingFile = self.incomingFolder + os.sep + file
shutil.copy2(incomingFile, self.destinationFolder)
Comandos.log.info('Copy file ' + incomingFile + ' to ' +
self.destinationFolder)
incomingFilesFullPath.append(incomingFile)
# Calcular el hash de cada fichero origen, de cada fichero destino y verificar que son el mismo para verificar integridad
# Recuperar los nombres de fichero originales
Comandos.log.info('Files: ' + str(incomingFilesFiltered))
# Lista donde se guardaran todos los ficheros pertenecientes al caso, todos con los mismos atributos CASE, ID y ALIAS
forensicCase = list()
for incomingFile in incomingFilesFullPath:
destinationFile = self.destinationFolder + os.sep + util.get_basename(
incomingFile)
md5IncomingFile = util.get_md5(incomingFile)
md5DestinationFile = util.get_md5(destinationFile)
if md5IncomingFile != md5DestinationFile:
Comandos.log.error('Error: integrity error file ' +
incomingFile)
print('Error: integrity error file ' + incomingFile)
return
# Recuperar datos del fichero copiado
dataFile = os.stat(destinationFile)
fileCase = model.FileCase(
caseName=self.caseName,
idCase=self.idCase,
alias=self.alias,
size=util.get_bytes_in_megabytes(dataFile.st_size),
fileName=util.get_basename(destinationFile),
hashMd5=md5DestinationFile,
# Fecha de creacion del fichero original
creationTime=util.format_date_time(
time.ctime(os.stat(incomingFile).st_ctime)),
# Fecha de creacion del fichero copiado
copyTime=util.format_date_time(time.ctime(dataFile.st_ctime)),
fileType=util.get_extension(destinationFile))
forensicCase.append(fileCase)
Comandos.log.debug('Copy files to destination finished')
# TODO se podran eliminar los antiguos una vez copiados?
Comandos.log.debug("Registers: " + pprint.pformat(forensicCase))
# Conectar a bbdd, creando la tabla "filecase" si no existe, y guardar todos los casos
Comandos.log.info('Inserting metadata in database: %s', forensicCase)
try:
model.db.connect()
model.db.create_table(model.FileCase, safe=True)
with model.db.transaction():
[fileCase.save(force_insert=True) for fileCase in forensicCase]
except:
Comandos.log.error('Database error, aborting operation')
return
finally:
model.db.close()
Comandos.log.info('Metadata inserted in database')
# Guardar los ficheros en un fichero de texto con campos separados por |
Comandos.log.info('Creating CSV file')
csv = [fileCase.get_text_format() for fileCase in forensicCase]
# Poner cada fichero del caso en una linea distinta y guardar en fichero
# El nombre de fichero sera la composicion de caso, id y alias y con extension csv
csvContent = util.join_list('\n', csv)
csvName = self.caseName + '_' + str(
self.idCase) + '_' + self.alias + '.csv'
csvFile = open(csvName, 'w')
csvFile.write(csvContent)
csvFile.close()
Comandos.log.info('CSV file created')
Comandos.log.info('Copy finished')
def _get_output_dir_from_ckpt_dir(ckpt_dir):
dir_basename = util.get_basename(ckpt_dir, include_path=False)
return f"{self.TRACK_PATH}/outputs/{dir_basename}"
def registration(moving_img, fixed, reg_type):
# pylint: disable= too-many-statements
"""Image2Image registration """
reg = ants.Registration()
path = moving_img.temp_data_path
name = util.get_basename(moving_img.pre_processed_filepath) + '_' + reg_type
moving_img.processed_filepath = path + name + '_RegTo' + str(moving_img.fixed_image) + '.nii.gz'
moving_img.transform = path + name + '_RegTo' + str(moving_img.fixed_image) + '.h5'
init_moving_transform = moving_img.init_transform
if init_moving_transform is not None and os.path.exists(init_moving_transform):
print("Found initial transform")
# reg.inputs.initial_moving_transform = init_moving_transform
reg.inputs.initial_moving_transform_com = False
mask = util.transform_volume(moving_img.label_inv_filepath,
moving_img.init_transform, label_img=True)
else:
reg.inputs.initial_moving_transform_com = True
mask = moving_img.label_inv_filepath
reg.inputs.collapse_output_transforms = True
reg.inputs.fixed_image = moving_img.pre_processed_filepath
reg.inputs.fixed_image_mask = mask
reg.inputs.moving_image = fixed
reg.inputs.num_threads = 8
if reg_type == RIGID:
reg.inputs.transforms = ['Rigid']
reg.inputs.metric = ['MI']
reg.inputs.radius_or_number_of_bins = [32]
reg.inputs.convergence_window_size = [5]
reg.inputs.number_of_iterations = ([[10000, 10000, 10000, 10000, 10000]])
reg.inputs.shrink_factors = [[5, 4, 3, 2, 1]]
reg.inputs.smoothing_sigmas = [[4, 3, 2, 1, 0]]
reg.inputs.sigma_units = ['vox']
reg.inputs.transform_parameters = [(0.25,)]
reg.inputs.use_histogram_matching = [True]
reg.inputs.metric_weight = [1.0]
elif reg_type == AFFINE:
reg.inputs.transforms = ['Rigid', 'Affine']
reg.inputs.metric = ['MI', ['MI', 'CC']]
reg.inputs.metric_weight = [1] + [[0.5, 0.5]]
reg.inputs.radius_or_number_of_bins = [32, [32, 4]]
reg.inputs.convergence_window_size = [5, 5]
reg.inputs.sampling_strategy = ['Regular'] + [[None, None]]
reg.inputs.sampling_percentage = [0.5] + [[None, None]]
if reg.inputs.initial_moving_transform_com:
reg.inputs.number_of_iterations = ([[10000, 10000, 1000, 1000, 1000],
[10000, 10000, 1000, 1000, 1000]])
reg.inputs.shrink_factors = [[9, 5, 3, 2, 1], [5, 4, 3, 2, 1]]
reg.inputs.smoothing_sigmas = [[8, 4, 2, 1, 0], [4, 3, 2, 1, 0]]
else:
reg.inputs.number_of_iterations = ([[5000, 5000, 1000, 500],
[5000, 5000, 1000, 500]])
reg.inputs.shrink_factors = [[7, 5, 2, 1], [4, 3, 2, 1]]
reg.inputs.smoothing_sigmas = [[6, 4, 1, 0], [3, 2, 1, 0]]
reg.inputs.convergence_threshold = [1.e-6] + [-0.01]
reg.inputs.sigma_units = ['vox']*2
reg.inputs.transform_parameters = [(0.25,),
(0.25,)]
reg.inputs.use_estimate_learning_rate_once = [True] * 2
reg.inputs.use_histogram_matching = [False, True]
elif reg_type == SYN:
reg.inputs.transforms = ['Rigid', 'Affine', 'SyN']
reg.inputs.metric = ['MI', 'MI', ['MI', 'CC']]
reg.inputs.metric_weight = [1] * 2 + [[0.5, 0.5]]
reg.inputs.radius_or_number_of_bins = [32, 32, [32, 4]]
reg.inputs.convergence_window_size = [5, 5, 5]
reg.inputs.sampling_strategy = ['Regular'] * 2 + [[None, None]]
reg.inputs.sampling_percentage = [0.5] * 2 + [[None, None]]
if reg.inputs.initial_moving_transform_com:
reg.inputs.number_of_iterations = ([[10000, 10000, 1000, 1000, 1000],
[10000, 10000, 1000, 1000, 1000],
[100, 75, 75, 75]])
reg.inputs.shrink_factors = [[9, 5, 3, 2, 1], [5, 4, 3, 2, 1], [5, 3, 2, 1]]
reg.inputs.smoothing_sigmas = [[8, 4, 2, 1, 0], [4, 3, 2, 1, 0], [4, 2, 1, 0]]
else:
reg.inputs.number_of_iterations = ([[5000, 5000, 1000, 500],
[5000, 5000, 1000, 500],
[100, 90, 75]])
reg.inputs.shrink_factors = [[7, 5, 2, 1], [4, 3, 2, 1], [4, 2, 1]]
reg.inputs.smoothing_sigmas = [[6, 4, 1, 0], [3, 2, 1, 0], [1, 0.5, 0]]
reg.inputs.convergence_threshold = [1.e-6] * 2 + [-0.01]
reg.inputs.sigma_units = ['vox']*3
reg.inputs.transform_parameters = [(0.25,),
(0.25,),
(0.2, 3.0, 0.0)]
reg.inputs.use_estimate_learning_rate_once = [True] * 3
reg.inputs.use_histogram_matching = [False, False, True]
else:
raise Exception("Wrong registration format " + reg_type)
reg.inputs.winsorize_lower_quantile = 0.005
reg.inputs.winsorize_upper_quantile = 0.995
reg.inputs.write_composite_transform = True
reg.inputs.output_transform_prefix = path + name
transform = path + name + 'InverseComposite.h5'
if os.path.exists(moving_img.processed_filepath) and\
os.path.exists(moving_img.transform):
# generate_image(reg.inputs.output_warped_image, fixed)
return moving_img
print("starting registration")
start_time = datetime.datetime.now()
reg.run()
print("Finished registration: ")
print(datetime.datetime.now() - start_time)
util.transform_volume(moving_img.pre_processed_filepath, transform,
outputpath=moving_img.processed_filepath)
shutil.copy(transform, moving_img.transform)
util.generate_image(moving_img.processed_filepath, fixed)
return moving_img
def process_tracts(folder):
""" Post process data tumor volume"""
util.setup(folder)
print(folder)
thres = 0.75
atlas_paths = ["/mnt/b7cde2db-ac2d-4cbb-b2b0-a9b110f05d32/data/Segmentations/WM_tracts/Arcuate/Arcuate_Left.nii",
"/mnt/b7cde2db-ac2d-4cbb-b2b0-a9b110f05d32/data/Segmentations/WM_tracts/Arcuate/Arcuate_Right.nii",
"/mnt/b7cde2db-ac2d-4cbb-b2b0-a9b110f05d32/data/Segmentations/WM_tracts/Anterior_Commissure/Anterior_Commissure.nii",
"/mnt/b7cde2db-ac2d-4cbb-b2b0-a9b110f05d32/data/Segmentations/WM_tracts/Cerebellar/Cortico_Ponto_Cerebellum_Left.nii",
"/mnt/b7cde2db-ac2d-4cbb-b2b0-a9b110f05d32/data/Segmentations/WM_tracts/Cerebellar/Cortico_Ponto_Cerebellum_Right.nii",
"/mnt/b7cde2db-ac2d-4cbb-b2b0-a9b110f05d32/data/Segmentations/WM_tracts/Cerebellar/Inferior_Cerebellar_Pedunculus_Left.nii",
"/mnt/b7cde2db-ac2d-4cbb-b2b0-a9b110f05d32/data/Segmentations/WM_tracts/Cerebellar/Inferior_Cerebellar_Pedunculus_Right.nii",
"/mnt/b7cde2db-ac2d-4cbb-b2b0-a9b110f05d32/data/Segmentations/WM_tracts/Cerebellar/Superior_Cerebelar_Pedunculus_Left.nii",
"/mnt/b7cde2db-ac2d-4cbb-b2b0-a9b110f05d32/data/Segmentations/WM_tracts/Cerebellar/Superior_Cerebelar_Pedunculus_Right.nii",
"/mnt/b7cde2db-ac2d-4cbb-b2b0-a9b110f05d32/data/Segmentations/WM_tracts/Cingulum/Cingulum_Left.nii",
"/mnt/b7cde2db-ac2d-4cbb-b2b0-a9b110f05d32/data/Segmentations/WM_tracts/Cingulum/Cingulum_Right.nii",
"/mnt/b7cde2db-ac2d-4cbb-b2b0-a9b110f05d32/data/Segmentations/WM_tracts/Corpus_Callosum/Corpus_Callosum.nii",
"/mnt/b7cde2db-ac2d-4cbb-b2b0-a9b110f05d32/data/Segmentations/WM_tracts/Fornix/Fornix.nii",
"/mnt/b7cde2db-ac2d-4cbb-b2b0-a9b110f05d32/data/Segmentations/WM_tracts/Inferior_Network/Inferior_Longitudinal_Fasciculus_Left.nii",
"/mnt/b7cde2db-ac2d-4cbb-b2b0-a9b110f05d32/data/Segmentations/WM_tracts/Inferior_Network/Inferior_Longitudinal_Fasciculus_Right.nii",
"/mnt/b7cde2db-ac2d-4cbb-b2b0-a9b110f05d32/data/Segmentations/WM_tracts/Inferior_Network/Inferior_Occipito_Frontal_Fasciculus_Left.nii",
"/mnt/b7cde2db-ac2d-4cbb-b2b0-a9b110f05d32/data/Segmentations/WM_tracts/Inferior_Network/Inferior_Occipito_Frontal_Fasciculus_Right.nii",
"/mnt/b7cde2db-ac2d-4cbb-b2b0-a9b110f05d32/data/Segmentations/WM_tracts/Inferior_Network/Uncinate_Left.nii",
"/mnt/b7cde2db-ac2d-4cbb-b2b0-a9b110f05d32/data/Segmentations/WM_tracts/Inferior_Network/Uncinate_Right.nii",
"/mnt/b7cde2db-ac2d-4cbb-b2b0-a9b110f05d32/data/Segmentations/WM_tracts/Optic_Radiations/Optic_Radiations_Left.nii",
"/mnt/b7cde2db-ac2d-4cbb-b2b0-a9b110f05d32/data/Segmentations/WM_tracts/Optic_Radiations/Optic_Radiations_Right.nii",
"/mnt/b7cde2db-ac2d-4cbb-b2b0-a9b110f05d32/data/Segmentations/WM_tracts/Perisylvian/Anterior_Segment_Left.nii",
"/mnt/b7cde2db-ac2d-4cbb-b2b0-a9b110f05d32/data/Segmentations/WM_tracts/Perisylvian/Anterior_Segment_Right.nii",
"/mnt/b7cde2db-ac2d-4cbb-b2b0-a9b110f05d32/data/Segmentations/WM_tracts/Perisylvian/Long_Segment_Left.nii",
"/mnt/b7cde2db-ac2d-4cbb-b2b0-a9b110f05d32/data/Segmentations/WM_tracts/Perisylvian/Long_Segment_Right.nii",
"/mnt/b7cde2db-ac2d-4cbb-b2b0-a9b110f05d32/data/Segmentations/WM_tracts/Perisylvian/Posterior_Segment_Left.nii",
"/mnt/b7cde2db-ac2d-4cbb-b2b0-a9b110f05d32/data/Segmentations/WM_tracts/Perisylvian/Posterior_Segment_Right.nii",
"/home/dahoiv/disk/Dropbox/Jobb/gbm/FINAL_RES_GBM_0919_09_06_2017/WM_tracts/Projections/Internal_Capsule.nii"
]
for atlas_path in atlas_paths:
tract = util.get_basename(atlas_path)
resample = slicer.registration.brainsresample.BRAINSResample(command=util.BRAINSResample_PATH,
inputVolume=atlas_path,
outputVolume=os.path.abspath(folder + tract + '.nii.gz'),
referenceVolume=os.path.abspath(util.TEMPLATE_VOLUME))
print(resample.cmdline)
resample.run()
conn = sqlite3.connect(util.DB_PATH, timeout=120)
conn.text_factory = str
cursor = conn.execute('''SELECT pid from Patient where study_id = ?''', ("qol_grade3,4", ))
book = Workbook()
sheet = book.active
sheet.cell(row=1, column=1).value = 'PID'
k = 2
for pid in cursor:
pid = pid[0]
_id = conn.execute('''SELECT id from Images where pid = ?''', (pid, )).fetchone()
if not _id:
print("---No data for ", pid)
continue
_id = _id[0]
_filepath = conn.execute("SELECT filepath_reg from Labels where image_id = ?",
(_id, )).fetchone()[0]
if _filepath is None:
print("No filepath for ", pid)
continue
tumor_data = nib.load(util.DATA_FOLDER + _filepath).get_data()
sheet.cell(row=k, column=1).value = pid
m = 1
for atlas_path in atlas_paths:
tract = util.get_basename(atlas_path)
if 'Internal_Capsule' not in tract:
continue
m += 1
sheet.cell(row=1, column=m).value = tract
atlas_data = nib.load(folder + tract + '.nii.gz').get_data()
union_data = atlas_data * tumor_data
sheet.cell(row=k, column=m).value = '1' if np.max(union_data) >= thres else '0'
k += 1
book.save("brain_tracts_Internal_Capsule.xlsx")
