def _test_Image_atts(imgtype):
"""Test that basic Nifti/Image attributes are correct. """
testdir = tempfile.mkdtemp()
allowedExts = fslimage.ALLOWED_EXTENSIONS
fileGroups = fslimage.FILE_GROUPS
# (file, dims, pixdims, dtype)
dtypes = [np.uint8, np.int16, np.int32, np.float32, np.double]
dims = [(1, 1, 1), (10, 1, 1), (1, 10, 1), (1, 1, 10), (10, 10, 1),
(10, 1, 10), (1, 10, 10), (10, 10, 10), (1, 1, 1, 1),
(10, 1, 1, 1), (1, 10, 1, 1), (1, 1, 10, 1), (10, 10, 1, 1),
(10, 10, 1, 5), (10, 1, 10, 5), (1, 10, 10, 5), (10, 10, 10, 5)]
pixdims = [(0.5, 0.5, 0.5, 2), (1.0, 1.0, 1.0, 2), (2.0, 2.0, 2.0, 2),
(1.0, 5.0, 1.0, 3)]
tests = it.product(dims, pixdims, dtypes)
tests = list(tests)
paths = ['test{:03d}'.format(i) for i in range(len(tests))]
for path, atts in zip(paths, tests):
dims, pixdims, dtype = atts
ndims = len(dims)
pixdims = pixdims[:ndims]
path = op.abspath(op.join(testdir, path))
make_image(path, imgtype, dims, pixdims, dtype)
try:
for path, atts in zip(paths, tests):
dims, pixdims, dtype = atts
expdims = imagewrapper.canonicalShape(dims)
expndims = len(expdims)
ndims = len(dims)
pixdims = pixdims[:ndims]
exppixdims = pixdims[:expndims]
path = op.abspath(op.join(testdir, path))
i = fslimage.Image(path)
assert tuple(i.shape) == tuple(expdims)
assert tuple(i.pixdim) == tuple(exppixdims)
assert tuple(i.nibImage.shape) == tuple(dims)
assert tuple(i.nibImage.header.get_zooms()) == tuple(pixdims)
assert i.ndims == expndims
assert i.dtype == dtype
assert i.name == op.basename(path)
assert i.dataSource == fslpath.addExt(path,
allowedExts=allowedExts,
mustExist=True,
fileGroups=fileGroups)
finally:
shutil.rmtree(testdir)
def findReferenceImage(fname):
"""Attempts to locate the volumetric reference image for (what is
assumed to be) the given Freesurfer geometry file.
"""
basedir = op.dirname(op.dirname(op.abspath(fname)))
t1 = op.join(basedir, 'mri', 'T1.mgz')
exts = fslimage.ALLOWED_EXTENSIONS + fslmgh.ALLOWED_EXTENSIONS
try:
return fslpath.addExt(t1, allowedExts=exts, mustExist=True)
except fslpath.PathError:
return None
def save(self, cifti_filename, default_axis=None):
"""
Writes this sparse representation to/from a filename
:param cifti_filename: output filename
:param default_axis: What to use as an axis along any undefined dimensions
- By default an error is raised
- if set to "scalar" a ScalarAxis is used with names of "default {index}"
- if set to "series" a SeriesAxis is used
:return:
"""
self.to_cifti(default_axis).to_filename(
addExt(cifti_filename, defaultExt=self.extension, mustExist=False))
def Mesh(filename):
"""
Reads in a mesh from either a GIFTI (.surf.gii) or a VTK (.vtk) file
:param filename: filename provided by the user
:return: GIFTI or VTK sub-class of fsl.data.mesh.Mesh
"""
try:
full_filename = path.addExt(filename, ['.surf.gii', '.vtk'])
except path.PathError as e:
raise argparse.ArgumentTypeError(*e.args)
if path.hasExt(full_filename, '.surf.gii'):
return gifti.GiftiMesh(full_filename)
else:
return vtk.VTKMesh(full_filename)
def write(filename: str, arr: np.ndarray, axes: Tuple[cifti2.Axis]):
"""
Writes a CIFTI file guessing the extension of the filename
:param filename: full filename of basename
:param arr: array to be stored
:param axes: CIFTI axes describing the rows/columns of a CIFTI file
"""
extensions = guess_extension(axes)
if len(extensions) == 0:
raise ValueError(
"No valid extensions found for axes of type {}".format(
type(a) for a in axes))
new_filename = path.addExt(filename,
allowedExts=extensions,
mustExist=False,
defaultExt=extensions[0])
cifti2.write(new_filename, arr, axes)
def load(filename,
mask_values=(0, np.nan),
writable=False) -> Union[DenseCifti, ParcelCifti]:
"""
Reads CIFTI data from the given file
File can be:
- NIFTI file
- GIFTI file
- CIFTI file
:param filename: input filename
:param mask_values: which values are outside of the mask for NIFTI or GIFTI input
:param writable: allow to write to disk
:return: appropriate CIFTI sub-class (parcellated or dense)
"""
possible_extensions = (tuple(dense_extensions.values()) +
tuple(parcel_extensions.values()) +
tuple(image.ALLOWED_EXTENSIONS) +
('.shape.gii', '.gii'))
if isinstance(filename, str):
filename = addExt(filename,
possible_extensions,
fileGroups=image.FILE_GROUPS)
img = nib.load(filename)
else:
img = filename
if isinstance(img, nib.Cifti2Image):
return Cifti.from_cifti(img, writable=writable)
if isinstance(img, nib.GiftiImage):
if writable:
raise ValueError("Can not open GIFTI file in writable mode")
return Cifti.from_gifti(img, mask_values)
try:
vol_img = image.Image(img)
except ValueError:
raise ValueError(
f"I do not know how to convert {type(img)} into greyordinates (from {filename})"
)
if writable:
raise ValueError("Can not open NIFTI file in writable mode")
return Cifti.from_image(vol_img, mask_values)
def imglob(paths, output=None):
"""Given a list of file names, identifies and returns the unique
NIFTI/ANALYZE image files that exist.
:arg paths: Sequence of paths/prefixes to glob.
:arg output: One of ``'prefix'`` (the default), ``'all'``, or
``'primary'``:
- ``'prefix'``: Returns the files without extensions.
- ``'all'``: Returns all files that match (e.g. both
``.img`` and ``.hdr`` files will be
returned).
- ``'primary'``: Returns only the primary file of each
matching file group, e.g. only the
``.hdr`` file would be returned from
an ``.img``/``.hdr`` pair.
:returns: A sequence of resolved path names, in the form specified
by the ``output`` parameter.
"""
if output is None:
output = 'prefix'
if output not in ('prefix', 'all', 'primary'):
raise ValueError('Unsupported output format: {}'.format(output))
imgfiles = []
# Expand any wildcard paths if provided.
# Depending on the way that imglob is
# invoked, this may not get done by the
# calling shell.
expanded = []
for path in paths:
if any(c in path for c in '*?[]'):
expanded.extend(glob.glob(path))
else:
expanded.append(path)
paths = expanded
# Build a list of all image files (both
# hdr and img and otherwise) that match
for path in paths:
try:
path = fslpath.removeExt(path, allowedExts=exts)
imgfiles.extend(
fslpath.addExt(path, allowedExts=exts, unambiguous=False))
except fslpath.PathError:
continue
if output == 'prefix':
imgfiles = fslpath.removeDuplicates(imgfiles,
allowedExts=exts,
fileGroups=groups)
imgfiles = [fslpath.removeExt(f, exts) for f in imgfiles]
elif output == 'primary':
imgfiles = fslpath.removeDuplicates(imgfiles,
allowedExts=exts,
fileGroups=groups)
return list(sorted(set(imgfiles)))
def _test_Image_atts(imgtype):
"""Test that basic Nifti/Image attributes are correct. """
allowedExts = fslimage.ALLOWED_EXTENSIONS
fileGroups = fslimage.FILE_GROUPS
typeMap = {
np.uint8: constants.NIFTI_DT_UINT8,
np.int16: constants.NIFTI_DT_INT16,
np.int32: constants.NIFTI_DT_INT32,
np.float32: constants.NIFTI_DT_FLOAT32,
np.float64: constants.NIFTI_DT_FLOAT64
}
# (file, dims, pixdims, dtype)
dtypes = [np.uint8, np.int16, np.int32, np.float32, np.double]
dims = [(1, 1, 1), (10, 1, 1), (1, 10, 1), (1, 1, 10), (10, 10, 1),
(10, 1, 10), (1, 10, 10), (10, 10, 10), (1, 1, 1, 1),
(10, 1, 1, 1), (1, 10, 1, 1), (1, 1, 10, 1), (10, 10, 1, 1),
(10, 10, 1, 5), (10, 1, 10, 5), (1, 10, 10, 5), (10, 10, 10, 5)]
pixdims = [(0.5, 0.5, 0.5, 2), (1.0, 1.0, 1.0, 2), (2.0, 2.0, 2.0, 2),
(1.0, 5.0, 1.0, 3)]
tests = it.product(dims, pixdims, dtypes)
tests = list(tests)
paths = ['test{:03d}'.format(i) for i in range(len(tests))]
with tempdir() as testdir:
for path, atts in zip(paths, tests):
dims, pixdims, dtype = atts
ndims = len(dims)
pixdims = pixdims[:ndims]
path = op.abspath(op.join(testdir, path))
make_image(path, imgtype, dims, pixdims, dtype)
for path, atts in zip(paths, tests):
dims, pixdims, dtype = atts
expdims = fslimage.canonicalShape(dims)
expndims = len(expdims)
ndims = len(dims)
pixdims = pixdims[:ndims]
exppixdims = pixdims[:expndims]
path = op.abspath(op.join(testdir, path))
i = fslimage.Image(path)
assert not i.iscomplex
assert tuple(i.shape) == tuple(expdims)
assert tuple(i.data.shape) == tuple(expdims)
assert tuple(i.pixdim) == tuple(exppixdims)
assert tuple(i.nibImage.shape) == tuple(dims)
assert tuple(i.nibImage.header.get_zooms()) == tuple(pixdims)
assert i.nvals == 1
assert i.ndim == expndims
assert i.dtype == dtype
assert i.niftiDataType == typeMap[dtype]
assert i.name == op.basename(path)
assert i.dataSource == fslpath.addExt(path,
allowedExts=allowedExts,
mustExist=True,
fileGroups=fileGroups)
i = None
