def _run_interface(self, runtime):
src_nii = nb.load(self.inputs.src_file)
src = NiftiWrapper(src_nii, make_empty=True)
dest_nii = nb.load(self.inputs.dest_file)
dest = NiftiWrapper(dest_nii, make_empty=True)
classes = src.meta_ext.get_valid_classes()
if self.inputs.include_classes:
classes = [cls
for cls in classes
if cls in self.inputs.include_classes
]
if self.inputs.exclude_classes:
classes = [cls
for cls in classes
if cls not in self.inputs.exclude_classes
]
for cls in classes:
src_dict = src.meta_ext.get_class_dict(cls)
dest_dict = dest.meta_ext.get_class_dict(cls)
dest_dict.update(src_dict)
# Update the shape and slice dimension to reflect the meta extension update.
dest.meta_ext.slice_dim = src.meta_ext.slice_dim
dest.meta_ext.shape = src.meta_ext.shape
self.out_path = op.join(os.getcwd(),
op.basename(self.inputs.dest_file))
dest.to_filename(self.out_path)
return runtime
def _run_interface(self, runtime):
src_nii = nb.load(self.inputs.src_file)
src = NiftiWrapper(src_nii, make_empty=True)
dest_nii = nb.load(self.inputs.dest_file)
dest = NiftiWrapper(dest_nii, make_empty=True)
classes = src.meta_ext.get_valid_classes()
if self.inputs.include_classes:
classes = [
cls for cls in classes if cls in self.inputs.include_classes
]
if self.inputs.exclude_classes:
classes = [
cls for cls in classes
if not cls in self.inputs.exclude_classes
]
for cls in classes:
src_dict = src.meta_ext.get_class_dict(cls)
dest_dict = dest.meta_ext.get_class_dict(cls)
dest_dict.update(src_dict)
self.out_path = path.join(os.getcwd(),
path.basename(self.inputs.dest_file))
dest.to_filename(self.out_path)
return runtime
def _run_interface(self, runtime):
src_paths = self._get_filelist(self.inputs.dicom_files)
stacks = dcmstack.parse_and_stack(src_paths)
self.out_list = []
for key, stack in list(stacks.items()):
nw = NiftiWrapper(stack.to_nifti(embed_meta=True))
const_meta = nw.meta_ext.get_class_dict(("global", "const"))
out_path = self._get_out_path(const_meta)
if not self.inputs.embed_meta:
nw.remove_extension()
nb.save(nw.nii_img, out_path)
self.out_list.append(out_path)
return runtime
def _run_interface(self, runtime):
self.out_list = []
nii = nb.load(self.inputs.in_file)
nw = NiftiWrapper(nii, make_empty=True)
split_dim = None
if self.inputs.split_dim == traits.Undefined:
split_dim = None
else:
split_dim = self.inputs.split_dim
for split_idx, split_nw in enumerate(nw.split(split_dim)):
const_meta = split_nw.meta_ext.get_class_dict(("global", "const"))
out_path = self._get_out_path(const_meta, idx=split_idx)
nb.save(split_nw.nii_img, out_path)
self.out_list.append(out_path)
return runtime
def _run_interface(self, runtime):
niis = [nb.load(fn) for fn in self.inputs.in_files]
nws = [NiftiWrapper(nii, make_empty=True) for nii in niis]
if self.inputs.sort_order:
sort_order = self.inputs.sort_order
if isinstance(sort_order, (str, bytes)):
sort_order = [sort_order]
nws.sort(key=make_key_func(sort_order))
if self.inputs.merge_dim == traits.Undefined:
merge_dim = None
else:
merge_dim = self.inputs.merge_dim
merged = NiftiWrapper.from_sequence(nws, merge_dim)
const_meta = merged.meta_ext.get_class_dict(("global", "const"))
self.out_path = self._get_out_path(const_meta)
nb.save(merged.nii_img, self.out_path)
return runtime
def extract_meta(func):
"""Extracts meta-data from niftis that were created from dcmstack_
Parameters
----------
func : String
Filename of nifti image created from dcmstack_
Returns
-------
so : List of Integers
Slice order of nifti
tr : Float
Repetition Time (TR) in seconds
.. _dcmstack: https://github.com/moloney/dcmstack
"""
from nibabel import load
import numpy as np
from dcmstack.dcmmeta import NiftiWrapper
sliceorders = []
trs = []
if not isinstance(func, list):
func = [func]
for f in func:
img = load(f)
wrp = NiftiWrapper(img)
sliceorder = np.argsort(
wrp.meta_ext.get_values('CsaImage.MosaicRefAcqTimes')[0]).tolist()
sliceorders.append(sliceorder)
tr = wrp.meta_ext.get_values('RepetitionTime')
trs.append(tr)
so = sliceorders[0]
if np.sum(np.diff(sliceorders, axis=0)):
raise Exception("The functional runs have different slice orders!")
if np.sum(np.diff(trs)):
raise Exception("The functional runs have different TRs!")
else:
return so, trs[0] / 1000.
def _run_interface(self, runtime):
src_paths = self._get_filelist(self.inputs.dicom_files)
include_regexes = dcmstack.default_key_incl_res
if isdefined(self.inputs.include_regexes):
include_regexes += self.inputs.include_regexes
exclude_regexes = dcmstack.default_key_excl_res
if isdefined(self.inputs.exclude_regexes):
exclude_regexes += self.inputs.exclude_regexes
meta_filter = dcmstack.make_key_regex_filter(exclude_regexes,
include_regexes)
stack = dcmstack.DicomStack(meta_filter=meta_filter)
for src_path in src_paths:
src_dcm = dicom.read_file(src_path, force=True)
stack.add_dcm(src_dcm)
nii = stack.to_nifti(embed_meta=True)
nw = NiftiWrapper(nii)
self.out_path = \
self._get_out_path(nw.meta_ext.get_class_dict(('global', 'const')))
if not self.inputs.embed_meta:
nw.remove_extension()
nb.save(nii, self.out_path)
return runtime
