def pad_template_data_after_loop(template, path_to_template, pad_size=2, save=True, ndim=3):
if isinstance(template, (str, np.str, np.string_, np.unicode_)):
image = load_nii(template)
else:
image = template.copy()
padded_template = padding(image, pad_size=pad_size, ndim=ndim)
if save:
save_nii(padded_template, path_to_template)
return padded_template
def load_data_from_dirs(path_to_data, data_type, file_type):
data = []
subj_names = []
path = sorted(os.listdir(path_to_data))
for subj in tqdm(path, desc='loading subjects'):
path_to_subj = os.path.join(os.path.join(path_to_data, subj), 'nii')
image = load_nii(path_to_subj, data_type)
if image.sum() != 0:
if file_type == 'nii':
data.append(image)
if file_type == 'path':
data.append(os.path.join(path_to_subj, data_type + '.nii'))
subj_names.append(subj)
return data, subj_names
def load_data_from_one_dir(path_to_data, file_type, target_type):
data, target = [], []
subj = sorted(os.listdir(path_to_data))
for subj in tqdm(subj, desc='loading subjects'):
for k, i in target_type.items():
if k in subj:
target += [i]
path_to_subj = os.path.join(path_to_data, subj)
if file_type == 'nii':
data += [load_nii(path_to_subj, file_type)]
if file_type == 'path':
data += [path_to_subj]
print('data shape {}, target shape {}'.format(
np.array(data).shape,
np.array(target).shape))
return np.squeeze(np.array(data)), np.squeeze(np.array(target))
def update_template(template, template_path, template_name, delta, learning_rate=0.1):
if isinstance(template, (str, np.string_, np.str, np.unicode_)):
image = load_nii(template)
else:
image = template.copy()
if image.shape != delta.shape:
print('Error not correct shape or resolution')
raise TypeError
image -= learning_rate * delta
save_nii(image, os.path.join(template_path, template_name))
if isinstance(template, np.ndarray):
return image
elif isinstance(template, (str, np.string_, np.str, np.unicode_)):
return os.path.join(template_path, template_name)
else:
raise TypeError('Unknown type of template')
def one_to_one(data1, data2, **kwargs):
a, b = kwargs['a'], kwargs['b']
# registration
similarity = rtk.SSD(variance=kwargs['ssd_var'])
regularizer = rtk.BiharmonicRegularizer(convexity_penalty=a,
norm_penalty=b)
reg = rtk.LDDMM(regularizer=regularizer,
similarity=similarity,
n_jobs=1,
**kwargs['reg_params'])
if kwargs['file_type'] == 'path':
data1 = load_nii(data1)
if isinstance(data2, (str, np.str, np.string_, np.unicode_)):
data2 = load_nii(data2)
if kwargs['change_res']:
data1 = np.squeeze(
change_resolution(data1, kwargs['init_resolution'],
multiple=False))
if kwargs['add_padding']:
# should be add by all iterations! (if two times!! fix it by add pad size!)
data1 = padding(data1,
ndim=data1.ndim,
pad_size=kwargs['pad_size'],
mode='edge')
kwargs['shape'] = data1.shape
kwargs['ndim'] = data1.ndim
# inverse means that we would like to find path from X to template
# it means that we would like to find vf[-1] ~ vf^(-1)[0]
if data1.shape != data2.shape:
if data1.shape < data2.shape:
pad_size = data2.shape[0] - data1.shape[0]
data1 = padding(data1,
ndim=data1.ndim,
pad_size=pad_size,
mode='edge')
kwargs['pad_size'] += pad_size
elif data1.shape > data2.shape:
pad_size = data1.shape[0] - data2.shape[0]
data1 = padding(data2,
ndim=data2.ndim,
pad_size=pad_size,
mode='edge')
kwargs['pad_size'] += pad_size
else:
raise TypeError(
str(data1.shape) + '!=' + str(data2.shape),
'data shape != template shape')
if kwargs['inverse']:
# first image = fixed, second = moving
reg.set_images(rtk.ScalarImage(data=data2),
rtk.ScalarImage(data=data1))
else:
reg.set_images(rtk.ScalarImage(data=data1),
rtk.ScalarImage(data=data2))
warp = reg.execute()
# get resulting vector field in one resolution
# if vf0=True, get (1, ndim, img_shape), else get (t, ndim, img_shape)
if kwargs['pipe_template']:
gc.collect()
return template_pipeline_derivatives(
reg=copy.deepcopy(reg),
regularizer=regularizer,
data=data1,
template=data2,
a=a,
b=b,
epsilon=kwargs['epsilon'],
shape=data1.shape,
inverse=kwargs['inverse'],
params_der=kwargs['params_der'],
optim_template=kwargs['optim_template'],
window=kwargs['window'],
n_jobs=kwargs['n_jobs'])
else:
gc.collect()
return pairwise_pipeline_derivatives(reg, kwargs['inverse'])
def get_shape(img):
if isinstance(img, (str, np.str, np.string_, np.unicode_)):
tmp_img = load_nii(img)
return tmp_img.shape
if isinstance(img, (np.ndarray)):
return img.shape
def load_images(path):
images = []
for subj in path:
images.append(load_nii(subj, None))
return np.array(images)