def save(self):
if self.perc_bad_voxels == None and self.file:
import neurovault.apps.statmaps.utils as nvutils
self.file.open()
gzfileobj = GzipFile(filename=self.file.name,
mode='rb',
fileobj=self.file.file)
nii = nb.Nifti1Image.from_file_map(
{'image': nb.FileHolder(self.file.name, gzfileobj)})
self.is_thresholded, ratio_bad = nvutils.is_thresholded(nii)
self.perc_bad_voxels = ratio_bad * 100.0
if self.brain_coverage == None and self.file:
import neurovault.apps.statmaps.utils as nvutils
self.file.open()
gzfileobj = GzipFile(filename=self.file.name,
mode='rb',
fileobj=self.file.file)
nii = nb.Nifti1Image.from_file_map(
{'image': nb.FileHolder(self.file.name, gzfileobj)})
self.not_mni, self.brain_coverage, self.perc_voxels_outside = nvutils.not_in_mni(
nii)
if self.map_type == self.OTHER:
import neurovault.apps.statmaps.utils as nvutils
self.file.open()
gzfileobj = GzipFile(filename=self.file.name,
mode='rb',
fileobj=self.file.file)
nii = nb.Nifti1Image.from_file_map(
{'image': nb.FileHolder(self.file.name, gzfileobj)})
self.map_type = nvutils.infer_map_type(nii)
# Calculation of image reduced_representation and comparisons
file_changed = False
if self.pk is not None:
existing = Image.objects.get(pk=self.pk)
if existing.file != self.file:
file_changed = True
do_update = True if file_changed else False
new_image = True if self.pk is None else False
# If we have an update, delete old pkl and comparisons first before saving
if do_update and self.collection:
if self.reduced_representation: # not applicable for private collections
self.reduced_representation.delete()
# If more than one metric is added to NeuroVault, this must also filter based on metric
comparisons = Comparison.objects.filter(
Q(image1=self) | Q(image2=self))
if comparisons:
comparisons.delete()
super(BaseStatisticMap, self).save()
# Calculate comparisons
if do_update or new_image:
run_voxelwise_pearson_similarity.apply_async([self.pk])
self.file.close()
def generate_surface_image(image_pk):
from neurovault.apps.statmaps.models import Image
from scipy.io import loadmat
import numpy.matlib as matlib
from scipy.interpolate import interpn
img = Image.objects.get(pk=image_pk)
if img.target_template_image in ['GenericMNI', 'MNI152NLin2009cAsym'] and \
img.data_origin == 'volume':
img_vol = nib.load(img.file.path)
data_vol = img_vol.get_data()
if data_vol.ndim > 3:
data_dim = data_vol.shape[3] #number of time points
else:
data_dim = 1
this_path = os.path.abspath(os.path.dirname(__file__))
for hemi in ['lh', 'rh']:
if hemi == 'lh':
ras_coor = loadmat(os.path.abspath(os.path.join(this_path, "static", "anatomical",
"lh.avgMapping_allSub_RF_ANTs_MNI2fs.mat")))['ras']
else:
ras_coor = loadmat(os.path.abspath(os.path.join(this_path, "static", "anatomical",
"rh.avgMapping_allSub_RF_ANTs_MNI2fs.mat")))['ras']
vox2ras = img_vol.get_sform()
ras_centered = ras_coor - matlib.repmat(vox2ras[0:3, 3], ras_coor.shape[1], 1).T
vox_coor = numpy.dot(numpy.linalg.inv(vox2ras[0:3, 0:3]), ras_centered) # convert to voxel coordinates
img_surf = nib.gifti.GiftiImage()
for i in range(data_dim):
if data_vol.ndim > 3:
data_curr = data_vol[:, :, :, i]
data_surf = interpn([range(data_vol.shape[0]), range(data_vol.shape[1]), range(data_vol.shape[2])],
data_curr, vox_coor.T, 'linear')
data_surf_gifti = nib.gifti.GiftiDataArray(data_surf, 'NIFTI_INTENT_TIME_SERIES', 'NIFTI_TYPE_FLOAT32',
'ASCII')
else:
data_curr = data_vol
data_surf = interpn([range(data_vol.shape[0]), range(data_vol.shape[1]), range(data_vol.shape[2])],
data_curr, vox_coor.T, 'linear')
data_surf_gifti = nib.gifti.GiftiDataArray(data_surf, 'NIFTI_INTENT_NONE', 'NIFTI_TYPE_FLOAT32',
'ASCII')
img_surf.add_gifti_data_array(data_surf_gifti)
f = BytesIO()
fmap = {'image': nib.FileHolder(fileobj=f), 'header': nib.FileHolder(fileobj=f)}
img_surf.to_file_map(fmap)
f.seek(0)
content_file = ContentFile(f.read())
if hemi == 'lh':
img.surface_left_file.save("surface_%s_%s.gii" % (hemi, img.pk), content_file)
else:
img.surface_right_file.save("surface_%s_%s.gii" % (hemi, img.pk), content_file)
img.save()
print("Surface image generation done.")
def clean(self, **kwargs):
cleaned_data = super(StatisticMapForm, self).clean()
django_file = cleaned_data.get("file")
cleaned_data[
"is_valid"] = True #This will be only saved if the form will validate
cleaned_data["tags"] = clean_tags(cleaned_data)
if django_file and "file" not in self._errors and "hdr_file" not in self._errors:
django_file.open()
fileobj = StringIO(django_file.read())
django_file.seek(0)
gzfileobj = GzipFile(filename=django_file.name,
mode='rb',
fileobj=fileobj)
nii = nb.Nifti1Image.from_file_map(
{'image': nb.FileHolder(django_file.name, gzfileobj)})
cleaned_data["is_thresholded"], ratio_bad = is_thresholded(nii)
cleaned_data["perc_bad_voxels"] = ratio_bad * 100.0
if cleaned_data["is_thresholded"] and not cleaned_data.get(
"ignore_file_warning") and cleaned_data.get(
"map_type") != "R":
self._errors["file"] = self.error_class([
"This map seems to be thresholded (%.4g%% of voxels are zeros). Please use an unthresholded version of the map if possible."
% (cleaned_data["perc_bad_voxels"])
])
if cleaned_data.get("hdr_file"):
self._errors["hdr_file"] = self.error_class([
"This map seems to be thresholded (%.4g%% of voxels are zeros). Please use an unthresholded version of the map if possible."
% (cleaned_data["perc_bad_voxels"])
])
self.fields[
"ignore_file_warning"].widget = forms.CheckboxInput()
else:
cleaned_data["not_mni"], cleaned_data[
"brain_coverage"], cleaned_data[
"perc_voxels_outside"] = not_in_mni(nii)
if cleaned_data["not_mni"] and not cleaned_data.get(
"ignore_file_warning") and cleaned_data.get(
"map_type") != "R":
self._errors["file"] = self.error_class([
"This map seems not to be in the MNI space (%.4g%% of meaningful voxels are outside of the brain). Please use transform your data to MNI space."
% (cleaned_data["perc_voxels_outside"])
])
if cleaned_data.get("hdr_file"):
self._errors["hdr_file"] = self.error_class([
"This map seems not to be in the MNI space (%.4g%% of meaningful voxels are outside of the brain). Please use transform your data to MNI space."
% (cleaned_data["perc_voxels_outside"])
])
self.fields[
"ignore_file_warning"].widget = forms.CheckboxInput()
if cleaned_data.get("map_type") == "R":
if "not_mni" in cleaned_data:
del cleaned_data["not_mni"]
if "is_thresholded" in cleaned_data:
del cleaned_data["is_thresholded"]
return cleaned_data
def read_img(filename, data, benchmark, start, output_dir, bench_dir=None):
start_time = time() - start
print('Reading image', filename)
# load binary data into Nibabel
fh = nib.FileHolder(fileobj=BytesIO(data))
im = nib.Nifti1Image.from_file_map({'header': fh, 'image': fh})
data = im.get_data()
end_time = time() - start
bn = os.path.basename(filename)
bench_file = None
if benchmark:
bench_file = write_bench('read_img',
start_time,
end_time,
socket.gethostname(),
output_dir,
bn,
get_ident(),
benchmark_dir=bench_dir)
return (socket.gethostname(), filename, data, (im.affine, im.header),
bench_file)
def get_2dimg(s3obj, axis=1, begin=1, end=1, rot=0):
""" obtain slices of 2D images from nifti data"""
# get the images from 3s obj
response = s3obj.get()
zipfile = gzip.open(response['Body'])
iobyte = io.BytesIO(zipfile.read())
fholder = nib.FileHolder(fileobj=iobyte)
imgs = nib.Nifti1Image.from_file_map({'header': fholder, 'image': fholder})
imgdata = imgs.get_fdata()
logging.info(imgs.shape)
# extract region of interest; slices from 'begin' to 'end' along 'axis'
# axis = 0: x-axis (sagittal), 1: y-axis (coronal), 2: z-axis (axial)
if axis == 0:
imgdata = imgdata[int(begin):int(end), :, :]
elif axis == 1:
imgdata = imgdata[:, int(begin):int(end), :]
elif axis == 2:
imgdata = imgdata[:, :, int(begin):int(end)]
imgs = []
for j in range(imgdata.shape[axis]):
if axis == 0:
imgs.append(np.rot90(imgdata[j, :, :], rot))
elif axis == 1:
imgs.append(np.rot90(imgdata[:, j, :], rot))
elif axis == 2:
imgs.append(np.rot90(imgdata[:, :, j], rot))
return np.asarray(imgs)
def s3fs_nifti_read(fname, fs=None):
"""
Lazily reads a nifti image from S3.
Paramters
---------
fname : string
Full path (including bucket name and extension) to the S3 location
of the file to be read.
fs : an s3fs.S3FileSystem class instance, optional
A file-system to refer to. Default to create a new file-system.
Returns
-------
nib.Nifti1Image class instance
Note
----
Because the image is lazily loaded, data stored in the file
is not transferred until `get_fdata` is called.
"""
if fs is None:
fs = s3fs.S3FileSystem()
with fs.open(fname) as ff:
zz = gzip.open(ff)
rr = zz.read()
bb = BytesIO(rr)
fh = nib.FileHolder(fileobj=bb)
img = nib.Nifti1Image.from_file_map({'header': fh, 'image': fh})
return img
def get_voxels(filename, start, args):
"""Retrieve voxel intensity of a Nifti image as a byte stream.
Parameters
----------
filename: str
Representation of the path for the input file.
Returns
-------
data : da.array
Data of the nifti imaeg read.
"""
start_time = time() - start
img = None
with open(filename, "rb") as f_in:
fh = nib.FileHolder(fileobj=BytesIO(f_in.read()))
img = nib.Nifti1Image.from_file_map({"header": fh, "image": fh})
data = img.get_fdata(caching="unchanged")
data = nib.casting.float_to_int(data, np.int16)
end_time = time() - start
if args.benchmark:
benchmark(
start_time,
end_time,
filename,
args.output_dir,
args.experiment,
get_voxels.__name__,
)
return da.from_array(data)
def get_voxels(d):
# read data into nibabel
fh = nib.FileHolder(fileobj=BytesIO(d[1]))
im = nib.Nifti1Image.from_file_map({'header': fh, 'image': fh})
data = im.get_data()
return data.flatten('F')
def read_nii(filename):
with tf.gfile.GFile(filename, 'rb') as f:
bb = io.BytesIO(f.read())
fh = nib.FileHolder(fileobj=bb)
img = nib.Nifti1Image.from_file_map({'header': fh, 'image': fh})
subject, seriesID = get_keys(filename)
image = img.get_fdata()
image = image[40:200, 40:200, 112:144]
image /= 255.0
image = np.asmatrix(image.ravel())
return {'image': image, 'subject': subject, 'series': seriesID}
def load_volume(volume, log_file="timelog.json"):
"""
Load volumetric data into a
`Nibabel SpatialImage <http://nipy.org/nibabel/reference/nibabel.spatialimages.html#nibabel.spatialimages.SpatialImage>`_
Parameters
----------
volume: niimg
Volumetric data to be loaded, can be a path to a file that nibabel can
load, or a Nibabel SpatialImage
Returns
----------
image: Nibabel SpatialImage
Notes
----------
Originally created as part of Laminar Python [1]_ .
References
-----------
.. [1] Huntenburg et al. (2017), Laminar Python: Tools for cortical
depth-resolved analysis of high-resolution brain imaging data in
Python. DOI: 10.3897/rio.3.e12346
""" # noqa
# if input is a filename, try to load it
# python 2 version if isinstance(volume, basestring):
if isinstance(volume, str):
start = time.time()
# importing nifti files
# image = nb.load(volume) # disable lazy-load
# Read from file instead
with open(volume, "rb") as in_file:
# fh = nb.FileHolder(fileobj=GzipFile(fileobj=BytesIO(in_file.read())))
fh = nb.FileHolder(fileobj=BytesIO(
in_file.read())) # read uncompressed file
image = nb.Nifti1Image.from_file_map({"header": fh, "image": fh})
end = time.time()
caller_function = str(inspect.stack()[1].function)
time_log(log_file, caller_function, "read", volume, start, end)
# if volume is already a nibabel object
elif isinstance(volume, nb.spatialimages.SpatialImage):
image = volume
else:
raise ValueError('Input volume must be a either a path to a file in a '
'format that Nibabel can load, or a nibabel'
'SpatialImage.')
return image
def get_2dimg_cent(s3obj, axis=1, nslices=-1, rot=0):
""" obtain central slices of 2D images from nifti data"""
# get the images from 3s obj
iobyte = io.BytesIO(gzip.open(s3obj.get()['Body']).read())
fholder = nib.FileHolder(fileobj=iobyte)
imgs = nib.Nifti1Image.from_file_map({'header': fholder, 'image': fholder})
header = imgs.header
imgdata = imgs.get_fdata()
logging.info(imgs.shape)
# extract region of interest; slices from 'begin' to 'end' along 'axis'
# axis = 0: x-axis (sagittal), 1: y-axis (coronal), 2: z-axis (axial)
# in header['dim'] 1: x-axis, 2: y- axis, 3: z-axis
begin = 0
end = header['dim'][axis + 1] - 1
if nslices != -1:
nslices /= 2
middle = header['dim'][axis + 1] / 2
begin = middle - nslices
end = middle + nslices
if begin < 0:
begin = 0
if end >= header['dim'][axis + 1]:
end = header['dim'][axis + 1] - 1
resx = header['pixdim'][2]
resy = header['pixdim'][3]
# get the slices
logging.info("Slice range: %i to %i", begin, end)
if axis == 0:
imgdata = imgdata[int(begin):int(end), :, :]
elif axis == 1:
imgdata = imgdata[:, int(begin):int(end), :]
resx = header['pixdim'][1]
resy = header['pixdim'][3]
elif axis == 2:
imgdata = imgdata[:, :, int(begin):int(end)]
resx = header['pixdim'][1]
resy = header['pixdim'][2]
imgs = []
for j in range(imgdata.shape[axis]):
if axis == 0:
imgs.append(np.rot90(imgdata[j, :, :], rot))
elif axis == 1:
imgs.append(np.rot90(imgdata[:, j, :], rot))
elif axis == 2:
imgs.append(np.rot90(imgdata[:, :, j], rot))
return np.asarray(imgs), [resx, resy]
def read_img(filename, data, benchmark, start, output_dir):
start_time = time() - start
# load binary data into Nibabel
fh = nib.FileHolder(fileobj=BytesIO(data))
im = nib.Nifti1Image.from_file_map({'header': fh, 'image': fh})
data = im.get_data()
end_time = time() - start
bn = os.path.basename(filename)
if benchmark:
write_bench('read_img', start_time, end_time, socket.gethostname(),
output_dir, bn)
return (filename, data, (im.affine, im.header))
def save_segmented(d, assignments, out):
# read data into nibabel
fh = nib.FileHolder(fileobj=BytesIO(d[1]))
im = nib.Nifti1Image.from_file_map({'header': fh, 'image': fh})
data = im.get_data()
assigned_class = [c[0] for c in assignments]
for i in range(0, len(assignments)):
assigned_voxels = list(set(assignments[i][1]))
data[np.where(np.isin(data, assigned_voxels))] = assigned_class[i]
im_seg = nib.Nifti1Image(data, im.affine)
# save segmented image
output_file = op.join(out, 'seg-' + op.basename(d[0]))
nib.save(im_seg, output_file)
return (output_file, "SAVED")
def read_img(filename, data, benchmark, start, bench_dir=None):
"""Convert image in-memory binary data into Numpy array.
For in-memory Spark only.
Keyword arguments:
filename -- filename for which data belongs to
data -- binary image data
benchmark -- boolean value that specifies whether to benchmark the task
start -- start time of the driver (in seconds)
benchmark_dir -- benchmark directory required if benchmarking is requested.
(default None)
Returns: Tuple containing image data and metadata
"""
start_time = time() - start
print('Reading image')
# load binary data into Nibabel
if data is not None:
fh = nib.FileHolder(fileobj=BytesIO(data))
im = nib.Nifti1Image.from_file_map({'header': fh, 'image': fh})
else:
im = nib.load(filename)
data = np.asanyarray(im.dataobj)
end_time = time() - start
bn = os.path.basename(filename)
bench_file = None
if benchmark:
bench_file = write_bench('load_img',
start_time,
end_time,
bn,
os.getpid(),
benchmark_dir=bench_dir)
return (os.getpid(), filename, im, bench_file)
def read_img(filename, start, args):
"""Read a Nifti image as a byte stream.
Parameters
----------
filename: str
Representation of the path for the input file.
Returns
-------
filename : str
Representation of the path for the input file.
data : np.array
Data of the nifti imaeg read.
(img.affine, img.header) : (np.array, np.array)
Affine and header of the nifti image read.
"""
start_time = time() - start
img = None
with open(filename, "rb") as f_in:
fh = nib.FileHolder(fileobj=BytesIO(f_in.read()))
img = nib.Nifti1Image.from_file_map({"header": fh, "image": fh})
data = img.get_fdata(caching="unchanged")
data = nib.casting.float_to_int(data, np.int16)
end_time = time() - start
if args.benchmark:
benchmark(
start_time,
end_time,
filename,
args.output_dir,
args.experiment,
read_img.__name__,
)
return filename, data, (img.affine, img.header)
def load_nifti(self, base64str, is_zipped):
"""
Load base64 encoded string read from uploaded file upload into array.
Also crops and flips the resulting image.
:param str base64str: base64 encoded string (i.e. the uploaded file)
:param boolean is_zipped: if the file is zipped (i.e. if the uploaded file name ends with '.gz')
:return: the nifti image as numpy array:
<li> 1. dimension: image row
<li> 2. dimension: image column
<li> 3. dimension: image depth
<li> 4. dimension: color channels (should be 1, because of monochrome gray scan)
:rtype: numpy.ndarray
"""
# x: sag
# y: cor
# z: axi
x_range_from = 10
x_range_to = 110
y_range_from = 13
y_range_to = 133
z_range_from = 5
z_range_to = 105
if debug: print('Called load_nifti().')
img_arr = np.zeros(
(z_range_to - z_range_from, x_range_to - x_range_from,
y_range_to - y_range_from, 1),
dtype=np.float32) # z×x×y×1; avoid 64bit types
base64_bytes = base64str.encode("ascii")
raw_bytes = base64.b64decode(base64_bytes)
if is_zipped:
if debug: print("Unzipping...")
nifti_bytes = gzip.decompress(raw_bytes)
else:
if debug: print("Not unzipping...")
nifti_bytes = raw_bytes
inputstream = BytesIO(nifti_bytes)
file_holder = nib.FileHolder(fileobj=inputstream)
img = nib.Nifti1Image.from_file_map({
'header': file_holder,
'image': file_holder
})
assert (img.shape == (121, 145, 121))
if debug:
print("original img.shape:")
print(img.shape)
img = img.get_fdata()[x_range_from:x_range_to, y_range_from:y_range_to,
z_range_from:z_range_to]
inputstream.close()
img = np.transpose(
img, (2, 0, 1)
) # reorder dimensions to match coronal view z*x*y in MRIcron etc.
img = np.flip(img) # flip all positions
if debug:
print("cropped img.shape: ")
print(img.shape)
img_arr[:, :, :, 0] = np.nan_to_num(
img) # orientation: axial,sagittal,coronal,colorchannel
print("Successfully loaded uploaded nifti.")
self.uploaded_bg_img = img_arr
return img_arr
import os
from gzip import GzipFile
import django
import nibabel as nb
import neurovault.apps.statmaps.utils as nvutils
from neurovault.apps.statmaps.models import StatisticMap, BaseStatisticMap
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "neurovault.settings")
django.setup()
for image in StatisticMap.objects.filter(map_type=BaseStatisticMap.OTHER):
image.file.open()
gzfileobj = GzipFile(filename=image.file.name,
mode='rb',
fileobj=image.file.file)
nii = nb.Nifti1Image.from_file_map(
{'image': nb.FileHolder(image.file.name, gzfileobj)})
map_type = nvutils.infer_map_type(nii)
if map_type != BaseStatisticMap.OTHER:
print "changed type of %s to %s" % (image.get_absolute_url(), map_type)
image.map_type = map_type
image.save()
image.file.close()
def get_data(x):
fh = nib.FileHolder(fileobj=GzipFile(fileobj=BytesIO(x[1])))
im = nib.Nifti1Image.from_file_map({'header': fh, 'image': fh})
return (x[0], (im.affine, im.get_data()))
def generate_surface_image(image_pk):
from neurovault.apps.statmaps.models import Image
from scipy.io import loadmat
from scipy.interpolate import interpn
img = Image.objects.get(pk=image_pk)
if img.target_template_image in ['GenericMNI', 'MNI152NLin2009cAsym'] and \
img.data_origin == 'volume':
img_vol = nib.load(img.file.path)
data_vol = img_vol.get_data()
if data_vol.ndim > 3:
data_vol = data_vol[:, :, :, 0] #number of time points
this_path = os.path.abspath(os.path.dirname(__file__))
for hemi in ['lh', 'rh']:
ras_coor = loadmat(
os.path.abspath(
os.path.join(
this_path, "static", "anatomical",
"%s.avgMapping_allSub_RF_ANTs_MNI2fs.mat" %
hemi)))['ras']
vox_coor = nib.affines.apply_affine(
numpy.linalg.inv(img_vol.affine), ras_coor.T).T
img_surf = nib.gifti.GiftiImage()
if img.polymorphic_ctype.model == 'atlas' or (hasattr(
img, 'map_type') and img.map_type in ['Pa', 'R']):
method = 'nearest'
else:
method = 'linear'
data_surf = interpn(points=[
range(data_vol.shape[0]),
range(data_vol.shape[1]),
range(data_vol.shape[2])
],
values=data_vol,
xi=vox_coor.T,
method=method,
bounds_error=False,
fill_value=0)
# without turning nan's to zeros Connectome Workbench behaves weird
data_surf[numpy.isnan(data_surf)] = 0
# ASCII is the only encoding that produces outputs compatible with Connectome Workbench
data_surf_gifti = nib.gifti.GiftiDataArray(data_surf,
'NIFTI_INTENT_NONE',
'NIFTI_TYPE_FLOAT32',
'ASCII')
img_surf.add_gifti_data_array(data_surf_gifti)
img_surf.meta.data.insert(
0,
nib.gifti.GiftiNVPairs('AnatomicalStructurePrimary', {
'lh': 'CortexLeft',
'rh': 'CortexRight'
}[hemi]))
f = BytesIO()
fmap = {
'image': nib.FileHolder(fileobj=f),
'header': nib.FileHolder(fileobj=f)
}
img_surf.to_file_map(fmap)
f.seek(0)
content_file = ContentFile(f.read())
if hemi == 'lh':
img.surface_left_file.save(
"%s.%s.func.gii" % (img.pk, {
'lh': 'L',
'rh': 'R'
}[hemi]), content_file)
else:
img.surface_right_file.save(
"%s.%s.func.gii" % (img.pk, {
'lh': 'L',
'rh': 'R'
}[hemi]), content_file)
img.save()
print("Surface image generation done.")
def clean_and_validate(self, cleaned_data):
file = cleaned_data.get('file')
if file:
# check extension of the data file
_, fname, ext = split_filename(file.name)
if not ext.lower() in [".nii.gz", ".nii", ".img"]:
self._errors["file"] = self.error_class(
["Doesn't have proper extension"])
del cleaned_data["file"]
return cleaned_data
# prepare file to loading into memory
file.open()
fileobj = file.file
if file.name.lower().endswith(".gz"):
fileobj = GzipFile(filename=file.name,
mode='rb',
fileobj=fileobj)
file_map = {'image': nb.FileHolder(file.name, fileobj)}
try:
tmp_dir = tempfile.mkdtemp()
if ext.lower() == ".img":
hdr_file = cleaned_data.get('hdr_file')
if hdr_file:
# check extension of the hdr file
_, _, hdr_ext = split_filename(hdr_file.name)
if not hdr_ext.lower() in [".hdr"]:
self._errors["hdr_file"] = self.error_class(
["Doesn't have proper extension"])
del cleaned_data["hdr_file"]
return cleaned_data
else:
hdr_file.open()
file_map["header"] = nb.FileHolder(
hdr_file.name, hdr_file.file)
else:
self._errors["hdr_file"] = self.error_class(
[".img file requires .hdr file"])
del cleaned_data["hdr_file"]
return cleaned_data
# check if it is really nifti
try:
print file_map
if "header" in file_map:
nii = nb.Nifti1Pair.from_file_map(file_map)
else:
nii = nb.Nifti1Image.from_file_map(file_map)
except Exception as e:
raise
# detect AFNI 4D files and prepare 3D slices
if nii is not None and detect_4D(nii):
self.afni_subbricks = split_4D_to_3D(nii, tmp_dir=tmp_dir)
else:
squeezable_dimensions = len(
filter(lambda a: a not in [0, 1], nii.shape))
if squeezable_dimensions != 3:
self._errors["file"] = self.error_class([
"4D files are not supported.\n "
"If it's multiple maps in one "
"file please split them and "
"upload separately"
])
del cleaned_data["file"]
return cleaned_data
# convert to nii.gz if needed
if (ext.lower() != ".nii.gz"
or squeezable_dimensions < len(nii.shape)):
# convert pseudo 4D to 3D
if squeezable_dimensions < len(nii.shape):
new_data = np.squeeze(nii.get_data())
nii = nb.Nifti1Image(new_data, nii.get_affine(),
nii.get_header())
# Papaya does not handle float64, but by converting
# files we loose precision
# if nii.get_data_dtype() == np.float64:
# ii.set_data_dtype(np.float32)
new_name = fname + ".nii.gz"
nii_tmp = os.path.join(tmp_dir, new_name)
nb.save(nii, nii_tmp)
print "updating file in cleaned_data"
cleaned_data['file'] = memory_uploadfile(
nii_tmp, new_name, cleaned_data['file'])
finally:
try:
if self.afni_subbricks:
# keep temp dir for AFNI slicing
self.afni_tmp = tmp_dir
else:
print "removing %s" % tmp_dir
shutil.rmtree(tmp_dir)
except OSError as exc:
if exc.errno != 2: # code 2 - no such file or directory
raise # re-raise exception
elif not getattr(self, 'partial', False):
# Skip validation error if this is a partial update from the API
raise ValidationError("Couldn't read uploaded file")
return cleaned_data
_, fname, ext = split_filename(file.name)
if not ext.lower() in [".nii.gz", ".nii", ".img"]:
self._errors["file"] = self.error_class(
["Doesn't have proper extension"]
)
del cleaned_data["file"]
return cleaned_data
# prepare file to loading into memory
file.open()
fileobj = file.file
if file.name.lower().endswith(".gz"):
fileobj = GzipFile(filename=file.name, mode='rb',
fileobj=fileobj)
file_map = {'image': nb.FileHolder(file.name, fileobj)}
try:
tmp_dir = tempfile.mkdtemp()
if ext.lower() == ".img":
hdr_file = cleaned_data.get('hdr_file')
if hdr_file:
# check extension of the hdr file
_, _, hdr_ext = split_filename(hdr_file.name)
if not hdr_ext.lower() in [".hdr"]:
self._errors["hdr_file"] = self.error_class(
["Doesn't have proper extension"])
del cleaned_data["hdr_file"]
return cleaned_data
else:
hdr_file.open()
file_map["header"] = nb.FileHolder(hdr_file.name,
