def test_labels1(): img = load_image(funcfile) parcelmap = fromarray(np.asarray(img[0]), 'kji', 'zyx') parcelmap = (np.asarray(parcelmap) * 100).astype(np.int32) v = 0 for i, d in fmri_generator(img, parcels(parcelmap)): v += d.shape[1] assert_equal(v, parcelmap.size)
def aniso2iso(self, image, spacing, dimensions): ''' from dipy.align.aniso2iso ''' header = image.header oldspacing = header.get_zooms() olddimensions = image.shape[:3] if spacing == 'no': newspacing = (min(oldspacing), min(oldspacing), min(oldspacing)) else: newspacing = (float(spacing.split(',')[0]), float(spacing.split(',')[1]), float(spacing.split(',')[2])) if dimensions == 'no': newdimensions = olddimensions else: newdimensions = (int(dimensions.split(',')[0]), int(dimensions.split(',')[1]), int(dimensions.split(',')[2])) c.info('Resampling the master image..') c.info(' old spacing ' + str(oldspacing)) c.info(' old dimensions ' + str(olddimensions)) # work on a numpy array to resample to isotropic spacing R = numpy.diag(numpy.array(newspacing) / numpy.array(oldspacing)) new_shape = numpy.array(oldspacing) / numpy.array( newspacing) * numpy.array(newdimensions) new_shape = numpy.round(new_shape).astype('i8') newImage = affine_transform(input=image, matrix=R, offset=numpy.zeros(3, ), output_shape=tuple(new_shape), order=0) Rx = numpy.eye(4) Rx[:3, :3] = R # get the mew world-image matrix affine = numpy.dot(image.coordmap.affine, Rx) # convert to NiPy image # copy the old coordmap and replace the affine matrix newCoordMap = image.coordmap newCoordMap.affine = affine # create a new NiPy image with the resampled data and the new coordmap (including the affine matrix) nipyImage = fromarray(newImage, '', '', newCoordMap) c.info(' new spacing ' + str(newspacing)) c.info(' new dimensions ' + str(nipyImage.shape[:3])) return nipyImage
def uint8_to_dtype(dtype, name): dtype = dtype shape = (2,3,4) dmax = np.iinfo(np.uint8).max data = np.random.randint(0, dmax, size=shape) data[0,0,0] = 0 data[1,0,0] = dmax data = data.astype(np.uint8) # randint returns np.int32 img = fromarray(data, 'kji', 'zxy') newimg = save_image(img, name, dtype=dtype) return newimg.get_data(), data
def test_slicing_returns_image(): data = np.ones((2,3,4)) img = fromarray(data, 'kji', 'zyx') assert isinstance(img, Image) assert img.ndim == 3 # 2D slice img2D = img[:,:,0] assert isinstance(img2D, Image) assert img2D.ndim == 2 # 1D slice img1D = img[:,0,0] assert isinstance(img1D, Image) assert img1D.ndim == 1
def float32_to_dtype(dtype, name): # Utility function for the scaling_float32 function dtype = dtype shape = (2,3,4) # set some value value for scaling our data scale = np.iinfo(np.uint16).max * 2.0 data = np.random.normal(size=(2,3,4), scale=scale) data[0,0,0] = np.finfo(np.float32).max data[1,0,0] = np.finfo(np.float32).min # random.normal will return data as native machine type data = data.astype(np.float32) img = fromarray(data, 'kji', 'zyx') newimg = save_image(img, name, dtype=dtype) return newimg.get_data(), data
def test_roundtrip_fromarray(): data = np.random.rand(10,20,30) img = fromarray(data, 'kji', 'xyz') with InTemporaryDirectory(): save_image(img, 'img.nii.gz') img2 = load_image('img.nii.gz') data2 = img2.get_data() # verify data assert_almost_equal(data2, data) assert_almost_equal(data2.mean(), data.mean()) assert_almost_equal(data2.min(), data.min()) assert_almost_equal(data2.max(), data.max()) # verify shape and ndims assert_equal(img2.shape, img.shape) assert_equal(img2.ndim, img.ndim) # verify affine assert_almost_equal(img2.affine, img.affine)
def test_roundtrip_fromarray(): data = np.random.rand(10,20,30) img = fromarray(data, 'kji', 'xyz') fd, name = mkstemp(suffix='.nii.gz') tmpfile = open(name) save_image(img, tmpfile.name) img2 = load_image(tmpfile.name) data2 = np.asarray(img2) tmpfile.close() os.unlink(name) # verify data yield assert_true, np.allclose(data2, data) yield assert_true, np.allclose(data2.mean(), data.mean()) yield assert_true, np.allclose(data2.min(), data.min()) yield assert_true, np.allclose(data2.max(), data.max()) # verify shape and ndims yield assert_equal, img2.shape, img.shape yield assert_equal, img2.ndim, img.ndim # verify affine yield assert_true, np.allclose(img2.affine, img.affine)
from nipy.core.image import image from nipy.core.api import Image, fromarray, merge_images, is_image from nipy.core.api import parcels, data_generator, write_data from nipy.core.reference.coordinate_map import Affine from nipy.io.api import load_image def setup(): # Suppress warnings during tests to reduce noise warnings.simplefilter("ignore") def teardown(): # Clear list of warning filters warnings.resetwarnings() _data = np.arange(24).reshape((4,3,2)) gimg = fromarray(_data, 'ijk', 'xyz') def test_init(): new = Image(np.asarray(gimg), gimg.coordmap) yield assert_array_almost_equal, np.asarray(gimg), np.asarray(new) yield assert_raises, ValueError, Image, None, None def test_maxmin_values(): y = np.asarray(gimg) yield assert_equal, y.shape, tuple(gimg.shape) yield assert_equal, y.max(), 23 yield assert_equal, y.min(), 0.0
# Specify the axis order of the input coordinates input_coords = ['k', 'j', 'i'] output_coords = ['z','y','x'] #or innames = ('kji') outnames = ('zyx') # either way works # Build a CoordinateMap to create the image with affine_coordmap = Affine.from_params(innames, outnames, affine_array) # 2) Create a nipy image from the array and CoordinateMap # Create new image newimg = fromarray(arr, innames=innames, outnames=outnames, coordmap=affine_coordmap) ################################################################################ # END HERE, for testing purposes only. ################################################################################ # Imports used just for development and testing. Users typically # would not uses these when creating an image. from tempfile import mkstemp from nipy.testing import assert_equal # We use a temporary file for this example so as to not create junk # files in the nipy directory. fd, name = mkstemp(suffix='.nii.gz') tmpfile = open(name) # Save the nipy image to the specified filename
"""This example shows how to create a temporary image to use during processing. The array is filled with zeros. """ import numpy as np from nipy.core.api import fromarray, save_image # create an array of zeros, the shape of your data array zero_array = np.zeros((91,109,91)) # create an image from our array img = fromarray(zero_array) # save the image to a file newimg = save_image(img, 'tempimage.nii.gz') # Example of creating a temporary image file from an existing image # with a matching comap. # from nipy.core.api import load_image # img = load_image('foo.nii.gz') # zeroarray = np.zeros(img.comap.shape) # zeroimg = fromarray(zeroarray, comap=img.comap) # newimg = save_image(zeroimg, 'tempimage.nii.gz')