def auto_crop(image, ): """Loads data. """ nifti_img = nib.Nifti1Image(image, affine=np.eye(4)) image_croped = nil_image.crop_img(nifti_img) volume = image_croped.get_data() return volume
def crop(img, ZOOM='N'): img = crop_img(img) # crop it img = img.get_data()[:, :, :, 0] # make it array # This is only to make the code exectuable on local machine. if ZOOM == 'Y': img = ndimage.zoom(img, 0.25, order=1, mode='reflect', prefilter=False) logging.info('Downsampling ON') else: pass return img
def crop_blackspace(ffVOL, ffOUT): """ Crop blackspace in MRI volume. Will retain 1 voxel grid of zeros before the nonzero part. Will write output at ffOUT. Parameters ---------- ffVOL: str ffOUT: str Returns ------- None """ img = ni.load_img(ffVOL) img = ni.crop_img(img, copy=True) img.to_filename(ffOUT)
def crop_nifti(input_img, ref_img): """ :param input_img: :param crop_sagittal: :param crop_coronal: :param crop_axial: :return: """ import nibabel as nib import os import numpy as np from nilearn.image import resample_img, crop_img, resample_to_img from nibabel.spatialimages import SpatialImage basedir = os.getcwd() crop_ref = crop_img(ref_img, rtol=0.5) crop_ref.to_filename( os.path.join( basedir, os.path.basename(input_img).split('.nii')[0] + '_cropped_template.nii.gz')) crop_template = os.path.join( basedir, os.path.basename(input_img).split('.nii')[0] + '_cropped_template.nii.gz') ## resample the individual MRI onto the cropped template image crop_img = resample_to_img(input_img, crop_template) crop_img.to_filename( os.path.join( basedir, os.path.basename(input_img).split('.nii')[0] + '_cropped.nii.gz')) output_img = os.path.join( basedir, os.path.basename(input_img).split('.nii')[0] + '_cropped.nii.gz') return output_img, crop_template
def test_cropping_code_paths(): # Will mask data with an identically sampled mask and # with a smaller mask. The results must be identical rng = np.random.RandomState(42) data = np.zeros([20, 30, 40, 5]) data[10:15, 5:20, 10:30, :] = 1. + rng.rand(5, 15, 20, 5) affine = np.eye(4) img = nibabel.Nifti1Image(data, affine=affine) mask = (data[..., 0] > 0).astype(int) mask_img = nibabel.Nifti1Image(mask, affine=affine) # the mask in mask_img has the same shape and affine as the # data and should thus avoid resampling # we now crop the mask to its non-zero part. Masking with this # mask must yield the same result cropped_mask_img = image.crop_img(mask_img) parameters = {"smoothing_fwhm": None, "high_pass": None, "low_pass": None, "t_r": None, "detrend": None, "standardize": None } # Now do the two maskings out_data_uncropped, affine_uncropped = filter_and_mask(img, mask_img, parameters) out_data_cropped, affine_cropped = filter_and_mask(img, cropped_mask_img, parameters) assert_array_almost_equal(out_data_cropped, out_data_uncropped)
def test_cropping_code_paths(): # Will mask data with an identically sampled mask and # with a smaller mask. The results must be identical rng = np.random.RandomState(42) data = np.zeros([20, 30, 40, 5]) data[10:15, 5:20, 10:30, :] = 1. + rng.rand(5, 15, 20, 5) affine = np.eye(4) img = nibabel.Nifti1Image(data, affine=affine) mask = (data[..., 0] > 0).astype(int) mask_img = nibabel.Nifti1Image(mask, affine=affine) # the mask in mask_img has the same shape and affine as the # data and should thus avoid resampling # we now crop the mask to its non-zero part. Masking with this # mask must yield the same result cropped_mask_img = image.crop_img(mask_img) parameters = { "smoothing_fwhm": None, "high_pass": None, "low_pass": None, "t_r": None, "detrend": None, "standardize": None } # Now do the two maskings out_data_uncropped, affine_uncropped = filter_and_mask( img, mask_img, parameters) out_data_cropped, affine_cropped = filter_and_mask(img, cropped_mask_img, parameters) assert_array_almost_equal(out_data_cropped, out_data_uncropped)
a minimum and compresses the files with a high enough compression level. This all to reduce the disk size and control the load time (driven by the level of compression). """ import nibabel as nb from glob import glob from nilearn.image import crop_img # Get the list of atlases atlases = sorted(glob('atlases/atlas_*nii.gz')) for fname in atlases: # Load atlas and crop image img = crop_img(fname) # Get data array data = img.get_fdata() # Decide which datatype to use if data.max() <= 255 and data.min() >= 0: dtype = '>u1' elif data.max() <= 65535 and data.min() >= 0: dtype = '>u2' else: dtype = 'i2' # Create a new image with the correct datatype img.set_data_dtype(dtype) new_img = nb.Nifti1Image(data.astype(dtype),
def NIFTI_to_PNG(path_list, dir): """ :param LOS path_list: the list of paths to NIFTI images :param string dir: a specified path to create directory NIFTI_to_PNG: creates a directory to save NIFTI images as png files If the directory already exists, then that part is skipped. Each NIFITI image is augmented in 3 different ways and the 3 resulting images are saved. This is done to increase the size of the small sample of available NIFTI images """ ## Create location for NIFTI images to be saved try: os.makedirs(dir) except OSError: print("error: directory already exists") #augment the images and save them as pngs count = 0 # a count of the files saved so far for path in gm_img_paths: #first augmentation -- color fig = plt.figure(figsize=(5, 7), facecolor='k') img_crop_1 = image.crop_img(path, rtol=1e-0001, copy=True) display = plotting.plot_img(img_crop_1, display_mode='z', cut_coords=[23], annotate=False, figure=fig) fig.savefig(dir + '\\' + 'brain' + str(count + 1) + '.png') count += 1 plt.close(fig) # second augmentation -- added countours to color fig = plt.figure(figsize=(5, 7), facecolor='k') img_crop_2 = image.crop_img(path, rtol=1e-0001, copy=True) display_2 = plotting.plot_anat(img_crop_2, display_mode='z', cut_coords=[23], annotate=False, figure=fig) display_2.add_contours(img_crop_2, contours=1, antialiased=False, linewidths=1., levels=[0], colors=['red']) display_2.add_contours(img_crop_2, contours=1, antialiased=False, linewidths=1., levels=[.3], colors=['blue']) display_2.add_contours(img_crop_2, contours=1, antialiased=False, linewidths=1., levels=[.5], colors=['limegreen']) fig.savefig(dir + '\\' + 'brain' + str(count + 1) + '.png') count += 1 plt.close(fig) #third augmentation -- gray scale fig = plt.figure(figsize=(5, 7), facecolor='k') img_crop_3 = image.crop_img(path, rtol=1e-0001, copy=True) display_3 = plotting.plot_anat(img_crop_3, display_mode='z', cut_coords=[23], annotate=False, figure=fig) fig.savefig(dir + '\\' + 'brain' + str(count + 1) + '.png') count += 1 plt.close(fig)
from nilearn.image import crop_img import numpy as np from ecoggui import ElectrodeGUI fname = 'T1_post_deface.nii.gz' niimg = crop_img(fname) # to automatically zoom on useful voxels # We know we have a 8x8 grid of ecog channels, separated by 10 mm. xy = np.meshgrid(range(0, 80, 10), range(0, 80, 10)) xy = np.transpose([ii.ravel() for ii in xy]) # Click on the grid to select the electrode and press spacebar to add it. gui = ElectrodeGUI(niimg=niimg, xy=xy) # Show electrode manually identified positions print(gui.ch_user) # Show electrodes predictions print(gui.ch_pred)