def niftiToRaw(infile, outfile=None, sizefile=None, dimorder=None, diskorder='F', dtype=None, dtype_as_ext=False):
"""Converts a NIfTI file (or set of files) to a raw file.
Arguments:
infile: Filename of a NIfTI file, or a list of strings. The list
indicates a sequence of files to be concatenated together,
in the order given, along dimension 4 (where 1 is the
fastest-changing).
outfile: Filename of a raw file to generate. If None, the filename
will be copied from infile, but with an extension indicating
the dtype. See also dtype_as_ext.
sizefile: Filename of a size_info metadata file. If None, it will go
in the same directory as outfile. If empty string, no
size_info file will be generated.
dimorder: Four-character string that is a permutation of "XYZI",
indicating the desired dimension order of the output image.
The default value, None, is equivalent to "XYZI".
diskorder: 'F' or 'C' --- the order for storage on disk.
dtype: A numpy data type to cast to. If None, the data type
either remains whatever the NIfTI header specifies, or is
cast to the type specified by the extension on outfile.
dtype_as_ext: If True, and if outfile is not None, then this appends the
dtype to the end of outfile.
"""
if dimorder is None:
dimorder = _miraw_helpers.DIM_DEFAULT_ORDER
if not _miraw_helpers.isValidDimorder(dimorder):
raise ValueError('"%s" is not a valid dimorder argument.' % repr(dimorder))
# Figure out the desired dtype.
fname_dtype = None
try:
fname_dtype = _miraw_helpers.inferDtypeFromFilename(outfile)
except:
pass
if dtype is not None and fname_dtype is not None:
if fname_dtype != np.dtype(dtype):
raise ValueError("Arguments specify contradictory dtypes:\n outfile: {}\n dtype: {}".format(outfile, dtype))
elif dtype is None:
dtype = fname_dtype
# Now either dtype is None, because both the outfile and dtype arguments
# failed to set it, or it and the outfile agree. If it's None, then we'll
# just keep the dtype from the NIfTI file.
# Read the file and set the dtype once and for all.
(img, cfg, header) = readNifti(infile, dtype)
dtype = img.dtype
# Apply any dimension flips or permutations according to the header.
(img, xform, vox_sz) = applyNiftiXform(img, niftiGetXform(header), cfg)
# And finally put the data in the requested storage order.
img = applyDimOrder(img, dimorder)
# Generate new names for the output files as necessary.
if outfile is None:
if not isinstance(infile, str):
raise ValueError("No outfile specified, but infile %s is not a string!" % repr(infile))
(base, ext) = os.path.splitext(infile)
if ext == ".gz":
(base, ext) = os.path.splitext(base)
outfile = base + "." + str(dtype)
elif dtype_as_ext:
outfile += "." + str(dtype)
if sizefile is None:
sizefile = os.path.join(os.path.dirname(outfile), "size_info")
# Write the size_info file.
if len(sizefile) > 0:
saveSizeInfo(sizefile, img, size_cfg=cfg, infer_name=False)
# And finally write the raw file.
saveRaw(outfile, img, diskorder, dtype_as_ext)
def readRaw(f, shape, dtype=None, diskorder='F', memorder='C'):
"""Loads array data from a raw binary file on disk.
This is a wrapper around numpy.fromfile, and returns a numpy.ndarray that
owns its own memory. Its particular purpose is to work with differing
dimension orderings on disk and in memory. The default is to interpret
the file as "Fortran-ordered" (Matlab's default; column-major; first index
is fastest-changing) and to produce an ndarray that is "C-ordered" (numpy's
default; row-major; last index is fastest-changing).
This function does not support memory mapping (yet), so it's not
appropriate to use if your array is too big to fit comfortably in memory.
numpy.load() and the h5py package are alternatives, but they put
restrictions on the file format. numpy.memmap() may be the right option.
Arguments:
f: An open file object or a filename.
shape: A tuple of dimension extents. One dimension may be given
extent -1; if so, this dimension stretches to fit all the
voxel values.
dtype: A numpy data type (like numpy.float32). If None, dtype is
inferred from the filename.
diskorder: 'F' or 'C', default 'F'.
memorder: 'F' or 'C', default 'C'.
Throws a ValueError if shape does not match the number of voxels stored on
disk, or if the product of the non-negative values in shape does not divide
the number of voxels evenly.
Returns a numpy.ndarray with the given shape and order=memorder.
"""
# Read the data into a flat array.
if dtype is None:
dtype = _miraw_helpers.inferDtypeFromFilename(f)
raw = np.fromfile(f, dtype=dtype)
# Resolve the shape argument.
shape = np.array(shape)
num_voxels = np.prod(shape)
if num_voxels < 0:
num_voxels = -num_voxels
missing_dim = int(raw.shape[0] / num_voxels)
if num_voxels * missing_dim != raw.shape[0]:
err = (('File has %i voxels; you gave me shape = %s = %i voxels,\n' +
'which does not divide evenly.') %
(raw.shape[0], repr(shape.tolist()), num_voxels))
raise ValueError(err)
# Replace the missing dimension.
shape = np.where(shape < 0, missing_dim, shape)
# Reshape the flat array, interpreting according to the disk order.
try:
X = np.ndarray(shape=shape, dtype=dtype, buffer=raw.data, order=diskorder)
except TypeError:
num_voxels = np.prod(shape)
if num_voxels != raw.shape[0]:
err = ('File has %i voxels; you gave me shape = %s = %i voxels.' %
(raw.shape[0], repr(shape.tolist()), num_voxels))
raise ValueError(err)
else:
raise
# Now convert to the memory order and return.
return _miraw_helpers.ndcopyWithOrder(X, memorder)