def load_manual_gmseg(list_slices_target,
list_fname_manual_gmseg,
tmp_dir,
im_sc_seg_rpi,
new_res,
square_size_size_mm,
for_model=False,
fname_mask=None):
if isinstance(list_fname_manual_gmseg, str):
# consider fname_manual_gmseg as a list of file names to allow multiple manual GM segmentation
list_fname_manual_gmseg = [list_fname_manual_gmseg]
curdir = os.getcwd()
for fname_manual_gmseg in list_fname_manual_gmseg:
copy(fname_manual_gmseg, tmp_dir)
# change fname level to only file name (path = tmp dir now)
path_gm, file_gm, ext_gm = extract_fname(fname_manual_gmseg)
fname_manual_gmseg = file_gm + ext_gm
os.chdir(tmp_dir)
im_manual_gmseg = Image(fname_manual_gmseg).change_orientation("RPI")
if fname_mask is not None:
cropper = ImageCropper(im_manual_gmseg)
cropper.get_bbox_from_mask(fname_mask)
im_manual_gmseg_crop = cropper.crop()
im_manual_gmseg = im_manual_gmseg_crop
# assert gmseg has the right number of slices
assert im_manual_gmseg.data.shape[2] == len(
list_slices_target
), 'ERROR: the manual GM segmentation has not the same number of slices than the image.'
# interpolate gm to reference image
nz_gmseg, nx_gmseg, ny_gmseg, nt_gmseg, pz_gmseg, px_gmseg, py_gmseg, pt_gmseg = im_manual_gmseg.dim
list_im_gm = interpolate_im_to_ref(im_manual_gmseg,
im_sc_seg_rpi,
new_res=new_res,
sq_size_size_mm=square_size_size_mm,
interpolation_mode=0)
# load gm seg in list of slices
n_poped = 0
for im_gm, slice_im in zip(list_im_gm, list_slices_target):
if im_gm.data.max() == 0 and for_model:
list_slices_target.pop(slice_im.id - n_poped)
n_poped += 1
else:
slice_im.gm_seg.append(im_gm.data)
wm_slice = (slice_im.im > 0) - im_gm.data
slice_im.wm_seg.append(wm_slice)
os.chdir(curdir)
return list_slices_target
def main(argv=None):
"""
Main function
:param argv:
:return:
"""
parser = get_parser()
arguments = parser.parse_args(argv if argv else ['--help'])
verbose = arguments.v
set_global_loglevel(verbose=verbose)
# initialize ImageCropper
cropper = ImageCropper(Image(arguments.i))
cropper.verbose = verbose
# 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 = add_suffix(arguments.i, '_crop')
else:
fname_out = arguments.o
img_crop.save(fname_out)
display_viewer_syntax([arguments.i, fname_out])
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 pre_processing(fname_target,
fname_sc_seg,
fname_level=None,
fname_manual_gmseg=None,
new_res=0.3,
square_size_size_mm=22.5,
denoising=True,
verbose=1,
rm_tmp=True,
for_model=False):
printv('\nPre-process data...', verbose, 'normal')
tmp_dir = tmp_create()
copy(fname_target, tmp_dir)
fname_target = ''.join(extract_fname(fname_target)[1:])
copy(fname_sc_seg, tmp_dir)
fname_sc_seg = ''.join(extract_fname(fname_sc_seg)[1:])
curdir = os.getcwd()
os.chdir(tmp_dir)
original_info = {
'orientation': None,
'im_sc_seg_rpi': None,
'interpolated_images': []
}
im_target = Image(fname_target).copy()
im_sc_seg = Image(fname_sc_seg).copy()
# get original orientation
printv(' Reorient...', verbose, 'normal')
original_info['orientation'] = im_target.orientation
# assert images are in the same orientation
assert im_target.orientation == im_sc_seg.orientation, "ERROR: the image to segment and it's SC segmentation are not in the same orientation"
im_target_rpi = im_target.copy().change_orientation(
'RPI', generate_path=True).save()
im_sc_seg_rpi = im_sc_seg.copy().change_orientation(
'RPI', generate_path=True).save()
original_info['im_sc_seg_rpi'] = im_sc_seg_rpi.copy(
) # target image in RPI will be used to post-process segmentations
# denoise using P. Coupe non local means algorithm (see [Manjon et al. JMRI 2010]) implemented in dipy
if denoising:
printv(' Denoise...', verbose, 'normal')
# crop image before denoising to fasten denoising
nx, ny, nz, nt, px, py, pz, pt = im_target_rpi.dim
size_x, size_y = (square_size_size_mm + 1) / px, (square_size_size_mm +
1) / py
size = int(np.ceil(max(size_x, size_y)))
# create mask
fname_mask = 'mask_pre_crop.nii.gz'
sct_create_mask.main([
'-i', im_target_rpi.absolutepath, '-p',
'centerline,' + im_sc_seg_rpi.absolutepath, '-f', 'box', '-size',
str(size), '-o', fname_mask
])
# crop image
cropper = ImageCropper(im_target_rpi)
cropper.get_bbox_from_mask(Image(fname_mask))
im_target_rpi_crop = cropper.crop()
# crop segmentation
cropper = ImageCropper(im_sc_seg_rpi)
cropper.get_bbox_from_mask(Image(fname_mask))
im_sc_seg_rpi_crop = cropper.crop()
# denoising
from spinalcordtoolbox.math import denoise_nlmeans
block_radius = 3
block_radius = int(
im_target_rpi_crop.data.shape[2] /
2) if im_target_rpi_crop.data.shape[2] < (block_radius *
2) else block_radius
patch_radius = block_radius - 1
data_denoised = denoise_nlmeans(im_target_rpi_crop.data,
block_radius=block_radius,
patch_radius=patch_radius)
im_target_rpi_crop.data = data_denoised
im_target_rpi = im_target_rpi_crop
im_sc_seg_rpi = im_sc_seg_rpi_crop
else:
fname_mask = None
# interpolate image to reference square image (resample and square crop centered on SC)
printv(' Interpolate data to the model space...', verbose, 'normal')
list_im_slices = interpolate_im_to_ref(im_target_rpi,
im_sc_seg_rpi,
new_res=new_res,
sq_size_size_mm=square_size_size_mm)
original_info[
'interpolated_images'] = list_im_slices # list of images (not Slice() objects)
printv(' Mask data using the spinal cord segmentation...', verbose,
'normal')
list_sc_seg_slices = interpolate_im_to_ref(
im_sc_seg_rpi,
im_sc_seg_rpi,
new_res=new_res,
sq_size_size_mm=square_size_size_mm,
interpolation_mode=1)
for i in range(len(list_im_slices)):
# list_im_slices[i].data[list_sc_seg_slices[i].data == 0] = 0
list_sc_seg_slices[i] = binarize(list_sc_seg_slices[i],
thr_min=0.5,
thr_max=1)
list_im_slices[
i].data = list_im_slices[i].data * list_sc_seg_slices[i].data
printv(' Split along rostro-caudal direction...', verbose, 'normal')
list_slices_target = [
Slice(slice_id=i, im=im_slice.data, gm_seg=[], wm_seg=[])
for i, im_slice in enumerate(list_im_slices)
]
# load vertebral levels
if fname_level is not None:
printv(' Load vertebral levels...', verbose, 'normal')
# copy level file to tmp dir
os.chdir(curdir)
copy(fname_level, tmp_dir)
os.chdir(tmp_dir)
# change fname level to only file name (path = tmp dir now)
fname_level = ''.join(extract_fname(fname_level)[1:])
# load levels
list_slices_target = load_level(list_slices_target, fname_level)
os.chdir(curdir)
# load manual gmseg if there is one (model data)
if fname_manual_gmseg is not None:
printv('\n\tLoad manual GM segmentation(s) ...', verbose, 'normal')
list_slices_target = load_manual_gmseg(list_slices_target,
fname_manual_gmseg,
tmp_dir,
im_sc_seg_rpi,
new_res,
square_size_size_mm,
for_model=for_model,
fname_mask=fname_mask)
if rm_tmp:
# remove tmp folder
rmtree(tmp_dir)
return list_slices_target, original_info
def apply(self):
# Initialization
fname_src = self.input_filename # source image (moving)
list_warp = self.list_warp # 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 = []
# list_warp = list_warp.replace(' ', '') # remove spaces
# list_warp = list_warp.split(",") # parse with comma
for idx_warp, path_warp in enumerate(self.list_warp):
# Check if this transformation should be inverted
if path_warp in self.list_warpinv:
use_inverse.append('-i')
# list_warp[idx_warp] = path_warp[1:] # remove '-'
fname_warp_list_invert += [[
use_inverse[idx_warp], list_warp[idx_warp]
]]
else:
use_inverse.append('')
fname_warp_list_invert += [[path_warp]]
path_warp = list_warp[idx_warp]
if path_warp.endswith((".nii", ".nii.gz")) \
and Image(list_warp[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 = 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:
dim = '4'
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 list_warp:
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 = 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)
# Copy affine matrix from destination space to make sure qform/sform are the same
sct.printv(
"Copy affine matrix from destination space to make sure qform/sform are the same.",
verbose)
im_src_reg = Image(fname_out)
im_src_reg.copy_qform_from_ref(Image(fname_dest))
im_src_reg.save(
verbose=0
) # set verbose=0 to avoid warning message about rewriting file
# 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')
else:
if crop_reference in [1, 2]:
# Extract only the first ndim of the warping field
img_warp = Image(warping_field)
if dim == '2':
img_warp_ndim = Image(img_src.data[:, :], hdr=img_warp.hdr)
elif dim in ['3', '4']:
img_warp_ndim = Image(img_src.data[:, :, :],
hdr=img_warp.hdr)
# Set zero to everything outside the warping field
cropper = ImageCropper(Image(fname_out))
cropper.get_bbox_from_ref(img_warp_ndim)
if crop_reference == 1:
img_out = cropper.crop(background=0)
elif crop_reference == 2:
img_out = cropper.crop()
img_out.save(fname_out)
sct.display_viewer_syntax([fname_dest, fname_out], verbose=verbose)