def main(argv=None):
"""
Main function
:param argv:
:return:
"""
parser = get_parser()
arguments = parser.parse_args(argv)
verbose = arguments.v
set_global_loglevel(verbose=verbose)
# check number of input args
if not len(arguments.i) == len(arguments.order):
raise Exception(
"Number of items between flags '-i' and '-order' should be the same."
)
if not len(arguments.bval) == len(arguments.bvec):
raise Exception(
"Number of files for bval and bvec should be the same.")
# Concatenate NIFTI files
im_list = [Image(fname) for fname in arguments.i]
im_concat = concat_data(im_list, dim=3, squeeze_data=False)
im_concat.save(arguments.o)
printv("Generated file: {}".format(arguments.o))
# Concatenate bvals and bvecs
bvals_concat = ''
bvecs_concat = ['', '', '']
i_dwi = 0 # counter for DWI files, to read in bvec/bval files
for i_item in range(len(arguments.order)):
if arguments.order[i_item] == 'b0':
# count number of b=0
n_b0 = Image(arguments.i[i_item]).dim[3]
bval = np.array([0.0] * n_b0)
bvec = np.array([[0.0, 0.0, 0.0]] * n_b0)
elif arguments.order[i_item] == 'dwi':
# read bval/bvec files
bval, bvec = read_bvals_bvecs(arguments.bval[i_dwi],
arguments.bvec[i_dwi])
i_dwi += 1
# Concatenate bvals
bvals_concat += ' '.join(str(v) for v in bval)
bvals_concat += ' '
# Concatenate bvecs
for i in (0, 1, 2):
bvecs_concat[i] += ' '.join(
str(v) for v in map(lambda n: '%.16f' % n, bvec[:, i]))
bvecs_concat[i] += ' '
bvecs_concat = '\n'.join(
str(v) for v in bvecs_concat) # transform list into lines of strings
# Write files
new_f = open(arguments.obval, 'w')
new_f.write(bvals_concat)
new_f.close()
printv("Generated file: {}".format(arguments.obval))
new_f = open(arguments.obvec, 'w')
new_f.write(bvecs_concat)
new_f.close()
printv("Generated file: {}".format(arguments.obvec))
def dummy_segmentation_4d(vol_num=10, create_bvecs=False, size_arr=(256, 256, 256), pixdim=(1, 1, 1), dtype=np.float64,
orientation='LPI', shape='rectangle', angle_RL=0, angle_AP=0, angle_IS=0, radius_RL=5.0,
radius_AP=3.0, degree=2, interleaved=False, zeroslice=[], debug=False):
"""
Create a dummy 4D segmentation (dMRI/fMRI) and dummy bvecs file (optional)
:param vol_num: int: number of volumes in 4D data
:param create_bvecs: bool: create dummy bvecs file (necessary e.g. for sct_dmri_moco)
other parameters are same as in dummy_segmentation function
:return: Image object
"""
img_list = []
# Loop across individual volumes of 4D data
for volume in range(0,vol_num):
# set debug=True in line below for saving individual volumes into individual nii files
img_list.append(dummy_segmentation(size_arr=size_arr, pixdim=pixdim, dtype=dtype, orientation=orientation,
shape=shape, angle_RL=angle_RL, angle_AP=angle_AP, angle_IS=angle_IS,
radius_RL=radius_RL, radius_AP=radius_AP, degree=degree, zeroslice=zeroslice,
interleaved=interleaved, debug=False))
# Concatenate individual 3D images into 4D data
img_4d = concat_data(img_list, 3)
if debug:
out_name = datetime.now().strftime("%Y%m%d%H%M%S%f")
file_4d_data = 'tmp_dummy_4d_' + out_name + '.nii.gz'
img_4d.save(file_4d_data, verbose=0)
# Create a dummy bvecs file (necessary e.g. for sct_dmri_moco)
if create_bvecs:
n_b0 = 1 # number of b0
n_dwi = vol_num-n_b0 # number of dwi
bvecs_dummy = ['', '', '']
bvec_b0 = np.array([[0.0, 0.0, 0.0]] * n_b0)
bvec_dwi = np.array([[uniform(0,1), uniform(0,1), uniform(0,1)]] * n_dwi)
bvec = np.concatenate((bvec_b0,bvec_dwi),axis=0)
# Concatenate bvecs
for i in (0, 1, 2):
bvecs_dummy[i] += ' '.join(str(v) for v in map(lambda n: '%.16f' % n, bvec[:, i]))
bvecs_dummy[i] += ' '
bvecs_concat = '\n'.join(str(v) for v in bvecs_dummy) # transform list into lines of strings
if debug:
new_f = open('tmp_dummy_4d_' + out_name + '.bvec', 'w')
new_f.write(bvecs_concat)
new_f.close()
return img_4d
def mean_angle(self):
im_metric_lst = [
self.fname_metric_lst[f].split('_' +
str(self.param_glcm.distance) +
'_')[0] + '_'
for f in self.fname_metric_lst
]
im_metric_lst = list(set(im_metric_lst))
printv('\nMean across angles...', self.param.verbose, 'normal')
extension = extract_fname(self.param.fname_im)[2]
for im_m in im_metric_lst: # Loop across GLCM texture properties
# List images to mean
fname_mean_list = [
im_m + str(self.param_glcm.distance) + '_' + a + extension
for a in self.param_glcm.angle.split(',')
]
im_mean_list = [Image(fname) for fname in fname_mean_list]
# Average across angles and save it as wrk_folder/fnameIn_feature_distance_mean.extension
fname_out = im_m + str(
self.param_glcm.distance) + '_mean' + extension
dim_idx = 3 # img is [x, y, z, angle] so specify 4th dimension (angle)
img = concat_data(im_mean_list, dim_idx).save(fname_out,
mutable=True)
if len(np.shape(
img.data)) < 4: # in case input volume is 3d and dim=t
img.data = img.data[..., np.newaxis]
img.data = np.mean(img.data, dim_idx)
img.save()
self.fname_metric_lst[im_m + str(self.param_glcm.distance) +
'_mean'] = fname_out
def main(args=None):
"""
Main function
:param args:
:return:
"""
# initializations
output_type = None
dim_list = ['x', 'y', 'z', 't']
# Get parser args
if args is None:
args = None if sys.argv[1:] else ['--help']
parser = get_parser()
arguments = parser.parse_args(args=args)
fname_in = arguments.i
n_in = len(fname_in)
verbose = arguments.v
sct.init_sct(log_level=verbose, update=True) # Update log level
if arguments.o is not None:
fname_out = arguments.o
else:
fname_out = None
# Run command
# Arguments are sorted alphabetically (not according to the usage order)
if arguments.concat is not None:
dim = arguments.concat
assert dim in dim_list
dim = dim_list.index(dim)
im_out = [concat_data(fname_in, dim)] # TODO: adapt to fname_in
elif arguments.copy_header is not None:
im_in = Image(fname_in[0])
im_dest = Image(arguments.copy_header)
im_dest_new = im_in.copy()
im_dest_new.data = im_dest.data.copy()
# im_dest.header = im_in.header
im_dest_new.absolutepath = im_dest.absolutepath
im_out = [im_dest_new]
fname_out = arguments.copy_header
elif arguments.display_warp:
im_in = fname_in[0]
visualize_warp(im_in, fname_grid=None, step=3, rm_tmp=True)
im_out = None
elif arguments.getorient:
im_in = Image(fname_in[0])
orient = im_in.orientation
im_out = None
elif arguments.keep_vol is not None:
index_vol = (arguments.keep_vol).split(',')
for iindex_vol, vol in enumerate(index_vol):
index_vol[iindex_vol] = int(vol)
im_in = Image(fname_in[0])
im_out = [remove_vol(im_in, index_vol, todo='keep')]
elif arguments.mcs:
im_in = Image(fname_in[0])
if n_in != 1:
sct.printv(parser.error('ERROR: -mcs need only one input'))
if len(im_in.data.shape) != 5:
sct.printv(
parser.error(
'ERROR: -mcs input need to be a multi-component image'))
im_out = multicomponent_split(im_in)
elif arguments.omc:
im_ref = Image(fname_in[0])
for fname in fname_in:
im = Image(fname)
if im.data.shape != im_ref.data.shape:
sct.printv(
parser.error(
'ERROR: -omc inputs need to have all the same shapes'))
del im
im_out = [multicomponent_merge(fname_in)] # TODO: adapt to fname_in
elif arguments.pad is not None:
im_in = Image(fname_in[0])
ndims = len(im_in.data.shape)
if ndims != 3:
sct.printv('ERROR: you need to specify a 3D input file.', 1,
'error')
return
pad_arguments = arguments.pad.split(',')
if len(pad_arguments) != 3:
sct.printv('ERROR: you need to specify 3 padding values.', 1,
'error')
padx, pady, padz = pad_arguments
padx, pady, padz = int(padx), int(pady), int(padz)
im_out = [
pad_image(im_in,
pad_x_i=padx,
pad_x_f=padx,
pad_y_i=pady,
pad_y_f=pady,
pad_z_i=padz,
pad_z_f=padz)
]
elif arguments.pad_asym is not None:
im_in = Image(fname_in[0])
ndims = len(im_in.data.shape)
if ndims != 3:
sct.printv('ERROR: you need to specify a 3D input file.', 1,
'error')
return
pad_arguments = arguments.pad_asym.split(',')
if len(pad_arguments) != 6:
sct.printv('ERROR: you need to specify 6 padding values.', 1,
'error')
padxi, padxf, padyi, padyf, padzi, padzf = pad_arguments
padxi, padxf, padyi, padyf, padzi, padzf = int(padxi), int(padxf), int(
padyi), int(padyf), int(padzi), int(padzf)
im_out = [
pad_image(im_in,
pad_x_i=padxi,
pad_x_f=padxf,
pad_y_i=padyi,
pad_y_f=padyf,
pad_z_i=padzi,
pad_z_f=padzf)
]
elif arguments.remove_vol is not None:
index_vol = (arguments.remove_vol).split(',')
for iindex_vol, vol in enumerate(index_vol):
index_vol[iindex_vol] = int(vol)
im_in = Image(fname_in[0])
im_out = [remove_vol(im_in, index_vol, todo='remove')]
elif arguments.setorient is not None:
sct.printv(fname_in[0])
im_in = Image(fname_in[0])
im_out = [msct_image.change_orientation(im_in, arguments.setorient)]
elif arguments.setorient_data is not None:
im_in = Image(fname_in[0])
im_out = [
msct_image.change_orientation(im_in,
arguments.setorient_data,
data_only=True)
]
elif arguments.split is not None:
dim = arguments.split
assert dim in dim_list
im_in = Image(fname_in[0])
dim = dim_list.index(dim)
im_out = split_data(im_in, dim)
elif arguments.type is not None:
output_type = arguments.type
im_in = Image(fname_in[0])
im_out = [im_in] # TODO: adapt to fname_in
elif arguments.to_fsl is not None:
space_files = arguments.to_fsl
if len(space_files) > 2 or len(space_files) < 1:
sct.printv(parser.error('ERROR: -to-fsl expects 1 or 2 arguments'))
return
spaces = [Image(s) for s in space_files]
if len(spaces) < 2:
spaces.append(None)
im_out = [
displacement_to_abs_fsl(Image(fname_in[0]), spaces[0], spaces[1])
]
else:
im_out = None
sct.printv(
parser.error(
'ERROR: you need to specify an operation to do on the input image'
))
# in case fname_out is not defined, use first element of input file name list
if fname_out is None:
fname_out = fname_in[0]
# Write output
if im_out is not None:
sct.printv('Generate output files...', verbose)
# if only one output
if len(im_out) == 1 and not '-split' in arguments:
im_out[0].save(fname_out, dtype=output_type, verbose=verbose)
sct.display_viewer_syntax([fname_out], verbose=verbose)
if arguments.mcs:
# use input file name and add _X, _Y _Z. Keep the same extension
l_fname_out = []
for i_dim in range(3):
l_fname_out.append(
sct.add_suffix(fname_out or fname_in[0],
'_' + dim_list[i_dim].upper()))
im_out[i_dim].save(l_fname_out[i_dim], verbose=verbose)
sct.display_viewer_syntax(fname_out)
if arguments.split is not None:
# use input file name and add _"DIM+NUMBER". Keep the same extension
l_fname_out = []
for i, im in enumerate(im_out):
l_fname_out.append(
sct.add_suffix(
fname_out or fname_in[0],
'_' + dim_list[dim].upper() + str(i).zfill(4)))
im.save(l_fname_out[i])
sct.display_viewer_syntax(l_fname_out)
elif arguments.getorient:
sct.printv(orient)
elif arguments.display_warp:
sct.printv('Warping grid generated.', verbose, 'info')
def main(argv=None):
"""
Main function
:param argv:
:return:
"""
parser = get_parser()
arguments = parser.parse_args(argv)
verbose = arguments.v
set_global_loglevel(verbose=verbose)
# initializations
output_type = None
dim_list = ['x', 'y', 'z', 't']
fname_in = arguments.i
n_in = len(fname_in)
# TODO: The functions for '-concat', '-omc', and '-display-warp' take in filenames, so they ignore 'im_in'.
# Instead, we should harmonize this functionality so that 'im_in' is used everywhere.
im_in = Image(fname_in[0])
if arguments.set_sform_to_qform is not None:
im_in.set_sform_to_qform()
if arguments.o is not None:
fname_out = arguments.o
else:
fname_out = None
# Run command
# Arguments are sorted alphabetically (not according to the usage order)
if arguments.concat is not None:
dim = arguments.concat
assert dim in dim_list
dim = dim_list.index(dim)
# TODO: Modify concat_data to take in a list of Image() objects so that 'im_in' can be passed instead
im_out = [concat_data(fname_in, dim)]
elif arguments.copy_header is not None:
if fname_out is None:
raise ValueError("Need to specify output image with -o!")
im_dest = Image(arguments.copy_header)
im_dest_new = im_in.copy()
im_dest_new.data = im_dest.data.copy()
# im_dest.header = im_in.header
im_dest_new.absolutepath = im_dest.absolutepath
im_out = [im_dest_new]
elif arguments.display_warp:
# TODO: Modify visualize_warp to take in an Image() object so that 'im_in' can be passed instead
visualize_warp(fname_in[0], fname_grid=None, step=3, rm_tmp=True)
im_out = None
elif arguments.getorient:
orient = im_in.orientation
im_out = None
elif arguments.keep_vol is not None:
index_vol = (arguments.keep_vol).split(',')
for iindex_vol, vol in enumerate(index_vol):
index_vol[iindex_vol] = int(vol)
im_out = [remove_vol(im_in, index_vol, todo='keep')]
elif arguments.mcs:
if n_in != 1:
printv(parser.error('ERROR: -mcs need only one input'))
if len(im_in.data.shape) != 5:
printv(
parser.error(
'ERROR: -mcs input need to be a multi-component image'))
im_out = multicomponent_split(im_in)
elif arguments.omc:
im_ref = im_in
for fname in fname_in:
im = Image(fname)
if im.data.shape != im_ref.data.shape:
printv(
parser.error(
'ERROR: -omc inputs need to have all the same shapes'))
del im
# TODO: Modify multicomponent_merge to take in a list of Image() objects so that 'im_in' can be passed instead
im_out = [multicomponent_merge(fname_in)] # TODO: adapt to fname_in
elif arguments.pad is not None:
ndims = len(im_in.data.shape)
if ndims != 3:
printv('ERROR: you need to specify a 3D input file.', 1, 'error')
return
pad_arguments = arguments.pad.split(',')
if len(pad_arguments) != 3:
printv('ERROR: you need to specify 3 padding values.', 1, 'error')
padx, pady, padz = pad_arguments
padx, pady, padz = int(padx), int(pady), int(padz)
im_out = [
pad_image(im_in,
pad_x_i=padx,
pad_x_f=padx,
pad_y_i=pady,
pad_y_f=pady,
pad_z_i=padz,
pad_z_f=padz)
]
elif arguments.pad_asym is not None:
ndims = len(im_in.data.shape)
if ndims != 3:
printv('ERROR: you need to specify a 3D input file.', 1, 'error')
return
pad_arguments = arguments.pad_asym.split(',')
if len(pad_arguments) != 6:
printv('ERROR: you need to specify 6 padding values.', 1, 'error')
padxi, padxf, padyi, padyf, padzi, padzf = pad_arguments
padxi, padxf, padyi, padyf, padzi, padzf = int(padxi), int(padxf), int(
padyi), int(padyf), int(padzi), int(padzf)
im_out = [
pad_image(im_in,
pad_x_i=padxi,
pad_x_f=padxf,
pad_y_i=padyi,
pad_y_f=padyf,
pad_z_i=padzi,
pad_z_f=padzf)
]
elif arguments.remove_vol is not None:
index_vol = (arguments.remove_vol).split(',')
for iindex_vol, vol in enumerate(index_vol):
index_vol[iindex_vol] = int(vol)
im_out = [remove_vol(im_in, index_vol, todo='remove')]
elif arguments.setorient is not None:
printv(fname_in[0])
im_out = [change_orientation(im_in, arguments.setorient)]
elif arguments.setorient_data is not None:
im_out = [
change_orientation(im_in, arguments.setorient_data, data_only=True)
]
elif arguments.split is not None:
dim = arguments.split
assert dim in dim_list
dim = dim_list.index(dim)
im_out = split_data(im_in, dim)
elif arguments.type is not None:
output_type = arguments.type
im_out = [im_in] # TODO: adapt to fname_in
elif arguments.to_fsl is not None:
space_files = arguments.to_fsl
if len(space_files) > 2 or len(space_files) < 1:
printv(parser.error('ERROR: -to-fsl expects 1 or 2 arguments'))
return
spaces = [Image(s) for s in space_files]
if len(spaces) < 2:
spaces.append(None)
im_out = [displacement_to_abs_fsl(im_in, spaces[0], spaces[1])]
# If this argument is used standalone, simply pass the input image to the output (sform was set for im_in earlier)
elif arguments.set_sform_to_qform is not None:
im_out = [im_in]
else:
im_out = None
printv(
parser.error(
'ERROR: you need to specify an operation to do on the input image'
))
# in case fname_out is not defined, use first element of input file name list
if fname_out is None:
fname_out = fname_in[0]
# Write output
if im_out is not None:
printv('Generate output files...', verbose)
# if only one output
if len(im_out) == 1 and arguments.split is None:
im_out[0].save(fname_out, dtype=output_type, verbose=verbose)
display_viewer_syntax([fname_out], verbose=verbose)
if arguments.mcs:
# use input file name and add _X, _Y _Z. Keep the same extension
l_fname_out = []
for i_dim in range(3):
l_fname_out.append(
add_suffix(fname_out or fname_in[0],
'_' + dim_list[i_dim].upper()))
im_out[i_dim].save(l_fname_out[i_dim], verbose=verbose)
display_viewer_syntax(fname_out)
if arguments.split is not None:
# use input file name and add _"DIM+NUMBER". Keep the same extension
l_fname_out = []
for i, im in enumerate(im_out):
l_fname_out.append(
add_suffix(fname_out or fname_in[0],
'_' + dim_list[dim].upper() + str(i).zfill(4)))
im.save(l_fname_out[i])
display_viewer_syntax(l_fname_out)
elif arguments.getorient:
printv(orient)
elif arguments.display_warp:
printv('Warping grid generated.', verbose, 'info')
def main(argv=None):
"""
Main function
:param argv:
:return:
"""
parser = get_parser()
arguments = parser.parse_args(argv)
verbose = arguments.v
set_loglevel(verbose=verbose)
# initializations
output_type = None
dim_list = ['x', 'y', 'z', 't']
fname_in = arguments.i
im_in_list = [Image(fname) for fname in fname_in]
if len(im_in_list
) > 1 and arguments.concat is None and arguments.omc is None:
parser.error(
"Multi-image input is only supported for the '-concat' and '-omc' arguments."
)
# Apply initialization steps to all input images first
if arguments.set_sform_to_qform:
[im.set_sform_to_qform() for im in im_in_list]
elif arguments.set_qform_to_sform:
[im.set_qform_to_sform() for im in im_in_list]
# Most sct_image options don't accept multi-image input, so here we simply separate out the first image
# TODO: Extend the options so that they iterate through the list of images (to support multi-image input)
im_in = im_in_list[0]
if arguments.o is not None:
fname_out = arguments.o
else:
fname_out = None
# Run command
# Arguments are sorted alphabetically (not according to the usage order)
if arguments.concat is not None:
dim = arguments.concat
assert dim in dim_list
dim = dim_list.index(dim)
im_out = [concat_data(im_in_list, dim)]
elif arguments.copy_header is not None:
if fname_out is None:
raise ValueError("Need to specify output image with -o!")
im_dest = Image(arguments.copy_header)
im_dest_new = im_in.copy()
im_dest_new.data = im_dest.data.copy()
# im_dest.header = im_in.header
im_dest_new.absolutepath = im_dest.absolutepath
im_out = [im_dest_new]
elif arguments.display_warp:
visualize_warp(im_warp=im_in, im_grid=None, step=3, rm_tmp=True)
im_out = None
elif arguments.getorient:
orient = im_in.orientation
im_out = None
elif arguments.keep_vol is not None:
index_vol = (arguments.keep_vol).split(',')
for iindex_vol, vol in enumerate(index_vol):
index_vol[iindex_vol] = int(vol)
im_out = [remove_vol(im_in, index_vol, todo='keep')]
elif arguments.mcs:
if len(im_in.data.shape) != 5:
printv(
parser.error(
'ERROR: -mcs input need to be a multi-component image'))
im_out = multicomponent_split(im_in)
elif arguments.omc:
im_ref = im_in_list[0]
for im in im_in_list:
if im.data.shape != im_ref.data.shape:
printv(
parser.error(
'ERROR: -omc inputs need to have all the same shapes'))
del im
im_out = [multicomponent_merge(im_in_list=im_in_list)]
elif arguments.pad is not None:
ndims = len(im_in.data.shape)
if ndims != 3:
printv('ERROR: you need to specify a 3D input file.', 1, 'error')
return
pad_arguments = arguments.pad.split(',')
if len(pad_arguments) != 3:
printv('ERROR: you need to specify 3 padding values.', 1, 'error')
padx, pady, padz = pad_arguments
padx, pady, padz = int(padx), int(pady), int(padz)
im_out = [
pad_image(im_in,
pad_x_i=padx,
pad_x_f=padx,
pad_y_i=pady,
pad_y_f=pady,
pad_z_i=padz,
pad_z_f=padz)
]
elif arguments.pad_asym is not None:
ndims = len(im_in.data.shape)
if ndims != 3:
printv('ERROR: you need to specify a 3D input file.', 1, 'error')
return
pad_arguments = arguments.pad_asym.split(',')
if len(pad_arguments) != 6:
printv('ERROR: you need to specify 6 padding values.', 1, 'error')
padxi, padxf, padyi, padyf, padzi, padzf = pad_arguments
padxi, padxf, padyi, padyf, padzi, padzf = int(padxi), int(padxf), int(
padyi), int(padyf), int(padzi), int(padzf)
im_out = [
pad_image(im_in,
pad_x_i=padxi,
pad_x_f=padxf,
pad_y_i=padyi,
pad_y_f=padyf,
pad_z_i=padzi,
pad_z_f=padzf)
]
elif arguments.remove_vol is not None:
index_vol = (arguments.remove_vol).split(',')
for iindex_vol, vol in enumerate(index_vol):
index_vol[iindex_vol] = int(vol)
im_out = [remove_vol(im_in, index_vol, todo='remove')]
elif arguments.setorient is not None:
printv(im_in.absolutepath)
im_out = [change_orientation(im_in, arguments.setorient)]
elif arguments.setorient_data is not None:
im_out = [
change_orientation(im_in, arguments.setorient_data, data_only=True)
]
elif arguments.header is not None:
header = im_in.header
# Necessary because of https://github.com/nipy/nibabel/issues/480#issuecomment-239227821
im_file = nib.load(im_in.absolutepath)
header.structarr['scl_slope'] = im_file.dataobj.slope
header.structarr['scl_inter'] = im_file.dataobj.inter
printv(create_formatted_header_string(header=header,
output_format=arguments.header),
verbose=verbose)
im_out = None
elif arguments.split is not None:
dim = arguments.split
assert dim in dim_list
dim = dim_list.index(dim)
im_out = split_data(im_in, dim)
elif arguments.type is not None:
output_type = arguments.type
im_out = [im_in]
elif arguments.to_fsl is not None:
space_files = arguments.to_fsl
if len(space_files) > 2 or len(space_files) < 1:
printv(parser.error('ERROR: -to-fsl expects 1 or 2 arguments'))
return
spaces = [Image(s) for s in space_files]
if len(spaces) < 2:
spaces.append(None)
im_out = [displacement_to_abs_fsl(im_in, spaces[0], spaces[1])]
# If these arguments are used standalone, simply pass the input image to the output (the affines were set earlier)
elif arguments.set_sform_to_qform or arguments.set_qform_to_sform:
im_out = [im_in]
else:
im_out = None
printv(
parser.error(
'ERROR: you need to specify an operation to do on the input image'
))
# in case fname_out is not defined, use first element of input file name list
if fname_out is None:
fname_out = fname_in[0]
# Write output
if im_out is not None:
printv('Generate output files...', verbose)
# if only one output
if len(im_out) == 1 and arguments.split is None:
im_out[0].save(fname_out, dtype=output_type, verbose=verbose)
display_viewer_syntax([fname_out], verbose=verbose)
if arguments.mcs:
# use input file name and add _X, _Y _Z. Keep the same extension
l_fname_out = []
for i_dim in range(3):
l_fname_out.append(
add_suffix(fname_out or fname_in[0],
'_' + dim_list[i_dim].upper()))
im_out[i_dim].save(l_fname_out[i_dim], verbose=verbose)
display_viewer_syntax(fname_out)
if arguments.split is not None:
# use input file name and add _"DIM+NUMBER". Keep the same extension
l_fname_out = []
for i, im in enumerate(im_out):
l_fname_out.append(
add_suffix(fname_out or fname_in[0],
'_' + dim_list[dim].upper() + str(i).zfill(4)))
im.save(l_fname_out[i])
display_viewer_syntax(l_fname_out)
elif arguments.getorient:
printv(orient)
elif arguments.display_warp:
printv('Warping grid generated.', verbose, 'info')
def find_centerline(algo, image_fname, contrast_type, brain_bool,
folder_output, remove_temp_files, centerline_fname):
"""
Assumes RPI orientation
:param algo:
:param image_fname:
:param contrast_type:
:param brain_bool:
:param folder_output:
:param remove_temp_files:
:param centerline_fname:
:return:
"""
im = Image(image_fname)
ctl_absolute_path = add_suffix(im.absolutepath, "_ctr")
# isct_spine_detect requires nz > 1
if im.dim[2] == 1:
im = concat_data([im, im], dim=2)
im.hdr['dim'][
3] = 2 # Needs to be change manually since dim not updated during concat_data
bool_2d = True
else:
bool_2d = False
# TODO: maybe change 'svm' for 'optic', because this is how we call it in sct_get_centerline
if algo == 'svm':
# run optic on a heatmap computed by a trained SVM+HoG algorithm
# optic_models_fname = os.path.join(path_sct, 'data', 'optic_models', '{}_model'.format(contrast_type))
# # TODO: replace with get_centerline(method=optic)
im_ctl, _, _, _ = get_centerline(
im, ParamCenterline(algo_fitting='optic', contrast=contrast_type))
elif algo == 'cnn':
# CNN parameters
dct_patch_ctr = {
't2': {
'size': (80, 80),
'mean': 51.1417,
'std': 57.4408
},
't2s': {
'size': (80, 80),
'mean': 68.8591,
'std': 71.4659
},
't1': {
'size': (80, 80),
'mean': 55.7359,
'std': 64.3149
},
'dwi': {
'size': (80, 80),
'mean': 55.744,
'std': 45.003
}
}
dct_params_ctr = {
't2': {
'features': 16,
'dilation_layers': 2
},
't2s': {
'features': 8,
'dilation_layers': 3
},
't1': {
'features': 24,
'dilation_layers': 3
},
'dwi': {
'features': 8,
'dilation_layers': 2
}
}
# load model
ctr_model_fname = sct_dir_local_path('data', 'deepseg_sc_models',
'{}_ctr.h5'.format(contrast_type))
ctr_model = nn_architecture_ctr(
height=dct_patch_ctr[contrast_type]['size'][0],
width=dct_patch_ctr[contrast_type]['size'][1],
channels=1,
classes=1,
features=dct_params_ctr[contrast_type]['features'],
depth=2,
temperature=1.0,
padding='same',
batchnorm=True,
dropout=0.0,
dilation_layers=dct_params_ctr[contrast_type]['dilation_layers'])
ctr_model.load_weights(ctr_model_fname)
# compute the heatmap
im_heatmap, z_max = heatmap(
im=im,
model=ctr_model,
patch_shape=dct_patch_ctr[contrast_type]['size'],
mean_train=dct_patch_ctr[contrast_type]['mean'],
std_train=dct_patch_ctr[contrast_type]['std'],
brain_bool=brain_bool)
im_ctl, _, _, _ = get_centerline(
im_heatmap,
ParamCenterline(algo_fitting='optic', contrast=contrast_type))
if z_max is not None:
logger.info('Cropping brain section.')
im_ctl.data[:, :, z_max:] = 0
elif algo == 'viewer':
im_labels = _call_viewer_centerline(im)
im_ctl, _, _, _ = get_centerline(im_labels, param=ParamCenterline())
elif algo == 'file':
im_ctl = Image(centerline_fname)
im_ctl.change_orientation('RPI')
else:
logger.error(
'The parameter "-centerline" is incorrect. Please try again.')
sys.exit(1)
# TODO: for some reason, when algo == 'file', the absolutepath is changed to None out of the method find_centerline
im_ctl.absolutepath = ctl_absolute_path
if bool_2d:
im_ctl = split_img_data(im_ctl, dim=2)[0]
if algo != 'viewer':
im_labels = None
# TODO: remove unecessary return params
return "dummy_file_name", im_ctl, im_labels