def main(args=None):
if args is None:
args = sys.argv[1:]
# Get parser
parser = get_parser()
arguments = parser.parse(args)
# Set param arguments ad inputted by user
fname_in = arguments["-i"]
contrast = arguments["-c"]
# Segmentation or Centerline line
if '-s' in arguments:
fname_seg = arguments['-s']
if not os.path.isfile(fname_seg):
fname_seg = None
sct.printv('WARNING: -s input file: "' + arguments['-s'] + '" does not exist.\nDetecting PMJ without using segmentation information', 1, 'warning')
else:
fname_seg = None
# Output Folder
if '-ofolder' in arguments:
path_results = arguments["-ofolder"]
if not os.path.isdir(path_results) and os.path.exists(path_results):
sct.printv("ERROR output directory %s is not a valid directory" % path_results, 1, 'error')
if not os.path.exists(path_results):
os.makedirs(path_results)
else:
path_results = '.'
path_qc = arguments.get("-qc", None)
# Remove temp folder
rm_tmp = bool(int(arguments.get("-r", 1)))
verbose = int(arguments.get('-v'))
sct.init_sct(log_level=verbose, update=True) # Update log level
# Initialize DetectPMJ
detector = DetectPMJ(fname_im=fname_in,
contrast=contrast,
fname_seg=fname_seg,
path_out=path_results,
verbose=verbose)
# run the extraction
fname_out, tmp_dir = detector.apply()
# Remove tmp_dir
if rm_tmp:
sct.rmtree(tmp_dir)
# View results
if fname_out is not None:
if path_qc is not None:
generate_qc(fname_in, fname_seg=fname_out, args=args, path_qc=os.path.abspath(path_qc),
process='sct_detect_pmj')
sct.display_viewer_syntax([fname_in, fname_out], colormaps=['gray', 'red'])
def main():
parser = get_parser()
args = parser.parse_args(args=None if sys.argv[1:] else ['--help'])
verbose = args.v
sct.init_sct(log_level=verbose, update=True) # Update log level
fname_mtsat, fname_t1map = mtsat.compute_mtsat_from_file(
args.mt,
args.pd,
args.t1,
args.trmt,
args.trpd,
args.trt1,
args.famt,
args.fapd,
args.fat1,
fname_b1map=args.b1map,
fname_mtsat=args.omtsat,
fname_t1map=args.ot1map,
verbose=verbose)
sct.display_viewer_syntax([fname_mtsat, fname_t1map],
colormaps=['gray', 'gray'],
minmax=['-10,10', '0, 3'],
opacities=['1', '1'],
verbose=verbose)
def resample_file(fname_data, fname_out, new_size, new_size_type,
interpolation, verbose):
"""This function will resample the specified input
image file to the target size.
Can deal with 2d, 3d or 4d image objects.
:param fname_data: The input image filename.
:param fname_out: The output image filename.
:param new_size: The target size, i.e. 0.25x0.25
:param new_size_type: Unit of resample (mm, vox, factor)
:param interpolation: The interpolation type
:param verbose: verbosity level
"""
# Load data
sct.printv('\nLoad data...', verbose)
nii = nipy.load_image(fname_data)
nii_r = resample_image(nii, new_size, new_size_type, interpolation,
verbose)
# build output file name
if fname_out == '':
fname_out = sct.add_suffix(fname_data, '_r')
else:
fname_out = fname_out
# save data
nipy.save_image(nii_r, fname_out)
# to view results
sct.display_viewer_syntax([fname_out], verbose=verbose)
return nii_r
def main():
import numpy as np
import spinalcordtoolbox.image as msct_image
parser = get_parser()
args = parser.parse_args(args=None if sys.argv[1:] else ['--help'])
# Initialization
fname_mt0 = ''
fname_mt1 = ''
fname_mtr = ''
# register = param.register
# remove_temp_files = param.remove_temp_files
# verbose = param.verbose
# Check input parameters
fname_mt0 = args.mt0
fname_mt1 = args.mt1
fname_mtr = args.o
verbose = args.v
sct.init_sct(log_level=verbose, update=True) # Update log level
# compute MTR
sct.printv('\nCompute MTR...', verbose)
nii_mt1 = msct_image.Image(fname_mt1)
data_mt1 = nii_mt1.data
data_mt0 = msct_image.Image(fname_mt0).data
data_mtr = 100 * (data_mt0 - data_mt1) / data_mt0
# save MTR file
nii_mtr = nii_mt1
nii_mtr.data = data_mtr
nii_mtr.save(fname_mtr)
# sct.run(fsloutput+'fslmaths -dt double mt0.nii -sub mt1.nii -mul 100 -div mt0.nii -thr 0 -uthr 100 fname_mtr', verbose)
sct.display_viewer_syntax([fname_mt0, fname_mt1, fname_mtr])
def main():
"""Main function."""
parser = get_parser()
args = parser.parse_args(args=None if sys.argv[1:] else ['--help'])
fname_image = args.i
contrast_type = args.c
ctr_algo = args.centerline
brain_bool = bool(args.brain)
if args.brain is None and contrast_type in ['t2s', 't2_ax']:
brain_bool = False
output_folder = args.ofolder
if ctr_algo == 'file' and args.file_centerline is None:
sct.printv('Please use the flag -file_centerline to indicate the centerline filename.', 1, 'error')
sys.exit(1)
if args.file_centerline is not None:
manual_centerline_fname = args.file_centerline
ctr_algo = 'file'
else:
manual_centerline_fname = None
remove_temp_files = args.r
verbose = args.v
sct.init_sct(log_level=verbose, update=True) # Update log level
algo_config_stg = '\nMethod:'
algo_config_stg += '\n\tCenterline algorithm: ' + str(ctr_algo)
algo_config_stg += '\n\tAssumes brain section included in the image: ' + str(brain_bool) + '\n'
sct.printv(algo_config_stg)
# Segment image
from spinalcordtoolbox.image import Image
from spinalcordtoolbox.deepseg_lesion.core import deep_segmentation_MSlesion
im_image = Image(fname_image)
im_seg, im_labels_viewer, im_ctr = deep_segmentation_MSlesion(im_image, contrast_type, ctr_algo=ctr_algo, ctr_file=manual_centerline_fname,
brain_bool=brain_bool, remove_temp_files=remove_temp_files, verbose=verbose)
# Save segmentation
fname_seg = os.path.abspath(os.path.join(output_folder, sct.extract_fname(fname_image)[1] + '_lesionseg' +
sct.extract_fname(fname_image)[2]))
im_seg.save(fname_seg)
if ctr_algo == 'viewer':
# Save labels
fname_labels = os.path.abspath(os.path.join(output_folder, sct.extract_fname(fname_image)[1] + '_labels-centerline' +
sct.extract_fname(fname_image)[2]))
im_labels_viewer.save(fname_labels)
if verbose == 2:
# Save ctr
fname_ctr = os.path.abspath(os.path.join(output_folder, sct.extract_fname(fname_image)[1] + '_centerline' +
sct.extract_fname(fname_image)[2]))
im_ctr.save(fname_ctr)
sct.display_viewer_syntax([fname_image, fname_seg], colormaps=['gray', 'red'], opacities=['', '0.7'])
def resample_file(fname_data, fname_out, new_size, new_size_type, interpolation, verbose, fname_ref=None):
"""This function will resample the specified input
image file to the target size.
Can deal with 2d, 3d or 4d image objects.
:param fname_data: The input image filename.
:param fname_out: The output image filename.
:param new_size: The target size, i.e. 0.25x0.25
:param new_size_type: Unit of resample (mm, vox, factor)
:param interpolation: The interpolation type
:param verbose: verbosity level
:param fname_ref: Reference image to resample input image to
"""
# Load data
logger.info('load data...')
nii = nib.load(fname_data)
if fname_ref is not None:
nii_ref = nib.load(fname_ref)
else:
nii_ref = None
nii_r = resample_nib(nii, new_size.split('x'), new_size_type, img_dest=nii_ref, interpolation=interpolation)
# build output file name
if fname_out == '':
fname_out = sct.add_suffix(fname_data, '_r')
else:
fname_out = fname_out
# save data
nib.save(nii_r, fname_out)
# to view results
sct.display_viewer_syntax([fname_out], verbose=verbose)
return nii_r
def run_main(args):
import sct_utils as sct
from spinalcordtoolbox.mtsat import mtsat
sct.start_stream_logger()
fname_mtsat, fname_t1map = mtsat.compute_mtsat_from_file(
args.mt,
args.pd,
args.t1,
args.trmt,
args.trpd,
args.trt1,
args.famt,
args.fapd,
args.fat1,
fname_b1map=args.b1map,
fname_mtsat=args.omtsat,
fname_t1map=args.ot1map,
verbose=1)
sct.display_viewer_syntax([fname_mtsat, fname_t1map],
colormaps=['gray', 'gray'],
minmax=['-10,10', '0, 3'],
opacities=['1', '1'],
verbose=args.v)
def main():
# create param objects
param = Param()
# get parser
parser = get_parser()
arguments = parser.parse_args(args=None if sys.argv[1:] else ['--help'])
# set param arguments ad inputted by user
list_fname_src = arguments.i
fname_dest = arguments.d
list_fname_warp = arguments.w
param.fname_out = arguments.o
# if '-ofolder' in arguments:
# path_results = arguments.ofolder
if arguments.x is not None:
param.interp = arguments.x
if arguments.r is not None:
param.rm_tmp = arguments.r
param.verbose = arguments.v
sct.init_sct(log_level=param.verbose, update=True) # Update log level
# check if list of input files and warping fields have same length
assert len(list_fname_src) == len(
list_fname_warp), "ERROR: list of files are not of the same length"
# merge src images to destination image
try:
merge_images(list_fname_src, fname_dest, list_fname_warp, param)
except Exception as e:
sct.printv(str(e), 1, 'error')
sct.display_viewer_syntax([fname_dest, os.path.abspath(param.fname_out)])
def run_main():
sct.init_sct()
parser = get_parser()
args = sys.argv[1:]
arguments = parser.parse(args)
# Input filename
fname_input_data = arguments["-i"]
fname_data = os.path.abspath(fname_input_data)
# Method used
method = 'optic'
if "-method" in arguments:
method = arguments["-method"]
# Contrast type
contrast_type = ''
if "-c" in arguments:
contrast_type = arguments["-c"]
if method == 'optic' and not contrast_type:
# Contrast must be
error = 'ERROR: -c is a mandatory argument when using Optic method.'
sct.printv(error, type='error')
return
# Ga between slices
interslice_gap = 10.0
if "-gap" in arguments:
interslice_gap = float(arguments["-gap"])
# Output folder
if "-o" in arguments:
file_output = arguments["-o"]
else:
path_data, file_data, ext_data = sct.extract_fname(fname_data)
file_output = os.path.join(path_data, file_data + '_centerline')
# Verbosity
verbose = 0
if "-v" in arguments:
verbose = int(arguments["-v"])
if method == 'viewer':
im_labels = _call_viewer_centerline(Image(fname_data),
interslice_gap=interslice_gap)
im_centerline, arr_centerline, _ = \
get_centerline(im_labels, algo_fitting='polyfit', param=ParamCenterline(degree=3), minmax=True,
verbose=verbose)
else:
im_centerline, arr_centerline, _ = \
get_centerline(Image(fname_data), algo_fitting='optic', param=ParamCenterline(contrast=contrast_type),
minmax=True, verbose=verbose)
# save centerline as nifti (discrete) and csv (continuous) files
im_centerline.save(file_output + '.nii.gz')
np.savetxt(file_output + '.csv', arr_centerline.transpose(), delimiter=",")
sct.display_viewer_syntax([fname_input_data, file_output + '.nii.gz'],
colormaps=['gray', 'red'],
opacities=['', '1'])
def main(fname_anat, fname_centerline, degree_poly, centerline_fitting, interp,
remove_temp_files, verbose):
# load input image
im_anat = Image(fname_anat)
nx, ny, nz, nt, px, py, pz, pt = im_anat.dim
# re-oriente to RPI
orientation_native = im_anat.orientation
im_anat.change_orientation("RPI")
# load centerline
im_centerline = Image(fname_centerline).change_orientation("RPI")
# smooth centerline and return fitted coordinates in voxel space
x_centerline_fit, y_centerline_fit, z_centerline, x_centerline_deriv, y_centerline_deriv, z_centerline_deriv = smooth_centerline(
im_centerline,
algo_fitting=centerline_fitting,
type_window='hanning',
window_length=50,
nurbs_pts_number=3000,
phys_coordinates=False,
verbose=verbose,
all_slices=True)
# compute translation for each slice, such that the flattened centerline is centered in the medial plane (R-L) and
# avoid discontinuity in slices where there is no centerline (in which case, simply copy the translation of the
# closest Z).
# first, get zmin and zmax spanned by the centerline (i.e. with non-zero values)
indz_centerline = np.where(
[np.sum(im_centerline.data[:, :, iz]) for iz in range(nz)])[0]
zmin, zmax = indz_centerline[0], indz_centerline[-1]
# then, extend the centerline by copying values below zmin and above zmax
x_centerline_extended = np.concatenate([
np.ones(zmin) * x_centerline_fit[0], x_centerline_fit,
np.ones(nz - zmax) * x_centerline_fit[-1]
])
# loop across slices and apply translation
im_anat_flattened = msct_image.change_type(im_anat, np.float32)
# change type to float32 because of subsequent conversion (img_as_float). See #1790
for iz in range(nz):
# compute translation along x (R-L)
translation_x = x_centerline_extended[iz] - np.round(nx / 2.0)
# apply transformation to 2D image with linear interpolation
# tform = tf.SimilarityTransform(scale=1, rotation=0, translation=(translation_x, 0))
tform = transform.SimilarityTransform(translation=(0, translation_x))
# important to force input in float to skikit image, because it will output float values
img = img_as_float(im_anat.data[:, :, iz])
img_reg = transform.warp(img, tform)
im_anat_flattened.data[:, :, iz] = img_reg # img_as_uint(img_reg)
# change back to native orientation
im_anat_flattened.change_orientation(orientation_native)
# save output
fname_out = sct.add_suffix(fname_anat, '_flatten')
im_anat_flattened.save(fname_out)
sct.display_viewer_syntax([fname_anat, fname_out])
def main(args=None):
parser = get_parser()
arguments = parser.parse(sys.argv[1:])
fname_src = arguments["-d"]
fname_transfo = arguments["-w"]
warp_atlas = int(arguments["-a"])
warp_spinal_levels = int(arguments["-s"])
folder_out = arguments['-ofolder']
path_template = arguments['-t']
verbose = int(arguments['-v'])
path_qc = arguments.get("-qc", None)
# call main function
w = WarpTemplate(fname_src, fname_transfo, warp_atlas, warp_spinal_levels,
folder_out, path_template, verbose)
path_template = os.path.join(w.folder_out, w.folder_template)
# Only deal with QC and verbose if white matter was warped (meaning, everything under template/)
if "white matter" in spinalcordtoolbox.metadata.get_indiv_label_names(
path_template):
# Deal with QC report
if path_qc is not None:
fname_wm = os.path.join(
w.folder_out, w.folder_template,
spinalcordtoolbox.metadata.get_file_label(
path_template, 'white matter'))
generate_qc(fname_src,
fname_seg=fname_wm,
args=sys.argv[1:],
path_qc=os.path.abspath(path_qc),
process='sct_warp_template')
# Deal with verbose
sct.display_viewer_syntax(
[
fname_src,
spinalcordtoolbox.metadata.get_file_label(
path_template,
'T2-weighted template',
output="filewithpath"),
spinalcordtoolbox.metadata.get_file_label(
path_template, 'gray matter', output="filewithpath"),
spinalcordtoolbox.metadata.get_file_label(
path_template, 'white matter', output="filewithpath")
],
colormaps=['gray', 'gray', 'red-yellow', 'blue-lightblue'],
opacities=['1', '1', '0.5', '0.5'],
minmax=['', '0,4000', '0.4,1', '0.4,1'],
verbose=verbose,
)
else:
if path_qc is not None:
sct.printv(
"QC not generated since expected labels are missing from template",
type="warning")
def crop(self):
"""
Crop image (change dimension)
"""
# create command line
img_in = Image(self.input_filename)
self.cmd = ["isct_crop_image", "-i", self.input_filename, "-o", self.output_filename]
# Handling optional arguments
# if mask is specified, find -start and -end arguments
if self.mask is not None:
# if user already specified -start or -end arguments, let him know they will be ignored
if self.start is not None or self.end is not None:
sct.printv('WARNING: Mask was specified for cropping. Arguments -start and -end will be ignored', 1, 'warning')
self.start, self.end, self.dim = find_mask_boundaries(self.mask)
if self.start is not None:
self.cmd += ["-start", ','.join(map(str, self.start))]
if self.end is not None:
self.cmd += ["-end", ','.join(map(str, self.end))]
if self.dim is not None:
self.cmd += ["-dim", ','.join(map(str, self.dim))]
if self.shift is not None:
self.cmd += ["-shift", ','.join(map(str, self.shift))]
if self.background is not None:
self.cmd += ["-b", str(self.background)]
if self.bmax is True:
self.cmd += ["-bmax"]
if self.ref is not None:
self.cmd += ["-ref", self.ref]
if self.mesh is not None:
self.cmd += ["-mesh", self.mesh]
verb = 0
if self.verbose == 1:
verb = 2
if self.mask is not None and self.background is not None:
self.crop_from_mask_with_background()
else:
# Run command line
sct.run(self.cmd, verb, is_sct_binary=True)
self.result = Image(self.output_filename, verbose=self.verbose)
# removes the output file created by the script if it is not needed
if self.rm_output_file:
try:
os.remove(self.output_filename)
except OSError:
sct.printv("WARNING : Couldn't remove output file. Either it is opened elsewhere or "
"it doesn't exist.", self.verbose, 'warning')
else:
sct.display_viewer_syntax([self.output_filename])
return self.result
def main():
"""Main function."""
sct.init_sct()
parser = get_parser()
args = sys.argv[1:]
arguments = parser.parse(args)
fname_image = arguments['-i']
contrast_type = arguments['-c']
ctr_algo = arguments["-centerline"]
brain_bool = bool(int(arguments["-brain"]))
if "-brain" not in args and contrast_type in ['t2s', 't2_ax']:
brain_bool = False
if '-ofolder' not in args:
output_folder = os.getcwd()
else:
output_folder = arguments["-ofolder"]
if ctr_algo == 'manual' and "-file_centerline" not in args:
sct.log.error(
'Please use the flag -file_centerline to indicate the centerline filename.'
)
sys.exit(1)
if "-file_centerline" in args:
manual_centerline_fname = arguments["-file_centerline"]
ctr_algo = 'manual'
else:
manual_centerline_fname = None
remove_temp_files = int(arguments['-r'])
verbose = arguments['-v']
algo_config_stg = '\nMethod:'
algo_config_stg += '\n\tCenterline algorithm: ' + str(ctr_algo)
algo_config_stg += '\n\tAssumes brain section included in the image: ' + str(
brain_bool) + '\n'
sct.printv(algo_config_stg)
fname_seg = deep_segmentation_MSlesion(fname_image,
contrast_type,
output_folder,
ctr_algo=ctr_algo,
ctr_file=manual_centerline_fname,
brain_bool=brain_bool,
remove_temp_files=remove_temp_files,
verbose=verbose)
sct.display_viewer_syntax(
[fname_image, os.path.join(output_folder, fname_seg)],
colormaps=['gray', 'red'],
opacities=['', '0.7'])
def run_main():
sct.init_sct()
parser = get_parser()
args = sys.argv[1:]
arguments = parser.parse(args)
# Input filename
fname_input_data = arguments["-i"]
fname_data = os.path.abspath(fname_input_data)
# Method used
method = 'optic'
if "-method" in arguments:
method = arguments["-method"]
# Contrast type
contrast_type = ''
if "-c" in arguments:
contrast_type = arguments["-c"]
if method == 'optic' and not contrast_type:
# Contrast must be
error = 'ERROR: -c is a mandatory argument when using Optic method.'
sct.printv(error, type='error')
return
# Ga between slices
interslice_gap = 10.0
if "-gap" in arguments:
interslice_gap = float(arguments["-gap"])
# Output folder
if "-o" in arguments:
file_output = arguments["-o"]
else:
path_data, file_data, ext_data = sct.extract_fname(fname_data)
file_output = os.path.join(path_data, file_data + '_centerline')
verbose = int(arguments.get('-v'))
sct.init_sct(log_level=verbose, update=True) # Update log level
if method == 'viewer':
im_labels = _call_viewer_centerline(Image(fname_data), interslice_gap=interslice_gap)
im_centerline, arr_centerline, _ = \
get_centerline(im_labels, algo_fitting='polyfit', degree=3, minmax=True, verbose=verbose)
else:
im_centerline, arr_centerline, _ = \
get_centerline(Image(fname_data), algo_fitting='optic', contrast=contrast_type, minmax=True,
verbose=verbose)
# save centerline as nifti (discrete) and csv (continuous) files
im_centerline.save(file_output + '.nii.gz')
np.savetxt(file_output + '.csv', arr_centerline.transpose(), delimiter=",")
sct.display_viewer_syntax([fname_input_data, file_output+'.nii.gz'], colormaps=['gray', 'red'], opacities=['', '1'])
def main(arguments):
fname_input_data = os.path.abspath(arguments["-i"])
img_input = Image(fname_input_data)
img_seg = propseg(img_input, arguments)
fname_seg = img_seg.absolutepath
path_qc = arguments.get("-qc", None)
if path_qc is not None:
generate_qc(fname_input_data, fname_seg, args,
os.path.abspath(path_qc))
sct.display_viewer_syntax([fname_input_data, fname_seg],
colormaps=['gray', 'red'],
opacities=['', '0.7'])
def main(arguments):
fname_input_data = os.path.abspath(arguments["-i"])
img_input = Image(fname_input_data)
img_seg = propseg(img_input, arguments)
fname_seg = img_seg.absolutepath
path_qc = arguments.get("-qc", None)
qc_dataset = arguments.get("-qc-dataset", None)
qc_subject = arguments.get("-qc-subject", None)
if path_qc is not None:
generate_qc(fname_in1=fname_input_data, fname_seg=fname_seg, args=args, path_qc=os.path.abspath(path_qc),
dataset=qc_dataset, subject=qc_subject, process='sct_propseg')
sct.display_viewer_syntax([fname_input_data, fname_seg], colormaps=['gray', 'red'], opacities=['', '1'])
def main(args=None):
parser = get_parser()
arguments = parser.parse_args(args=None if sys.argv[1:] else ['--help'])
fname_src = arguments.d
fname_transfo = arguments.w
warp_atlas = arguments.a
warp_spinal_levels = arguments.s
folder_out = arguments.ofolder
path_template = arguments.t
verbose = int(arguments.v)
init_sct(log_level=verbose, update=True) # Update log level
path_qc = arguments.qc
qc_dataset = arguments.qc_dataset
qc_subject = arguments.qc_subject
# call main function
w = WarpTemplate(fname_src, fname_transfo, warp_atlas, warp_spinal_levels, folder_out, path_template, verbose)
path_template = os.path.join(w.folder_out, w.folder_template)
# Deal with QC report
if path_qc is not None:
try:
fname_wm = os.path.join(
w.folder_out, w.folder_template, spinalcordtoolbox.metadata.get_file_label(path_template, id_label=4)) # label = 'white matter mask (probabilistic)'
generate_qc(
fname_src, fname_seg=fname_wm, args=sys.argv[1:], path_qc=os.path.abspath(path_qc), dataset=qc_dataset,
subject=qc_subject, process='sct_warp_template')
# If label is missing, get_file_label() throws a RuntimeError
except RuntimeError:
sct.printv("QC not generated since expected labels are missing from template", type="warning")
# Deal with verbose
try:
sct.display_viewer_syntax(
[fname_src,
spinalcordtoolbox.metadata.get_file_label(path_template, id_label=1, output="filewithpath"), # label = 'T2-weighted template'
spinalcordtoolbox.metadata.get_file_label(path_template, id_label=5, output="filewithpath"), # label = 'gray matter mask (probabilistic)'
spinalcordtoolbox.metadata.get_file_label(path_template, id_label=4, output="filewithpath")], # label = 'white matter mask (probabilistic)'
colormaps=['gray', 'gray', 'red-yellow', 'blue-lightblue'],
opacities=['1', '1', '0.5', '0.5'],
minmax=['', '0,4000', '0.4,1', '0.4,1'],
verbose=verbose)
# If label is missing, continue silently
except RuntimeError:
pass
def main(args=None):
parser = get_parser()
arguments = parser.parse(sys.argv[1:])
fname_src = arguments["-d"]
fname_transfo = arguments["-w"]
warp_atlas = int(arguments["-a"])
warp_spinal_levels = int(arguments["-s"])
folder_out = arguments['-ofolder']
path_template = arguments['-t']
verbose = int(arguments.get('-v'))
sct.init_sct(log_level=verbose, update=True) # Update log level
path_qc = arguments.get("-qc", None)
qc_dataset = arguments.get("-qc-dataset", None)
qc_subject = arguments.get("-qc-subject", None)
# call main function
w = WarpTemplate(fname_src, fname_transfo, warp_atlas, warp_spinal_levels, folder_out, path_template, verbose)
path_template = os.path.join(w.folder_out, w.folder_template)
# Only deal with QC and verbose if white matter was warped (meaning, everything under template/)
if "white matter" in spinalcordtoolbox.metadata.get_indiv_label_names(path_template):
# Deal with QC report
if path_qc is not None:
fname_wm = os.path.join(w.folder_out, w.folder_template,
spinalcordtoolbox.metadata.get_file_label(path_template, 'white matter'))
generate_qc(fname_src, fname_seg=fname_wm, args=sys.argv[1:], path_qc=os.path.abspath(path_qc),
dataset=qc_dataset, subject=qc_subject, process='sct_warp_template')
# Deal with verbose
sct.display_viewer_syntax(
[
fname_src,
spinalcordtoolbox.metadata.get_file_label(path_template, 'T2-weighted template', output="filewithpath"),
spinalcordtoolbox.metadata.get_file_label(path_template, 'gray matter', output="filewithpath"),
spinalcordtoolbox.metadata.get_file_label(path_template, 'white matter', output="filewithpath")
],
colormaps=['gray', 'gray', 'red-yellow', 'blue-lightblue'],
opacities=['1', '1', '0.5', '0.5'],
minmax=['', '0,4000', '0.4,1', '0.4,1'],
verbose=verbose,
)
else:
if path_qc is not None:
sct.printv("QC not generated since expected labels are missing from template", type="warning" )
def main():
parser = get_parser()
args = parser.parse_args(args=None if sys.argv[1:] else ['--help'])
verbose = args.v
sct.init_sct(log_level=verbose, update=True) # Update log level
sct.printv('Load data...', verbose)
nii_mt = Image(args.mt)
nii_pd = Image(args.pd)
nii_t1 = Image(args.t1)
if args.b1map is None:
nii_b1map = None
else:
nii_b1map = Image(args.b1map)
# compute MTsat
nii_mtsat, nii_t1map = compute_mtsat(nii_mt,
nii_pd,
nii_t1,
args.trmt,
args.trpd,
args.trt1,
args.famt,
args.fapd,
args.fat1,
nii_b1map=nii_b1map)
# Output MTsat and T1 maps
# by default, output in the same directory as the input images
sct.printv('Generate output files...', verbose)
if args.omtsat is None:
fname_mtsat = os.path.join(os.path.dirname(nii_mt.absolutepath),
"mtsat.nii.gz")
else:
fname_mtsat = args.omtsat
nii_mtsat.save(fname_mtsat)
if args.ot1map is None:
fname_t1map = os.path.join(os.path.dirname(nii_mt.absolutepath),
"t1map.nii.gz")
else:
fname_t1map = args.ot1map
nii_t1map.save(fname_t1map)
sct.display_viewer_syntax([fname_mtsat, fname_t1map],
colormaps=['gray', 'gray'],
minmax=['-10,10', '0, 3'],
opacities=['1', '1'],
verbose=verbose)
def main(args):
import sct_utils as sct
from spinalcordtoolbox.mtsat import mtsat
verbose = args.v
sct.init_sct(log_level=verbose, update=True) # Update log level
fname_mtsat, fname_t1map = mtsat.compute_mtsat_from_file(
args.mt, args.pd, args.t1, args.trmt, args.trpd, args.trt1, args.famt, args.fapd, args.fat1,
fname_b1map=args.b1map, fname_mtsat=args.omtsat, fname_t1map=args.ot1map, verbose=verbose)
sct.display_viewer_syntax([fname_mtsat, fname_t1map],
colormaps=['gray', 'gray'],
minmax=['-10,10', '0, 3'],
opacities=['1', '1'],
verbose=verbose)
def main():
# Check input parameters
parser = get_parser()
args = parser.parse_args(args=None if sys.argv[1:] else ['--help'])
fname_mtr = args.o
verbose = args.v
# Update log level
sct.init_sct(log_level=verbose, update=True)
# compute MTR
sct.printv('\nCompute MTR...', verbose)
nii_mtr = compute_mtr(nii_mt1=Image(args.mt1), nii_mt0=Image(args.mt0))
# save MTR file
nii_mtr.save(fname_mtr)
sct.display_viewer_syntax([args.mt0, args.mt1, fname_mtr])
def main(fname_anat, fname_centerline, degree_poly, centerline_fitting, interp,
remove_temp_files, verbose):
# load input images
im_anat = Image(fname_anat)
im_centerline = Image(fname_centerline)
# flatten sagittal
im_anat_flattened = flatten_sagittal(im_anat, im_centerline,
centerline_fitting, verbose)
# save output
fname_out = sct.add_suffix(fname_anat, '_flatten')
im_anat_flattened.save(fname_out)
sct.display_viewer_syntax([fname_anat, fname_out])
def main():
# Check input parameters
parser = get_parser()
args = parser.parse_args(args=None if sys.argv[1:] else ['--help'])
fname_mtr = args.o
verbose = args.v
# compute MTR
sct.printv('\nCompute MTR...', verbose)
nii_mtr = compute_mtr(nii_mt1=Image(args.mt1),
nii_mt0=Image(args.mt0),
threshold_mtr=args.thr)
# save MTR file
nii_mtr.save(fname_mtr, dtype='float32')
sct.display_viewer_syntax([args.mt0, args.mt1, fname_mtr])
def run_main():
parser = get_parser()
arguments = parser.parse_args(args=None if sys.argv[1:] else ['--help'])
input_filename = arguments.i
if arguments.o is not None:
output_filename = arguments.o
else:
output_filename = sct.add_suffix(input_filename, '_gmseg')
use_tta = arguments.t
model_name = arguments.m
threshold = arguments.thr
verbose = arguments.v
sct.init_sct(log_level=verbose, update=True) # Update log level
if threshold > 1.0 or threshold < 0.0:
raise RuntimeError("Threshold should be between 0.0 and 1.0.")
# Threshold zero means no thresholding
if threshold == 0.0:
threshold = None
from spinalcordtoolbox.deepseg_gm import deepseg_gm
deepseg_gm.check_backend()
out_fname = deepseg_gm.segment_file(input_filename,
output_filename, model_name, threshold,
int(verbose), use_tta)
path_qc = arguments.qc
qc_dataset = arguments.qc_dataset
qc_subject = arguments.qc_subject
if path_qc is not None:
generate_qc(fname_in1=input_filename,
fname_seg=out_fname,
args=sys.argv[1:],
path_qc=os.path.abspath(path_qc),
dataset=qc_dataset,
subject=qc_subject,
process='sct_deepseg_gm')
sct.display_viewer_syntax(
[input_filename, format(out_fname)],
colormaps=['gray', 'red'],
opacities=['1', '0.7'],
verbose=verbose)
def main(argv):
parser = get_parser(argv)
args = parser.parse_args(argv if argv else ['--help'])
verbose = args.v
init_sct(log_level=verbose, update=True) # Update log level
sct.printv('Load data...', verbose)
nii_mt = Image(args.mt)
nii_pd = Image(args.pd)
nii_t1 = Image(args.t1)
if args.b1map is None:
nii_b1map = None
else:
nii_b1map = Image(args.b1map)
if args.trmt is None:
args.trmt = fetch_metadata(get_json_file_name(args.mt, check_exist=True), 'RepetitionTime')
if args.trpd is None:
args.trpd = fetch_metadata(get_json_file_name(args.pd, check_exist=True), 'RepetitionTime')
if args.trt1 is None:
args.trt1 = fetch_metadata(get_json_file_name(args.t1, check_exist=True), 'RepetitionTime')
if args.famt is None:
args.famt = fetch_metadata(get_json_file_name(args.mt, check_exist=True), 'FlipAngle')
if args.fapd is None:
args.fapd = fetch_metadata(get_json_file_name(args.pd, check_exist=True), 'FlipAngle')
if args.fat1 is None:
args.fat1 = fetch_metadata(get_json_file_name(args.t1, check_exist=True), 'FlipAngle')
# compute MTsat
nii_mtsat, nii_t1map = compute_mtsat(nii_mt, nii_pd, nii_t1,
args.trmt, args.trpd, args.trt1,
args.famt, args.fapd, args.fat1,
nii_b1map=nii_b1map)
# Output MTsat and T1 maps
sct.printv('Generate output files...', verbose)
nii_mtsat.save(args.omtsat)
nii_t1map.save(args.ot1map)
sct.display_viewer_syntax([args.omtsat, args.ot1map],
colormaps=['gray', 'gray'],
minmax=['-10,10', '0, 3'],
opacities=['1', '1'],
verbose=verbose)
def main(arguments):
fname_input_data = os.path.abspath(arguments.i)
img_input = Image(fname_input_data)
img_seg = propseg(img_input, arguments)
fname_seg = img_seg.absolutepath
path_qc = arguments.qc
qc_dataset = arguments.qc_dataset
qc_subject = arguments.qc_subject
if path_qc is not None:
generate_qc(fname_in1=fname_input_data,
fname_seg=fname_seg,
args=arguments,
path_qc=os.path.abspath(path_qc),
dataset=qc_dataset,
subject=qc_subject,
process='sct_propseg')
sct.display_viewer_syntax([fname_input_data, fname_seg],
colormaps=['gray', 'red'],
opacities=['', '1'])
def run_main():
parser = get_parser()
arguments = parser.parse(sys.argv[1:])
input_filename = arguments["-i"]
try:
output_filename = arguments["-o"]
except KeyError:
output_filename = sct.add_suffix(input_filename, '_gmseg')
use_tta = "-t" in arguments
verbose = arguments["-v"]
model_name = arguments["-m"]
threshold = arguments['-thr']
if threshold > 1.0 or threshold < 0.0:
raise RuntimeError("Threshold should be between 0.0 and 1.0.")
# Threshold zero means no thresholding
if threshold == 0.0:
threshold = None
from spinalcordtoolbox.deepseg_gm import deepseg_gm
deepseg_gm.check_backend()
out_fname = deepseg_gm.segment_file(input_filename,
output_filename, model_name, threshold,
int(verbose), use_tta)
path_qc = arguments.get("-qc", None)
if path_qc is not None:
generate_qc(fname_in1=input_filename,
fname_seg=out_fname,
args=sys.argv[1:],
path_qc=os.path.abspath(path_qc),
process='sct_deepseg_gm')
sct.display_viewer_syntax(
[input_filename, format(out_fname)],
colormaps=['gray', 'red'],
opacities=['1', '0.7'],
verbose=verbose)
def main(fname_anat, fname_centerline, verbose):
"""
Main function
:param fname_anat:
:param fname_centerline:
:param verbose:
:return:
"""
# load input images
im_anat = Image(fname_anat)
im_centerline = Image(fname_centerline)
# flatten sagittal
im_anat_flattened = flatten_sagittal(im_anat, im_centerline, verbose)
# save output
fname_out = sct.add_suffix(fname_anat, '_flatten')
im_anat_flattened.save(fname_out)
sct.display_viewer_syntax([fname_anat, fname_out])
def main(fname_anat, fname_centerline, verbose):
"""
Main function
:param fname_anat:
:param fname_centerline:
:param verbose:
:return:
"""
# load input images
im_anat = Image(fname_anat)
im_centerline = Image(fname_centerline)
# flatten sagittal
im_anat_flattened = flatten_sagittal(im_anat, im_centerline, verbose)
# save output
fname_out = sct.add_suffix(fname_anat, '_flatten')
im_anat_flattened.save(fname_out)
sct.display_viewer_syntax([fname_anat, fname_out])
def run_main():
parser = get_parser()
arguments = parser.parse(sys.argv[1:])
input_filename = arguments["-i"]
try:
output_filename = arguments["-o"]
except KeyError:
output_filename = sct.add_suffix(input_filename, '_gmseg')
use_tta = "-t" in arguments
model_name = arguments["-m"]
threshold = arguments['-thr']
verbose = int(arguments.get('-v'))
sct.init_sct(log_level=verbose, update=True) # Update log level
if threshold > 1.0 or threshold < 0.0:
raise RuntimeError("Threshold should be between 0.0 and 1.0.")
# Threshold zero means no thresholding
if threshold == 0.0:
threshold = None
from spinalcordtoolbox.deepseg_gm import deepseg_gm
deepseg_gm.check_backend()
out_fname = deepseg_gm.segment_file(input_filename, output_filename,
model_name, threshold, int(verbose),
use_tta)
path_qc = arguments.get("-qc", None)
qc_dataset = arguments.get("-qc-dataset", None)
qc_subject = arguments.get("-qc-subject", None)
if path_qc is not None:
generate_qc(fname_in1=input_filename, fname_seg=out_fname, args=sys.argv[1:], path_qc=os.path.abspath(path_qc),
dataset=qc_dataset, subject=qc_subject, process='sct_deepseg_gm')
sct.display_viewer_syntax([input_filename, format(out_fname)],
colormaps=['gray', 'red'],
opacities=['1', '0.7'],
verbose=verbose)
def main(args=None):
"""
Main function
:param args:
:return:
"""
# get parser args
if args is None:
args = None if sys.argv[1:] else ['--help']
parser = get_parser()
arguments = parser.parse_args(args=args)
# initialize ImageCropper
cropper = ImageCropper(Image(arguments.i))
cropper.verbose = arguments.v
init_sct(log_level=cropper.verbose, update=True) # Update log level
# Switch across cropping methods
if arguments.g:
cropper.get_bbox_from_gui()
elif arguments.m:
cropper.get_bbox_from_mask(Image(arguments.m))
elif arguments.ref:
cropper.get_bbox_from_ref(Image(arguments.ref))
else:
cropper.get_bbox_from_minmax(
BoundingBox(arguments.xmin, arguments.xmax, arguments.ymin,
arguments.ymax, arguments.zmin, arguments.zmax))
# Crop image
img_crop = cropper.crop(background=arguments.b)
# Write cropped image to file
if arguments.o is None:
fname_out = sct.add_suffix(arguments.i, '_crop')
else:
fname_out = arguments.o
img_crop.save(fname_out)
sct.display_viewer_syntax([arguments.i, fname_out])
def compute(self):
fname_data = self.fmri
# open data
nii_data = Image(fname_data)
data = nii_data.data
# compute mean
data_mean = np.mean(data, 3)
# compute STD
data_std = np.std(data, 3, ddof=1)
# compute TSNR
data_tsnr = data_mean / data_std
# save TSNR
fname_tsnr = self.out
nii_tsnr = msct_image.empty_like(nii_data)
nii_tsnr.data = data_tsnr
nii_tsnr.save(fname_tsnr, dtype=np.float32)
sct.display_viewer_syntax([fname_tsnr])
def main(args=None):
import numpy as np
import spinalcordtoolbox.image as msct_image
# Initialization
fname_mt0 = ''
fname_mt1 = ''
fname_mtr = ''
# register = param.register
# remove_temp_files = param.remove_temp_files
# verbose = param.verbose
# check user arguments
if not args:
args = sys.argv[1:]
# Check input parameters
parser = get_parser()
arguments = parser.parse(args)
fname_mt0 = arguments['-mt0']
fname_mt1 = arguments['-mt1']
fname_mtr = arguments['-o']
verbose = int(arguments.get('-v'))
sct.init_sct(log_level=verbose, update=True) # Update log level
# compute MTR
sct.printv('\nCompute MTR...', verbose)
nii_mt1 = msct_image.Image(fname_mt1)
data_mt1 = nii_mt1.data
data_mt0 = msct_image.Image(fname_mt0).data
data_mtr = 100 * (data_mt0 - data_mt1) / data_mt0
# save MTR file
nii_mtr = nii_mt1
nii_mtr.data = data_mtr
nii_mtr.save(fname_mtr)
# sct.run(fsloutput+'fslmaths -dt double mt0.nii -sub mt1.nii -mul 100 -div mt0.nii -thr 0 -uthr 100 fname_mtr', verbose)
sct.display_viewer_syntax([fname_mt0, fname_mt1, fname_mtr])
def compute(self):
fname_data = self.fmri
# open data
nii_data = Image(fname_data)
data = nii_data.data
# compute mean
data_mean = np.mean(data, 3)
# compute STD
data_std = np.std(data, 3, ddof=1)
# compute TSNR
data_tsnr = data_mean / data_std
# save TSNR
fname_tsnr = sct.add_suffix(fname_data, '_tsnr')
nii_tsnr = nii_data
nii_tsnr.data = data_tsnr
nii_tsnr.setFileName(fname_tsnr)
nii_tsnr.save(type='float32')
sct.display_viewer_syntax([fname_tsnr])
def main(args=None):
if args is None:
args = sys.argv[1:]
# create param objects
param = Param()
# get parser
parser = get_parser()
arguments = parser.parse(args)
# set param arguments ad inputted by user
list_fname_src = arguments["-i"]
fname_dest = arguments["-d"]
list_fname_warp = arguments["-w"]
param.fname_out = arguments["-o"]
# if '-ofolder' in arguments:
# path_results = arguments['-ofolder']
if '-x' in arguments:
param.interp = arguments['-x']
if '-r' in arguments:
param.rm_tmp = bool(int(arguments['-r']))
if '-v' in arguments:
param.verbose = arguments['-v']
# check if list of input files and warping fields have same length
assert len(list_fname_src) == len(
list_fname_warp), "ERROR: list of files are not of the same length"
# merge src images to destination image
try:
merge_images(list_fname_src, fname_dest, list_fname_warp, param)
except Exception as e:
sct.printv(str(e), 1, 'error')
sct.display_viewer_syntax([fname_dest, os.path.abspath(param.fname_out)])
def main(args=None):
if args is None:
args = sys.argv[1:]
# create param objects
param = Param()
# get parser
parser = get_parser()
arguments = parser.parse(args)
# set param arguments ad inputted by user
list_fname_src = arguments["-i"]
fname_dest = arguments["-d"]
list_fname_warp = arguments["-w"]
param.fname_out = arguments["-o"]
# if '-ofolder' in arguments:
# path_results = arguments['-ofolder']
if '-x' in arguments:
param.interp = arguments['-x']
if '-r' in arguments:
param.rm_tmp = bool(int(arguments['-r']))
param.verbose = int(arguments.get('-v'))
sct.init_sct(log_level=param.verbose, update=True) # Update log level
# check if list of input files and warping fields have same length
assert len(list_fname_src) == len(list_fname_warp), "ERROR: list of files are not of the same length"
# merge src images to destination image
try:
merge_images(list_fname_src, fname_dest, list_fname_warp, param)
except Exception as e:
sct.printv(str(e), 1, 'error')
sct.display_viewer_syntax([fname_dest, os.path.abspath(param.fname_out)])
def main():
"""Main function."""
sct.init_sct()
parser = get_parser()
args = sys.argv[1:]
arguments = parser.parse(args)
fname_image = arguments['-i']
contrast_type = arguments['-c']
ctr_algo = arguments["-centerline"]
brain_bool = bool(int(arguments["-brain"]))
if "-brain" not in args and contrast_type in ['t2s', 't2_ax']:
brain_bool = False
if '-ofolder' not in args:
output_folder = os.getcwd()
else:
output_folder = arguments["-ofolder"]
if ctr_algo == 'file' and "-file_centerline" not in args:
sct.printv('Please use the flag -file_centerline to indicate the centerline filename.', 1, 'error')
sys.exit(1)
if "-file_centerline" in args:
manual_centerline_fname = arguments["-file_centerline"]
ctr_algo = 'file'
else:
manual_centerline_fname = None
remove_temp_files = int(arguments['-r'])
verbose = int(arguments.get('-v'))
sct.init_sct(log_level=verbose, update=True) # Update log level
algo_config_stg = '\nMethod:'
algo_config_stg += '\n\tCenterline algorithm: ' + str(ctr_algo)
algo_config_stg += '\n\tAssumes brain section included in the image: ' + str(brain_bool) + '\n'
sct.printv(algo_config_stg)
im_image = Image(fname_image)
im_seg, im_labels_viewer, im_ctr = deep_segmentation_MSlesion(im_image, contrast_type, ctr_algo=ctr_algo, ctr_file=manual_centerline_fname,
brain_bool=brain_bool, remove_temp_files=remove_temp_files, verbose=verbose)
# Save segmentation
fname_seg = os.path.abspath(os.path.join(output_folder, sct.extract_fname(fname_image)[1] + '_lesionseg' +
sct.extract_fname(fname_image)[2]))
im_seg.save(fname_seg)
if ctr_algo == 'viewer':
# Save labels
fname_labels = os.path.abspath(os.path.join(output_folder, sct.extract_fname(fname_image)[1] + '_labels-centerline' +
sct.extract_fname(fname_image)[2]))
im_labels_viewer.save(fname_labels)
if verbose == 2:
# Save ctr
fname_ctr = os.path.abspath(os.path.join(output_folder, sct.extract_fname(fname_image)[1] + '_centerline' +
sct.extract_fname(fname_image)[2]))
im_ctr.save(fname_ctr)
sct.display_viewer_syntax([fname_image, fname_seg], colormaps=['gray', 'red'], opacities=['', '0.7'])
def main(args = None):
dim_list = ['x', 'y', 'z', 't']
if not args:
args = sys.argv[1:]
# Get parser info
parser = get_parser()
arguments = parser.parse(args)
fname_in = arguments["-i"]
fname_out = arguments["-o"]
verbose = int(arguments.get('-v'))
sct.init_sct(log_level=verbose, update=True) # Update log level
if '-type' in arguments:
output_type = arguments['-type']
else:
output_type = None
# Open file(s)
im = Image(fname_in)
data = im.data # 3d or 4d numpy array
dim = im.dim
# run command
if '-otsu' in arguments:
param = arguments['-otsu']
data_out = otsu(data, param)
elif '-otsu_adap' in arguments:
param = arguments['-otsu_adap']
data_out = otsu_adap(data, param[0], param[1])
elif '-otsu_median' in arguments:
param = arguments['-otsu_median']
data_out = otsu_median(data, param[0], param[1])
elif '-thr' in arguments:
param = arguments['-thr']
data_out = threshold(data, param)
elif '-percent' in arguments:
param = arguments['-percent']
data_out = perc(data, param)
elif '-bin' in arguments:
bin_thr = arguments['-bin']
data_out = binarise(data, bin_thr=bin_thr)
elif '-add' in arguments:
from numpy import sum
data2 = get_data_or_scalar(arguments["-add"], data)
data_concat = concatenate_along_4th_dimension(data, data2)
data_out = sum(data_concat, axis=3)
elif '-sub' in arguments:
data2 = get_data_or_scalar(arguments['-sub'], data)
data_out = data - data2
elif "-laplacian" in arguments:
sigmas = arguments["-laplacian"]
if len(sigmas) == 1:
sigmas = [sigmas for i in range(len(data.shape))]
elif len(sigmas) != len(data.shape):
printv(parser.usage.generate(error='ERROR: -laplacian need the same number of inputs as the number of image dimension OR only one input'))
# adjust sigma based on voxel size
sigmas = [sigmas[i] / dim[i + 4] for i in range(3)]
# smooth data
data_out = laplacian(data, sigmas)
elif '-mul' in arguments:
from numpy import prod
data2 = get_data_or_scalar(arguments["-mul"], data)
data_concat = concatenate_along_4th_dimension(data, data2)
data_out = prod(data_concat, axis=3)
elif '-div' in arguments:
from numpy import divide
data2 = get_data_or_scalar(arguments["-div"], data)
data_out = divide(data, data2)
elif '-mean' in arguments:
from numpy import mean
dim = dim_list.index(arguments['-mean'])
if dim + 1 > len(np.shape(data)): # in case input volume is 3d and dim=t
data = data[..., np.newaxis]
data_out = mean(data, dim)
elif '-rms' in arguments:
from numpy import mean, sqrt, square
dim = dim_list.index(arguments['-rms'])
if dim + 1 > len(np.shape(data)): # in case input volume is 3d and dim=t
data = data[..., np.newaxis]
data_out = sqrt(mean(square(data.astype(float)), dim))
elif '-std' in arguments:
from numpy import std
dim = dim_list.index(arguments['-std'])
if dim + 1 > len(np.shape(data)): # in case input volume is 3d and dim=t
data = data[..., np.newaxis]
data_out = std(data, dim, ddof=1)
elif "-smooth" in arguments:
sigmas = arguments["-smooth"]
if len(sigmas) == 1:
sigmas = [sigmas[0] for i in range(len(data.shape))]
elif len(sigmas) != len(data.shape):
printv(parser.usage.generate(error='ERROR: -smooth need the same number of inputs as the number of image dimension OR only one input'))
# adjust sigma based on voxel size
sigmas = [sigmas[i] / dim[i + 4] for i in range(3)]
# smooth data
data_out = smooth(data, sigmas)
elif '-dilate' in arguments:
data_out = dilate(data, arguments['-dilate'])
elif '-erode' in arguments:
data_out = erode(data, arguments['-erode'])
elif '-denoise' in arguments:
# parse denoising arguments
p, b = 1, 5 # default arguments
list_denoise = arguments['-denoise']
for i in list_denoise:
if 'p' in i:
p = int(i.split('=')[1])
if 'b' in i:
b = int(i.split('=')[1])
data_out = denoise_nlmeans(data, patch_radius=p, block_radius=b)
elif '-symmetrize' in arguments:
data_out = (data + data[list(range(data.shape[0] - 1, -1, -1)), :, :]) / float(2)
elif '-mi' in arguments:
# input 1 = from flag -i --> im
# input 2 = from flag -mi
im_2 = Image(arguments['-mi'])
compute_similarity(im.data, im_2.data, fname_out, metric='mi', verbose=verbose)
data_out = None
elif '-minorm' in arguments:
im_2 = Image(arguments['-minorm'])
compute_similarity(im.data, im_2.data, fname_out, metric='minorm', verbose=verbose)
data_out = None
elif '-corr' in arguments:
# input 1 = from flag -i --> im
# input 2 = from flag -mi
im_2 = Image(arguments['-corr'])
compute_similarity(im.data, im_2.data, fname_out, metric='corr', verbose=verbose)
data_out = None
# if no flag is set
else:
data_out = None
printv(parser.usage.generate(error='ERROR: you need to specify an operation to do on the input image'))
if data_out is not None:
# Write output
nii_out = Image(fname_in) # use header of input file
nii_out.data = data_out
nii_out.save(fname_out, dtype=output_type)
# TODO: case of multiple outputs
# assert len(data_out) == n_out
# if n_in == n_out:
# for im_in, d_out, fn_out in zip(nii, data_out, fname_out):
# im_in.data = d_out
# im_in.absolutepath = fn_out
# if "-w" in arguments:
# im_in.hdr.set_intent('vector', (), '')
# im_in.save()
# elif n_out == 1:
# nii[0].data = data_out[0]
# nii[0].absolutepath = fname_out[0]
# if "-w" in arguments:
# nii[0].hdr.set_intent('vector', (), '')
# nii[0].save()
# elif n_out > n_in:
# for dat_out, name_out in zip(data_out, fname_out):
# im_out = nii[0].copy()
# im_out.data = dat_out
# im_out.absolutepath = name_out
# if "-w" in arguments:
# im_out.hdr.set_intent('vector', (), '')
# im_out.save()
# else:
# printv(parser.usage.generate(error='ERROR: not the correct numbers of inputs and outputs'))
# display message
if data_out is not None:
sct.display_viewer_syntax([fname_out], verbose=verbose)
else:
printv('\nDone! File created: ' + fname_out, verbose, 'info')
def main():
"""Main function."""
sct.init_sct()
parser = get_parser()
args = sys.argv[1:]
arguments = parser.parse(args)
fname_image = os.path.abspath(arguments['-i'])
contrast_type = arguments['-c']
ctr_algo = arguments["-centerline"]
if "-brain" not in args:
if contrast_type in ['t2s', 'dwi']:
brain_bool = False
if contrast_type in ['t1', 't2']:
brain_bool = True
else:
brain_bool = bool(int(arguments["-brain"]))
kernel_size = arguments["-kernel"]
if kernel_size == '3d' and contrast_type == 'dwi':
kernel_size = '2d'
sct.printv('3D kernel model for dwi contrast is not available. 2D kernel model is used instead.', type="warning")
if '-ofolder' not in args:
output_folder = os.getcwd()
else:
output_folder = arguments["-ofolder"]
if ctr_algo == 'file' and "-file_centerline" not in args:
logger.warning('Please use the flag -file_centerline to indicate the centerline filename.')
sys.exit(1)
if "-file_centerline" in args:
manual_centerline_fname = arguments["-file_centerline"]
ctr_algo = 'file'
else:
manual_centerline_fname = None
remove_temp_files = int(arguments['-r'])
verbose = int(arguments.get('-v'))
sct.init_sct(log_level=verbose, update=True) # Update log level
path_qc = arguments.get("-qc", None)
qc_dataset = arguments.get("-qc-dataset", None)
qc_subject = arguments.get("-qc-subject", None)
algo_config_stg = '\nMethod:'
algo_config_stg += '\n\tCenterline algorithm: ' + str(ctr_algo)
algo_config_stg += '\n\tAssumes brain section included in the image: ' + str(brain_bool)
algo_config_stg += '\n\tDimension of the segmentation kernel convolutions: ' + kernel_size + '\n'
sct.printv(algo_config_stg)
im_image = Image(fname_image)
# note: below we pass im_image.copy() otherwise the field absolutepath becomes None after execution of this function
im_seg, im_image_RPI_upsamp, im_seg_RPI_upsamp, im_labels_viewer, im_ctr = deep_segmentation_spinalcord(
im_image.copy(), contrast_type, ctr_algo=ctr_algo, ctr_file=manual_centerline_fname,
brain_bool=brain_bool, kernel_size=kernel_size, remove_temp_files=remove_temp_files, verbose=verbose)
# Save segmentation
fname_seg = os.path.abspath(os.path.join(output_folder, sct.extract_fname(fname_image)[1] + '_seg' +
sct.extract_fname(fname_image)[2]))
im_seg.save(fname_seg)
if ctr_algo == 'viewer':
# Save labels
fname_labels = os.path.abspath(os.path.join(output_folder, sct.extract_fname(fname_image)[1] + '_labels-centerline' +
sct.extract_fname(fname_image)[2]))
im_labels_viewer.save(fname_labels)
if verbose == 2:
# Save ctr
fname_ctr = os.path.abspath(os.path.join(output_folder, sct.extract_fname(fname_image)[1] + '_centerline' +
sct.extract_fname(fname_image)[2]))
im_ctr.save(fname_ctr)
if path_qc is not None:
generate_qc(fname_image, fname_seg=fname_seg, args=args, path_qc=os.path.abspath(path_qc),
dataset=qc_dataset, subject=qc_subject, process='sct_deepseg_sc')
sct.display_viewer_syntax([fname_image, fname_seg], colormaps=['gray', 'red'], opacities=['', '0.7'])
def main(args=None):
if args is None:
args = sys.argv[1:]
# initialize parameters
param = Param()
# Initialization
fname_output = ''
path_out = ''
fname_src_seg = ''
fname_dest_seg = ''
fname_src_label = ''
fname_dest_label = ''
generate_warpinv = 1
start_time = time.time()
# get path of the toolbox
path_sct = os.environ.get("SCT_DIR",
os.path.dirname(os.path.dirname(__file__)))
# get default registration parameters
# step1 = Paramreg(step='1', type='im', algo='syn', metric='MI', iter='5', shrink='1', smooth='0', gradStep='0.5')
step0 = Paramreg(
step='0',
type='im',
algo='syn',
metric='MI',
iter='0',
shrink='1',
smooth='0',
gradStep='0.5',
slicewise='0',
dof='Tx_Ty_Tz_Rx_Ry_Rz') # only used to put src into dest space
step1 = Paramreg(step='1', type='im')
paramreg = ParamregMultiStep([step0, step1])
parser = get_parser(paramreg=paramreg)
arguments = parser.parse(args)
# get arguments
fname_src = arguments['-i']
fname_dest = arguments['-d']
if '-iseg' in arguments:
fname_src_seg = arguments['-iseg']
if '-dseg' in arguments:
fname_dest_seg = arguments['-dseg']
if '-ilabel' in arguments:
fname_src_label = arguments['-ilabel']
if '-dlabel' in arguments:
fname_dest_label = arguments['-dlabel']
if '-o' in arguments:
fname_output = arguments['-o']
if '-ofolder' in arguments:
path_out = arguments['-ofolder']
if '-owarp' in arguments:
fname_output_warp = arguments['-owarp']
else:
fname_output_warp = ''
if '-initwarp' in arguments:
fname_initwarp = os.path.abspath(arguments['-initwarp'])
else:
fname_initwarp = ''
if '-initwarpinv' in arguments:
fname_initwarpinv = os.path.abspath(arguments['-initwarpinv'])
else:
fname_initwarpinv = ''
if '-m' in arguments:
fname_mask = arguments['-m']
else:
fname_mask = ''
padding = arguments['-z']
if "-param" in arguments:
paramreg_user = arguments['-param']
# update registration parameters
for paramStep in paramreg_user:
paramreg.addStep(paramStep)
path_qc = arguments.get("-qc", None)
identity = int(arguments['-identity'])
interp = arguments['-x']
remove_temp_files = int(arguments['-r'])
verbose = int(arguments['-v'])
# sct.printv(arguments)
sct.printv('\nInput parameters:')
sct.printv(' Source .............. ' + fname_src)
sct.printv(' Destination ......... ' + fname_dest)
sct.printv(' Init transfo ........ ' + fname_initwarp)
sct.printv(' Mask ................ ' + fname_mask)
sct.printv(' Output name ......... ' + fname_output)
# sct.printv(' Algorithm ........... '+paramreg.algo)
# sct.printv(' Number of iterations '+paramreg.iter)
# sct.printv(' Metric .............. '+paramreg.metric)
sct.printv(' Remove temp files ... ' + str(remove_temp_files))
sct.printv(' Verbose ............. ' + str(verbose))
# update param
param.verbose = verbose
param.padding = padding
param.fname_mask = fname_mask
param.remove_temp_files = remove_temp_files
# Get if input is 3D
sct.printv('\nCheck if input data are 3D...', verbose)
sct.check_if_3d(fname_src)
sct.check_if_3d(fname_dest)
# Check if user selected type=seg, but did not input segmentation data
if 'paramreg_user' in locals():
if True in [
'type=seg' in paramreg_user[i]
for i in range(len(paramreg_user))
]:
if fname_src_seg == '' or fname_dest_seg == '':
sct.printv(
'\nERROR: if you select type=seg you must specify -iseg and -dseg flags.\n',
1, 'error')
# Extract path, file and extension
path_src, file_src, ext_src = sct.extract_fname(fname_src)
path_dest, file_dest, ext_dest = sct.extract_fname(fname_dest)
# check if source and destination images have the same name (related to issue #373)
# If so, change names to avoid conflict of result files and warns the user
suffix_src, suffix_dest = '_reg', '_reg'
if file_src == file_dest:
suffix_src, suffix_dest = '_src_reg', '_dest_reg'
# define output folder and file name
if fname_output == '':
path_out = '' if not path_out else path_out # output in user's current directory
file_out = file_src + suffix_src
file_out_inv = file_dest + suffix_dest
ext_out = ext_src
else:
path, file_out, ext_out = sct.extract_fname(fname_output)
path_out = path if not path_out else path_out
file_out_inv = file_out + '_inv'
# create temporary folder
path_tmp = sct.tmp_create()
sct.printv('\nCopying input data to tmp folder and convert to nii...',
verbose)
Image(fname_src).save(os.path.join(path_tmp, "src.nii"))
Image(fname_dest).save(os.path.join(path_tmp, "dest.nii"))
if fname_src_seg:
Image(fname_src_seg).save(os.path.join(path_tmp, "src_seg.nii"))
if fname_dest_seg:
Image(fname_dest_seg).save(os.path.join(path_tmp, "dest_seg.nii"))
if fname_src_label:
Image(fname_src_label).save(os.path.join(path_tmp, "src_label.nii"))
Image(fname_dest_label).save(os.path.join(path_tmp, "dest_label.nii"))
if fname_mask != '':
Image(fname_mask).save(os.path.join(path_tmp, "mask.nii.gz"))
# go to tmp folder
curdir = os.getcwd()
os.chdir(path_tmp)
# reorient destination to RPI
Image('dest.nii').change_orientation("RPI").save('dest_RPI.nii')
if fname_dest_seg:
Image('dest_seg.nii').change_orientation("RPI").save(
'dest_seg_RPI.nii')
if fname_dest_label:
Image('dest_label.nii').change_orientation("RPI").save(
'dest_label_RPI.nii')
if identity:
# overwrite paramreg and only do one identity transformation
step0 = Paramreg(step='0',
type='im',
algo='syn',
metric='MI',
iter='0',
shrink='1',
smooth='0',
gradStep='0.5')
paramreg = ParamregMultiStep([step0])
# Put source into destination space using header (no estimation -- purely based on header)
# TODO: Check if necessary to do that
# TODO: use that as step=0
# sct.printv('\nPut source into destination space using header...', verbose)
# sct.run('isct_antsRegistration -d 3 -t Translation[0] -m MI[dest_pad.nii,src.nii,1,16] -c 0 -f 1 -s 0 -o
# [regAffine,src_regAffine.nii] -n BSpline[3]', verbose)
# if segmentation, also do it for seg
# initialize list of warping fields
warp_forward = []
warp_inverse = []
# initial warping is specified, update list of warping fields and skip step=0
if fname_initwarp:
sct.printv('\nSkip step=0 and replace with initial transformations: ',
param.verbose)
sct.printv(' ' + fname_initwarp, param.verbose)
# sct.copy(fname_initwarp, 'warp_forward_0.nii.gz')
warp_forward = [fname_initwarp]
start_step = 1
if fname_initwarpinv:
warp_inverse = [fname_initwarpinv]
else:
sct.printv(
'\nWARNING: No initial inverse warping field was specified, therefore the inverse warping field '
'will NOT be generated.', param.verbose, 'warning')
generate_warpinv = 0
else:
start_step = 0
# loop across registration steps
for i_step in range(start_step, len(paramreg.steps)):
sct.printv('\n--\nESTIMATE TRANSFORMATION FOR STEP #' + str(i_step),
param.verbose)
# identify which is the src and dest
if paramreg.steps[str(i_step)].type == 'im':
src = 'src.nii'
dest = 'dest_RPI.nii'
interp_step = 'spline'
elif paramreg.steps[str(i_step)].type == 'seg':
src = 'src_seg.nii'
dest = 'dest_seg_RPI.nii'
interp_step = 'nn'
elif paramreg.steps[str(i_step)].type == 'label':
src = 'src_label.nii'
dest = 'dest_label_RPI.nii'
interp_step = 'nn'
else:
# src = dest = interp_step = None
sct.printv('ERROR: Wrong image type.', 1, 'error')
# if step>0, apply warp_forward_concat to the src image to be used
if i_step > 0:
sct.printv('\nApply transformation from previous step',
param.verbose)
sct.run([
'sct_apply_transfo', '-i', src, '-d', dest, '-w',
','.join(warp_forward), '-o',
sct.add_suffix(src, '_reg'), '-x', interp_step
], verbose)
src = sct.add_suffix(src, '_reg')
# register src --> dest
warp_forward_out, warp_inverse_out = register(src, dest, paramreg,
param, str(i_step))
warp_forward.append(warp_forward_out)
warp_inverse.insert(0, warp_inverse_out)
# Concatenate transformations
sct.printv('\nConcatenate transformations...', verbose)
sct.run([
'sct_concat_transfo', '-w', ','.join(warp_forward), '-d', 'dest.nii',
'-o', 'warp_src2dest.nii.gz'
], verbose)
sct.run([
'sct_concat_transfo', '-w', ','.join(warp_inverse), '-d', 'src.nii',
'-o', 'warp_dest2src.nii.gz'
], verbose)
# Apply warping field to src data
sct.printv('\nApply transfo source --> dest...', verbose)
sct.run([
'sct_apply_transfo', '-i', 'src.nii', '-o', 'src_reg.nii', '-d',
'dest.nii', '-w', 'warp_src2dest.nii.gz', '-x', interp
], verbose)
sct.printv('\nApply transfo dest --> source...', verbose)
sct.run([
'sct_apply_transfo', '-i', 'dest.nii', '-o', 'dest_reg.nii', '-d',
'src.nii', '-w', 'warp_dest2src.nii.gz', '-x', interp
], verbose)
# come back
os.chdir(curdir)
# Generate output files
sct.printv('\nGenerate output files...', verbose)
# generate: src_reg
fname_src2dest = sct.generate_output_file(
os.path.join(path_tmp, "src_reg.nii"),
os.path.join(path_out, file_out + ext_out), verbose)
# generate: forward warping field
if fname_output_warp == '':
fname_output_warp = os.path.join(
path_out, 'warp_' + file_src + '2' + file_dest + '.nii.gz')
sct.generate_output_file(os.path.join(path_tmp, "warp_src2dest.nii.gz"),
fname_output_warp, verbose)
if generate_warpinv:
# generate: dest_reg
fname_dest2src = sct.generate_output_file(
os.path.join(path_tmp, "dest_reg.nii"),
os.path.join(path_out, file_out_inv + ext_dest), verbose)
# generate: inverse warping field
sct.generate_output_file(
os.path.join(path_tmp, "warp_dest2src.nii.gz"),
os.path.join(path_out,
'warp_' + file_dest + '2' + file_src + '.nii.gz'),
verbose)
# Delete temporary files
if remove_temp_files:
sct.printv('\nRemove temporary files...', verbose)
sct.rmtree(path_tmp, verbose=verbose)
# display elapsed time
elapsed_time = time.time() - start_time
sct.printv(
'\nFinished! Elapsed time: ' + str(int(np.round(elapsed_time))) + 's',
verbose)
if path_qc is not None:
if fname_dest_seg:
generate_qc(fname_src2dest,
fname_in2=fname_dest,
fname_seg=fname_dest_seg,
args=args,
path_qc=os.path.abspath(path_qc),
process='sct_register_multimodal')
else:
sct.printv(
'WARNING: Cannot generate QC because it requires destination segmentation.',
1, 'warning')
if generate_warpinv:
sct.display_viewer_syntax([fname_src, fname_dest2src], verbose=verbose)
sct.display_viewer_syntax([fname_dest, fname_src2dest], verbose=verbose)
def main(args=None):
if args is None:
args = sys.argv[1:]
parser = get_parser()
arguments = parser.parse(args)
# assigning variables to arguments
input_filename = arguments["-i"]
centerline_file = arguments["-s"]
sc_straight = SpinalCordStraightener(input_filename, centerline_file)
if "-dest" in arguments:
sc_straight.use_straight_reference = True
sc_straight.centerline_reference_filename = str(arguments["-dest"])
if "-ldisc_input" in arguments:
if not sc_straight.use_straight_reference:
sct.printv('Warning: discs position are not taken into account if reference is not provided.')
else:
sc_straight.discs_input_filename = str(arguments["-ldisc_input"])
sc_straight.precision = 4.0
if "-ldisc_dest" in arguments:
if not sc_straight.use_straight_reference:
sct.printv('Warning: discs position are not taken into account if reference is not provided.')
else:
sc_straight.discs_ref_filename = str(arguments["-ldisc_dest"])
sc_straight.precision = 4.0
# Handling optional arguments
if "-r" in arguments:
sc_straight.remove_temp_files = int(arguments["-r"])
if "-x" in arguments:
sc_straight.interpolation_warp = str(arguments["-x"])
if "-o" in arguments:
sc_straight.output_filename = str(arguments["-o"])
if '-ofolder' in arguments:
sc_straight.path_output = arguments['-ofolder']
else:
sc_straight.path_output = './'
verbose = int(arguments.get('-v'))
sct.init_sct(log_level=verbose, update=True) # Update log level
sc_straight.verbose = verbose
# if "-cpu-nb" in arguments:
# sc_straight.cpu_number = int(arguments["-cpu-nb"])
if '-disable-straight2curved' in arguments:
sc_straight.straight2curved = False
if '-disable-curved2straight' in arguments:
sc_straight.curved2straight = False
if '-speed_factor' in arguments:
sc_straight.speed_factor = arguments['-speed_factor']
if '-xy_size' in arguments:
sc_straight.xy_size = arguments['-xy_size']
if "-param" in arguments:
params_user = arguments['-param']
# update registration parameters
for param in params_user:
param_split = param.split('=')
if param_split[0] == 'algo_fitting':
sc_straight.algo_fitting = param_split[1]
if param_split[0] == 'degree':
sc_straight.degree = int(param_split[1])
if param_split[0] == 'precision':
sc_straight.precision = float(param_split[1])
if param_split[0] == 'threshold_distance':
sc_straight.threshold_distance = float(param_split[1])
if param_split[0] == 'accuracy_results':
sc_straight.accuracy_results = int(param_split[1])
if param_split[0] == 'template_orientation':
sc_straight.template_orientation = int(param_split[1])
fname_straight = sc_straight.straighten()
sct.printv("\nFinished! Elapsed time: {} s".format(sc_straight.elapsed_time), verbose)
sct.display_viewer_syntax([fname_straight], verbose=verbose)
def main(args=None):
# initializations
initz = ''
initcenter = ''
fname_initlabel = ''
file_labelz = 'labelz.nii.gz'
param = Param()
# check user arguments
if not args:
args = sys.argv[1:]
# Get parser info
parser = get_parser()
arguments = parser.parse(args)
fname_in = os.path.abspath(arguments["-i"])
fname_seg = os.path.abspath(arguments['-s'])
contrast = arguments['-c']
path_template = arguments['-t']
scale_dist = arguments['-scale-dist']
if '-ofolder' in arguments:
path_output = arguments['-ofolder']
else:
path_output = os.curdir
param.path_qc = arguments.get("-qc", None)
if '-discfile' in arguments:
fname_disc = os.path.abspath(arguments['-discfile'])
else:
fname_disc = None
if '-initz' in arguments:
initz = arguments['-initz']
if '-initcenter' in arguments:
initcenter = arguments['-initcenter']
# if user provided text file, parse and overwrite arguments
if '-initfile' in arguments:
file = open(arguments['-initfile'], 'r')
initfile = ' ' + file.read().replace('\n', '')
arg_initfile = initfile.split(' ')
for idx_arg, arg in enumerate(arg_initfile):
if arg == '-initz':
initz = [int(x) for x in arg_initfile[idx_arg + 1].split(',')]
if arg == '-initcenter':
initcenter = int(arg_initfile[idx_arg + 1])
if '-initlabel' in arguments:
# get absolute path of label
fname_initlabel = os.path.abspath(arguments['-initlabel'])
if '-param' in arguments:
param.update(arguments['-param'][0])
verbose = int(arguments.get('-v'))
sct.init_sct(log_level=verbose, update=True) # Update log level
remove_temp_files = int(arguments['-r'])
denoise = int(arguments['-denoise'])
laplacian = int(arguments['-laplacian'])
path_tmp = sct.tmp_create(basename="label_vertebrae", verbose=verbose)
# Copying input data to tmp folder
sct.printv('\nCopying input data to tmp folder...', verbose)
Image(fname_in).save(os.path.join(path_tmp, "data.nii"))
Image(fname_seg).save(os.path.join(path_tmp, "segmentation.nii"))
# Go go temp folder
curdir = os.getcwd()
os.chdir(path_tmp)
# Straighten spinal cord
sct.printv('\nStraighten spinal cord...', verbose)
# check if warp_curve2straight and warp_straight2curve already exist (i.e. no need to do it another time)
cache_sig = sct.cache_signature(
input_files=[fname_in, fname_seg],
)
cachefile = os.path.join(curdir, "straightening.cache")
if sct.cache_valid(cachefile, cache_sig) and os.path.isfile(os.path.join(curdir, "warp_curve2straight.nii.gz")) and os.path.isfile(os.path.join(curdir, "warp_straight2curve.nii.gz")) and os.path.isfile(os.path.join(curdir, "straight_ref.nii.gz")):
# if they exist, copy them into current folder
sct.printv('Reusing existing warping field which seems to be valid', verbose, 'warning')
sct.copy(os.path.join(curdir, "warp_curve2straight.nii.gz"), 'warp_curve2straight.nii.gz')
sct.copy(os.path.join(curdir, "warp_straight2curve.nii.gz"), 'warp_straight2curve.nii.gz')
sct.copy(os.path.join(curdir, "straight_ref.nii.gz"), 'straight_ref.nii.gz')
# apply straightening
s, o = sct.run(['sct_apply_transfo', '-i', 'data.nii', '-w', 'warp_curve2straight.nii.gz', '-d', 'straight_ref.nii.gz', '-o', 'data_straight.nii'])
else:
cmd = ['sct_straighten_spinalcord',
'-i', 'data.nii',
'-s', 'segmentation.nii',
'-r', str(remove_temp_files)]
if param.path_qc is not None and os.environ.get("SCT_RECURSIVE_QC", None) == "1":
cmd += ['-qc', param.path_qc]
s, o = sct.run(cmd)
sct.cache_save(cachefile, cache_sig)
# resample to 0.5mm isotropic to match template resolution
sct.printv('\nResample to 0.5mm isotropic...', verbose)
s, o = sct.run(['sct_resample', '-i', 'data_straight.nii', '-mm', '0.5x0.5x0.5', '-x', 'linear', '-o', 'data_straightr.nii'], verbose=verbose)
# Apply straightening to segmentation
# N.B. Output is RPI
sct.printv('\nApply straightening to segmentation...', verbose)
sct.run('isct_antsApplyTransforms -d 3 -i %s -r %s -t %s -o %s -n %s' %
('segmentation.nii',
'data_straightr.nii',
'warp_curve2straight.nii.gz',
'segmentation_straight.nii',
'Linear'),
verbose=verbose,
is_sct_binary=True,
)
# Threshold segmentation at 0.5
sct.run(['sct_maths', '-i', 'segmentation_straight.nii', '-thr', '0.5', '-o', 'segmentation_straight.nii'], verbose)
# If disc label file is provided, label vertebrae using that file instead of automatically
if fname_disc:
# Apply straightening to disc-label
sct.printv('\nApply straightening to disc labels...', verbose)
sct.run('isct_antsApplyTransforms -d 3 -i %s -r %s -t %s -o %s -n %s' %
(fname_disc,
'data_straightr.nii',
'warp_curve2straight.nii.gz',
'labeldisc_straight.nii.gz',
'NearestNeighbor'),
verbose=verbose,
is_sct_binary=True,
)
label_vert('segmentation_straight.nii', 'labeldisc_straight.nii.gz', verbose=1)
else:
# create label to identify disc
sct.printv('\nCreate label to identify disc...', verbose)
fname_labelz = os.path.join(path_tmp, file_labelz)
if initz or initcenter:
if initcenter:
# find z centered in FOV
nii = Image('segmentation.nii').change_orientation("RPI")
nx, ny, nz, nt, px, py, pz, pt = nii.dim # Get dimensions
z_center = int(np.round(nz / 2)) # get z_center
initz = [z_center, initcenter]
# create single label and output as labels.nii.gz
label = ProcessLabels('segmentation.nii', fname_output='tmp.labelz.nii.gz',
coordinates=['{},{}'.format(initz[0], initz[1])])
im_label = label.process('create-seg')
im_label.data = sct_maths.dilate(im_label.data, [3]) # TODO: create a dilation method specific to labels,
# which does not apply a convolution across all voxels (highly inneficient)
im_label.save(fname_labelz)
elif fname_initlabel:
import sct_label_utils
# subtract "1" to label value because due to legacy, in this code the disc C2-C3 has value "2", whereas in the
# recent version of SCT it is defined as "3". Therefore, when asking the user to define a label, we point to the
# new definition of labels (i.e., C2-C3 = 3).
sct_label_utils.main(['-i', fname_initlabel, '-add', '-1', '-o', fname_labelz])
else:
# automatically finds C2-C3 disc
im_data = Image('data.nii')
im_seg = Image('segmentation.nii')
im_label_c2c3 = detect_c2c3(im_data, im_seg, contrast)
ind_label = np.where(im_label_c2c3.data)
if not np.size(ind_label) == 0:
# subtract "1" to label value because due to legacy, in this code the disc C2-C3 has value "2", whereas in the
# recent version of SCT it is defined as "3".
im_label_c2c3.data[ind_label] = 2
else:
sct.printv('Automatic C2-C3 detection failed. Please provide manual label with sct_label_utils', 1, 'error')
im_label_c2c3.save(fname_labelz)
# dilate label so it is not lost when applying warping
sct_maths.main(['-i', fname_labelz, '-dilate', '3', '-o', fname_labelz])
# Apply straightening to z-label
sct.printv('\nAnd apply straightening to label...', verbose)
sct.run('isct_antsApplyTransforms -d 3 -i %s -r %s -t %s -o %s -n %s' %
(file_labelz,
'data_straightr.nii',
'warp_curve2straight.nii.gz',
'labelz_straight.nii.gz',
'NearestNeighbor'),
verbose=verbose,
is_sct_binary=True,
)
# get z value and disk value to initialize labeling
sct.printv('\nGet z and disc values from straight label...', verbose)
init_disc = get_z_and_disc_values_from_label('labelz_straight.nii.gz')
sct.printv('.. ' + str(init_disc), verbose)
# denoise data
if denoise:
sct.printv('\nDenoise data...', verbose)
sct.run(['sct_maths', '-i', 'data_straightr.nii', '-denoise', 'h=0.05', '-o', 'data_straightr.nii'], verbose)
# apply laplacian filtering
if laplacian:
sct.printv('\nApply Laplacian filter...', verbose)
sct.run(['sct_maths', '-i', 'data_straightr.nii', '-laplacian', '1', '-o', 'data_straightr.nii'], verbose)
# detect vertebral levels on straight spinal cord
vertebral_detection('data_straightr.nii', 'segmentation_straight.nii', contrast, param, init_disc=init_disc,
verbose=verbose, path_template=path_template, path_output=path_output, scale_dist=scale_dist)
# un-straighten labeled spinal cord
sct.printv('\nUn-straighten labeling...', verbose)
sct.run('isct_antsApplyTransforms -d 3 -i %s -r %s -t %s -o %s -n %s' %
('segmentation_straight_labeled.nii',
'segmentation.nii',
'warp_straight2curve.nii.gz',
'segmentation_labeled.nii',
'NearestNeighbor'),
verbose=verbose,
is_sct_binary=True,
)
# Clean labeled segmentation
sct.printv('\nClean labeled segmentation (correct interpolation errors)...', verbose)
clean_labeled_segmentation('segmentation_labeled.nii', 'segmentation.nii', 'segmentation_labeled.nii')
# label discs
sct.printv('\nLabel discs...', verbose)
label_discs('segmentation_labeled.nii', verbose=verbose)
# come back
os.chdir(curdir)
# Generate output files
path_seg, file_seg, ext_seg = sct.extract_fname(fname_seg)
fname_seg_labeled = os.path.join(path_output, file_seg + '_labeled' + ext_seg)
sct.printv('\nGenerate output files...', verbose)
sct.generate_output_file(os.path.join(path_tmp, "segmentation_labeled.nii"), fname_seg_labeled)
sct.generate_output_file(os.path.join(path_tmp, "segmentation_labeled_disc.nii"), os.path.join(path_output, file_seg + '_labeled_discs' + ext_seg))
# copy straightening files in case subsequent SCT functions need them
sct.generate_output_file(os.path.join(path_tmp, "warp_curve2straight.nii.gz"), os.path.join(path_output, "warp_curve2straight.nii.gz"), verbose)
sct.generate_output_file(os.path.join(path_tmp, "warp_straight2curve.nii.gz"), os.path.join(path_output, "warp_straight2curve.nii.gz"), verbose)
sct.generate_output_file(os.path.join(path_tmp, "straight_ref.nii.gz"), os.path.join(path_output, "straight_ref.nii.gz"), verbose)
# Remove temporary files
if remove_temp_files == 1:
sct.printv('\nRemove temporary files...', verbose)
sct.rmtree(path_tmp)
# Generate QC report
if param.path_qc is not None:
path_qc = os.path.abspath(param.path_qc)
qc_dataset = arguments.get("-qc-dataset", None)
qc_subject = arguments.get("-qc-subject", None)
labeled_seg_file = os.path.join(path_output, file_seg + '_labeled' + ext_seg)
generate_qc(fname_in, fname_seg=labeled_seg_file, args=args, path_qc=os.path.abspath(path_qc),
dataset=qc_dataset, subject=qc_subject, process='sct_label_vertebrae')
sct.display_viewer_syntax([fname_in, fname_seg_labeled], colormaps=['', 'subcortical'], opacities=['1', '0.5'])
def main(args=None):
if args is None:
args = sys.argv[1:]
# initialize parameters
param = Param()
# Initialization
fname_output = ''
path_out = ''
fname_src_seg = ''
fname_dest_seg = ''
fname_src_label = ''
fname_dest_label = ''
generate_warpinv = 1
start_time = time.time()
# get default registration parameters
# step1 = Paramreg(step='1', type='im', algo='syn', metric='MI', iter='5', shrink='1', smooth='0', gradStep='0.5')
step0 = Paramreg(step='0', type='im', algo='syn', metric='MI', iter='0', shrink='1', smooth='0', gradStep='0.5',
slicewise='0', dof='Tx_Ty_Tz_Rx_Ry_Rz') # only used to put src into dest space
step1 = Paramreg(step='1', type='im')
paramregmulti = ParamregMultiStep([step0, step1])
parser = get_parser(paramregmulti=paramregmulti)
arguments = parser.parse(args)
# get arguments
fname_src = arguments['-i']
fname_dest = arguments['-d']
if '-iseg' in arguments:
fname_src_seg = arguments['-iseg']
if '-dseg' in arguments:
fname_dest_seg = arguments['-dseg']
if '-ilabel' in arguments:
fname_src_label = arguments['-ilabel']
if '-dlabel' in arguments:
fname_dest_label = arguments['-dlabel']
if '-o' in arguments:
fname_output = arguments['-o']
if '-ofolder' in arguments:
path_out = arguments['-ofolder']
if '-owarp' in arguments:
fname_output_warp = arguments['-owarp']
else:
fname_output_warp = ''
if '-initwarp' in arguments:
fname_initwarp = os.path.abspath(arguments['-initwarp'])
else:
fname_initwarp = ''
if '-initwarpinv' in arguments:
fname_initwarpinv = os.path.abspath(arguments['-initwarpinv'])
else:
fname_initwarpinv = ''
if '-m' in arguments:
fname_mask = arguments['-m']
else:
fname_mask = ''
padding = arguments['-z']
if "-param" in arguments:
paramregmulti_user = arguments['-param']
# update registration parameters
for paramStep in paramregmulti_user:
paramregmulti.addStep(paramStep)
path_qc = arguments.get("-qc", None)
qc_dataset = arguments.get("-qc-dataset", None)
qc_subject = arguments.get("-qc-subject", None)
identity = int(arguments['-identity'])
interp = arguments['-x']
remove_temp_files = int(arguments['-r'])
verbose = int(arguments.get('-v'))
sct.init_sct(log_level=verbose, update=True) # Update log level
# sct.printv(arguments)
sct.printv('\nInput parameters:')
sct.printv(' Source .............. ' + fname_src)
sct.printv(' Destination ......... ' + fname_dest)
sct.printv(' Init transfo ........ ' + fname_initwarp)
sct.printv(' Mask ................ ' + fname_mask)
sct.printv(' Output name ......... ' + fname_output)
# sct.printv(' Algorithm ........... '+paramregmulti.algo)
# sct.printv(' Number of iterations '+paramregmulti.iter)
# sct.printv(' Metric .............. '+paramregmulti.metric)
sct.printv(' Remove temp files ... ' + str(remove_temp_files))
sct.printv(' Verbose ............. ' + str(verbose))
# update param
param.verbose = verbose
param.padding = padding
param.fname_mask = fname_mask
param.remove_temp_files = remove_temp_files
# Get if input is 3D
sct.printv('\nCheck if input data are 3D...', verbose)
sct.check_dim(fname_src, dim_lst=[3])
sct.check_dim(fname_dest, dim_lst=[3])
# Check if user selected type=seg, but did not input segmentation data
if 'paramregmulti_user' in locals():
if True in ['type=seg' in paramregmulti_user[i] for i in range(len(paramregmulti_user))]:
if fname_src_seg == '' or fname_dest_seg == '':
sct.printv('\nERROR: if you select type=seg you must specify -iseg and -dseg flags.\n', 1, 'error')
# Put source into destination space using header (no estimation -- purely based on header)
# TODO: Check if necessary to do that
# TODO: use that as step=0
# sct.printv('\nPut source into destination space using header...', verbose)
# sct.run('isct_antsRegistration -d 3 -t Translation[0] -m MI[dest_pad.nii,src.nii,1,16] -c 0 -f 1 -s 0 -o
# [regAffine,src_regAffine.nii] -n BSpline[3]', verbose)
# if segmentation, also do it for seg
fname_src2dest, fname_dest2src, _, _ = \
register_wrapper(fname_src, fname_dest, param, paramregmulti, fname_src_seg=fname_src_seg,
fname_dest_seg=fname_dest_seg, fname_src_label=fname_src_label,
fname_dest_label=fname_dest_label, fname_mask=fname_mask, fname_initwarp=fname_initwarp,
fname_initwarpinv=fname_initwarpinv, identity=identity, interp=interp,
fname_output=fname_output,
fname_output_warp=fname_output_warp,
path_out=path_out)
# display elapsed time
elapsed_time = time.time() - start_time
sct.printv('\nFinished! Elapsed time: ' + str(int(np.round(elapsed_time))) + 's', verbose)
if path_qc is not None:
if fname_dest_seg:
generate_qc(fname_src2dest, fname_in2=fname_dest, fname_seg=fname_dest_seg, args=args,
path_qc=os.path.abspath(path_qc), dataset=qc_dataset, subject=qc_subject,
process='sct_register_multimodal')
else:
sct.printv('WARNING: Cannot generate QC because it requires destination segmentation.', 1, 'warning')
if generate_warpinv:
sct.display_viewer_syntax([fname_src, fname_dest2src], verbose=verbose)
sct.display_viewer_syntax([fname_dest, fname_src2dest], verbose=verbose)
def main(args=None):
if args is None:
args = sys.argv[1:]
# initialize parameters
param = Param()
# Initialization
fname_output = ''
path_out = ''
fname_src_seg = ''
fname_dest_seg = ''
fname_src_label = ''
fname_dest_label = ''
generate_warpinv = 1
start_time = time.time()
# get default registration parameters
# step1 = Paramreg(step='1', type='im', algo='syn', metric='MI', iter='5', shrink='1', smooth='0', gradStep='0.5')
step0 = Paramreg(step='0', type='im', algo='syn', metric='MI', iter='0', shrink='1', smooth='0', gradStep='0.5',
slicewise='0', dof='Tx_Ty_Tz_Rx_Ry_Rz') # only used to put src into dest space
step1 = Paramreg(step='1', type='im')
paramreg = ParamregMultiStep([step0, step1])
parser = get_parser(paramreg=paramreg)
arguments = parser.parse(args)
# get arguments
fname_src = arguments['-i']
fname_dest = arguments['-d']
if '-iseg' in arguments:
fname_src_seg = arguments['-iseg']
if '-dseg' in arguments:
fname_dest_seg = arguments['-dseg']
if '-ilabel' in arguments:
fname_src_label = arguments['-ilabel']
if '-dlabel' in arguments:
fname_dest_label = arguments['-dlabel']
if '-o' in arguments:
fname_output = arguments['-o']
if '-ofolder' in arguments:
path_out = arguments['-ofolder']
if '-owarp' in arguments:
fname_output_warp = arguments['-owarp']
else:
fname_output_warp = ''
if '-initwarp' in arguments:
fname_initwarp = os.path.abspath(arguments['-initwarp'])
else:
fname_initwarp = ''
if '-initwarpinv' in arguments:
fname_initwarpinv = os.path.abspath(arguments['-initwarpinv'])
else:
fname_initwarpinv = ''
if '-m' in arguments:
fname_mask = arguments['-m']
else:
fname_mask = ''
padding = arguments['-z']
if "-param" in arguments:
paramreg_user = arguments['-param']
# update registration parameters
for paramStep in paramreg_user:
paramreg.addStep(paramStep)
path_qc = arguments.get("-qc", None)
qc_dataset = arguments.get("-qc-dataset", None)
qc_subject = arguments.get("-qc-subject", None)
identity = int(arguments['-identity'])
interp = arguments['-x']
remove_temp_files = int(arguments['-r'])
verbose = int(arguments.get('-v'))
sct.init_sct(log_level=verbose, update=True) # Update log level
# sct.printv(arguments)
sct.printv('\nInput parameters:')
sct.printv(' Source .............. ' + fname_src)
sct.printv(' Destination ......... ' + fname_dest)
sct.printv(' Init transfo ........ ' + fname_initwarp)
sct.printv(' Mask ................ ' + fname_mask)
sct.printv(' Output name ......... ' + fname_output)
# sct.printv(' Algorithm ........... '+paramreg.algo)
# sct.printv(' Number of iterations '+paramreg.iter)
# sct.printv(' Metric .............. '+paramreg.metric)
sct.printv(' Remove temp files ... ' + str(remove_temp_files))
sct.printv(' Verbose ............. ' + str(verbose))
# update param
param.verbose = verbose
param.padding = padding
param.fname_mask = fname_mask
param.remove_temp_files = remove_temp_files
# Get if input is 3D
sct.printv('\nCheck if input data are 3D...', verbose)
sct.check_if_3d(fname_src)
sct.check_if_3d(fname_dest)
# Check if user selected type=seg, but did not input segmentation data
if 'paramreg_user' in locals():
if True in ['type=seg' in paramreg_user[i] for i in range(len(paramreg_user))]:
if fname_src_seg == '' or fname_dest_seg == '':
sct.printv('\nERROR: if you select type=seg you must specify -iseg and -dseg flags.\n', 1, 'error')
# Extract path, file and extension
path_src, file_src, ext_src = sct.extract_fname(fname_src)
path_dest, file_dest, ext_dest = sct.extract_fname(fname_dest)
# check if source and destination images have the same name (related to issue #373)
# If so, change names to avoid conflict of result files and warns the user
suffix_src, suffix_dest = '_reg', '_reg'
if file_src == file_dest:
suffix_src, suffix_dest = '_src_reg', '_dest_reg'
# define output folder and file name
if fname_output == '':
path_out = '' if not path_out else path_out # output in user's current directory
file_out = file_src + suffix_src
file_out_inv = file_dest + suffix_dest
ext_out = ext_src
else:
path, file_out, ext_out = sct.extract_fname(fname_output)
path_out = path if not path_out else path_out
file_out_inv = file_out + '_inv'
# create temporary folder
path_tmp = sct.tmp_create()
sct.printv('\nCopying input data to tmp folder and convert to nii...', verbose)
Image(fname_src).save(os.path.join(path_tmp, "src.nii"))
Image(fname_dest).save(os.path.join(path_tmp, "dest.nii"))
if fname_src_seg:
Image(fname_src_seg).save(os.path.join(path_tmp, "src_seg.nii"))
if fname_dest_seg:
Image(fname_dest_seg).save(os.path.join(path_tmp, "dest_seg.nii"))
if fname_src_label:
Image(fname_src_label).save(os.path.join(path_tmp, "src_label.nii"))
Image(fname_dest_label).save(os.path.join(path_tmp, "dest_label.nii"))
if fname_mask != '':
Image(fname_mask).save(os.path.join(path_tmp, "mask.nii.gz"))
# go to tmp folder
curdir = os.getcwd()
os.chdir(path_tmp)
# reorient destination to RPI
Image('dest.nii').change_orientation("RPI").save('dest_RPI.nii')
if fname_dest_seg:
Image('dest_seg.nii').change_orientation("RPI").save('dest_seg_RPI.nii')
if fname_dest_label:
Image('dest_label.nii').change_orientation("RPI").save('dest_label_RPI.nii')
if identity:
# overwrite paramreg and only do one identity transformation
step0 = Paramreg(step='0', type='im', algo='syn', metric='MI', iter='0', shrink='1', smooth='0', gradStep='0.5')
paramreg = ParamregMultiStep([step0])
# Put source into destination space using header (no estimation -- purely based on header)
# TODO: Check if necessary to do that
# TODO: use that as step=0
# sct.printv('\nPut source into destination space using header...', verbose)
# sct.run('isct_antsRegistration -d 3 -t Translation[0] -m MI[dest_pad.nii,src.nii,1,16] -c 0 -f 1 -s 0 -o
# [regAffine,src_regAffine.nii] -n BSpline[3]', verbose)
# if segmentation, also do it for seg
# initialize list of warping fields
warp_forward = []
warp_inverse = []
# initial warping is specified, update list of warping fields and skip step=0
if fname_initwarp:
sct.printv('\nSkip step=0 and replace with initial transformations: ', param.verbose)
sct.printv(' ' + fname_initwarp, param.verbose)
# sct.copy(fname_initwarp, 'warp_forward_0.nii.gz')
warp_forward = [fname_initwarp]
start_step = 1
if fname_initwarpinv:
warp_inverse = [fname_initwarpinv]
else:
sct.printv('\nWARNING: No initial inverse warping field was specified, therefore the inverse warping field '
'will NOT be generated.', param.verbose, 'warning')
generate_warpinv = 0
else:
start_step = 0
# loop across registration steps
for i_step in range(start_step, len(paramreg.steps)):
sct.printv('\n--\nESTIMATE TRANSFORMATION FOR STEP #' + str(i_step), param.verbose)
# identify which is the src and dest
if paramreg.steps[str(i_step)].type == 'im':
src = 'src.nii'
dest = 'dest_RPI.nii'
interp_step = 'spline'
elif paramreg.steps[str(i_step)].type == 'seg':
src = 'src_seg.nii'
dest = 'dest_seg_RPI.nii'
interp_step = 'nn'
elif paramreg.steps[str(i_step)].type == 'label':
src = 'src_label.nii'
dest = 'dest_label_RPI.nii'
interp_step = 'nn'
else:
# src = dest = interp_step = None
sct.printv('ERROR: Wrong image type.', 1, 'error')
# if step>0, apply warp_forward_concat to the src image to be used
if i_step > 0:
sct.printv('\nApply transformation from previous step', param.verbose)
sct.run(['sct_apply_transfo', '-i', src, '-d', dest, '-w', ','.join(warp_forward), '-o',
sct.add_suffix(src, '_reg'), '-x', interp_step], verbose)
src = sct.add_suffix(src, '_reg')
# register src --> dest
warp_forward_out, warp_inverse_out = register(src, dest, paramreg, param, str(i_step))
warp_forward.append(warp_forward_out)
warp_inverse.insert(0, warp_inverse_out)
# Concatenate transformations
sct.printv('\nConcatenate transformations...', verbose)
sct.run(['sct_concat_transfo', '-w', ','.join(warp_forward), '-d', 'dest.nii', '-o', 'warp_src2dest.nii.gz'],
verbose)
sct.run(['sct_concat_transfo', '-w', ','.join(warp_inverse), '-d', 'src.nii', '-o', 'warp_dest2src.nii.gz'],
verbose)
# Apply warping field to src data
sct.printv('\nApply transfo source --> dest...', verbose)
sct.run(['sct_apply_transfo', '-i', 'src.nii', '-o', 'src_reg.nii', '-d', 'dest.nii', '-w', 'warp_src2dest.nii.gz',
'-x', interp], verbose)
sct.printv('\nApply transfo dest --> source...', verbose)
sct.run(['sct_apply_transfo', '-i', 'dest.nii', '-o', 'dest_reg.nii', '-d', 'src.nii', '-w', 'warp_dest2src.nii.gz',
'-x', interp], verbose)
# come back
os.chdir(curdir)
# Generate output files
sct.printv('\nGenerate output files...', verbose)
# generate: src_reg
fname_src2dest = sct.generate_output_file(os.path.join(path_tmp, "src_reg.nii"),
os.path.join(path_out, file_out + ext_out), verbose)
# generate: forward warping field
if fname_output_warp == '':
fname_output_warp = os.path.join(path_out, 'warp_' + file_src + '2' + file_dest + '.nii.gz')
sct.generate_output_file(os.path.join(path_tmp, "warp_src2dest.nii.gz"), fname_output_warp, verbose)
if generate_warpinv:
# generate: dest_reg
fname_dest2src = sct.generate_output_file(os.path.join(path_tmp, "dest_reg.nii"),
os.path.join(path_out, file_out_inv + ext_dest), verbose)
# generate: inverse warping field
sct.generate_output_file(os.path.join(path_tmp, "warp_dest2src.nii.gz"),
os.path.join(path_out, 'warp_' + file_dest + '2' + file_src + '.nii.gz'), verbose)
# Delete temporary files
if remove_temp_files:
sct.printv('\nRemove temporary files...', verbose)
sct.rmtree(path_tmp, verbose=verbose)
# display elapsed time
elapsed_time = time.time() - start_time
sct.printv('\nFinished! Elapsed time: ' + str(int(np.round(elapsed_time))) + 's', verbose)
if path_qc is not None:
if fname_dest_seg:
generate_qc(fname_src2dest, fname_in2=fname_dest, fname_seg=fname_dest_seg, args=args,
path_qc=os.path.abspath(path_qc), dataset=qc_dataset, subject=qc_subject,
process='sct_register_multimodal')
else:
sct.printv('WARNING: Cannot generate QC because it requires destination segmentation.', 1, 'warning')
if generate_warpinv:
sct.display_viewer_syntax([fname_src, fname_dest2src], verbose=verbose)
sct.display_viewer_syntax([fname_dest, fname_src2dest], verbose=verbose)
def apply(self):
# Initialization
fname_src = self.input_filename # source image (moving)
fname_warp_list = self.warp_input # list of warping fields
fname_out = self.output_filename # output
fname_dest = self.fname_dest # destination image (fix)
verbose = self.verbose
remove_temp_files = self.remove_temp_files
crop_reference = self.crop # if = 1, put 0 everywhere around warping field, if = 2, real crop
interp = sct.get_interpolation('isct_antsApplyTransforms', self.interp)
# Parse list of warping fields
sct.printv('\nParse list of warping fields...', verbose)
use_inverse = []
fname_warp_list_invert = []
# fname_warp_list = fname_warp_list.replace(' ', '') # remove spaces
# fname_warp_list = fname_warp_list.split(",") # parse with comma
for idx_warp, path_warp in enumerate(fname_warp_list):
# Check if inverse matrix is specified with '-' at the beginning of file name
if path_warp.startswith("-"):
use_inverse.append('-i')
fname_warp_list[idx_warp] = path_warp[1:] # remove '-'
fname_warp_list_invert += [[use_inverse[idx_warp], fname_warp_list[idx_warp]]]
else:
use_inverse.append('')
fname_warp_list_invert += [[path_warp]]
path_warp = fname_warp_list[idx_warp]
if path_warp.endswith((".nii", ".nii.gz")) \
and msct_image.Image(fname_warp_list[idx_warp]).header.get_intent()[0] != 'vector':
raise ValueError("Displacement field in {} is invalid: should be encoded" \
" in a 5D file with vector intent code" \
" (see https://nifti.nimh.nih.gov/pub/dist/src/niftilib/nifti1.h" \
.format(path_warp))
# need to check if last warping field is an affine transfo
isLastAffine = False
path_fname, file_fname, ext_fname = sct.extract_fname(fname_warp_list_invert[-1][-1])
if ext_fname in ['.txt', '.mat']:
isLastAffine = True
# check if destination file is 3d
if not sct.check_if_3d(fname_dest):
sct.printv('ERROR: Destination data must be 3d')
# N.B. Here we take the inverse of the warp list, because sct_WarpImageMultiTransform concatenates in the reverse order
fname_warp_list_invert.reverse()
fname_warp_list_invert = functools.reduce(lambda x,y: x+y, fname_warp_list_invert)
# Extract path, file and extension
path_src, file_src, ext_src = sct.extract_fname(fname_src)
path_dest, file_dest, ext_dest = sct.extract_fname(fname_dest)
# Get output folder and file name
if fname_out == '':
path_out = '' # output in user's current directory
file_out = file_src + '_reg'
ext_out = ext_src
fname_out = os.path.join(path_out, file_out + ext_out)
# Get dimensions of data
sct.printv('\nGet dimensions of data...', verbose)
img_src = msct_image.Image(fname_src)
nx, ny, nz, nt, px, py, pz, pt = img_src.dim
# nx, ny, nz, nt, px, py, pz, pt = sct.get_dimension(fname_src)
sct.printv(' ' + str(nx) + ' x ' + str(ny) + ' x ' + str(nz) + ' x ' + str(nt), verbose)
# if 3d
if nt == 1:
# Apply transformation
sct.printv('\nApply transformation...', verbose)
if nz in [0, 1]:
dim = '2'
else:
dim = '3'
sct.run(['isct_antsApplyTransforms',
'-d', dim,
'-i', fname_src,
'-o', fname_out,
'-t',
] + fname_warp_list_invert + [
'-r', fname_dest,
] + interp, verbose=verbose, is_sct_binary=True)
# if 4d, loop across the T dimension
else:
path_tmp = sct.tmp_create(basename="apply_transfo", verbose=verbose)
# convert to nifti into temp folder
sct.printv('\nCopying input data to tmp folder and convert to nii...', verbose)
img_src.save(os.path.join(path_tmp, "data.nii"))
sct.copy(fname_dest, os.path.join(path_tmp, file_dest + ext_dest))
fname_warp_list_tmp = []
for fname_warp in fname_warp_list:
path_warp, file_warp, ext_warp = sct.extract_fname(fname_warp)
sct.copy(fname_warp, os.path.join(path_tmp, file_warp + ext_warp))
fname_warp_list_tmp.append(file_warp + ext_warp)
fname_warp_list_invert_tmp = fname_warp_list_tmp[::-1]
curdir = os.getcwd()
os.chdir(path_tmp)
# split along T dimension
sct.printv('\nSplit along T dimension...', verbose)
im_dat = msct_image.Image('data.nii')
im_header = im_dat.hdr
data_split_list = sct_image.split_data(im_dat, 3)
for im in data_split_list:
im.save()
# apply transfo
sct.printv('\nApply transformation to each 3D volume...', verbose)
for it in range(nt):
file_data_split = 'data_T' + str(it).zfill(4) + '.nii'
file_data_split_reg = 'data_reg_T' + str(it).zfill(4) + '.nii'
status, output = sct.run(['isct_antsApplyTransforms',
'-d', '3',
'-i', file_data_split,
'-o', file_data_split_reg,
'-t',
] + fname_warp_list_invert_tmp + [
'-r', file_dest + ext_dest,
] + interp, verbose, is_sct_binary=True)
# Merge files back
sct.printv('\nMerge file back...', verbose)
import glob
path_out, name_out, ext_out = sct.extract_fname(fname_out)
# im_list = [Image(file_name) for file_name in glob.glob('data_reg_T*.nii')]
# concat_data use to take a list of image in input, now takes a list of file names to open the files one by one (see issue #715)
fname_list = glob.glob('data_reg_T*.nii')
fname_list.sort()
im_out = sct_image.concat_data(fname_list, 3, im_header['pixdim'])
im_out.save(name_out + ext_out)
os.chdir(curdir)
sct.generate_output_file(os.path.join(path_tmp, name_out + ext_out), fname_out)
# Delete temporary folder if specified
if int(remove_temp_files):
sct.printv('\nRemove temporary files...', verbose)
sct.rmtree(path_tmp, verbose=verbose)
# 2. crop the resulting image using dimensions from the warping field
warping_field = fname_warp_list_invert[-1]
# if last warping field is an affine transfo, we need to compute the space of the concatenate warping field:
if isLastAffine:
sct.printv('WARNING: the resulting image could have wrong apparent results. You should use an affine transformation as last transformation...', verbose, 'warning')
elif crop_reference == 1:
ImageCropper(input_file=fname_out, output_file=fname_out, ref=warping_field, background=0).crop()
# sct.run('sct_crop_image -i '+fname_out+' -o '+fname_out+' -ref '+warping_field+' -b 0')
elif crop_reference == 2:
ImageCropper(input_file=fname_out, output_file=fname_out, ref=warping_field).crop()
# sct.run('sct_crop_image -i '+fname_out+' -o '+fname_out+' -ref '+warping_field)
sct.display_viewer_syntax([fname_dest, fname_out], verbose=verbose)
def crop_with_gui(self):
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
# Initialization
fname_data = self.input_filename
suffix_out = '_crop'
remove_temp_files = self.rm_tmp_files
verbose = self.verbose
# Check file existence
sct.printv('\nCheck file existence...', verbose)
sct.check_file_exist(fname_data, verbose)
# Get dimensions of data
sct.printv('\nGet dimensions of data...', verbose)
nx, ny, nz, nt, px, py, pz, pt = Image(fname_data).dim
sct.printv('.. ' + str(nx) + ' x ' + str(ny) + ' x ' + str(nz), verbose)
# check if 4D data
if not nt == 1:
sct.printv('\nERROR in ' + os.path.basename(__file__) + ': Data should be 3D.\n', 1, 'error')
sys.exit(2)
# sct.printv(arguments)
sct.printv('\nCheck parameters:')
sct.printv(' data ................... ' + fname_data)
# Extract path/file/extension
path_data, file_data, ext_data = sct.extract_fname(fname_data)
path_out, file_out, ext_out = '', file_data + suffix_out, ext_data
path_tmp = sct.tmp_create() + "/"
# copy files into tmp folder
from sct_convert import convert
sct.printv('\nCopying input data to tmp folder and convert to nii...', verbose)
convert(fname_data, os.path.join(path_tmp, "data.nii"))
# go to tmp folder
curdir = os.getcwd()
os.chdir(path_tmp)
# change orientation
sct.printv('\nChange orientation to RPI...', verbose)
Image('data.nii').change_orientation("RPI").save('data_rpi.nii')
# get image of medial slab
sct.printv('\nGet image of medial slab...', verbose)
image_array = nibabel.load('data_rpi.nii').get_data()
nx, ny, nz = image_array.shape
scipy.misc.imsave('image.jpg', image_array[math.floor(nx / 2), :, :])
# Display the image
sct.printv('\nDisplay image and get cropping region...', verbose)
fig = plt.figure()
# fig = plt.gcf()
# ax = plt.gca()
ax = fig.add_subplot(111)
img = mpimg.imread("image.jpg")
implot = ax.imshow(img.T)
implot.set_cmap('gray')
plt.gca().invert_yaxis()
# mouse callback
ax.set_title('Left click on the top and bottom of your cropping field.\n Right click to remove last point.\n Close window when your done.')
line, = ax.plot([], [], 'ro') # empty line
cropping_coordinates = LineBuilder(line)
plt.show()
# disconnect callback
# fig.canvas.mpl_disconnect(line)
# check if user clicked two times
if len(cropping_coordinates.xs) != 2:
sct.printv('\nERROR: You have to select two points. Exit program.\n', 1, 'error')
sys.exit(2)
# convert coordinates to integer
zcrop = [int(i) for i in cropping_coordinates.ys]
# sort coordinates
zcrop.sort()
# crop image
sct.printv('\nCrop image...', verbose)
nii = Image('data_rpi.nii')
data_crop = nii.data[:, :, zcrop[0]:zcrop[1]]
nii.data = data_crop
nii.absolutepath = 'data_rpi_crop.nii'
nii.save()
# come back
os.chdir(curdir)
sct.printv('\nGenerate output files...', verbose)
sct.generate_output_file(os.path.join(path_tmp, "data_rpi_crop.nii"), os.path.join(path_out, file_out + ext_out))
# Remove temporary files
if remove_temp_files == 1:
sct.printv('\nRemove temporary files...')
sct.rmtree(path_tmp)
sct.display_viewer_syntax(files=[os.path.join(path_out, file_out + ext_out)])
def main(args=None):
# initializations
output_type = None
param = Param()
dim_list = ['x', 'y', 'z', 't']
# check user arguments
if not args:
args = sys.argv[1:]
# Get parser info
parser = get_parser()
arguments = parser.parse(args)
fname_in = arguments["-i"]
n_in = len(fname_in)
verbose = int(arguments.get('-v'))
sct.init_sct(log_level=verbose, update=True) # Update log level
if "-o" in arguments:
fname_out = arguments["-o"]
else:
fname_out = None
# Open file(s)
# im_in_list = [Image(fn) for fn in fname_in]
# run command
if "-concat" in arguments:
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 "-copy-header" in arguments:
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 '-display-warp' in arguments:
im_in = fname_in[0]
visualize_warp(im_in, fname_grid=None, step=3, rm_tmp=True)
im_out = None
elif "-getorient" in arguments:
im_in = Image(fname_in[0])
orient = im_in.orientation
im_out = None
elif '-keep-vol' in arguments:
index_vol = arguments['-keep-vol']
im_in = Image(fname_in[0])
im_out = [remove_vol(im_in, index_vol, todo='keep')]
elif '-mcs' in arguments:
im_in = Image(fname_in[0])
if n_in != 1:
sct.printv(parser.usage.generate(error='ERROR: -mcs need only one input'))
if len(im_in.data.shape) != 5:
sct.printv(parser.usage.generate(error='ERROR: -mcs input need to be a multi-component image'))
im_out = multicomponent_split(im_in)
elif '-omc' in arguments:
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.usage.generate(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 "-pad" in arguments:
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 "-pad-asym" in arguments:
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 '-remove-vol' in arguments:
index_vol = arguments['-remove-vol']
im_in = Image(fname_in[0])
im_out = [remove_vol(im_in, index_vol, todo='remove')]
elif "-setorient" in arguments:
sct.printv(fname_in[0])
im_in = Image(fname_in[0])
im_out = [msct_image.change_orientation(im_in, arguments["-setorient"]).save(fname_out)]
elif "-setorient-data" in arguments:
im_in = Image(fname_in[0])
im_out = [msct_image.change_orientation(im_in, arguments["-setorient-data"], inverse=True).save(fname_out)]
elif "-split" in arguments:
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 '-type' in arguments:
output_type = arguments['-type']
im_in = Image(fname_in[0])
im_out = [im_in] # TODO: adapt to fname_in
else:
im_out = None
sct.printv(parser.usage.generate(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 == 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 '-mcs' in arguments:
# 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 '-split' in arguments:
# 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 "-getorient" in arguments:
sct.printv(orient)
elif '-display-warp' in arguments:
sct.printv('Warping grid generated.', verbose, 'info')
def main(args=None):
# initialization
start_time = time.time()
param = Param()
# check user arguments
if not args:
args = sys.argv[1:]
# Get parser info
parser = get_parser()
arguments = parser.parse(sys.argv[1:])
param.fname_data = arguments['-i']
if '-g' in arguments:
param.group_size = arguments['-g']
if '-m' in arguments:
param.fname_mask = arguments['-m']
if '-param' in arguments:
param.update(arguments['-param'])
if '-x' in arguments:
param.interp = arguments['-x']
if '-ofolder' in arguments:
path_out = arguments['-ofolder']
if '-r' in arguments:
param.remove_temp_files = int(arguments['-r'])
param.verbose = int(arguments.get('-v'))
sct.init_sct(log_level=param.verbose, update=True) # Update log level
sct.printv('\nInput parameters:', param.verbose)
sct.printv(' input file ............' + param.fname_data, param.verbose)
# Get full path
param.fname_data = os.path.abspath(param.fname_data)
if param.fname_mask != '':
param.fname_mask = os.path.abspath(param.fname_mask)
# Extract path, file and extension
path_data, file_data, ext_data = sct.extract_fname(param.fname_data)
path_tmp = sct.tmp_create(basename="fmri_moco", verbose=param.verbose)
# Copying input data to tmp folder and convert to nii
# TODO: no need to do that (takes time for nothing)
sct.printv('\nCopying input data to tmp folder and convert to nii...', param.verbose)
convert(param.fname_data, os.path.join(path_tmp, "fmri.nii"), squeeze_data=False)
# go to tmp folder
curdir = os.getcwd()
os.chdir(path_tmp)
# run moco
fmri_moco(param)
# come back
os.chdir(curdir)
# Generate output files
fname_fmri_moco = os.path.join(path_out, file_data + param.suffix + ext_data)
sct.create_folder(path_out)
sct.printv('\nGenerate output files...', param.verbose)
sct.generate_output_file(os.path.join(path_tmp, "fmri" + param.suffix + '.nii'), fname_fmri_moco, param.verbose)
sct.generate_output_file(os.path.join(path_tmp, "fmri" + param.suffix + '_mean.nii'), os.path.join(path_out, file_data + param.suffix + '_mean' + ext_data), param.verbose)
# Delete temporary files
if param.remove_temp_files == 1:
sct.printv('\nDelete temporary files...', param.verbose)
sct.rmtree(path_tmp, verbose=param.verbose)
# display elapsed time
elapsed_time = time.time() - start_time
sct.printv('\nFinished! Elapsed time: ' + str(int(np.round(elapsed_time))) + 's', param.verbose)
sct.display_viewer_syntax([fname_fmri_moco, file_data], mode='ortho,ortho')
def main(args=None):
# initializations
output_type = None
param = Param()
dim_list = ['x', 'y', 'z', 't']
# check user arguments
if not args:
args = sys.argv[1:]
# Get parser info
parser = get_parser()
arguments = parser.parse(args)
fname_in = arguments["-i"]
n_in = len(fname_in)
verbose = int(arguments.get('-v'))
sct.init_sct(log_level=verbose, update=True) # Update log level
if "-o" in arguments:
fname_out = arguments["-o"]
else:
fname_out = None
# Open file(s)
# im_in_list = [Image(fn) for fn in fname_in]
# run command
if "-concat" in arguments:
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 "-copy-header" in arguments:
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 '-display-warp' in arguments:
im_in = fname_in[0]
visualize_warp(im_in, fname_grid=None, step=3, rm_tmp=True)
im_out = None
elif "-getorient" in arguments:
im_in = Image(fname_in[0])
orient = im_in.orientation
im_out = None
elif '-keep-vol' in arguments:
index_vol = arguments['-keep-vol']
im_in = Image(fname_in[0])
im_out = [remove_vol(im_in, index_vol, todo='keep')]
elif '-mcs' in arguments:
im_in = Image(fname_in[0])
if n_in != 1:
sct.printv(
parser.usage.generate(error='ERROR: -mcs need only one input'))
if len(im_in.data.shape) != 5:
sct.printv(
parser.usage.generate(
error='ERROR: -mcs input need to be a multi-component image'
))
im_out = multicomponent_split(im_in)
elif '-omc' in arguments:
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.usage.generate(
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 "-pad" in arguments:
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 "-pad-asym" in arguments:
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 '-remove-vol' in arguments:
index_vol = arguments['-remove-vol']
im_in = Image(fname_in[0])
im_out = [remove_vol(im_in, index_vol, todo='remove')]
elif "-setorient" in arguments:
sct.printv(fname_in[0])
im_in = Image(fname_in[0])
im_out = [
msct_image.change_orientation(
im_in, arguments["-setorient"]).save(fname_out)
]
elif "-setorient-data" in arguments:
im_in = Image(fname_in[0])
im_out = [
msct_image.change_orientation(im_in,
arguments["-setorient-data"],
inverse=True).save(fname_out)
]
elif "-split" in arguments:
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 '-type' in arguments:
output_type = arguments['-type']
im_in = Image(fname_in[0])
im_out = [im_in] # TODO: adapt to fname_in
else:
im_out = None
sct.printv(
parser.usage.generate(
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 == 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 '-mcs' in arguments:
# 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 '-split' in arguments:
# 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 "-getorient" in arguments:
sct.printv(orient)
elif '-display-warp' in arguments:
sct.printv('Warping grid generated.', verbose, 'info')
def main(args=None):
# initializations
param = Param()
# check user arguments
if not args:
args = sys.argv[1:]
# Get parser info
parser = get_parser()
arguments = parser.parse(args)
fname_data = arguments['-i']
fname_seg = arguments['-s']
if '-l' in arguments:
fname_landmarks = arguments['-l']
label_type = 'body'
elif '-ldisc' in arguments:
fname_landmarks = arguments['-ldisc']
label_type = 'disc'
else:
sct.printv('ERROR: Labels should be provided.', 1, 'error')
if '-ofolder' in arguments:
path_output = arguments['-ofolder']
else:
path_output = ''
param.path_qc = arguments.get("-qc", None)
path_template = arguments['-t']
contrast_template = arguments['-c']
ref = arguments['-ref']
param.remove_temp_files = int(arguments.get('-r'))
verbose = int(arguments.get('-v'))
sct.init_sct(log_level=verbose, update=True) # Update log level
param.verbose = verbose # TODO: not clean, unify verbose or param.verbose in code, but not both
param.straighten_fitting = arguments['-straighten-fitting']
# if '-cpu-nb' in arguments:
# arg_cpu = ' -cpu-nb '+str(arguments['-cpu-nb'])
# else:
# arg_cpu = ''
# registration parameters
if '-param' in arguments:
# reset parameters but keep step=0 (might be overwritten if user specified step=0)
paramreg = ParamregMultiStep([step0])
if ref == 'subject':
paramreg.steps['0'].dof = 'Tx_Ty_Tz_Rx_Ry_Rz_Sz'
# add user parameters
for paramStep in arguments['-param']:
paramreg.addStep(paramStep)
else:
paramreg = ParamregMultiStep([step0, step1, step2])
# if ref=subject, initialize registration using different affine parameters
if ref == 'subject':
paramreg.steps['0'].dof = 'Tx_Ty_Tz_Rx_Ry_Rz_Sz'
# initialize other parameters
zsubsample = param.zsubsample
# retrieve template file names
file_template_vertebral_labeling = get_file_label(os.path.join(path_template, 'template'), 'vertebral labeling')
file_template = get_file_label(os.path.join(path_template, 'template'), contrast_template.upper() + '-weighted template')
file_template_seg = get_file_label(os.path.join(path_template, 'template'), 'spinal cord')
# start timer
start_time = time.time()
# get fname of the template + template objects
fname_template = os.path.join(path_template, 'template', file_template)
fname_template_vertebral_labeling = os.path.join(path_template, 'template', file_template_vertebral_labeling)
fname_template_seg = os.path.join(path_template, 'template', file_template_seg)
fname_template_disc_labeling = os.path.join(path_template, 'template', 'PAM50_label_disc.nii.gz')
# check file existence
# TODO: no need to do that!
sct.printv('\nCheck template files...')
sct.check_file_exist(fname_template, verbose)
sct.check_file_exist(fname_template_vertebral_labeling, verbose)
sct.check_file_exist(fname_template_seg, verbose)
path_data, file_data, ext_data = sct.extract_fname(fname_data)
# sct.printv(arguments)
sct.printv('\nCheck parameters:', verbose)
sct.printv(' Data: ' + fname_data, verbose)
sct.printv(' Landmarks: ' + fname_landmarks, verbose)
sct.printv(' Segmentation: ' + fname_seg, verbose)
sct.printv(' Path template: ' + path_template, verbose)
sct.printv(' Remove temp files: ' + str(param.remove_temp_files), verbose)
# check input labels
labels = check_labels(fname_landmarks, label_type=label_type)
vertebral_alignment = False
if len(labels) > 2 and label_type == 'disc':
vertebral_alignment = True
path_tmp = sct.tmp_create(basename="register_to_template", verbose=verbose)
# set temporary file names
ftmp_data = 'data.nii'
ftmp_seg = 'seg.nii.gz'
ftmp_label = 'label.nii.gz'
ftmp_template = 'template.nii'
ftmp_template_seg = 'template_seg.nii.gz'
ftmp_template_label = 'template_label.nii.gz'
# copy files to temporary folder
sct.printv('\nCopying input data to tmp folder and convert to nii...', verbose)
Image(fname_data).save(os.path.join(path_tmp, ftmp_data))
Image(fname_seg).save(os.path.join(path_tmp, ftmp_seg))
Image(fname_landmarks).save(os.path.join(path_tmp, ftmp_label))
Image(fname_template).save(os.path.join(path_tmp, ftmp_template))
Image(fname_template_seg).save(os.path.join(path_tmp, ftmp_template_seg))
Image(fname_template_vertebral_labeling).save(os.path.join(path_tmp, ftmp_template_label))
if label_type == 'disc':
Image(fname_template_disc_labeling).save(os.path.join(path_tmp, ftmp_template_label))
# go to tmp folder
curdir = os.getcwd()
os.chdir(path_tmp)
# Generate labels from template vertebral labeling
if label_type == 'body':
sct.printv('\nGenerate labels from template vertebral labeling', verbose)
ftmp_template_label_, ftmp_template_label = ftmp_template_label, sct.add_suffix(ftmp_template_label, "_body")
sct_label_utils.main(args=['-i', ftmp_template_label_, '-vert-body', '0', '-o', ftmp_template_label])
# check if provided labels are available in the template
sct.printv('\nCheck if provided labels are available in the template', verbose)
image_label_template = Image(ftmp_template_label)
labels_template = image_label_template.getNonZeroCoordinates(sorting='value')
if labels[-1].value > labels_template[-1].value:
sct.printv('ERROR: Wrong landmarks input. Labels must have correspondence in template space. \nLabel max '
'provided: ' + str(labels[-1].value) + '\nLabel max from template: ' +
str(labels_template[-1].value), verbose, 'error')
# if only one label is present, force affine transformation to be Tx,Ty,Tz only (no scaling)
if len(labels) == 1:
paramreg.steps['0'].dof = 'Tx_Ty_Tz'
sct.printv('WARNING: Only one label is present. Forcing initial transformation to: ' + paramreg.steps['0'].dof,
1, 'warning')
# Project labels onto the spinal cord centerline because later, an affine transformation is estimated between the
# template's labels (centered in the cord) and the subject's labels (assumed to be centered in the cord).
# If labels are not centered, mis-registration errors are observed (see issue #1826)
ftmp_label = project_labels_on_spinalcord(ftmp_label, ftmp_seg)
# binarize segmentation (in case it has values below 0 caused by manual editing)
sct.printv('\nBinarize segmentation', verbose)
ftmp_seg_, ftmp_seg = ftmp_seg, sct.add_suffix(ftmp_seg, "_bin")
sct_maths.main(['-i', ftmp_seg_,
'-bin', '0.5',
'-o', ftmp_seg])
# Switch between modes: subject->template or template->subject
if ref == 'template':
# resample data to 1mm isotropic
sct.printv('\nResample data to 1mm isotropic...', verbose)
resample_file(ftmp_data, add_suffix(ftmp_data, '_1mm'), '1.0x1.0x1.0', 'mm', 'linear', verbose)
ftmp_data = add_suffix(ftmp_data, '_1mm')
resample_file(ftmp_seg, add_suffix(ftmp_seg, '_1mm'), '1.0x1.0x1.0', 'mm', 'linear', verbose)
ftmp_seg = add_suffix(ftmp_seg, '_1mm')
# N.B. resampling of labels is more complicated, because they are single-point labels, therefore resampling
# with nearest neighbour can make them disappear.
resample_labels(ftmp_label, ftmp_data, add_suffix(ftmp_label, '_1mm'))
ftmp_label = add_suffix(ftmp_label, '_1mm')
# Change orientation of input images to RPI
sct.printv('\nChange orientation of input images to RPI...', verbose)
ftmp_data = Image(ftmp_data).change_orientation("RPI", generate_path=True).save().absolutepath
ftmp_seg = Image(ftmp_seg).change_orientation("RPI", generate_path=True).save().absolutepath
ftmp_label = Image(ftmp_label).change_orientation("RPI", generate_path=True).save().absolutepath
ftmp_seg_, ftmp_seg = ftmp_seg, add_suffix(ftmp_seg, '_crop')
if vertebral_alignment:
# cropping the segmentation based on the label coverage to ensure good registration with vertebral alignment
# See https://github.com/neuropoly/spinalcordtoolbox/pull/1669 for details
image_labels = Image(ftmp_label)
coordinates_labels = image_labels.getNonZeroCoordinates(sorting='z')
nx, ny, nz, nt, px, py, pz, pt = image_labels.dim
offset_crop = 10.0 * pz # cropping the image 10 mm above and below the highest and lowest label
cropping_slices = [coordinates_labels[0].z - offset_crop, coordinates_labels[-1].z + offset_crop]
# make sure that the cropping slices do not extend outside of the slice range (issue #1811)
if cropping_slices[0] < 0:
cropping_slices[0] = 0
if cropping_slices[1] > nz:
cropping_slices[1] = nz
msct_image.spatial_crop(Image(ftmp_seg_), dict(((2, np.int32(np.round(cropping_slices))),))).save(ftmp_seg)
else:
# if we do not align the vertebral levels, we crop the segmentation from top to bottom
im_seg_rpi = Image(ftmp_seg_)
bottom = 0
for data in msct_image.SlicerOneAxis(im_seg_rpi, "IS"):
if (data != 0).any():
break
bottom += 1
top = im_seg_rpi.data.shape[2]
for data in msct_image.SlicerOneAxis(im_seg_rpi, "SI"):
if (data != 0).any():
break
top -= 1
msct_image.spatial_crop(im_seg_rpi, dict(((2, (bottom, top)),))).save(ftmp_seg)
# straighten segmentation
sct.printv('\nStraighten the spinal cord using centerline/segmentation...', verbose)
# check if warp_curve2straight and warp_straight2curve already exist (i.e. no need to do it another time)
fn_warp_curve2straight = os.path.join(curdir, "warp_curve2straight.nii.gz")
fn_warp_straight2curve = os.path.join(curdir, "warp_straight2curve.nii.gz")
fn_straight_ref = os.path.join(curdir, "straight_ref.nii.gz")
cache_input_files=[ftmp_seg]
if vertebral_alignment:
cache_input_files += [
ftmp_template_seg,
ftmp_label,
ftmp_template_label,
]
cache_sig = sct.cache_signature(
input_files=cache_input_files,
)
cachefile = os.path.join(curdir, "straightening.cache")
if sct.cache_valid(cachefile, cache_sig) and os.path.isfile(fn_warp_curve2straight) and os.path.isfile(fn_warp_straight2curve) and os.path.isfile(fn_straight_ref):
sct.printv('Reusing existing warping field which seems to be valid', verbose, 'warning')
sct.copy(fn_warp_curve2straight, 'warp_curve2straight.nii.gz')
sct.copy(fn_warp_straight2curve, 'warp_straight2curve.nii.gz')
sct.copy(fn_straight_ref, 'straight_ref.nii.gz')
# apply straightening
sct.run(['sct_apply_transfo', '-i', ftmp_seg, '-w', 'warp_curve2straight.nii.gz', '-d', 'straight_ref.nii.gz', '-o', add_suffix(ftmp_seg, '_straight')])
else:
from spinalcordtoolbox.straightening import SpinalCordStraightener
sc_straight = SpinalCordStraightener(ftmp_seg, ftmp_seg)
sc_straight.algo_fitting = param.straighten_fitting
sc_straight.output_filename = add_suffix(ftmp_seg, '_straight')
sc_straight.path_output = './'
sc_straight.qc = '0'
sc_straight.remove_temp_files = param.remove_temp_files
sc_straight.verbose = verbose
if vertebral_alignment:
sc_straight.centerline_reference_filename = ftmp_template_seg
sc_straight.use_straight_reference = True
sc_straight.discs_input_filename = ftmp_label
sc_straight.discs_ref_filename = ftmp_template_label
sc_straight.straighten()
sct.cache_save(cachefile, cache_sig)
# N.B. DO NOT UPDATE VARIABLE ftmp_seg BECAUSE TEMPORARY USED LATER
# re-define warping field using non-cropped space (to avoid issue #367)
s, o = sct.run(['sct_concat_transfo', '-w', 'warp_straight2curve.nii.gz', '-d', ftmp_data, '-o', 'warp_straight2curve.nii.gz'])
if vertebral_alignment:
sct.copy('warp_curve2straight.nii.gz', 'warp_curve2straightAffine.nii.gz')
else:
# Label preparation:
# --------------------------------------------------------------------------------
# Remove unused label on template. Keep only label present in the input label image
sct.printv('\nRemove unused label on template. Keep only label present in the input label image...', verbose)
sct.run(['sct_label_utils', '-i', ftmp_template_label, '-o', ftmp_template_label, '-remove-reference', ftmp_label])
# Dilating the input label so they can be straighten without losing them
sct.printv('\nDilating input labels using 3vox ball radius')
sct_maths.main(['-i', ftmp_label,
'-dilate', '3',
'-o', add_suffix(ftmp_label, '_dilate')])
ftmp_label = add_suffix(ftmp_label, '_dilate')
# Apply straightening to labels
sct.printv('\nApply straightening to labels...', verbose)
sct.run(['sct_apply_transfo', '-i', ftmp_label, '-o', add_suffix(ftmp_label, '_straight'), '-d', add_suffix(ftmp_seg, '_straight'), '-w', 'warp_curve2straight.nii.gz', '-x', 'nn'])
ftmp_label = add_suffix(ftmp_label, '_straight')
# Compute rigid transformation straight landmarks --> template landmarks
sct.printv('\nEstimate transformation for step #0...', verbose)
try:
register_landmarks(ftmp_label, ftmp_template_label, paramreg.steps['0'].dof,
fname_affine='straight2templateAffine.txt', verbose=verbose)
except RuntimeError:
raise('Input labels do not seem to be at the right place. Please check the position of the labels. '
'See documentation for more details: https://www.slideshare.net/neuropoly/sct-course-20190121/42')
# Concatenate transformations: curve --> straight --> affine
sct.printv('\nConcatenate transformations: curve --> straight --> affine...', verbose)
sct.run(['sct_concat_transfo', '-w', 'warp_curve2straight.nii.gz,straight2templateAffine.txt', '-d', 'template.nii', '-o', 'warp_curve2straightAffine.nii.gz'])
# Apply transformation
sct.printv('\nApply transformation...', verbose)
sct.run(['sct_apply_transfo', '-i', ftmp_data, '-o', add_suffix(ftmp_data, '_straightAffine'), '-d', ftmp_template, '-w', 'warp_curve2straightAffine.nii.gz'])
ftmp_data = add_suffix(ftmp_data, '_straightAffine')
sct.run(['sct_apply_transfo', '-i', ftmp_seg, '-o', add_suffix(ftmp_seg, '_straightAffine'), '-d', ftmp_template, '-w', 'warp_curve2straightAffine.nii.gz', '-x', 'linear'])
ftmp_seg = add_suffix(ftmp_seg, '_straightAffine')
"""
# Benjamin: Issue from Allan Martin, about the z=0 slice that is screwed up, caused by the affine transform.
# Solution found: remove slices below and above landmarks to avoid rotation effects
points_straight = []
for coord in landmark_template:
points_straight.append(coord.z)
min_point, max_point = int(np.round(np.min(points_straight))), int(np.round(np.max(points_straight)))
ftmp_seg_, ftmp_seg = ftmp_seg, add_suffix(ftmp_seg, '_black')
msct_image.spatial_crop(Image(ftmp_seg_), dict(((2, (min_point,max_point)),))).save(ftmp_seg)
"""
# open segmentation
im = Image(ftmp_seg)
im_new = msct_image.empty_like(im)
# binarize
im_new.data = im.data > 0.5
# find min-max of anat2template (for subsequent cropping)
zmin_template, zmax_template = msct_image.find_zmin_zmax(im_new, threshold=0.5)
# save binarized segmentation
im_new.save(add_suffix(ftmp_seg, '_bin')) # unused?
# crop template in z-direction (for faster processing)
# TODO: refactor to use python module instead of doing i/o
sct.printv('\nCrop data in template space (for faster processing)...', verbose)
ftmp_template_, ftmp_template = ftmp_template, add_suffix(ftmp_template, '_crop')
msct_image.spatial_crop(Image(ftmp_template_), dict(((2, (zmin_template,zmax_template)),))).save(ftmp_template)
ftmp_template_seg_, ftmp_template_seg = ftmp_template_seg, add_suffix(ftmp_template_seg, '_crop')
msct_image.spatial_crop(Image(ftmp_template_seg_), dict(((2, (zmin_template,zmax_template)),))).save(ftmp_template_seg)
ftmp_data_, ftmp_data = ftmp_data, add_suffix(ftmp_data, '_crop')
msct_image.spatial_crop(Image(ftmp_data_), dict(((2, (zmin_template,zmax_template)),))).save(ftmp_data)
ftmp_seg_, ftmp_seg = ftmp_seg, add_suffix(ftmp_seg, '_crop')
msct_image.spatial_crop(Image(ftmp_seg_), dict(((2, (zmin_template,zmax_template)),))).save(ftmp_seg)
# sub-sample in z-direction
# TODO: refactor to use python module instead of doing i/o
sct.printv('\nSub-sample in z-direction (for faster processing)...', verbose)
sct.run(['sct_resample', '-i', ftmp_template, '-o', add_suffix(ftmp_template, '_sub'), '-f', '1x1x' + zsubsample], verbose)
ftmp_template = add_suffix(ftmp_template, '_sub')
sct.run(['sct_resample', '-i', ftmp_template_seg, '-o', add_suffix(ftmp_template_seg, '_sub'), '-f', '1x1x' + zsubsample], verbose)
ftmp_template_seg = add_suffix(ftmp_template_seg, '_sub')
sct.run(['sct_resample', '-i', ftmp_data, '-o', add_suffix(ftmp_data, '_sub'), '-f', '1x1x' + zsubsample], verbose)
ftmp_data = add_suffix(ftmp_data, '_sub')
sct.run(['sct_resample', '-i', ftmp_seg, '-o', add_suffix(ftmp_seg, '_sub'), '-f', '1x1x' + zsubsample], verbose)
ftmp_seg = add_suffix(ftmp_seg, '_sub')
# Registration straight spinal cord to template
sct.printv('\nRegister straight spinal cord to template...', verbose)
# loop across registration steps
warp_forward = []
warp_inverse = []
for i_step in range(1, len(paramreg.steps)):
sct.printv('\nEstimate transformation for step #' + str(i_step) + '...', verbose)
# identify which is the src and dest
if paramreg.steps[str(i_step)].type == 'im':
src = ftmp_data
dest = ftmp_template
interp_step = 'linear'
elif paramreg.steps[str(i_step)].type == 'seg':
src = ftmp_seg
dest = ftmp_template_seg
interp_step = 'nn'
else:
sct.printv('ERROR: Wrong image type.', 1, 'error')
if paramreg.steps[str(i_step)].algo == 'centermassrot' and paramreg.steps[str(i_step)].rot_method == 'hog':
src_seg = ftmp_seg
dest_seg = ftmp_template_seg
# if step>1, apply warp_forward_concat to the src image to be used
if i_step > 1:
# apply transformation from previous step, to use as new src for registration
sct.run(['sct_apply_transfo', '-i', src, '-d', dest, '-w', ','.join(warp_forward), '-o', add_suffix(src, '_regStep' + str(i_step - 1)), '-x', interp_step], verbose)
src = add_suffix(src, '_regStep' + str(i_step - 1))
if paramreg.steps[str(i_step)].algo == 'centermassrot' and paramreg.steps[str(i_step)].rot_method == 'hog': # also apply transformation to the seg
sct.run(['sct_apply_transfo', '-i', src_seg, '-d', dest_seg, '-w', ','.join(warp_forward), '-o', add_suffix(src, '_regStep' + str(i_step - 1)), '-x', interp_step], verbose)
src_seg = add_suffix(src_seg, '_regStep' + str(i_step - 1))
# register src --> dest
# TODO: display param for debugging
if paramreg.steps[str(i_step)].algo == 'centermassrot' and paramreg.steps[str(i_step)].rot_method == 'hog': # im_seg case
warp_forward_out, warp_inverse_out = register([src, src_seg], [dest, dest_seg], paramreg, param, str(i_step))
else:
warp_forward_out, warp_inverse_out = register(src, dest, paramreg, param, str(i_step))
warp_forward.append(warp_forward_out)
warp_inverse.append(warp_inverse_out)
# Concatenate transformations:
sct.printv('\nConcatenate transformations: anat --> template...', verbose)
sct.run(['sct_concat_transfo', '-w', 'warp_curve2straightAffine.nii.gz,' + ','.join(warp_forward), '-d', 'template.nii', '-o', 'warp_anat2template.nii.gz'], verbose)
# sct.run('sct_concat_transfo -w warp_curve2straight.nii.gz,straight2templateAffine.txt,'+','.join(warp_forward)+' -d template.nii -o warp_anat2template.nii.gz', verbose)
sct.printv('\nConcatenate transformations: template --> anat...', verbose)
warp_inverse.reverse()
if vertebral_alignment:
sct.run(['sct_concat_transfo', '-w', ','.join(warp_inverse) + ',warp_straight2curve.nii.gz', '-d', 'data.nii', '-o', 'warp_template2anat.nii.gz'], verbose)
else:
sct.run(['sct_concat_transfo', '-w', ','.join(warp_inverse) + ',-straight2templateAffine.txt,warp_straight2curve.nii.gz', '-d', 'data.nii', '-o', 'warp_template2anat.nii.gz'], verbose)
# register template->subject
elif ref == 'subject':
# Change orientation of input images to RPI
sct.printv('\nChange orientation of input images to RPI...', verbose)
ftmp_data = Image(ftmp_data).change_orientation("RPI", generate_path=True).save().absolutepath
ftmp_seg = Image(ftmp_seg).change_orientation("RPI", generate_path=True).save().absolutepath
ftmp_label = Image(ftmp_label).change_orientation("RPI", generate_path=True).save().absolutepath
# Remove unused label on template. Keep only label present in the input label image
sct.printv('\nRemove unused label on template. Keep only label present in the input label image...', verbose)
sct.run(['sct_label_utils', '-i', ftmp_template_label, '-o', ftmp_template_label, '-remove-reference', ftmp_label])
# Add one label because at least 3 orthogonal labels are required to estimate an affine transformation. This
# new label is added at the level of the upper most label (lowest value), at 1cm to the right.
for i_file in [ftmp_label, ftmp_template_label]:
im_label = Image(i_file)
coord_label = im_label.getCoordinatesAveragedByValue() # N.B. landmarks are sorted by value
# Create new label
from copy import deepcopy
new_label = deepcopy(coord_label[0])
# move it 5mm to the left (orientation is RAS)
nx, ny, nz, nt, px, py, pz, pt = im_label.dim
new_label.x = np.round(coord_label[0].x + 5.0 / px)
# assign value 99
new_label.value = 99
# Add to existing image
im_label.data[int(new_label.x), int(new_label.y), int(new_label.z)] = new_label.value
# Overwrite label file
# im_label.absolutepath = 'label_rpi_modif.nii.gz'
im_label.save()
# Bring template to subject space using landmark-based transformation
sct.printv('\nEstimate transformation for step #0...', verbose)
warp_forward = ['template2subjectAffine.txt']
warp_inverse = ['-template2subjectAffine.txt']
try:
register_landmarks(ftmp_template_label, ftmp_label, paramreg.steps['0'].dof, fname_affine=warp_forward[0], verbose=verbose, path_qc="./")
except Exception:
sct.printv('ERROR: input labels do not seem to be at the right place. Please check the position of the labels. See documentation for more details: https://www.slideshare.net/neuropoly/sct-course-20190121/42', verbose=verbose, type='error')
# loop across registration steps
for i_step in range(1, len(paramreg.steps)):
sct.printv('\nEstimate transformation for step #' + str(i_step) + '...', verbose)
# identify which is the src and dest
if paramreg.steps[str(i_step)].type == 'im':
src = ftmp_template
dest = ftmp_data
interp_step = 'linear'
elif paramreg.steps[str(i_step)].type == 'seg':
src = ftmp_template_seg
dest = ftmp_seg
interp_step = 'nn'
else:
sct.printv('ERROR: Wrong image type.', 1, 'error')
# apply transformation from previous step, to use as new src for registration
sct.run(['sct_apply_transfo', '-i', src, '-d', dest, '-w', ','.join(warp_forward), '-o', add_suffix(src, '_regStep' + str(i_step - 1)), '-x', interp_step], verbose)
src = add_suffix(src, '_regStep' + str(i_step - 1))
# register src --> dest
# TODO: display param for debugging
warp_forward_out, warp_inverse_out = register(src, dest, paramreg, param, str(i_step))
warp_forward.append(warp_forward_out)
warp_inverse.insert(0, warp_inverse_out)
# Concatenate transformations:
sct.printv('\nConcatenate transformations: template --> subject...', verbose)
sct.run(['sct_concat_transfo', '-w', ','.join(warp_forward), '-d', 'data.nii', '-o', 'warp_template2anat.nii.gz'], verbose)
sct.printv('\nConcatenate transformations: subject --> template...', verbose)
sct.run(['sct_concat_transfo', '-w', ','.join(warp_inverse), '-d', 'template.nii', '-o', 'warp_anat2template.nii.gz'], verbose)
# Apply warping fields to anat and template
sct.run(['sct_apply_transfo', '-i', 'template.nii', '-o', 'template2anat.nii.gz', '-d', 'data.nii', '-w', 'warp_template2anat.nii.gz', '-crop', '1'], verbose)
sct.run(['sct_apply_transfo', '-i', 'data.nii', '-o', 'anat2template.nii.gz', '-d', 'template.nii', '-w', 'warp_anat2template.nii.gz', '-crop', '1'], verbose)
# come back
os.chdir(curdir)
# Generate output files
sct.printv('\nGenerate output files...', verbose)
fname_template2anat = os.path.join(path_output, 'template2anat' + ext_data)
fname_anat2template = os.path.join(path_output, 'anat2template' + ext_data)
sct.generate_output_file(os.path.join(path_tmp, "warp_template2anat.nii.gz"), os.path.join(path_output, "warp_template2anat.nii.gz"), verbose)
sct.generate_output_file(os.path.join(path_tmp, "warp_anat2template.nii.gz"), os.path.join(path_output, "warp_anat2template.nii.gz"), verbose)
sct.generate_output_file(os.path.join(path_tmp, "template2anat.nii.gz"), fname_template2anat, verbose)
sct.generate_output_file(os.path.join(path_tmp, "anat2template.nii.gz"), fname_anat2template, verbose)
if ref == 'template':
# copy straightening files in case subsequent SCT functions need them
sct.generate_output_file(os.path.join(path_tmp, "warp_curve2straight.nii.gz"), os.path.join(path_output, "warp_curve2straight.nii.gz"), verbose)
sct.generate_output_file(os.path.join(path_tmp, "warp_straight2curve.nii.gz"), os.path.join(path_output, "warp_straight2curve.nii.gz"), verbose)
sct.generate_output_file(os.path.join(path_tmp, "straight_ref.nii.gz"), os.path.join(path_output, "straight_ref.nii.gz"), verbose)
# Delete temporary files
if param.remove_temp_files:
sct.printv('\nDelete temporary files...', verbose)
sct.rmtree(path_tmp, verbose=verbose)
# display elapsed time
elapsed_time = time.time() - start_time
sct.printv('\nFinished! Elapsed time: ' + str(int(np.round(elapsed_time))) + 's', verbose)
qc_dataset = arguments.get("-qc-dataset", None)
qc_subject = arguments.get("-qc-subject", None)
if param.path_qc is not None:
generate_qc(fname_data, fname_in2=fname_template2anat, fname_seg=fname_seg, args=args,
path_qc=os.path.abspath(param.path_qc), dataset=qc_dataset, subject=qc_subject,
process='sct_register_to_template')
sct.display_viewer_syntax([fname_data, fname_template2anat], verbose=verbose)
sct.display_viewer_syntax([fname_template, fname_anat2template], verbose=verbose)
def create_mask(param):
# parse argument for method
method_type = param.process[0]
# check method val
if not method_type == 'center':
method_val = param.process[1]
# check existence of input files
if method_type == 'centerline':
sct.check_file_exist(method_val, param.verbose)
# Extract path/file/extension
path_data, file_data, ext_data = sct.extract_fname(param.fname_data)
# Get output folder and file name
if param.fname_out == '':
param.fname_out = os.path.abspath(param.file_prefix + file_data + ext_data)
path_tmp = sct.tmp_create(basename="create_mask", verbose=param.verbose)
sct.printv('\nOrientation:', param.verbose)
orientation_input = Image(param.fname_data).orientation
sct.printv(' ' + orientation_input, param.verbose)
# copy input data to tmp folder and re-orient to RPI
Image(param.fname_data).change_orientation("RPI").save(os.path.join(path_tmp, "data_RPI.nii"))
if method_type == 'centerline':
Image(method_val).change_orientation("RPI").save(os.path.join(path_tmp, "centerline_RPI.nii"))
if method_type == 'point':
Image(method_val).change_orientation("RPI").save(os.path.join(path_tmp, "point_RPI.nii"))
# go to tmp folder
curdir = os.getcwd()
os.chdir(path_tmp)
# Get dimensions of data
im_data = Image('data_RPI.nii')
nx, ny, nz, nt, px, py, pz, pt = im_data.dim
sct.printv('\nDimensions:', param.verbose)
sct.printv(im_data.dim, param.verbose)
# in case user input 4d data
if nt != 1:
sct.printv('WARNING in ' + os.path.basename(__file__) + ': Input image is 4d but output mask will be 3D from first time slice.', param.verbose, 'warning')
# extract first volume to have 3d reference
nii = msct_image.empty_like(Image('data_RPI.nii'))
data3d = nii.data[:, :, :, 0]
nii.data = data3d
nii.save('data_RPI.nii')
if method_type == 'coord':
# parse to get coordinate
coord = [x for x in map(int, method_val.split('x'))]
if method_type == 'point':
# get file name
# extract coordinate of point
sct.printv('\nExtract coordinate of point...', param.verbose)
# TODO: change this way to remove dependence to sct.run. ProcessLabels.display_voxel returns list of coordinates
status, output = sct.run(['sct_label_utils', '-i', 'point_RPI.nii', '-display'], verbose=param.verbose)
# parse to get coordinate
# TODO fixup... this is quite magic
coord = output[output.find('Position=') + 10:-17].split(',')
if method_type == 'center':
# set coordinate at center of FOV
coord = np.round(float(nx) / 2), np.round(float(ny) / 2)
if method_type == 'centerline':
# get name of centerline from user argument
fname_centerline = 'centerline_RPI.nii'
else:
# generate volume with line along Z at coordinates 'coord'
sct.printv('\nCreate line...', param.verbose)
fname_centerline = create_line(param, 'data_RPI.nii', coord, nz)
# create mask
sct.printv('\nCreate mask...', param.verbose)
centerline = nibabel.load(fname_centerline) # open centerline
hdr = centerline.get_header() # get header
hdr.set_data_dtype('uint8') # set imagetype to uint8
spacing = hdr.structarr['pixdim']
data_centerline = centerline.get_data() # get centerline
# if data is 2D, reshape with empty third dimension
if len(data_centerline.shape) == 2:
data_centerline_shape = list(data_centerline.shape)
data_centerline_shape.append(1)
data_centerline = data_centerline.reshape(data_centerline_shape)
z_centerline_not_null = [iz for iz in range(0, nz, 1) if data_centerline[:, :, iz].any()]
# get center of mass of the centerline
cx = [0] * nz
cy = [0] * nz
for iz in range(0, nz, 1):
if iz in z_centerline_not_null:
cx[iz], cy[iz] = ndimage.measurements.center_of_mass(np.array(data_centerline[:, :, iz]))
# create 2d masks
file_mask = 'data_mask'
for iz in range(nz):
if iz not in z_centerline_not_null:
# write an empty nifty volume
img = nibabel.Nifti1Image(data_centerline[:, :, iz], None, hdr)
nibabel.save(img, (file_mask + str(iz) + '.nii'))
else:
center = np.array([cx[iz], cy[iz]])
mask2d = create_mask2d(param, center, param.shape, param.size, im_data=im_data)
# Write NIFTI volumes
img = nibabel.Nifti1Image(mask2d, None, hdr)
nibabel.save(img, (file_mask + str(iz) + '.nii'))
fname_list = [file_mask + str(iz) + '.nii' for iz in range(nz)]
im_out = concat_data(fname_list, dim=2).save('mask_RPI.nii.gz')
im_out.change_orientation(orientation_input)
im_out.header = Image(param.fname_data).header
im_out.save(param.fname_out)
# come back
os.chdir(curdir)
# Remove temporary files
if param.remove_temp_files == 1:
sct.printv('\nRemove temporary files...', param.verbose)
sct.rmtree(path_tmp)
sct.display_viewer_syntax([param.fname_data, param.fname_out], colormaps=['gray', 'red'], opacities=['', '0.5'])
def main(args=None):
# initialization
start_time = time.time()
path_out = '.'
param = Param()
# check user arguments
if not args:
args = sys.argv[1:]
# Get parser info
parser = get_parser()
arguments = parser.parse(sys.argv[1:])
param.fname_data = arguments['-i']
param.fname_bvecs = arguments['-bvec']
if '-bval' in arguments:
param.fname_bvals = arguments['-bval']
if '-bvalmin' in arguments:
param.bval_min = arguments['-bvalmin']
if '-g' in arguments:
param.group_size = arguments['-g']
if '-m' in arguments:
param.fname_mask = arguments['-m']
if '-param' in arguments:
param.update(arguments['-param'])
if '-thr' in arguments:
param.otsu = arguments['-thr']
if '-x' in arguments:
param.interp = arguments['-x']
if '-ofolder' in arguments:
path_out = arguments['-ofolder']
if '-r' in arguments:
param.remove_temp_files = int(arguments['-r'])
param.verbose = int(arguments.get('-v'))
sct.init_sct(log_level=param.verbose, update=True) # Update log level
# Get full path
param.fname_data = os.path.abspath(param.fname_data)
param.fname_bvecs = os.path.abspath(param.fname_bvecs)
if param.fname_bvals != '':
param.fname_bvals = os.path.abspath(param.fname_bvals)
if param.fname_mask != '':
param.fname_mask = os.path.abspath(param.fname_mask)
# Extract path, file and extension
path_data, file_data, ext_data = sct.extract_fname(param.fname_data)
path_mask, file_mask, ext_mask = sct.extract_fname(param.fname_mask)
path_tmp = sct.tmp_create(basename="dmri_moco", verbose=param.verbose)
# names of files in temporary folder
mask_name = 'mask'
bvecs_fname = 'bvecs.txt'
# Copying input data to tmp folder
sct.printv('\nCopying input data to tmp folder and convert to nii...', param.verbose)
convert(param.fname_data, os.path.join(path_tmp, "dmri.nii"))
sct.copy(param.fname_bvecs, os.path.join(path_tmp, bvecs_fname), verbose=param.verbose)
if param.fname_mask != '':
sct.copy(param.fname_mask, os.path.join(path_tmp, mask_name + ext_mask), verbose=param.verbose)
# go to tmp folder
curdir = os.getcwd()
os.chdir(path_tmp)
# update field in param (because used later).
# TODO: make this cleaner...
if param.fname_mask != '':
param.fname_mask = mask_name + ext_mask
# run moco
fname_data_moco_tmp = dmri_moco(param)
# generate b0_moco_mean and dwi_moco_mean
args = ['-i', fname_data_moco_tmp, '-bvec', 'bvecs.txt', '-a', '1', '-v', '0']
if not param.fname_bvals == '':
# if bvals file is provided
args += ['-bval', param.fname_bvals]
fname_b0, fname_b0_mean, fname_dwi, fname_dwi_mean = sct_dmri_separate_b0_and_dwi.main(args=args)
# come back
os.chdir(curdir)
# Generate output files
fname_dmri_moco = os.path.join(path_out, file_data + param.suffix + ext_data)
fname_dmri_moco_b0_mean = sct.add_suffix(fname_dmri_moco, '_b0_mean')
fname_dmri_moco_dwi_mean = sct.add_suffix(fname_dmri_moco, '_dwi_mean')
sct.create_folder(path_out)
sct.printv('\nGenerate output files...', param.verbose)
sct.generate_output_file(fname_data_moco_tmp, fname_dmri_moco, param.verbose)
sct.generate_output_file(fname_b0_mean, fname_dmri_moco_b0_mean, param.verbose)
sct.generate_output_file(fname_dwi_mean, fname_dmri_moco_dwi_mean, param.verbose)
# Delete temporary files
if param.remove_temp_files == 1:
sct.printv('\nDelete temporary files...', param.verbose)
sct.rmtree(path_tmp, verbose=param.verbose)
# display elapsed time
elapsed_time = time.time() - start_time
sct.printv('\nFinished! Elapsed time: ' + str(int(np.round(elapsed_time))) + 's', param.verbose)
sct.display_viewer_syntax([fname_dmri_moco, file_data], mode='ortho,ortho')
def main(args=None):
# Initialization
param = Param()
start_time = time.time()
parser = get_parser()
arguments = parser.parse(sys.argv[1:])
fname_anat = arguments['-i']
fname_centerline = arguments['-s']
if '-smooth' in arguments:
sigma = arguments['-smooth']
if '-param' in arguments:
param.update(arguments['-param'])
if '-r' in arguments:
remove_temp_files = int(arguments['-r'])
verbose = int(arguments.get('-v'))
sct.init_sct(log_level=verbose, update=True) # Update log level
# Display arguments
sct.printv('\nCheck input arguments...')
sct.printv(' Volume to smooth .................. ' + fname_anat)
sct.printv(' Centerline ........................ ' + fname_centerline)
sct.printv(' Sigma (mm) ........................ ' + str(sigma))
sct.printv(' Verbose ........................... ' + str(verbose))
# Check that input is 3D:
from spinalcordtoolbox.image import Image
nx, ny, nz, nt, px, py, pz, pt = Image(fname_anat).dim
dim = 4 # by default, will be adjusted later
if nt == 1:
dim = 3
if nz == 1:
dim = 2
if dim == 4:
sct.printv('WARNING: the input image is 4D, please split your image to 3D before smoothing spinalcord using :\n'
'sct_image -i ' + fname_anat + ' -split t -o ' + fname_anat, verbose, 'warning')
sct.printv('4D images not supported, aborting ...', verbose, 'error')
# Extract path/file/extension
path_anat, file_anat, ext_anat = sct.extract_fname(fname_anat)
path_centerline, file_centerline, ext_centerline = sct.extract_fname(fname_centerline)
path_tmp = sct.tmp_create(basename="smooth_spinalcord", verbose=verbose)
# Copying input data to tmp folder
sct.printv('\nCopying input data to tmp folder and convert to nii...', verbose)
sct.copy(fname_anat, os.path.join(path_tmp, "anat" + ext_anat))
sct.copy(fname_centerline, os.path.join(path_tmp, "centerline" + ext_centerline))
# go to tmp folder
curdir = os.getcwd()
os.chdir(path_tmp)
# convert to nii format
convert('anat' + ext_anat, 'anat.nii')
convert('centerline' + ext_centerline, 'centerline.nii')
# Change orientation of the input image into RPI
sct.printv('\nOrient input volume to RPI orientation...')
fname_anat_rpi = msct_image.Image("anat.nii") \
.change_orientation("RPI", generate_path=True) \
.save() \
.absolutepath
# Change orientation of the input image into RPI
sct.printv('\nOrient centerline to RPI orientation...')
fname_centerline_rpi = msct_image.Image("centerline.nii") \
.change_orientation("RPI", generate_path=True) \
.save() \
.absolutepath
# Straighten the spinal cord
# straighten segmentation
sct.printv('\nStraighten the spinal cord using centerline/segmentation...', verbose)
cache_sig = sct.cache_signature(input_files=[fname_anat_rpi, fname_centerline_rpi],
input_params={"x": "spline"})
cachefile = os.path.join(curdir, "straightening.cache")
if sct.cache_valid(cachefile, cache_sig) and os.path.isfile(os.path.join(curdir, 'warp_curve2straight.nii.gz')) and os.path.isfile(os.path.join(curdir, 'warp_straight2curve.nii.gz')) and os.path.isfile(os.path.join(curdir, 'straight_ref.nii.gz')):
# if they exist, copy them into current folder
sct.printv('Reusing existing warping field which seems to be valid', verbose, 'warning')
sct.copy(os.path.join(curdir, 'warp_curve2straight.nii.gz'), 'warp_curve2straight.nii.gz')
sct.copy(os.path.join(curdir, 'warp_straight2curve.nii.gz'), 'warp_straight2curve.nii.gz')
sct.copy(os.path.join(curdir, 'straight_ref.nii.gz'), 'straight_ref.nii.gz')
# apply straightening
sct.run(['sct_apply_transfo', '-i', fname_anat_rpi, '-w', 'warp_curve2straight.nii.gz', '-d', 'straight_ref.nii.gz', '-o', 'anat_rpi_straight.nii', '-x', 'spline'], verbose)
else:
sct.run(['sct_straighten_spinalcord', '-i', fname_anat_rpi, '-o', 'anat_rpi_straight.nii', '-s', fname_centerline_rpi, '-x', 'spline', '-param', 'algo_fitting='+param.algo_fitting], verbose)
sct.cache_save(cachefile, cache_sig)
# move warping fields locally (to use caching next time)
sct.copy('warp_curve2straight.nii.gz', os.path.join(curdir, 'warp_curve2straight.nii.gz'))
sct.copy('warp_straight2curve.nii.gz', os.path.join(curdir, 'warp_straight2curve.nii.gz'))
# Smooth the straightened image along z
sct.printv('\nSmooth the straightened image...')
sigma_smooth = ",".join([str(i) for i in sigma])
sct_maths.main(args=['-i', 'anat_rpi_straight.nii',
'-smooth', sigma_smooth,
'-o', 'anat_rpi_straight_smooth.nii',
'-v', '0'])
# Apply the reversed warping field to get back the curved spinal cord
sct.printv('\nApply the reversed warping field to get back the curved spinal cord...')
sct.run(['sct_apply_transfo', '-i', 'anat_rpi_straight_smooth.nii', '-o', 'anat_rpi_straight_smooth_curved.nii', '-d', 'anat.nii', '-w', 'warp_straight2curve.nii.gz', '-x', 'spline'], verbose)
# replace zeroed voxels by original image (issue #937)
sct.printv('\nReplace zeroed voxels by original image...', verbose)
nii_smooth = Image('anat_rpi_straight_smooth_curved.nii')
data_smooth = nii_smooth.data
data_input = Image('anat.nii').data
indzero = np.where(data_smooth == 0)
data_smooth[indzero] = data_input[indzero]
nii_smooth.data = data_smooth
nii_smooth.save('anat_rpi_straight_smooth_curved_nonzero.nii')
# come back
os.chdir(curdir)
# Generate output file
sct.printv('\nGenerate output file...')
sct.generate_output_file(os.path.join(path_tmp, "anat_rpi_straight_smooth_curved_nonzero.nii"),
file_anat + '_smooth' + ext_anat)
# Remove temporary files
if remove_temp_files == 1:
sct.printv('\nRemove temporary files...')
sct.rmtree(path_tmp)
# Display elapsed time
elapsed_time = time.time() - start_time
sct.printv('\nFinished! Elapsed time: ' + str(int(np.round(elapsed_time))) + 's\n')
sct.display_viewer_syntax([file_anat, file_anat + '_smooth'], verbose=verbose)
def main(args=None):
if args is None:
args = sys.argv[1:]
# create param objects
param_seg = ParamSeg()
param_data = ParamData()
param_model = ParamModel()
param = Param()
# get parser
parser = get_parser()
arguments = parser.parse(args)
# set param arguments ad inputted by user
param_seg.fname_im = arguments["-i"]
param_seg.fname_im_original = arguments["-i"]
param_seg.fname_seg = arguments["-s"]
if '-vertfile' in arguments:
if extract_fname(arguments['-vertfile'])[1].lower() == "none":
param_seg.fname_level = None
elif os.path.isfile(arguments['-vertfile']):
param_seg.fname_level = arguments['-vertfile']
else:
param_seg.fname_level = None
printv('WARNING: -vertfile input file: "' + arguments['-vertfile'] + '" does not exist.\nSegmenting GM without using vertebral information', 1, 'warning')
if '-denoising' in arguments:
param_data.denoising = bool(int(arguments['-denoising']))
if '-normalization' in arguments:
param_data.normalization = bool(int(arguments['-normalization']))
if '-p' in arguments:
param_data.register_param = arguments['-p']
if '-w-levels' in arguments:
param_seg.weight_level = arguments['-w-levels']
if '-w-coordi' in arguments:
param_seg.weight_coord = arguments['-w-coordi']
if '-thr-sim' in arguments:
param_seg.thr_similarity = arguments['-thr-sim']
if '-model' in arguments:
param_model.path_model_to_load = os.path.abspath(arguments['-model'])
if '-res-type' in arguments:
param_seg.type_seg = arguments['-res-type']
if '-ref' in arguments:
param_seg.fname_manual_gmseg = arguments['-ref']
if '-ofolder' in arguments:
param_seg.path_results = os.path.abspath(arguments['-ofolder'])
param_seg.qc = arguments.get("-qc", None)
if '-r' in arguments:
param.rm_tmp = bool(int(arguments['-r']))
param.verbose = int(arguments.get('-v'))
sct.init_sct(log_level=param.verbose, update=True) # Update log level
start_time = time.time()
seg_gm = SegmentGM(param_seg=param_seg, param_data=param_data, param_model=param_model, param=param)
seg_gm.segment()
elapsed_time = time.time() - start_time
printv('\nFinished! Elapsed time: ' + str(int(np.round(elapsed_time))) + 's', param.verbose)
# save quality control and sct.printv(info)
if param_seg.type_seg == 'bin':
wm_col = 'red'
gm_col = 'blue'
b = '0,1'
else:
wm_col = 'blue-lightblue'
gm_col = 'red-yellow'
b = '0.4,1'
if param_seg.qc is not None:
generate_qc(param_seg.fname_im_original, seg_gm.fname_res_gmseg,
seg_gm.fname_res_wmseg, param_seg, args, os.path.abspath(param_seg.qc))
if param.rm_tmp:
# remove tmp_dir
sct.rmtree(seg_gm.tmp_dir)
sct.display_viewer_syntax([param_seg.fname_im_original, seg_gm.fname_res_gmseg, seg_gm.fname_res_wmseg], colormaps=['gray', gm_col, wm_col], minmax=['', b, b], opacities=['1', '0.7', '0.7'], verbose=param.verbose)
