fun=chi_star_func,method='TNC',x0=load('/home/raid3/vonhof/Documents/Riccardo_Data/230317/phantom_32_phs.nii.gz'),
bounds=None,
options=dict(maxiter=500, disp=500))
# print('Your results are: \n '+str(minimization)) # debug
chi_arr = minimization['x'].reshape(shape)
return chi_arr
# ======================================================================
# calling the function:
if __name__ == '__main__':
begin_time = datetime.datetime.now()
chi_arr = chi_star(
f=load('/home/raid3/vonhof/Documents/Riccardo_Data/230317/phantom_32_phs.nii.gz') * 100)
# saving the results here:
i = 0
template = '/home/raid3/vonhof/Documents/Riccardo_Data/230317/phantom_32_phs_TNC_nobound_{i}.nii.gz'
filepath = template.format_map(locals())
while os.path.isfile(filepath):
i += 1
filepath = template.format_map(locals())
save(filepath ,chi_arr)
end_time = datetime.datetime.now()
time_elapsed = end_time - begin_time
print('Time elapsed: {c} seconds!'.format(c=time_elapsed))
# results for:
def chi_star(
f=None,
shape=None,
d=None,
W=None,
M_G=None,
chi=None,
lambda_=np.power(10.,-3)):
"""
Minimization using scipy.optimize.minimize() and method='BFGS'.
The function takes input data and a guess for chi to perform
the minimization according to the scipy.optimize.minimize() function
with the method='BFGS'.
It calculates all necessary parameters if not provided for the input
of the minimization to be of the form:
.. math:
0.5 * ((np.linalg.norm(
W * (f - np.fft.ifftn(d * np.fft.fftn(chi))))) ** 2 +
lambda_ * np.sum(abs((M_G) * (np.gradient(chi)))))
Args:
f (np.ndarray): Input data that is to be minimized.
If not specified, takes it as (3,3,3) array of ones.
shape (tuple[int]): The shape of the input data.
By default this is (3,3,3).
d (np.ndarray): The kernel of the respective dipole field,
by default the dipole kernel in Fourier space according to the
'dipole_kernel' function.
W (np.ndarray): Data weighting term.
By default array of ones in shape of f.
M_G (np.ndarray): Mask of the data.
By default an array of ones in shape of f.
chi (np.ndarray): Term that is actively fitted/guessed.
By default an array of ones in the shape of f.
lambda_ (float): Numerical parameter taken according to the situation.
By default, it is 0.001.
time_ (bool): Boolean, gives choice if time for run should be printed.
By default it is printed (i.e. set to True).
Returns:
"""
# : setting the initial values:
if f is None:
f = np.ones((3,3,3))
if shape is None:
shape = f.shape
ones = np.ones((shape))
if chi is None:
chi = ones
if W is None:
W = ones
if M_G is None:
M_G = ones
if d is None:
d = dipole_kernel(shape=shape, origin=0.)
def chi_star_func(chi=chi, f=f, d=d, W=W, M_G=M_G, lambda_=lambda_):
"""Calculates the input for the minimazation."""
chi = chi.reshape(shape)
result = 0.5 * (np.linalg.norm(
W * (f - np.fft.ifftn(d * np.fft.fftn(chi)))) ** 2 +
lambda_ * np.sum(abs((M_G) * (pmu.gradient(arr=chi)))))
return result
# performs the minimization
minimization = scipy.optimize.minimize(
fun=chi_star_func,method='TNC',x0=load('/home/raid3/vonhof/Documents/Riccardo_Data/230317/phantom_32_phs.nii.gz'),
bounds=None,
options=dict(maxiter=500, disp=500))
# print('Your results are: \n '+str(minimization)) # debug
chi_arr = minimization['x'].reshape(shape)
return chi_arr
fun=chi_star_func,
method='TNC',
x0=load(
'/home/raid3/vonhof/Documents/Riccardo_Data/230317/phantom_32_phs.nii.gz'
),
bounds=None,
options=dict(maxiter=1, disp=100))
# print('Your results are: \n '+str(minimization)) # debug
chi_arr = minimization['x'].reshape(shape)
return chi_arr
# ======================================================================
# calling the function:
if __name__ == '__main__':
begin_time = datetime.datetime.now()
chi_arr = chi_star(f=load(
'/home/raid3/vonhof/Documents/Riccardo_Data/230317/phantom_32_phs.nii.gz'
))
# saving the results here:
save(
'/home/raid3/vonhof/Documents/Riccardo_Data/230317/phantom_32_phs_TNC_one_iter.nii.gz',
chi_arr)
end_time = datetime.datetime.now()
time_elapsed = end_time - begin_time
print('Time elapsed: {c} seconds!'.format(c=time_elapsed))
def abcd():
abcd = load(
'/home/raid3/vonhof/Documents/Riccardo Data/1703_phantomStuff/dipole_kernel_128.nii.gz'
)
return abcd
#aaddfda = scipy.optimize.minimize(fun=input_Gauss, x0=0.,method='Nelder-Mead')
import nibabel as nib
from pymrt.input_output import load, save
# put thtis into the equation to actually make up the function for input f
def abcd():
abcd = load(
'/home/raid3/vonhof/Documents/Riccardo Data/1703_phantomStuff/dipole_kernel_128.nii.gz'
)
return abcd
db_zero = load(
'/home/raid3/vonhof/Documents/Riccardo Data/1703_phantomStuff/phantom_db0.nii.gz'
)
def data_input(db_zero):
return
#other_adfaother_test = scipy.optimize.minimize(fun=abcd,method='BFGS',x0=0.)
#print(abcd.shape)
# correct dipole kernel function without error message:
def dipole_kernel(shape, origin=0.5, theta=0.0, phi=0.0):
"""
def compute_generic(sources,
out_dirpath,
params=None,
opts=None,
force=False,
verbose=D_VERB_LVL):
"""
Perform the specified computation on source files.
Args:
sources (list[str]): Directory containing data files.
out_dirpath (str): Directory containing metadata files.
params (dict): Parameters associated with the sources.
opts (dict):
Accepted options:
- types (list[str]): List of image types to use for results.
- mask: (tuple[tuple[int]): Slicing for each dimension.
- adapt_mask (bool): adapt over- or under-sized mask.
- dtype (str): data type to be used for the target images.
- compute_func (str): function used for the computation.
compute_func(images, params, compute_args, compute_kwargs)
-> img_list, img_type_list
- compute_args (list): additional positional parameters for
compute_func
- compute_kwargs (dict): additional keyword parameters for
compute_func
- affine_func (str): name of the function for affine
computation: affine_func(affines, affine_args...) -> affine
- affine_args (list): additional parameters for affine_func
force (bool): Force calculation of output
verbose (int): Set level of verbosity.
Returns:
targets ():
See Also:
pymrt.computation.sources_generic,
pymrt.computation.compute,
pymrt.computation.D_OPTS
"""
# TODO: implement affine_func, affine_args, affine_kwargs?
# get the num, name and seq from first source file
opts = pmu.merge_dicts(D_OPTS, opts)
if params is None:
params = {}
if opts is None:
opts = {}
targets = []
info = pmn.parse_filename(sources[0])
if 'ProtocolName' in params:
info['name'] = params['ProtocolName']
for image_type in opts['types']:
info['type'] = image_type
targets.append(os.path.join(out_dirpath, pmn.to_filename(info)))
# perform the calculation
if pmu.check_redo(sources, targets, force):
if verbose > VERB_LVL['none']:
print('{}:\t{}'.format('Object', os.path.basename(info['name'])))
if verbose >= VERB_LVL['medium']:
print('Opts:\t{}'.format(json.dumps(opts)))
images, affines = [], []
mask = [(slice(*dim) if dim is not None else slice(None))
for dim in opts['mask']]
for source in sources:
if verbose > VERB_LVL['none']:
print('Source:\t{}'.format(os.path.basename(source)))
if verbose > VERB_LVL['none']:
print('Params:\t{}'.format(params))
image, affine, header = pmio.load(source, full=True)
# fix mask if shapes are different
if opts['adapt_mask']:
mask = [(mask[i] if i < len(mask) else slice(None))
for i in range(len(image.shape))]
images.append(image[mask])
affines.append(affine)
if 'compute_func' in opts:
compute_func = eval(opts['compute_func'])
if 'compute_args' not in opts:
opts['compute_args'] = []
if 'compute_kwargs' not in opts:
opts['compute_kwargs'] = {}
img_list, aff_list, img_type_list, params_list = compute_func(
images, affines, params, *opts['compute_args'],
**opts['compute_kwargs'])
else:
img_list, aff_list, img_type_list = zip(
*[(img, aff, img_type) for img, aff, img_type in zip(
images, affines, itertools.cycle(opts['types']))])
params_list = ({}, ) * len(img_list)
for target, target_type in zip(targets, opts['types']):
for img, aff, img_type, params in \
zip(img_list, aff_list, img_type_list, params_list):
if img_type == target_type:
if 'dtype' in opts:
img = img.astype(opts['dtype'])
if params:
for key, val in params.items():
target = pmn.change_param_val(target, key, val)
if verbose > VERB_LVL['none']:
print('Target:\t{}'.format(os.path.basename(target)))
pmio.save(target, img, aff)
break
return targets
def ext_qsm_as_legacy(
images,
affines,
params,
te_label,
# b0_label,
# th_label,
img_types):
"""
Args:
images ():
affines ():
params ():
te_label ():
img_types ():
Returns:
"""
# determine correct TE
max_te = 25.0 # ms
selected = len(params[te_label])
for i, te in enumerate(params[te_label]):
if te < max_te:
selected = i
tmp_dirpath = '/tmp/{}'.format(hashlib.md5(str(params)).hexdigest())
if not os.path.isdir(tmp_dirpath):
os.makedirs(tmp_dirpath)
tmp_filenames = ('magnitude.nii.gz', 'phase.nii.gz', 'qsm.nii.gz',
'mask.nii.gz')
tmp_filepaths = tuple(
os.path.join(tmp_dirpath, tmp_filename)
for tmp_filename in tmp_filenames)
# export temp input
if len(images) > 2:
images = images[-2:]
affines = affines[-2:]
for image, affine, tmp_filepath in zip(images, affines, tmp_filepaths):
pmio.save(tmp_filepath, image[..., selected], affine)
# execute script on temp input
cmd = [
'qsm_as_legacy.py',
'--magnitude_input',
tmp_filepaths[0],
'--phase_input',
tmp_filepaths[1],
'--qsm_output',
tmp_filepaths[2],
'--mask_output',
tmp_filepaths[3],
'--echo_time',
str(params[te_label][selected]),
# '--field_strength', str(params[b0_label][selected]),
# '--angles', str(params[th_label][selected]),
'--units',
'ppb'
]
pmu.execute(str(' '.join(cmd)))
# import temp output
img_list, aff_list = [], []
for tmp_filepath in tmp_filepaths[2:]:
img, aff, hdr = pmio.load(tmp_filepath, full=True)
img_list.append(img)
aff_list.append(aff)
# clean up tmp files
if os.path.isdir(tmp_dirpath):
shutil.rmtree(tmp_dirpath)
# prepare output
type_list = ('qsm', 'mask')
params_list = ({'te': params[te_label][selected]}, {})
img_type_list = tuple(img_types[key] for key in type_list)
return img_list, aff_list, img_type_list, params_list