def _run_interface(self, runtime): img = nb.load(self.inputs.in_file[0], mmap=NUMPY_MMAP) header = img.header.copy() vollist = [nb.load(filename, mmap=NUMPY_MMAP) for filename in self.inputs.in_file] data = np.concatenate([vol.get_data().reshape( vol.shape[:3] + (-1,)) for vol in vollist], axis=3) data = np.nan_to_num(data) if data.dtype.kind == 'i': header.set_data_dtype(np.float32) data = data.astype(np.float32) if isdefined(self.inputs.regress_poly): data = regress_poly(self.inputs.regress_poly, data, remove_mean=False)[0] img = nb.Nifti1Image(data, img.affine, header) nb.save(img, op.abspath(self.inputs.detrended_file)) meanimg = np.mean(data, axis=3) stddevimg = np.std(data, axis=3) tsnr = np.zeros_like(meanimg) tsnr[stddevimg > 1.e-3] = meanimg[stddevimg > 1.e-3] / stddevimg[stddevimg > 1.e-3] img = nb.Nifti1Image(tsnr, img.affine, header) nb.save(img, op.abspath(self.inputs.tsnr_file)) img = nb.Nifti1Image(meanimg, img.affine, header) nb.save(img, op.abspath(self.inputs.mean_file)) img = nb.Nifti1Image(stddevimg, img.affine, header) nb.save(img, op.abspath(self.inputs.stddev_file)) return runtime
def _run_interface(self, runtime): from dipy.reconst import dti from dipy.io.utils import nifti1_symmat gtab = self._get_gradient_table() img = nb.load(self.inputs.in_file) data = img.get_data() affine = img.affine mask = None if isdefined(self.inputs.mask_file): mask = nb.load(self.inputs.mask_file).get_data() # Fit it tenmodel = dti.TensorModel(gtab) ten_fit = tenmodel.fit(data, mask) lower_triangular = ten_fit.lower_triangular() img = nifti1_symmat(lower_triangular, affine) out_file = self._gen_filename('dti') nb.save(img, out_file) IFLOGGER.info('DTI parameters image saved as {i}'.format(i=out_file)) #FA MD RD and AD for metric in ["fa", "md", "rd", "ad"]: data = getattr(ten_fit,metric).astype("float32") out_name = self._gen_filename(metric) nb.Nifti1Image(data, affine).to_filename(out_name) IFLOGGER.info('DTI {metric} image saved as {i}'.format(i=out_name, metric=metric)) return runtime
def intersect_masks(input_masks, output_filename=None, threshold=0.5, cc=True): """ Given a list of input mask images, generate the output image which is the the threshold-level intersection of the inputs Parameters ---------- input_masks: list of strings or ndarrays paths of the input images nsubj set as len(input_mask_files), or individual masks. output_filename, string: Path of the output image, if None no file is saved. threshold: float within [0, 1[, optional gives the level of the intersection. threshold=1 corresponds to keeping the intersection of all masks, whereas threshold=0 is the union of all masks. cc: bool, optional If true, extract the main connected component Returns ------- grp_mask, boolean array of shape the image shape """ grp_mask = None if threshold > 1: raise ValueError('The threshold should be < 1') if threshold <0: raise ValueError('The threshold should be > 0') threshold = min(threshold, 1 - 1.e-7) for this_mask in input_masks: if isinstance(this_mask, basestring): # We have a filename this_mask = load(this_mask).get_data() if grp_mask is None: grp_mask = this_mask.copy().astype(np.int) else: grp_mask += this_mask grp_mask = grp_mask > (threshold * len(list(input_masks))) if np.any(grp_mask > 0) and cc: grp_mask = largest_cc(grp_mask) if output_filename is not None: if isinstance(input_masks[0], basestring): nim = load(input_masks[0]) header = nim.get_header() affine = nim.get_affine() else: header = dict() affine = np.eye(4) header['descrip'] = 'mask image' output_image = nifti1.Nifti1Image(grp_mask.astype(np.uint8), affine=affine, header=header, ) save(output_image, output_filename) return grp_mask > 0
def tensor_fitting(data, bvals, bvecs, mask_file=None): """ Use dipy to fit DTI Parameters ---------- in_file : str Full path to a DWI data file. bvals : str Full path to a file containing gradient magnitude information (b-values). bvecs : str Full path to a file containing gradient direction information (b-vectors). mask_file : str, optional Full path to a file containing a binary mask. Defaults to use the entire volume. Returns ------- TensorFit object, affine """ img = nb.load(in_file).get_data() data = img.get_data() affine = img.get_affine() if mask_file is not None: mask = nb.load(self.inputs.mask_file).get_data() else: mask = None # Load information about the gradients: gtab = grad.gradient_table(self.inputs.bvals, self.inputs.bvecs) # Fit it tenmodel = dti.TensorModel(gtab) return tenmodel.fit(data, mask), affine
def extract_subrois(timeseries_file, label_file, indices): """Extract voxel time courses for each subcortical roi index Parameters ---------- timeseries_file: a 4D Nifti file label_file: a 3D file containing rois in the same space/size of the 4D file indices: a list of indices for ROIs to extract. Returns ------- out_file: a text file containing time courses for each voxel of each roi The first four columns are: freesurfer index, i, j, k positions in the label file """ img = nb.load(timeseries_file) data = img.get_data() roiimg = nb.load(label_file) rois = roiimg.get_data() prefix = split_filename(timeseries_file)[1] out_ts_file = os.path.join(os.getcwd(), '%s_subcortical_ts.txt' % prefix) with open(out_ts_file, 'wt') as fp: for fsindex in indices: ijk = np.nonzero(rois == fsindex) ts = data[ijk] for i0, row in enumerate(ts): fp.write('%d,%d,%d,%d,' % (fsindex, ijk[0][i0], ijk[1][i0], ijk[2][i0]) + ','.join(['%.10f' % val for val in row]) + '\n') return out_ts_file
def cutBrains(paths_to_nii, file_selector=None): ''' Takes the path to all of the .nii files that we want to put in the final dataset ''' good_slices = [] im_dims = None for path_to_nii in paths_to_nii: print("For directory %s ..."%(path_to_nii)) all_in_dir = listdir(path_to_nii) niis = [f for f in all_in_dir if isfile(join(path_to_nii, f)) and f[-4:] == '.nii'] if file_selector: niis = [nii for nii in niis if re.search(file_selector, nii)] if im_dims == None: ## take the first nii as an example (assumes all same shape) img = nibabel.load(join(path_to_nii, niis[0])) data = img.get_data() im_dims = data.shape[1:] ## take last two dims as images we'll want for i, nii in enumerate(niis): print("Processing brain %d of %d"%(i+1,len(niis))) img = nibabel.load(join(path_to_nii, nii)) data = img.get_data() if data.shape[1:] != im_dims: print("Skipping this brain due to inconsistent size") continue ## chose to slice at the middle of the x dimension cut_loc = data.shape[0] / 2 cut = data[cut_loc, :, :] ## convert memmap to array and drop it into the list with label ## and normalize cut = np.array(cut) cut /= np.max(cut) good_slices.append((cut, getLabel(path_to_nii))) X_dims = (len(good_slices), im_dims[0], im_dims[1]) y_dims = (len(good_slices), 1) X = np.zeros(X_dims, dtype='float32') y = np.zeros(y_dims, dtype='uint8') ## shuffle all the examples so we can get a good number of each in the test set shuffle(good_slices) for i, (sl, label) in enumerate(good_slices): X[i, :, :] = sl y[i] = label with open(join(path_to_nii, 'ADNI_X_normcuts_big'), 'w+') as X_file: pickle.dump(X, X_file) with open(join(path_to_nii, 'ADNI_y_normcuts_big'), 'w+') as y_file: pickle.dump(y, y_file)
def _run_interface(self, runtime): from dipy.reconst import dki from dipy.io.utils import nifti1_symmat gtab = self._get_gradient_table() img = nb.load(self.inputs.in_file) data = img.get_data() affine = img.affine mask = None if isdefined(self.inputs.mask_file): mask = nb.load(self.inputs.mask_file).get_data() # Fit the DKI model kurtosis_model = dki.DiffusionKurtosisModel(gtab) kurtosis_fit = kurtosis_model.fit(data, mask) lower_triangular = kurtosis_fit.lower_triangular() img = nifti1_symmat(lower_triangular, affine) out_file = self._gen_filename('dki') nb.save(img, out_file) IFLOGGER.info('DKI parameters image saved as {i}.format(i=out_file)') # FA, MD, RD, and AD for metric in ['fa', 'md', 'rd', 'ad', 'mk', 'ak', 'rk']: data = getattr(kurtosis_fit.metric).astype('float32') out_name = self._gen_filename(metric) nb.Nifti1Image(data, affine).to_filename(out_name) IFLOGGER.info('DKI {metric} image saved as {i}'.format(i=out_name, metric=metric)) return runtime
def test_high_level_glm_with_data(): shapes, rk = ((7, 6, 5, 20), (7, 6, 5, 19)), 3 mask, fmri_data, design_matrices = write_fake_fmri_data(shapes, rk) # without mask multi_session_model = FMRILinearModel(fmri_data, design_matrices, mask=None) multi_session_model.fit() z_image, = multi_session_model.contrast([np.eye(rk)[1]] * 2) assert_equal(np.sum(z_image.get_data() == 0), 0) # compute the mask multi_session_model = FMRILinearModel(fmri_data, design_matrices, m=0, M=.01, threshold=0.) multi_session_model.fit() z_image, = multi_session_model.contrast([np.eye(rk)[1]] * 2) assert_true(z_image.get_data().std() < 3. ) # with mask multi_session_model = FMRILinearModel(fmri_data, design_matrices, mask) multi_session_model.fit() z_image, effect_image, variance_image= multi_session_model.contrast( [np.eye(rk)[:2]] * 2, output_effects=True, output_variance=True) assert_array_equal(z_image.get_data() == 0., load(mask).get_data() == 0.) assert_true( (variance_image.get_data()[load(mask).get_data() > 0, 0] > .001).all()) # without scaling multi_session_model.fit(do_scaling=False) z_image, = multi_session_model.contrast([np.eye(rk)[1]] * 2) assert_true(z_image.get_data().std() < 3. )
def get_mean_timeseries(infile,roi,mask): import os import nibabel as nib from nipype.utils.filemanip import fname_presuffix, split_filename import numpy as np img = nib.load(infile) data, aff = img.get_data(), img.get_affine() roi_img = nib.load(roi) roi_data, roi_affine = roi_img.get_data(), roi_img.get_affine() if len(roi_data.shape) > 3: roi_data = roi_data[:,:,:,0] mask = nib.load(mask).get_data() roi_data = (roi_data > 0).astype(int) + (mask>0).astype(int) _,roiname,_ = split_filename(roi) outfile = fname_presuffix(infile,"%s_"%roiname,'.txt',newpath=os.path.abspath('.'),use_ext=False) out_data = np.mean(data[roi_data>1,:],axis=0) print out_data.shape np.savetxt(outfile,out_data) return outfile, roiname
def plot_haxby(activation, title): z = 25 fig = plt.figure(figsize=(4, 5.4)) fig.subplots_adjust(bottom=0., top=1., left=0., right=1.) plt.axis('off') # pl.title('SVM vectors') plt.imshow(mean_img[:, 4:58, z].T, cmap=pl.cm.gray, interpolation='nearest', origin='lower') plt.imshow(activation[:, 4:58, z].T, cmap=pl.cm.hot, interpolation='nearest', origin='lower') mask_house = nib.load(h.mask_house[0]).get_data() mask_face = nib.load(h.mask_face[0]).get_data() plt.contour(mask_house[:, 4:58, z].astype(np.bool).T, contours=1, antialiased=False, linewidths=4., levels=[0], interpolation='nearest', colors=['blue'], origin='lower') plt.contour(mask_face[:, 4:58, z].astype(np.bool).T, contours=1, antialiased=False, linewidths=4., levels=[0], interpolation='nearest', colors=['limegreen'], origin='lower') p_h = Rectangle((0, 0), 1, 1, fc="blue") p_f = Rectangle((0, 0), 1, 1, fc="limegreen") plt.legend([p_h, p_f], ["house", "face"]) plt.title(title, x=.05, ha='left', y=.90, color='w', size=28)
def intersubjectconsensus(): """Compute inter-subjects clustering consensus. """ base_dir = r'/nfs/h1/workingshop/huanglijie/uni_mul_analysis' db_dir = os.path.join(base_dir, 'multivariate', 'detection', 'mvpcluster') n_clusters = 60 mask_file = os.path.join(base_dir, 'multivariate', 'detection', 'mask.nii.gz') mask = nib.load(mask_file).get_data() for n in range(1, n_clusters): n += 1 merged_file = os.path.join(db_dir, 'merged_cluster_'+str(n)+'.nii.gz') merged_data = nib.load(merged_file).get_data() n_subjs = merged_data.shape[3] mtx = np.zeros((n_subjs, n_subjs)) for i in range(n_subjs): for j in range(n_subjs): data_i = merged_data[..., i] data_j = merged_data[..., j] vtr_i = data_i[np.nonzero(mask)] vtr_j = data_j[np.nonzero(mask)] tmp = metrics.adjusted_mutual_info_score(vtr_i, vtr_j) mtx[i, j] = tmp outfile = os.path.join(db_dir, 'consensus_'+str(n)+'.csv') np.savetxt(outfile, mtx, delimiter=',')
def _run_interface(self, runtime): maskdata = nb.load(self.inputs.mask).get_data() maskdata = np.logical_not(np.logical_or(maskdata == 0, np.isnan(maskdata))) session_datas = [[nb.load(fname).get_data()[maskdata].reshape(-1, 1) for fname in sessions] for sessions in self.inputs.subjects_sessions] list_of_sessions = [np.dstack(session_data) for session_data in session_datas] all_data = np.hstack(list_of_sessions) icc = np.zeros(session_datas[0][0].shape) session_F = np.zeros(session_datas[0][0].shape) session_var = np.zeros(session_datas[0][0].shape) subject_var = np.zeros(session_datas[0][0].shape) for x in range(icc.shape[0]): Y = all_data[x, :, :] icc[x], subject_var[x], session_var[x], session_F[x], _, _ = ICC_rep_anova(Y) nim = nb.load(self.inputs.subjects_sessions[0][0]) new_data = np.zeros(nim.shape) new_data[maskdata] = icc.reshape(-1,) new_img = nb.Nifti1Image(new_data, nim.affine, nim.header) nb.save(new_img, 'icc_map.nii') new_data = np.zeros(nim.shape) new_data[maskdata] = session_var.reshape(-1,) new_img = nb.Nifti1Image(new_data, nim.affine, nim.header) nb.save(new_img, 'session_var_map.nii') new_data = np.zeros(nim.shape) new_data[maskdata] = subject_var.reshape(-1,) new_img = nb.Nifti1Image(new_data, nim.affine, nim.header) nb.save(new_img, 'subject_var_map.nii') return runtime
def mrtrix_spherical_functions(): """Spherical functions represented by spherical harmonic coefficients and evaluated on a discrete sphere. Returns ------- func_coef : array (2, 3, 4, 45) Functions represented by the coefficients associated with the mxtrix spherical harmonic basis of order 8. func_discrete : array (2, 3, 4, 81) Functions evaluated on `sphere`. sphere : Sphere The discrete sphere, points on the surface of a unit sphere, used to evaluate the functions. Notes ----- These coefficients were obtained by using the dwi2SH command of mrtrix. """ func_discrete = load(pjoin(THIS_DIR, "func_discrete.nii.gz")).get_data() func_coef = load(pjoin(THIS_DIR, "func_coef.nii.gz")).get_data() gradients = np.loadtxt(pjoin(THIS_DIR, "sphere_grad.txt")) # gradients[0] and the first volume of func_discrete, # func_discrete[..., 0], are associated with the b=0 signal. # gradients[:, 3] are the b-values for each gradient/volume. sphere = Sphere(xyz=gradients[1:, :3]) return func_coef, func_discrete[..., 1:], sphere
def enhance(in_file, clip_limit=0.010, in_mask=None, out_file=None): import numpy as np import nibabel as nb import os.path as op from skimage import exposure, img_as_int if out_file is None: fname, fext = op.splitext(op.basename(in_file)) if fext == '.gz': fname, _ = op.splitext(fname) out_file = op.abspath('./%s_enh.nii.gz' % fname) im = nb.load(in_file) imdata = im.get_data() imshape = im.get_shape() if in_mask is not None: msk = nb.load(in_mask).get_data() msk[msk > 0] = 1 msk[msk < 1] = 0 imdata = imdata * msk immin = imdata.min() imdata = (imdata - immin).astype(np.uint16) adapted = exposure.equalize_adapthist(imdata.reshape(imshape[0], -1), clip_limit=clip_limit) nb.Nifti1Image(adapted.reshape(imshape), im.get_affine(), im.get_header()).to_filename(out_file) return out_file
def slicerGifCompare(self, source1, source2, target, gifSpeed=100, vmax=None, boundaries=None): """Create a animated gif from a 4d NIfTI Args: source: 4D NIfTI image target: outputfile gif name gifSpeed: delay between images (tens of ms), default=30 """ gifId = self.__idGenerator() image1 = nibabel.load(source1) imageData1 = image1.get_data() image2 = nibabel.load(source2) imageData2 = image2.get_data() if vmax == None: vmax=numpy.percentile(imageData1, 99) imageList = [] for num, image in enumerate([imageData1, imageData2]): output = gifId + '{0:04}.png'.format(num) self.slicerPng(image[:,:,:,2], output, vmax=vmax, isData=True, boundaries=boundaries) imageList.append(output) self.__imageList2Gif(imageList, target, gifSpeed) #Cleaning temp files cmd = 'rm {}*.png'.format(gifId) self.launchCommand(cmd) return target
def demean_image(in_file, in_mask=None, out_file=None): """ Demean image data inside mask """ import numpy as np import nibabel as nb import os.path as op import math if out_file is None: fname, fext = op.splitext(op.basename(in_file)) if fext == '.gz': fname, _ = op.splitext(fname) out_file = op.abspath('./%s_demean.nii.gz' % fname) im = nb.load(in_file) data = im.get_data().astype(np.float32) msk = np.ones_like(data) if in_mask is not None: msk = nb.load(in_mask).get_data().astype(np.float32) msk[msk > 0] = 1.0 msk[msk < 1] = 0.0 mean = np.median(data[msk == 1].reshape(-1)) data[msk == 1] = data[msk == 1] - mean nb.Nifti1Image(data, im.get_affine(), im.get_header()).to_filename(out_file) return out_file
def reorient_bvecs(in_dwi, old_dwi, in_bvec): """ Checks reorientations of ``in_dwi`` w.r.t. ``old_dwi`` and reorients the in_bvec table accordingly. """ import os import numpy as np import nibabel as nb name, fext = os.path.splitext(os.path.basename(in_bvec)) if fext == '.gz': name, _ = os.path.splitext(name) out_file = os.path.abspath('%s_reorient.bvec' % name) bvecs = np.loadtxt(in_bvec).T new_bvecs = [] N = nb.load(in_dwi).get_affine() O = nb.load(old_dwi).get_affine() RS = N.dot(np.linalg.inv(O))[:3, :3] sc_idx = np.where((np.abs(RS) != 1) & (RS != 0)) S = np.ones_like(RS) S[sc_idx] = RS[sc_idx] R = RS/S new_bvecs = [R.dot(b) for b in bvecs] np.savetxt(out_file, np.array(new_bvecs).T, fmt='%0.15f') return out_file
def recompose_dwi(in_dwi, in_bval, in_corrected, out_file=None): """ Recompose back the dMRI data accordingly the b-values table after EC correction """ import numpy as np import nibabel as nb import os.path as op if out_file is None: fname, ext = op.splitext(op.basename(in_dwi)) if ext == ".gz": fname, ext2 = op.splitext(fname) ext = ext2 + ext out_file = op.abspath("%s_eccorrect%s" % (fname, ext)) im = nb.load(in_dwi) dwidata = im.get_data() bvals = np.loadtxt(in_bval) dwis = np.where(bvals != 0)[0].tolist() if len(dwis) != len(in_corrected): raise RuntimeError(('Length of DWIs in b-values table and after' 'correction should match')) for bindex, dwi in zip(dwis, in_corrected): dwidata[..., bindex] = nb.load(dwi).get_data() nb.Nifti1Image(dwidata, im.get_affine(), im.get_header()).to_filename(out_file) return out_file
def siemens2rads(in_file, out_file=None): """ Converts input phase difference map to rads """ import numpy as np import nibabel as nb import os.path as op import math if out_file is None: fname, fext = op.splitext(op.basename(in_file)) if fext == '.gz': fname, _ = op.splitext(fname) out_file = op.abspath('./%s_rads.nii.gz' % fname) in_file = np.atleast_1d(in_file).tolist() im = nb.load(in_file[0]) data = im.get_data().astype(np.float32) hdr = im.get_header().copy() if len(in_file) == 2: data = nb.load(in_file[1]).get_data().astype(np.float32) - data elif (data.ndim == 4) and (data.shape[-1] == 2): data = np.squeeze(data[..., 1] - data[..., 0]) hdr.set_data_shape(data.shape[:3]) imin = data.min() imax = data.max() data = (2.0 * math.pi * (data - imin)/(imax-imin)) - math.pi hdr.set_data_dtype(np.float32) hdr.set_xyzt_units('mm') hdr['datatype'] = 16 nb.Nifti1Image(data, im.get_affine(), hdr).to_filename(out_file) return out_file
def readDataset(niifilename, niiBrainMaskFilename, btablefilename, parcellationfilename = None): # load the masked diffusion dataset diffusionData = nib.load(niifilename).get_data() affine = nib.load(niifilename).get_affine() # load the brain mask mask = nib.load(niiBrainMaskFilename).get_data() rows, cols, nSlices, nDirections = diffusionData.shape bvals, bvecs = readbtable(btablefilename) gtable = gradient_table(bvals, bvecs) if parcellationfilename != None: #parcellation = nib.load(parcellationfilename).get_data() parcellation,_ = nrrd.read(parcellationfilename) if parcellation.shape[2] != nSlices: # for the second phantom (unc_res) parcellation = parcellation[:,:,parcellation.shape[2]-nSlices:] parcellation = np.squeeze(parcellation) else: parcellation = None return diffusionData, mask, affine, gtable, parcellation
def bg_mask(in_file, in_mask, out_file=None): """ Rough mask of background from brain masks """ import nibabel as nb import numpy as np from scipy.ndimage import binary_dilation import scipy.ndimage as nd import os.path as op if out_file is None: fname, ext = op.splitext(op.basename(in_file)) if ext == ".gz": fname, ext2 = op.splitext(fname) ext = ext2 + ext out_file = op.abspath("%s_bgmask%s" % (fname, ext)) im = nb.load(in_file) hdr = im.get_header().copy() hdr.set_data_dtype(np.uint8) hdr.set_xyzt_units('mm') imdata = im.get_data() msk = nb.load(in_mask).get_data() msk = 1 - binary_dilation(msk, structure=np.ones((20, 20, 20))) nb.Nifti1Image(msk.astype(np.uint8), im.get_affine(), hdr).to_filename(out_file) return out_file
def data_generator(inputsamplelinks, inputlabellinks, conf, batch_size, rdm=True): while True: images = inputsamplelinks targets = inputlabellinks index = [i for i in range(len(images))] if rdm: rng_state = numpy.random.get_state() numpy.random.shuffle(images) numpy.random.set_state(rng_state) numpy.random.shuffle(targets) sample_in_batch = 0 all_img = numpy.zeros((2,2)) all_targ = numpy.zeros((2,2)) for i in range(len(images)): img = nibabel.load(images[i]).get_data() targ = nibabel.load(targets[i]).get_data() #targ = targ/255 img = img.reshape((1, img.shape[0], img.shape[1], img.shape[2], img.shape[3])) targ = targ.reshape((1, targ.shape[0], targ.shape[1], targ.shape[2])) targ = multiclass(targ, conf) if sample_in_batch == 0: all_img = img all_targ = targ sample_in_batch += 1 else: all_img = numpy.concatenate((all_img, img)) all_targ = numpy.concatenate((all_targ, targ)) sample_in_batch += 1 if sample_in_batch == batch_size: sample_in_batch = 0 yield (numpy.copy(all_img), numpy.copy(all_targ))
def read_mni_template(contrast="T2"): """ Read the MNI template from disk Parameters ---------- contrast : list or string, optional Which of the contrast templates to read. Two contrasts are available: "T1" and "T2", so you can either enter one of these strings as input, or a list containing both of them. Returns ------- list : contains the nibabel.Nifti1Image objects requested, according to the order they were requested in the input. Examples -------- Get only the T2 file: >>> T2_nifti = read_mni_template("T2") # doctest: +SKIP Get both files in this order: >>> T1_nifti, T2_nifti = read_mni_template(["T1", "T2"]) # doctest: +SKIP """ files, folder = fetch_mni_template() file_dict = {"T1": pjoin(folder, 'mni_icbm152_t1_tal_nlin_asym_09a.nii'), "T2": pjoin(folder, 'mni_icbm152_t2_tal_nlin_asym_09a.nii')} if isinstance(contrast, str): return nib.load(file_dict[contrast]) else: out_list = [] for k in contrast: out_list.append(nib.load(file_dict[k])) return out_list
def _run_interface(self, runtime): img = nb.load(self.inputs.in_file[0]) header = img.get_header().copy() vollist = [nb.load(filename) for filename in self.inputs.in_file] data = np.concatenate([vol.get_data().reshape( vol.get_shape()[:3] + (-1,)) for vol in vollist], axis=3) if data.dtype.kind == 'i': header.set_data_dtype(np.float32) data = data.astype(np.float32) if isdefined(self.inputs.regress_poly): timepoints = img.get_shape()[-1] X = np.ones((timepoints, 1)) for i in range(self.inputs.regress_poly): X = np.hstack((X, legendre( i + 1)(np.linspace(-1, 1, timepoints))[:, None])) betas = np.dot(np.linalg.pinv(X), np.rollaxis(data, 3, 2)) datahat = np.rollaxis(np.dot(X[:, 1:], np.rollaxis( betas[1:, :, :, :], 0, 3)), 0, 4) data = data - datahat img = nb.Nifti1Image(data, img.get_affine(), header) nb.save(img, self._gen_output_file_name('detrended')) meanimg = np.mean(data, axis=3) stddevimg = np.std(data, axis=3) tsnr = meanimg / stddevimg img = nb.Nifti1Image(tsnr, img.get_affine(), header) nb.save(img, self._gen_output_file_name()) img = nb.Nifti1Image(meanimg, img.get_affine(), header) nb.save(img, self._gen_output_file_name('mean')) img = nb.Nifti1Image(stddevimg, img.get_affine(), header) nb.save(img, self._gen_output_file_name('stddev')) return runtime
def check_images(file1, file2): """Check that 2 images have the same affines and data shapes. Parameters ---------- file1 : str Path to the first nifti image file2 : str Path to the second nifti image """ img = nibabel.load(file1) shape1 = np.shape(img.get_data()) affine1 = img.get_affine() img = nibabel.load(file2) shape2 = np.shape(img.get_data()) affine2 = img.get_affine() if shape1 != shape2: raise ValueError('Images got different shapes: {0} of shape {1}, {2} ' 'of shape {3}'.format(file1, shape1, file2, shape2)) if np.any(affine1 != affine2): raise ValueError('Images got different affines: {0} has affine {1}, ' '{2} has affine {3}'.format(file1, affine1, file2, affine2))
def test_median_otsu_flow(): with TemporaryDirectory() as out_dir: data_path, _, _ = get_data('small_25') volume = nib.load(data_path).get_data() save_masked = True median_radius = 3 numpass = 3 autocrop = False vol_idx = [0] dilate = 0 mo_flow = MedianOtsuFlow() mo_flow.run(data_path, out_dir=out_dir, save_masked=save_masked, median_radius=median_radius, numpass=numpass, autocrop=autocrop, vol_idx=vol_idx, dilate=dilate) mask_name = mo_flow.last_generated_outputs['out_mask'] masked_name = mo_flow.last_generated_outputs['out_masked'] masked, mask = median_otsu(volume, median_radius, numpass, autocrop, vol_idx, dilate) result_mask_data = nib.load(join(out_dir, mask_name)).get_data() npt.assert_array_equal(result_mask_data, mask) result_masked_data = nib.load(join(out_dir, masked_name)).get_data() npt.assert_array_equal(result_masked_data, masked)
def test_split_and_merge(tmpdir): import numpy as np import nibabel as nb import os.path as op import os from nipype.algorithms.misc import split_rois, merge_rois in_mask = example_data('tpms_msk.nii.gz') dwfile = op.join(str(tmpdir), 'dwi.nii.gz') mskdata = nb.load(in_mask).get_data() aff = nb.load(in_mask).affine dwshape = (mskdata.shape[0], mskdata.shape[1], mskdata.shape[2], 6) dwdata = np.random.normal(size=dwshape) os.chdir(str(tmpdir)) nb.Nifti1Image(dwdata.astype(np.float32), aff, None).to_filename(dwfile) resdw, resmsk, resid = split_rois(dwfile, in_mask, roishape=(20, 20, 2)) merged = merge_rois(resdw, resid, in_mask) dwmerged = nb.load(merged).get_data() dwmasked = dwdata * mskdata[:, :, :, np.newaxis] assert np.allclose(dwmasked, dwmerged)
def export(self, nidm_version, export_dir): """ Create prov graph. """ if self.expl_mean_sq_file is None: # Create Contrast Explained Mean Square Map as fstat<num>.nii.gz # multiplied by sigmasquareds.nii.gz and save it in export_dir fstat_img = nib.load(self.stat_file) fstat = fstat_img.get_data() sigma_sq_img = nib.load(self.sigma_sq_file) sigma_sq = sigma_sq_img.get_data() expl_mean_sq = nib.Nifti1Image( fstat*sigma_sq, fstat_img.get_qform()) self.filename = ("ContrastExplainedMeanSquareMap" + self.num + ".nii.gz") self.expl_mean_sq_file = os.path.join( export_dir, self.filename) nib.save(expl_mean_sq, self.expl_mean_sq_file) self.file = NIDMFile(self.id, self.expl_mean_sq_file, filename=self.filename, sha=self.sha, fmt=self.fmt) # Contrast Explained Mean Square Map entity path, filename = os.path.split(self.expl_mean_sq_file) self.add_attributes(( (PROV['type'], self.type), (NIDM_IN_COORDINATE_SPACE, self.coord_space.id), (PROV['label'], self.label)))
def _run_interface(self, runtime): src_nii = nb.load(self.inputs.src_file) src = NiftiWrapper(src_nii, make_empty=True) dest_nii = nb.load(self.inputs.dest_file) dest = NiftiWrapper(dest_nii, make_empty=True) classes = src.meta_ext.get_valid_classes() if self.inputs.include_classes: classes = [cls for cls in classes if cls in self.inputs.include_classes ] if self.inputs.exclude_classes: classes = [cls for cls in classes if not cls in self.inputs.exclude_classes ] for cls in classes: src_dict = src.meta_ext.get_class_dict(cls) dest_dict = dest.meta_ext.get_class_dict(cls) dest_dict.update(src_dict) # Update the shape and slice dimension to reflect the meta extension update. dest.meta_ext.slice_dim = src.meta_ext.slice_dim dest.meta_ext.shape = src.meta_ext.shape self.out_path = path.join(os.getcwd(), path.basename(self.inputs.dest_file)) dest.to_filename(self.out_path) return runtime
def extract_noise_components(realigned_file, noise_mask_file, num_components): """Derive components most reflective of physiological noise """ import os from nibabel import load import numpy as np import scipy as sp imgseries = load(realigned_file) components = None mask = load(noise_mask_file).get_data() voxel_timecourses = imgseries.get_data()[mask > 0] voxel_timecourses[np.isnan(np.sum(voxel_timecourses, axis=1)), :] = 0 # remove mean and normalize by variance # voxel_timecourses.shape == [nvoxels, time] X = voxel_timecourses.T stdX = np.std(X, axis=0) stdX[stdX == 0] = 1. stdX[np.isnan(stdX)] = 1. stdX[np.isinf(stdX)] = 1. X = (X - np.mean(X, axis=0))/stdX u, _, _ = sp.linalg.svd(X, full_matrices=False) if components is None: components = u[:, :num_components] else: components = np.hstack((components, u[:, :num_components])) components_file = os.path.join(os.getcwd(), 'noise_components.txt') np.savetxt(components_file, components, fmt="%.10f") return components_file
os.listdir(files_dir) #Iterate in Batch Folder for f in os.listdir(files_dir): if (f.endswith(".nii")): filenames.append(f) for l in filenames: if (l[0] == 'v'): path_file = os.path.join(niftis_path, l) idx = l.index('-') folder_volume = os.path.join(folder_volumes, l[idx + 1:-4]) #print(folder_volume) volume = nib.load(path_file) print("Processing Volume %s and saving at %s" % (l, folder_volume)) #print(volume.dataobj.shape) imgs = volume.dataobj imgs = np.array(imgs).astype('float32') imgs[imgs < -150] = -150 imgs[imgs > 250] = 250 #print(imgs.shape) #print(imgs.min(axis=(0,1)).shape) img_volume = 255 * (imgs - imgs.min(axis=(0, 1))) / ( imgs.max(axis=(0, 1)) - imgs.min(axis=(0, 1))) if (not os.path.isdir(folder_volume)): os.mkdir(folder_volume) #Iterate over image channels for section_id in range(imgs.shape[-1]):
def reconst_flow_core(flow, extra_args=[]): with TemporaryDirectory() as out_dir: data_path, bval_path, bvec_path = get_data('small_25') vol_img = nib.load(data_path) volume = vol_img.get_data() mask = np.ones_like(volume[:, :, :, 0]) mask_img = nib.Nifti1Image(mask.astype(np.uint8), vol_img.affine) mask_path = join(out_dir, 'tmp_mask.nii.gz') nib.save(mask_img, mask_path) dti_flow = flow() args = [data_path, bval_path, bvec_path, mask_path] args.extend(extra_args) dti_flow.run(*args, out_dir=out_dir) fa_path = dti_flow.last_generated_outputs['out_fa'] fa_data = nib.load(fa_path).get_data() assert_true(fa_data.shape == volume.shape[:-1]) tensor_path = dti_flow.last_generated_outputs['out_tensor'] tensor_data = nib.load(tensor_path) assert_true(tensor_data.shape[-1] == 6) assert_true(tensor_data.shape[:-1] == volume.shape[:-1]) ga_path = dti_flow.last_generated_outputs['out_ga'] ga_data = nib.load(ga_path).get_data() assert_true(ga_data.shape == volume.shape[:-1]) rgb_path = dti_flow.last_generated_outputs['out_rgb'] rgb_data = nib.load(rgb_path) assert_true(rgb_data.shape[-1] == 3) assert_true(rgb_data.shape[:-1] == volume.shape[:-1]) md_path = dti_flow.last_generated_outputs['out_md'] md_data = nib.load(md_path).get_data() assert_true(md_data.shape == volume.shape[:-1]) ad_path = dti_flow.last_generated_outputs['out_ad'] ad_data = nib.load(ad_path).get_data() assert_true(ad_data.shape == volume.shape[:-1]) rd_path = dti_flow.last_generated_outputs['out_rd'] rd_data = nib.load(rd_path).get_data() assert_true(rd_data.shape == volume.shape[:-1]) mode_path = dti_flow.last_generated_outputs['out_mode'] mode_data = nib.load(mode_path).get_data() assert_true(mode_data.shape == volume.shape[:-1]) evecs_path = dti_flow.last_generated_outputs['out_evec'] evecs_data = nib.load(evecs_path).get_data() assert_true(evecs_data.shape[-2:] == tuple((3, 3))) assert_true(evecs_data.shape[:-2] == volume.shape[:-1]) evals_path = dti_flow.last_generated_outputs['out_eval'] evals_data = nib.load(evals_path).get_data() assert_true(evals_data.shape[-1] == 3) assert_true(evals_data.shape[:-1] == volume.shape[:-1])
def test(model_name, epoch, gpu_id, n_test, invert_images, max_clip, indexing, use_miccai, atlas_file, atlas_seg_file, normalize_atlas, vol_size=(160, 192, 224), nf_enc=[16, 32, 32, 32], nf_dec=[32, 32, 32, 32, 32, 16, 16]): start_time = time.time() good_labels = sio.loadmat('../data/labels.mat')['labels'][0] # setup gpu = '/gpu:' + str(gpu_id) # print(gpu) os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' restrict_GPU_tf(str(gpu_id)) restrict_GPU_keras(str(gpu_id)) config = tf.ConfigProto() config.gpu_options.allow_growth = True config.allow_soft_placement = True set_session(tf.Session(config=config)) atlas_vol = nib.load(atlas_file).get_data()[np.newaxis, ..., np.newaxis] atlas_seg = nib.load(atlas_seg_file).get_data() if normalize_atlas: atlas_vol = atlas_vol / np.max(atlas_vol) * max_clip sz = atlas_seg.shape z_inp1 = tf.placeholder(tf.float32, sz) z_inp2 = tf.placeholder(tf.float32, sz) z_out = losses.kdice(z_inp1, z_inp2, good_labels) kdice_fn = K.function([z_inp1, z_inp2], [z_out]) # load weights of model with tf.device(gpu): if use_miccai: net = networks.miccai2018_net(vol_size, nf_enc, nf_dec) net.load_weights('../models/' + model_name + '/' + str(epoch) + '.h5') trf_model = networks.trf_core( (vol_size[0] // 2, vol_size[1] // 2, vol_size[2] // 2), nb_feats=len(good_labels) + 1, indexing=indexing) else: net = networks.cvpr2018_net(vol_size, nf_enc, nf_dec) net.load_weights('../models/' + model_name + '/' + str(epoch) + '.h5') trf_model = networks.trf_core(vol_size, nb_feats=len(good_labels) + 1, indexing=indexing) dice_means = [] dice_stds = [] for step in range(0, n_test): # get data if n_test == 1: X_vol = nib.load('../t1_atlas.nii').get_data()[np.newaxis, ..., np.newaxis] X_seg = nib.load('../t1_atlas_seg.nii').get_data()[np.newaxis, ..., np.newaxis] else: vol_name, seg_name = test_brain_strings[step].split(",") X_vol, X_seg = datagenerators.load_example_by_name( vol_name, seg_name) if invert_images: X_vol = max_clip - X_vol with tf.device(gpu): pred = net.predict([X_vol, atlas_vol]) all_labels = np.unique(X_seg) for l in all_labels: if l not in good_labels: X_seg[X_seg == l] = 0 for i in range(len(good_labels)): X_seg[X_seg == good_labels[i]] = i + 1 seg_onehot = tf.keras.utils.to_categorical( X_seg[0, :, :, :, 0], num_classes=len(good_labels) + 1) warp_seg_onehot = trf_model.predict( [seg_onehot[tf.newaxis, :, :, :, :], pred[1]]) warp_seg = np.argmax(warp_seg_onehot[0, :, :, :, :], axis=3) warp_seg_correct = np.zeros(warp_seg.shape) for i in range(len(good_labels)): warp_seg_correct[warp_seg == i + 1] = good_labels[i] dice = kdice_fn([warp_seg_correct, atlas_seg]) mean = np.mean(dice) std = np.std(dice) dice_means.append(mean) dice_stds.append(std) print(step, mean, std) print('average dice:', np.mean(dice_means)) print('std over patients:', np.std(dice_means)) print('average std over regions:', np.mean(dice_stds)) print('time taken:', time.time() - start_time)
def main(argv): inputfile = 'pat0-subvolume-tformed.nii' outputfile = 'folder' try: opts, args = getopt.getopt(argv, "hi:o:", ["ifile=", "ofile="]) except getopt.GetoptError: print('nii2png.py -i <inputfile> -o <outputfile>') sys.exit(2) for opt, arg in opts: if opt == '-h': print('nii2png.py -i <inputfile> -o <outputfile>') sys.exit() elif opt in ("-i", "--input"): inputfile = arg elif opt in ("-o", "--output"): outputfile = arg print('Input file is ', inputfile) print('Output folder is ', outputfile) # set fn as your 4d nifti file image_array = nibabel.load(inputfile).get_data() print(len(image_array.shape)) # ask if rotate # ask_rotate = input('Would you like to rotate the orientation? (y/n) ') ask_rotate = 'n' if ask_rotate.lower() == 'y': ask_rotate_num = int(input('OK. By 90° 180° or 270°? ')) if ask_rotate_num == 90 or ask_rotate_num == 180 or ask_rotate_num == 270: print('Got it. Your images will be rotated by {} degrees.'.format( ask_rotate_num)) else: print( 'You must enter a value that is either 90, 180, or 270. Quitting...' ) sys.exit() elif ask_rotate.lower() == 'n': print('OK, Your images will be converted it as it is.') else: print('You must choose either y or n. Quitting...') sys.exit() # if 4D image inputted if len(image_array.shape) == 4: # set 4d array dimension values nx, ny, nz, nw = image_array.shape # set destination folder if not os.path.exists(outputfile): os.makedirs(outputfile) print("Created ouput directory: " + outputfile) print('Reading NIfTI file...') total_volumes = image_array.shape[3] total_slices = image_array.shape[2] # iterate through volumes for current_volume in range(0, total_volumes): slice_counter = 0 # iterate through slices for current_slice in range(0, total_slices): if (slice_counter % 1) == 0: # rotate or no rotate if ask_rotate.lower() == 'y': if ask_rotate_num == 90 or ask_rotate_num == 180 or ask_rotate_num == 270: print('Rotating image...') if ask_rotate_num == 90: data = numpy.rot90(image_array[:, :, current_slice, current_volume]) elif ask_rotate_num == 180: data = numpy.rot90( numpy.rot90(image_array[:, :, current_slice, current_volume])) elif ask_rotate_num == 270: data = numpy.rot90( numpy.rot90( numpy.rot90( image_array[:, :, current_slice, current_volume]))) elif ask_rotate.lower() == 'n': data = image_array[:, :, current_slice, current_volume] # alternate slices and save as png print('Saving image...') image_name = inputfile[:-4] + "_t" + "{:0>3}".format( str(current_volume + 1)) + "_z" + "{:0>3}".format( str(current_slice + 1)) + ".png" scipy.misc.imsave(image_name, data) print('Saved.') # move images to folder print('Moving files...') src = image_name shutil.move(src, outputfile) slice_counter += 1 print('Moved.') print('Finished converting images') # else if 3D image inputted elif len(image_array.shape) == 3: # set 4d array dimension values nx, ny, nz = image_array.shape # set destination folder if not os.path.exists(outputfile): os.makedirs(outputfile) print("Created ouput directory: " + outputfile) print('Reading NIfTI file...') total_slices = image_array.shape[2] slice_counter = 0 # iterate through slices for current_slice in range(0, total_slices): # alternate slices if (slice_counter % 1) == 0: # rotate or no rotate if ask_rotate.lower() == 'y': if ask_rotate_num == 90 or ask_rotate_num == 180 or ask_rotate_num == 270: if ask_rotate_num == 90: data = numpy.rot90(image_array[:, :, current_slice]) elif ask_rotate_num == 180: data = numpy.rot90( numpy.rot90(image_array[:, :, current_slice])) elif ask_rotate_num == 270: data = numpy.rot90( numpy.rot90( numpy.rot90(image_array[:, :, current_slice]))) elif ask_rotate.lower() == 'n': data = image_array[:, :, current_slice] data = normalize_image(data) # alternate slices and save as png if (slice_counter % 1) == 0: print('Saving image...') image_name = inputfile[:-4] + "_z" + "{:0>3}".format( str(current_slice + 1)) + ".png" imageio.imwrite(image_name, data) print('Saved.') # move images to folder # print('Moving image...') # src = image_name # shutil.move(src, outputfile) # slice_counter += 1 # print('Moved.') print('Finished converting images') else: print('Not a 3D or 4D Image. Please try again.')
def get_studies_by_regions(dataset, masks, threshold=0.08, remove_overlap=True, studies=None, features=None, regularization="scale"): """ Set up data for a classification task given a set of masks Given a set of masks, this function retrieves studies associated with each mask at the specified threshold, optionally removes overlap and filters by studies and features, and returns studies by feature matrix (X) and class labels (y) Args: dataset: a Neurosynth dataset maks: a list of paths to Nifti masks threshold: percentage of voxels active within the mask for study to be included remove_overlap: A boolean indicating if studies studies that appear in more than one mask should be excluded studies: An optional list of study names used to constrain the set used in classification. If None, will use all features in the dataset. features: An optional list of feature names used to constrain the set used in classification. If None, will use all features in the dataset. regularize: Optional boolean indicating if X should be regularized Returns: A tuple (X, y) of np arrays. X is a feature by studies matrix and y is a vector of class labels """ import nibabel as nib import os # Load masks using NiBabel try: loaded_masks = [nib.load(os.path.relpath(m)) for m in masks] except OSError: print 'Error loading masks. Check the path' # Get a list of studies that activate for each mask file--i.e., a list of # lists grouped_ids = [dataset.get_ids_by_mask(m, threshold=threshold) for m in loaded_masks] # Flattened ids flat_ids = reduce(lambda a, b: a + b, grouped_ids) # Remove duplicates if remove_overlap: import collections flat_ids = [id for (id, count) in collections.Counter(flat_ids).items() if count == 1] grouped_ids = [[x for x in m if x in flat_ids] for m in grouped_ids] # Remove # Create class label(y) y = [[idx] * len(ids) for (idx, ids) in enumerate(grouped_ids)] y = reduce(lambda a, b: a + b, y) # Flatten y = np.array(y) # Extract feature set for only relevant ids X = dataset.get_feature_data(ids=flat_ids, features=features) if regularization: X = regularize(X, method=regularization) return (X, y)
def main(): # Plot Save Path base_plot_path = r'/nfs/masi/nathv/py_src_code_2020/dmipy_model_pictures' base_plot_path = os.path.normpath(base_plot_path) # Method Saving Paths base_save_path = r'/nfs/masi/nathv/miccai_2020/micro_methods_hcp_mini' base_save_path = os.path.normpath(base_save_path) # Create base saving path for Method # TODO The Method name can be made an argument later on method_name = 'IVIM' # Base HCP Data Path base_data_path = r'/nfs/HCP/data' base_data_path = os.path.normpath(base_data_path) # Subject ID's list subj_ID_List = ['115017', '114823', '116726', '118225'] # TODO When needed loop here over the ID list for subj_ID in subj_ID_List: # Subject Save Path subj_save_path = os.path.join(base_save_path, subj_ID) if os.path.exists(subj_save_path) == False: os.mkdir(subj_save_path) # TODO For later the subject data, bval and bvec reading part can be put inside a function subj_data_path = os.path.join(base_data_path, subj_ID, 'T1w', 'Diffusion') # Read the Nifti file, bvals and bvecs subj_bvals = np.loadtxt(os.path.join(subj_data_path, 'bvals')) subj_bvecs = np.loadtxt(os.path.join(subj_data_path, 'bvecs')) all_bvals = subj_bvals * 1e6 all_bvecs = np.transpose(subj_bvecs) subj_Acq_Scheme = acquisition_scheme_from_bvalues(all_bvals, all_bvecs) print(subj_Acq_Scheme.print_acquisition_info) print('Loading the Nifti Data ...') data_start_time = time.time() subj_babel_object = nib.load( os.path.join(subj_data_path, 'data.nii.gz')) subj_data = subj_babel_object.get_fdata() axial_slice_data = subj_data[:, :, 25:27, :] data_end_time = time.time() data_time = np.int(np.round(data_end_time - data_start_time)) print('Data Loaded ... Time Taken: {}'.format(data_end_time - data_start_time)) print('The Data Dimensions are: {}'.format(subj_data.shape)) #### IVIM #### print('Fitting IVIM ...') fit_start_time = time.time() ivim_fit_dmipy_fixed = ivim_Dstar_fixed(subj_Acq_Scheme, subj_data, mask=subj_data[..., 0] > 0) fit_end_time = time.time() print('IVIM Fitting Completed ... Time Taken to fit: {}'.format( fit_end_time - fit_start_time)) fit_time = np.int(np.round(fit_end_time - fit_start_time)) # Get List of Estimated Parameter Names # para_Names_list = ivim_fit_dmipy_fixed.parameter_names fitted_parameters = ivim_fit_dmipy_fixed.fitted_parameters para_Names_list = [] for key, value in fitted_parameters.items(): para_Names_list.append(key) ### Nifti Saving Part # Create a directory per subject subj_method_save_path = os.path.join(subj_save_path, method_name) if os.path.exists(subj_method_save_path) == False: os.mkdir(subj_method_save_path) # Retrieve the affine from already Read Nifti file to form the header affine = subj_babel_object.affine # Loop over fitted parameters name list for each_fitted_parameter in para_Names_list: new_img = nib.Nifti1Image(fitted_parameters[each_fitted_parameter], affine) # Form the file path f_name = each_fitted_parameter + '.nii.gz' param_file_path = os.path.join(subj_method_save_path, f_name) nib.save(new_img, param_file_path) return None
MDD_ind = np.argwhere(subjects>100)[:,0] sessions = [1,3] nDays = len(sessions) average_within_mat = np.zeros((n_systems,n_systems,nSub,nDays)) average_one_vs_all = np.zeros((n_systems,nSub,nDays)) # NOW CALCULATE DATA FOR SUBJECTS for s in np.arange(nSub): subjectNum=subjects[s] bids_id = 'sub-{0:03d}'.format(subjectNum) for ses in np.arange(nDays): subjectDay=sessions[ses] ses_id = 'ses-{0:02d}'.format(subjectDay) clean_path = noise_save_dir + '/' + bids_id + '/' + ses_id cleaned_image = '{0}/{1}_{2}_task_rest_glm.nii.gz'.format(clean_path,bids_id,ses_id) cleaned_image_data = nib.load(cleaned_image).get_fdata() # doing standardize = True here at least makes it so voxels outside of brain would have 0 std and not be included masker = NiftiLabelsMasker(labels_img=powerAtlas, standardize=True, memory='nilearn_cache', verbose=5) time_series = masker.fit_transform(cleaned_image) # now data is n time points x 264 nodes time_series_good_labels = time_series[:,all_good_labels] # now data is in n time points x 227 nodes correlation_measure = ConnectivityMeasure(kind='correlation') correlation_matrix = correlation_measure.fit_transform([time_series_good_labels])[0] # takes correlation for all 227 nodes np.fill_diagonal(correlation_matrix,np.nan) # to make sure you don't get the same node in the within connectivity difference for row in np.arange(n_systems): for col in np.arange(n_systems): if row == col: # diagonal average_within_mat[row,col,s,ses] = calculateWithinConnectivity(systems_to_keep[row],correlation_matrix,complete_labels,system,all_good_ROI) #else: # average_within_mat[row,col,s,ses] = calculatePairwiseConnectivity(systems_to_keep[row],systems_to_keep[col],correlation_matrix,complete_labels,system,all_good_ROI) # now calculate oneVsAll
def getISLEPad(): mainPath = 'F:/Research/isles2/' newPath = 'F:/Research/isles_padded/' for x in range(1, 95): path = mainPath + 'case_' + str(x) normPath = newPath + 'case_' + str(x) MTT = path + '/CT_MTT.nii' newMTT = normPath + '/CT_MTT.nii' if not os.path.exists(MTT): continue if not os.path.exists(normPath): os.mkdir(normPath) n1_img = nib.load(MTT) n1_header = n1_img.header n1_affine = n1_img.affine img = n1_img.get_fdata() # add padding padded = np.pad(img, ((0, 0), (0, 0), (18, 18)), 'constant', constant_values=(0, 0)) new_img = nib.Nifti1Image(padded, n1_affine, n1_header) nib.save(new_img, newMTT) rCBF = path + '/CT_CBF.nii' newrCBF = normPath + '/CT_CBF.nii' n1_img = nib.load(rCBF) n1_header = n1_img.header n1_affine = n1_img.affine img = n1_img.get_fdata() # add padding padded = np.pad(img, ((0, 0), (0, 0), (18, 18)), 'constant', constant_values=(0, 0)) new_img = nib.Nifti1Image(padded, n1_affine, n1_header) nib.save(new_img, newrCBF) rCBV = path + '/CT_CBV.nii' newrCBV = normPath + '/CT_CBV.nii' n1_img = nib.load(rCBV) n1_header = n1_img.header n1_affine = n1_img.affine img = n1_img.get_fdata() # add padding padded = np.pad(img, ((0, 0), (0, 0), (18, 18)), 'constant', constant_values=(0, 0)) new_img = nib.Nifti1Image(padded, n1_affine, n1_header) nib.save(new_img, newrCBV) Tmax = path + '/CT_Tmax.nii' newTmax = normPath + '/CT_Tmax.nii' n1_img = nib.load(Tmax) n1_header = n1_img.header n1_affine = n1_img.affine img = n1_img.get_fdata() # add padding padded = np.pad(img, ((0, 0), (0, 0), (18, 18)), 'constant', constant_values=(0, 0)) new_img = nib.Nifti1Image(padded, n1_affine, n1_header) nib.save(new_img, newTmax) label = path + '/OT.nii' newLabel = normPath + '/OT.nii' n1_img = nib.load(label) n1_header = n1_img.header n1_affine = n1_img.affine img = n1_img.get_fdata() # add padding padded = np.pad(img, ((0, 0), (0, 0), (18, 18)), 'constant', constant_values=(0, 0)) new_img = nib.Nifti1Image(padded, n1_affine, n1_header) nib.save(new_img, newLabel)
print("Error, file missing. #t1:{}, #masks:{}".format( len(filenames), len(masks))) print("Using model:", model_filename) # used only for printing result mean_dice = 0 pred_vols = [] gt_vols = [] roc_aucs = [] precision_scores = [] for filename, mask in zip(filenames, masks): # load nifti file data nii_obj = nib.load(os.path.join(DATA_DIR, filename)) nii_img = nii_obj.get_data() header = nii_obj.header affine = nii_obj.affine #print("nii image shape = {}".format(nii_img.shape)) # load mask file data mask_obj = nib.load(os.path.join(DATA_DIR, mask)) mask_img = mask_obj.get_data() # pad and reshape to account for implicit "1" channel # Uncomment if using just t1 nii_img = np.reshape(nii_img, nii_img.shape + (1, )) orig_shape = nii_img.shape
def start(self, ds, **kwargs): print("Split-Labels started..") run_dir = os.path.join(WORKFLOW_DIR, kwargs['dag_run'].run_id) batch_folders = [ f for f in glob.glob(os.path.join(run_dir, BATCH_NAME, '*')) ] print("Found {} batches".format(len(batch_folders))) for batch_element_dir in batch_folders: input_dir = os.path.join(batch_element_dir, self.operator_in_dir) output_dir = os.path.join(batch_element_dir, self.operator_out_dir) if not os.path.exists(output_dir): os.makedirs(output_dir) print("Search for NIFIs in {}".format(input_dir)) batch_nifti_files = sorted( glob.glob(os.path.join(input_dir, "**", "*.nii*"), recursive=True)) print("Found {} NIFTI files.".format(len(batch_nifti_files))) if len(batch_nifti_files) == 0: print("No NIFTI file was found!") print("abort!") exit(1) for nifti in batch_nifti_files: print("Loading labels...") label_names = self.get_labels_from_json( multilabel_dir=os.path.dirname(nifti)) print("Loading NIFTI: {}".format(nifti)) img = nib.load(nifti) data = img.get_fdata(dtype=np.float16) label_values = np.unique(data).astype( img.header.get_data_dtype())[1:] print("Found {} labels...".format(len(label_values))) if len(label_values) == 0: print("No labels could be idenified!") print("abort!") exit(1) if len(label_values) > len(label_names): print( "There were more labels detected than label-names provided!" ) print("abort!") exit(1) print("Splitting multilabel into single NIFTI-files!") for label in label_values: label_name = label_names[label] tmp_mask = (data == label) * data label_values = np.unique(tmp_mask).astype( img.header.get_data_dtype()) tmp_mask[tmp_mask == label] = 1 new_image = nib.nifti2.Nifti1Image(dataobj=tmp_mask.astype( img.header.get_data_dtype()), header=img.header, affine=img.affine) # new_image = nib.nifti2.Nifti2Image(dataobj=tmp_mask.astype(header.get_data_dtype()),header=img.header,affine=img.affine) print("Saving extracted mask {}: {}".format( label, label_name)) nib.save( new_image, os.path.join(output_dir, '{}.nii.gz'.format(label_name))) print("done")
def nifti4pycortex(nifti_file): """Load nifti file for pycortex visualization.""" data = nib.load(nifti_file).get_data() ndata = np.rollaxis(data, 0, 3) ndata = np.rollaxis(ndata, 0, 2) return ndata
""" Plot Haxby masks ================= Small script to plot the masks of the Haxby dataset. """ import numpy as np import matplotlib.pyplot as plt import nibabel from nilearn import datasets data = datasets.fetch_haxby() bold_img = nibabel.load(data.func[0]) # Build the mean image because we have no anatomic data fmri_data = bold_img.get_data().astype(float) mean_img = fmri_data.mean(axis=-1) z = 25 fig = plt.figure(figsize=(4, 5.4)) fig.subplots_adjust(bottom=0., top=1., left=0., right=1.) plt.axis('off') plt.imshow(mean_img[:, 4:58, z].T, cmap=plt.cm.gray, interpolation='nearest', origin='lower') mask_vt = nibabel.load(data.mask_vt[0]).get_data() plt.contour(mask_vt[:, 4:58, z].astype(np.bool).T,
def test_check_orient_and_dims(): """ Test check_orient_and_dims functionality """ # This test has a bak folder in its test_dir. # To replicate test rm data in test_dir and cp from bak base_dir = str(Path(__file__).parent / "examples") test_dir = f"{base_dir}/003/test_out/test_check_orient_and_dims" # Antomical: 1x1x1mm anat_LAS = f"{test_dir}/anat_LAS/sub-003_T1w_LAS.nii.gz" anat_RAS = f"{test_dir}/anat_RAS/sub-003_T1w_RAS.nii.gz" # Diffusion: 2x2x2mm dmri_LAS = f"{test_dir}/dmri_LAS/iso_eddy_corrected_data_denoised_LAS.nii.gz" dmri_RAS = f"{test_dir}/dmri_RAS/iso_eddy_corrected_data_denoised_RAS.nii.gz" bvecs_LAS = f"{test_dir}/dmri_LAS/bvec.orig.bvec" bvecs_RAS = f"{test_dir}/dmri_RAS/bvec.trans.bvec" anat_LAStoRAS = utils.check_orient_and_dims(anat_LAS, test_dir, '2mm', bvecs=None) anat_RAStoRAS = utils.check_orient_and_dims(anat_RAS, test_dir, '2mm', bvecs=None) dmri_LAStoRAS, bvecs_LAStoRAS = utils.check_orient_and_dims( dmri_LAS, test_dir, '1mm', bvecs=bvecs_LAS) dmri_RAStoRAS, bvecs_RAStoRAS = utils.check_orient_and_dims( dmri_RAS, test_dir, '1mm', bvecs=bvecs_RAS) anat_LAStoRAS = nib.load(anat_LAStoRAS) anat_RAStoRAS = nib.load(anat_RAStoRAS) dmri_LAStoRAS = nib.load(dmri_LAStoRAS) dmri_RAStoRAS = nib.load(dmri_RAStoRAS) # Assert that output arrays are identical. anat_check = np.allclose(anat_LAStoRAS.affine.astype('int'), anat_RAStoRAS.affine.astype('int')) dmri_check = np.allclose(dmri_LAStoRAS.affine.astype('int'), dmri_RAStoRAS.affine.astype('int')) # Assert that voxel dimensions in ouputs are correct. anat_LAStoRAS_dims = anat_LAStoRAS.header.get_zooms() anat_RAStoRAS_dims = anat_RAStoRAS.header.get_zooms() dmri_LAStoRAS_dims = dmri_LAStoRAS.header.get_zooms() dmri_RAStoRAS_dims = dmri_RAStoRAS.header.get_zooms() anat_LAStoRAS_success = True anat_RAStoRAS_success = True dmri_LAStoRAS_success = True dmri_RAStoRAS_success = True for anat_LAStoRAS_dim in anat_LAStoRAS_dims[:3]: if anat_LAStoRAS_dim != 2: anat_LAStoRAS_success = False for anat_RAStoRAS_dim in anat_RAStoRAS_dims[:3]: if anat_RAStoRAS_dim != 2: anat_RAStoRAS_success = False for dmri_LAStoRAS_dim in dmri_LAStoRAS_dims[:3]: if dmri_LAStoRAS_dim != 1: dmri_LAStoRAS_success = False print(dmri_RAStoRAS_dims) for dmri_RAStoRAS_dim in dmri_RAStoRAS_dims[:3]: if dmri_RAStoRAS_dim != 1: dmri_RAStoRAS_success = False # Checks arrays assert anat_check is True assert dmri_check is True # Checks voxel dimensions assert anat_LAStoRAS_success is True assert anat_RAStoRAS_success is True assert dmri_LAStoRAS_success is True assert dmri_RAStoRAS_success is True
def _tpm2roi( in_tpm, in_mask, mask_erosion_mm=None, erosion_mm=None, mask_erosion_prop=None, erosion_prop=None, pthres=0.95, newpath=None, ): """ Generate a mask from a tissue probability map """ tpm_img = nb.load(in_tpm) roi_mask = (tpm_img.get_fdata() >= pthres).astype(np.uint8) eroded_mask_file = None erode_in = (mask_erosion_mm is not None and mask_erosion_mm > 0) or (mask_erosion_prop is not None and mask_erosion_prop < 1) if erode_in: eroded_mask_file = fname_presuffix(in_mask, suffix="_eroded", newpath=newpath) mask_img = nb.load(in_mask) mask_data = np.asanyarray(mask_img.dataobj).astype(np.uint8) if mask_erosion_mm: iter_n = max( int(mask_erosion_mm / max(mask_img.header.get_zooms())), 1) mask_data = nd.binary_erosion(mask_data, iterations=iter_n) else: orig_vol = np.sum(mask_data > 0) while np.sum(mask_data > 0) / orig_vol > mask_erosion_prop: mask_data = nd.binary_erosion(mask_data, iterations=1) # Store mask eroded = nb.Nifti1Image(mask_data, mask_img.affine, mask_img.header) eroded.set_data_dtype(np.uint8) eroded.to_filename(eroded_mask_file) # Mask TPM data (no effect if not eroded) roi_mask[~mask_data] = 0 # shrinking erode_out = (erosion_mm is not None and erosion_mm > 0) or (erosion_prop is not None and erosion_prop < 1) if erode_out: if erosion_mm: iter_n = max(int(erosion_mm / max(tpm_img.header.get_zooms())), 1) iter_n = int(erosion_mm / max(tpm_img.header.get_zooms())) roi_mask = nd.binary_erosion(roi_mask, iterations=iter_n) else: orig_vol = np.sum(roi_mask > 0) while np.sum(roi_mask > 0) / orig_vol > erosion_prop: roi_mask = nd.binary_erosion(roi_mask, iterations=1) # Create image to resample roi_fname = fname_presuffix(in_tpm, suffix="_roi", newpath=newpath) roi_img = nb.Nifti1Image(roi_mask, tpm_img.affine, tpm_img.header) roi_img.set_data_dtype(np.uint8) roi_img.to_filename(roi_fname) return roi_fname, eroded_mask_file or in_mask
def main(): parser = _build_arg_parser() args = parser.parse_args() if args.verbose: logging.basicConfig(level=logging.DEBUG) else: logging.basicConfig(level=logging.INFO) assert_inputs_exist(parser, [args.input, args.bvals, args.bvecs]) assert_outputs_exist(parser, args, args.frf_file) vol = nib.load(args.input) data = vol.get_data() bvals, bvecs = read_bvals_bvecs(args.bvals, args.bvecs) if not is_normalized_bvecs(bvecs): logging.warning('Your b-vectors do not seem normalized...') bvecs = normalize_bvecs(bvecs) check_b0_threshold(args, bvals.min()) gtab = gradient_table(bvals, bvecs, b0_threshold=bvals.min()) if args.min_fa_thresh < 0.4: logging.warn( 'Minimal FA threshold ({}) seems really small. Make sure it ' 'makes sense for this dataset.'.format(args.min_fa_thresh)) if args.mask: mask = nib.load(args.mask).get_data().astype(np.bool) data = applymask(data, mask) if args.mask_wm: wm_mask = nib.load(args.mask_wm).get_data().astype('bool') else: wm_mask = np.ones_like(data[..., 0], dtype=np.bool) logging.warn( 'No white matter mask specified! mask_data will be used instead, ' 'if it has been supplied. \nBe *VERY* careful about the ' 'estimation of the fiber response function to ensure no invalid ' 'voxel was used.') data_in_wm = applymask(data, wm_mask) fa_thresh = args.fa_thresh # Iteratively trying to fit at least 300 voxels. Lower the FA threshold # when it doesn't work. Fail if the fa threshold is smaller than # the min_threshold. # We use an epsilon since the -= 0.05 might incurs numerical imprecision. nvox = 0 while nvox < args.min_nvox and fa_thresh >= args.min_fa_thresh - 0.00001: response, ratio, nvox = auto_response(gtab, data_in_wm, roi_center=args.roi_center, roi_radius=args.roi_radius, fa_thr=fa_thresh, return_number_of_voxels=True) logging.debug( 'Number of indices is %s with threshold of %s', nvox, fa_thresh) fa_thresh -= 0.05 if nvox < args.min_nvox: raise ValueError( "Could not find at least {} voxels with sufficient FA " "to estimate the FRF!".format(args.min_nvox)) logging.debug("Found %i voxels with FA threshold %f for FRF estimation", nvox, fa_thresh + 0.05) logging.debug("FRF eigenvalues: %s", str(response[0])) logging.debug("Ratio for smallest to largest eigen value is %f", ratio) logging.debug("Mean of the b=0 signal for voxels used for FRF: %f", response[1]) full_response = np.array([response[0][0], response[0][1], response[0][2], response[1]]) np.savetxt(args.frf_file, full_response)
def _get_zooms(in_file): import nibabel as nb return tuple(nb.load(in_file).header.get_zooms()[:3])
label_vol_path = sys.argv[1] label = sys.argv[2] icc = int(sys.argv[3]) try: os.mkdir("output") except: pass lut = [] meas = [] # Load mask cc_parc_img = nib.load(label_vol_path) cc_parc_data = cc_parc_img.get_data() # Arrange the array to be in RAS+ space ornt = nib.orientations.axcodes2ornt(nib.aff2axcodes(cc_parc_img.affine)) cc_parc_data = nib.orientations.apply_orientation(cc_parc_data, ornt) vxl_size = cc_parc_img.get_header().get_zooms() roi = {} roi["label"] = label meas = print_volume(roi, cc_parc_data, vxl_size[0] * vxl_size[1] * vxl_size[2]) with open('/output/measurement.json', 'w') as f: json.dump(meas, f, indent=4, separators=(',', ': '))
def data_load(dirOutput, data, row, bin_tresh, colourchannel_approach, penalisation_approach): print('--\nNow processing data: ' + data) ''' Create output folder(s) ''' dirOutData = dirOutput + '/' + data dirOutDataCom = dirOutput + '/' + data + '/IAM_combined_python/' dirOutDataFin = dirOutput + '/' + data + '/IAM_GPU_nifti_python/' dirOutDataPatch = dirOutput + '/' + data + '/IAM_combined_python/Patch/' if not os.path.exists(dirOutData): try: os.makedirs(dirOutData) os.makedirs(dirOutDataCom) os.makedirs(dirOutDataFin) os.makedirs(dirOutDataPatch) except OSError as e: if e.errno != errno.EEXIST: raise try: if penalisation_approach: os.makedirs(dirOutput + '/' + data + '/IAM_combined_python/Alg1_Result/') os.makedirs(dirOutput + '/' + data + '/IAM_combined_python/Alg1_Result/Image/') os.makedirs(dirOutput + '/' + data + '/IAM_combined_python/Alg1_Result/Data/') os.makedirs(dirOutput + '/' + data + '/IAM_combined_python/Alg2_Result/') os.makedirs(dirOutput + '/' + data + '/IAM_combined_python/Alg2_Result/Image/') os.makedirs(dirOutput + '/' + data + '/IAM_combined_python/Alg2_Result/Data/') if colourchannel_approach: os.makedirs(dirOutput + '/' + data + '/IAM_combined_python/ColorChannel_Result/') os.makedirs(dirOutput + '/' + data + '/IAM_combined_python/ColorChannel_Result/Image/') os.makedirs(dirOutput + '/' + data + '/IAM_combined_python/ColorChannel_Result/Data/') except OSError as e: if e.errno != errno.EEXIST: raise #niiDir = input_dir + '/' + data + '/' FLAIR_nii = nib.load(row[1]) #nib.load(niiDir + 'FLAIR.nii.gz') # T1w_nii = nib.load(row[2]) # nib.load(niiDir + 'T1W.nii.gz') # T2w_nii = nib.load(row[3]) icv_nii = nib.load(row[4]) #nib.load(niiDir + 'ICV.nii.gz') csf_nii = nib.load(row[5]) #nib.load(niiDir + 'CSF.nii.gz') # GT_nii = nib.load(row[6]) #nib.load(niiDir + 'WMH_label.nii.gz') # FLAIR_data = np.squeeze(FLAIR_nii.get_data()) icv_data = np.squeeze(icv_nii.get_data()) csf_data = np.squeeze(csf_nii.get_data()) T1w_data = np.squeeze(T1w_nii.get_data()) T2w_data = np.squeeze(T2w_nii.get_data()) gt_data = np.squeeze(GT_nii.get_data()) ''' Make sure that all brain masks are binary masks, not probability ''' icv_data[icv_data > bin_tresh] = 1 icv_data[icv_data <= bin_tresh] = 0 csf_data[csf_data > bin_tresh] = 1 csf_data[csf_data <= bin_tresh] = 0 gt_data[gt_data > bin_tresh] = 1 gt_data[gt_data <= bin_tresh] = 0 ''' Read and open NAWM data if available ''' #nawm_nii = nib.load(niiDir + 'NAWM.nii.gz') #print(niiDir) #nawm_data = np.squeeze(nawm_nii.get_data()) #print('NAWM:', len(nawm_data > 0)) del csf_nii, icv_nii, T1w_nii, GT_nii # Free memory return [FLAIR_data, T1w_data, T2w_data], icv_data, csf_data, gt_data, FLAIR_nii
import nibabel as nib import skimage.io as io import numpy as np img = nib.load(r'data\test\image\Case196.nii.gz') img_arr = img.get_fdata() img_arr = np.squeeze(img_arr) io.imshow(img_arr)
if __name__ == "__main__": base_image = "/dfsdata2/zhangyao_data/DB/Abdomen1K/Task100_FourAbdOrgans/imagesTr" base_label = "/dfsdata2/zhangyao_data/DB/Abdomen1K/Task100_FourAbdOrgans/labelsTr" out = "../data/nnUNet_raw_data/Task410_SpleenBase" cases = np.sort(os.listdir(base_label)) cases = [x for x in cases if x.split("_")[0] == "spleen"] maybe_mkdir_p(out) maybe_mkdir_p(join(out, "imagesTr")) maybe_mkdir_p(join(out, "imagesTs")) maybe_mkdir_p(join(out, "labelsTr")) for c in cases: shutil.copy(join(base_image, "Spleen41", c[:-7] + "_0000.nii.gz"), join(out, "imagesTr", c[:-7] + "_0000.nii.gz")) # shutil.copy(join(base_label, c), join(out, "labelsTr", c)) nii_volume = nib.load(join(base_label, c)) seg_volume = nii_volume.get_fdata() seg_volume[seg_volume!=3] = 0 seg_volume[seg_volume==3] = 1 nib.save(nib.Nifti1Image(seg_volume, nii_volume.affine), join(out, "labelsTr", c)) print(join(out, "imagesTr", c[:-7] + "_0000.nii.gz")) json_dict = {} json_dict['name'] = "SpleenBase" json_dict['description'] = "" json_dict['tensorImageSize'] = "4D" json_dict['reference'] = "" json_dict['licence'] = "" json_dict['release'] = "0.0" json_dict['modality'] = { "0": "CT",
def bigmask_creation(subj, subjects_dir, masks_dir): import nibabel as nib import numpy as np #mangle_hemi = lambda x:'%s_%s'%(x[-9:-7],x[:-10]) #demangle_hemi = lambda x:'%s-%s.nii.gz'%(x[3:],x[:2]) #parc_orig = 'laus125' #parc = '%s_nonoverlapping' % parc_orig for parc in ('laus250_wmreg', ): #masks_dir=os.path.join(masks_top_lev_dir,parc) centroids_dir = os.path.join(masks_dir, parc) #copy parc_orig to parc if parc doesnt exist yet if not os.path.exists(masks_dir): raise ValueError('No such parcellation') #os.makedirs(masks_dir) #import shutil #shutil.copytree(centroids_dir,masks_dir,symlinks=True) mask_template = nib.load( os.path.join(centroids_dir, 'bankssts_1-lh.nii.gz')) mask_shape = mask_template.shape big_mask = np.zeros((mask_shape[0], mask_shape[1], mask_shape[2]), dtype=int) binary_mask = big_mask.copy() print 'building mask in diffusion space with shape {0}'.format( mask_shape) #create centroids print "collecting centroids" centroids = {} #make sure dirents are in alphabetical order dirents = [] for hemi_path in ('lh.nii.gz', 'rh.nii.gz'): for dirent in sorted(os.listdir(centroids_dir)): if dirent.endswith(hemi_path): dirents.append(dirent) for i, dirent in enumerate(dirents): print 'DBG: collecting centroid for subsequent mask', i, dirent try: r = nib.load(os.path.join(centroids_dir, dirent)).get_data() r[np.where(r)] = 1 centroids.update({i: np.mean(np.where(r), axis=1)}) big_mask += r * (i + 1) binary_mask += r except nib.spatialimages.ImageFileError: continue #binary_mask[binary_mask>0]=1 print "all centroids collected" xi, yi, zi = np.where(binary_mask > 1) for x, y, z in zip(xi, yi, zi): #print x,y,z vox = np.array((x, y, z)) closest_centroid = 0 dist = np.inf nr_collisions = 2 #divisor starts at 2 #ensuring that a random voxel will be chosen for i, centroid in centroids.items(): #print vox,centroid cent_dist = np.linalg.norm(vox - centroid) if cent_dist < dist: dist = cent_dist closest_centroid = i + 1 if cent_dist == dist: if np.random.random() < 1. / nr_collisions: dist = cent_dist closest_centroid = i + 1 nr_collisions += 1 big_mask[x, y, z] = closest_centroid img = nib.Nifti1Image(big_mask, mask_template.get_affine(), mask_template.get_header()) nib.save(img, os.path.join(masks_dir, 'bigmask_%s.nii.gz' % parc)) print '%s bigmask saved' % parc
def main(): parser = _build_arg_parser() args = parser.parse_args() assert_inputs_exist(parser, [args.in_hdf5, args.in_labels], args.force_labels_list) log_level = logging.WARNING if args.verbose: log_level = logging.INFO logging.basicConfig(level=log_level) coloredlogs.install(level=log_level) measures_to_compute = [] measures_output_filename = [] if args.volume: measures_to_compute.append('volume') measures_output_filename.append(args.volume) if args.streamline_count: measures_to_compute.append('streamline_count') measures_output_filename.append(args.streamline_count) if args.length: measures_to_compute.append('length') measures_output_filename.append(args.length) if args.similarity: measures_to_compute.append('similarity') measures_output_filename.append(args.similarity[1]) dict_maps_out_name = {} if args.maps is not None: for in_folder, out_name in args.maps: measures_to_compute.append(in_folder) dict_maps_out_name[in_folder] = out_name measures_output_filename.append(out_name) dict_metrics_out_name = {} if args.metrics is not None: for in_name, out_name in args.metrics: # Verify that all metrics are compatible with each other if not is_header_compatible(args.metrics[0][0], in_name): raise IOError('Metrics {} and {} do not share a compatible ' 'header'.format(args.metrics[0][0], in_name)) # This is necessary to support more than one map for weighting measures_to_compute.append((in_name, nib.load(in_name))) dict_metrics_out_name[in_name] = out_name measures_output_filename.append(out_name) assert_outputs_exist(parser, args, measures_output_filename) if not measures_to_compute: parser.error('No connectivity measures were selected, nothing ' 'to compute.') logging.info('The following measures will be computed and save: {}'.format( measures_output_filename)) if args.include_dps: if not os.path.isdir(args.include_dps): os.makedirs(args.include_dps) logging.info('data_per_streamline weighting is activated.') img_labels = nib.load(args.in_labels) data_labels = get_data_as_label(img_labels) if not args.force_labels_list: labels_list = np.unique(data_labels)[1:].tolist() else: labels_list = np.loadtxt(args.force_labels_list, dtype=np.int16).tolist() comb_list = list(itertools.combinations(labels_list, r=2)) if not args.no_self_connection: comb_list.extend(zip(labels_list, labels_list)) nbr_cpu = validate_nbr_processes(parser, args, args.nbr_processes) measures_dict_list = [] if nbr_cpu == 1: for comb in comb_list: measures_dict_list.append( _processing_wrapper([ args.in_hdf5, img_labels, comb, measures_to_compute, args.similarity, args.density_weighting, args.include_dps ])) else: pool = multiprocessing.Pool(nbr_cpu) measures_dict_list = pool.map( _processing_wrapper, zip(itertools.repeat(args.in_hdf5), itertools.repeat(img_labels), comb_list, itertools.repeat(measures_to_compute), itertools.repeat(args.similarity), itertools.repeat(args.density_weighting), itertools.repeat(args.include_dps))) pool.close() pool.join() # Removing None entries (combinaisons that do not exist) # Fusing the multiprocessing output into a single dictionary measures_dict_list = [it for it in measures_dict_list if it is not None] measures_dict = measures_dict_list[0] for dix in measures_dict_list[1:]: measures_dict.update(dix) if args.no_self_connection: total_elem = len(labels_list)**2 - len(labels_list) results_elem = len(measures_dict.keys()) * 2 - len(labels_list) else: total_elem = len(labels_list)**2 results_elem = len(measures_dict.keys()) * 2 logging.info('Out of {} possible nodes, {} contain value'.format( total_elem, results_elem)) # Filling out all the matrices (symmetric) in the order of labels_list nbr_of_measures = len(list(measures_dict.values())[0]) matrix = np.zeros((len(labels_list), len(labels_list), nbr_of_measures)) for in_label, out_label in measures_dict: curr_node_dict = measures_dict[(in_label, out_label)] measures_ordering = list(curr_node_dict.keys()) for i, measure in enumerate(curr_node_dict): in_pos = labels_list.index(in_label) out_pos = labels_list.index(out_label) matrix[in_pos, out_pos, i] = curr_node_dict[measure] matrix[out_pos, in_pos, i] = curr_node_dict[measure] # Saving the matrices separatly with the specified name or dps for i, measure in enumerate(measures_ordering): if measure == 'volume': matrix_basename = args.volume elif measure == 'streamline_count': matrix_basename = args.streamline_count elif measure == 'length': matrix_basename = args.length elif measure == 'similarity': matrix_basename = args.similarity[1] elif measure in dict_metrics_out_name: matrix_basename = dict_metrics_out_name[measure] elif measure in dict_maps_out_name: matrix_basename = dict_maps_out_name[measure] else: matrix_basename = measure np.save(matrix_basename, matrix[:, :, i])
def read_ants_stats(ants_stats_file, ants_brainvols_file, mri_file, force_error=True): """ Reads in an ANTS stats file along with associated mri_file (for voxel sizes) and converts to a measures dictionary with keys: ['structure':XX, 'items': [{'name': 'NVoxels', 'description': 'Number of voxels','value':XX, 'units':'unitless'}, {'name': 'Volume_mm3', 'description': ''Volume', 'value':XX, 'units':'mm^3'}]] :param ants_stats_file: path to ANTS segmentation output file named "antslabelstats" :param ants_brainvols_file: path to ANTS segmentation output for Bvol, Gvol, Wvol, and ThicknessSum (called antsbrainvols" :param mri_file: mri file to extract voxel sizes from :param freesurfer_lookup_table: Lookup table used to map 1st column of ants_stats_file label numbers to structure names :return: measures is a list of dictionaries as defined above """ # fs_lookup_table = loadfreesurferlookuptable(freesurfer_lookup_table) # open stats file, brain vols file as pandas dataframes ants_stats = pd.read_csv(ants_stats_file) brain_vols = pd.read_csv(ants_brainvols_file) # load mri_file and extract voxel sizes img = nib.load(mri_file) vox_size = np.product(list(img.header.get_zooms())) with open(cde_file, "r") as fp: ants_cde = json.load(fp) measures = [] changed = False # iterate over columns in brain vols for key, j in brain_vols.T.iterrows(): value = j.values[0] keytuple = ANTSDKT( structure=key if "vol" in key.lower() else "Brain", hemi=None, measure="Volume" if "vol" in key.lower() else key, unit="mm^3" if "vol" in key.lower() else "mm" if "Thickness" in key else None, ) if str(keytuple) not in ants_cde: ants_cde["count"] += 1 ants_cde[str(keytuple)] = { "id": f"{ants_cde['count']:0>6d}", "label": f"{key} ({keytuple.unit})", } if force_error: raise ValueError( f"Key {keytuple} not found in ANTS data elements file") changed = True if "vol" in key.lower(): measures.append( (f'{ants_cde[str(keytuple)]["id"]}', str(int(value)))) else: measures.append((f'{ants_cde[str(keytuple)]["id"]}', str(value))) # iterate over columns in brain vols for row in ants_stats.iterrows(): structure = None for key, val in row[1].items(): if key == "Label": segid = int(val) structure = get_id_to_struct(segid) if structure is None: raise ValueError( f"{int(val):d} did not return any structure") continue if "VolumeInVoxels" not in key and "Area" not in key: continue hemi, measure, unit = get_details(key, structure) key_tuple = ANTSDKT(structure=structure, hemi=hemi, measure=measure, unit=unit) label = f"{structure} {measure} ({unit})" if str(key_tuple) not in ants_cde: ants_cde["count"] += 1 ants_cde[str(key_tuple)] = { "id": f"{ants_cde['count']:0>6d}", "structure_id": segid, "label": label, } if force_error: raise ValueError( f"Key {key_tuple} not found in ANTS data elements file" ) changed = True # measures.append((f'{ants_cde[str(key_tuple)]["id"]}', str(val))) if "VolumeInVoxels" in key: measure = "Volume" unit = "mm^3" key_tuple = ANTSDKT(structure=structure, hemi=hemi, measure=measure, unit=unit) label = f"{structure} {measure} ({unit})" if str(key_tuple) not in ants_cde: ants_cde["count"] += 1 ants_cde[str(key_tuple)] = { "id": f"{ants_cde['count']:0>6d}", "structure_id": segid, "label": label, } if force_error: raise ValueError( f"Key {key_tuple} not found in ANTS data elements file" ) changed = True measures.append( (f'{ants_cde[str(key_tuple)]["id"]}', str(val * vox_size))) if changed: with open(cde_file, "w") as fp: json.dump(ants_cde, fp, indent=2) return measures
def linearly_corrected_matrix_creation(subj, subjdir, nmr_dir, parclist_dir, masks_dir, shell=None, trk_stem='tracts20k'): import subprocess import numpy as np import nibabel as nib import os.path as op print 'moving on to harmonic mean algorithm' parc = 'laus250' parc_stem = 'wmreg' tracts_stem = trk_stem if shell is None else '%s_sgsh_%s' % (trk_stem, shell) #extract surf array if not os.path.exists( os.path.join(subjdir, subj, 'label', 'surf_%s.table.npy' % parc)): os.environ['SUBJECTS_DIR'] = nmr_dir for hemi in ('lh', 'rh'): labels = [] if not op.exists( op.join(subjdir, subj, 'label', '%s.%s.annot' % (hemi, parc))): label2annot_cmd = ( 'mris_label2annot --s %s --h %s --ldir %s ' '--a %s --ctab %s --no-unknown' % ('%s' % subj, hemi, os.path.join(subjdir, subj, 'label', parc), parc, os.path.join(parclist_dir, '%s_ctab_%s.txt' % (parc, hemi)))) print label2annot_cmd w = subprocess.call(label2annot_cmd, shell=True) #mris_anatomical_stats is needed to get the surface area of each #label which is not the same as the number of vertices if not op.exists( op.join(subjdir, subj, 'label', '%s.%s.table' % (hemi, parc))): extract_sa_cmd = 'mris_anatomical_stats -a %s -f %s %s %s' % ( os.path.join(subjdir, subj, 'label', '%s.%s.annot' % (hemi, parc)), os.path.join(subjdir, subj, 'label', '%s.%s.table' % (hemi, parc)), '%s' % subj, hemi) print extract_sa_cmd p = subprocess.call(extract_sa_cmd, shell=True) #build surf array lh_table = open( os.path.join(subjdir, subj, 'fsrecon', 'label', 'lh.%s.table' % parc)) rh_table = open( os.path.join(subjdir, subj, 'fsrecon', 'label', 'rh.%s.table' % parc)) labels_cmp_fname = op.join(parclist_dir, 'orders', '%s_cmp_all.txt' % parc) labels = open(labels_cmp_fname) a = [] for ln in labels: a.append(ln.strip()) surfArray = [0] * len(a) for i, r in enumerate(a): if r[:2] == 'rh': for line in rh_table: if filter(None, line.split(" "))[0].startswith(r[3:]): surfArray[i] = filter(None, line.split(" "))[2] if r[:2] == 'lh': for line in lh_table: if filter(None, line.split(" "))[0].startswith(r[3:]): print line surfArray[i] = filter(None, line.split(" "))[2] rh_table.seek(0, 0) lh_table.seek(0, 0) np.save( os.path.join(subjdir, subj, 'fsrecon', 'label', 'surf_%s.table.npy' % parc), surfArray) for file in (lh_table, rh_table, labels): file.close() #calculate fiber lengths and then add values to matrix in #single iteration over track file roi_mask = nib.load( os.path.join(masks_dir, 'bigmask_%s_%s.nii.gz' % (parc, parc_stem))).get_data() nr_rois = int(np.max(roi_mask)) connection_matrix = np.zeros((nr_rois, nr_rois)) def euclidean_track_length(xyz_array): '''see docstring in connectomemapper util.length''' xyz = np.asarray(xyz_array) if xyz.shape[0] < 2: return 0 dists = np.sqrt((np.diff(xyz, axis=0)**2).sum(axis=1)) return np.sum(dists) def fiber_endpoints(fiber, voxel_size, roi_mask, fov): ''' returns a 2x1 matrix with indices of the masks containing the start and end points of this fiber. adapted from cmp.connectionmatrix.creatematrix ''' f = fiber[0] start_xyz = np.array(f[0, :], dtype=int) end_xyz = np.array(f[-1, :], dtype=int) #account for the voxel size in the trk file which is #some random number based on the trk file format. #also account for the difference in FOV between the trk #file and the ROImask image which is independent. #print fov, roi_mask.shape, voxel_size # print voxel_size voxel_size = (2, 2, 2) # voxel_size = (1,1,2) voxel_size = voxel_size * fov / roi_mask.shape start_voxel = start_xyz // voxel_size end_voxel = end_xyz // voxel_size #DSI studio prints out voxel size as 1,1,1 no matter what (I think?) #start_voxel = start_xyz // (voxel_size*2) #end_voxel = end_xyz // (voxel_size*2) # print fov, roi_mask.shape # print start_xyz, end_xyz, voxel_size, start_voxel, end_voxel # dims_to_flip = (0,1,) # dims_to_flip = (1,2,) dims_to_flip = (1, ) for i in dims_to_flip: start_voxel[i] = roi_mask.shape[i] - start_voxel[i] - 1 end_voxel[i] = roi_mask.shape[i] - end_voxel[i] - 1 # print roi_mask[start_voxel[0], start_voxel[1], start_voxel[2]] # print [start_voxel[i] for i in xrange(3)] # print [[start_voxel[i]] for i in xrange(3)] # print roi_mask[[[start_voxel[i]] for i in xrange(3)]] start_roi = [roi_mask[[[start_voxel[i]] for i in xrange(3)]]] end_roi = [roi_mask[[[end_voxel[i]] for i in xrange(3)]]] #print start_roi, end_roi #unbox from list comprehension return int(start_roi[0]) - 1, int(end_roi[0]) - 1 #TRACKVIS WAY low_cutoff, high_cutoff = 20, 500 #if not os.path.exists(os.path.join(subjdir, subj, 'fiber_lengths.npy')): # tracks_file = os.path.join(subjdir, subj, '%s.trk'%tracts_stem) # streams, hdr = nib.trackvis.read(tracks_file, as_generator=True) #if int(hdr['n_count']) != nr_fibers: # raise Exception('The number of fibers is is not 20000') # voxel_size = np.array(hdr['voxel_size'], dtype=int) # nr_fibers = hdr['dim'] #low_cutoff, high_cutoff = -np.inf, np.inf # for i,fib in enumerate(streams): # fiber_length = euclidean_track_length(fib[0]) # # #apply fiber cutoffs -- length filtering as in CMP # #spline filtering should be done earlier if needed # if not low_cutoff < fiber_length < high_cutoff: # continue # # start_roi, end_roi = fiber_endpoints(fib, voxel_size, roi_mask, # hdr['dim']) # # if start_roi==-1 or end_roi==-1: # continue # connection_matrix[start_roi, end_roi] += 1./fiber_length # #np.save(os.path.join(subjdir, subj, 'fiber_lengths.npy'), fiber_lengths) #TEXT FILE WAY text_file = os.path.join(subjdir, subj, '%s.txt' % tracts_stem) with open(text_file) as fd: for ln in fd: tract = np.reshape(np.array(ln.split(), dtype=float), (-1, 3)) fiber_length = euclidean_track_length(tract) if not low_cutoff < fiber_length < high_cutoff: continue #get endpoints manually #no dealing with stupid trackvis space start_voxel = np.floor(tract[0]) end_voxel = np.floor(tract[-1]) #flip dimensions dims_to_flip = (1, ) for i in dims_to_flip: start_voxel[i] = roi_mask.shape[i] - start_voxel[i] - 1 end_voxel[i] = roi_mask.shape[i] - end_voxel[i] - 1 start_roi = [roi_mask[[[start_voxel[i]] for i in xrange(3)]]] start_roi = int(start_roi[0]) - 1 end_roi = [roi_mask[[[end_voxel[i]] for i in xrange(3)]]] end_roi = int(end_roi[0]) - 1 if start_roi == -1 or end_roi == -1: continue connection_matrix[start_roi, end_roi] += 1. / fiber_length connection_matrix = connection_matrix + connection_matrix.T print 'finished evaluating fibers' #normalize by surface area roisl, roisr = [], [] print "didn't find these ROIs" with open(os.path.join(parclist_dir, '%s_entries' % parc)) as fd: for ln in fd: for hemi, rois in zip(('lh', 'rh'), (roisl, roisr)): roi = '%s-%s' % (ln.strip(), hemi) if not os.path.exists( os.path.join(masks_dir, '%s_%s' % (parc, parc_stem), '%s.nii.gz' % roi)): print masks_dir, '%s_%s' % (parc, parc_stem), roi continue rois.append(roi) rois = roisl + roisr roi_ord = [] mangle_hemi = lambda s: '%s-%s' % (s[3:], s[:2]) with open(os.path.join(parclist_dir, '%s_cmp.txt' % parc)) as fd: for ln in fd: roi_ord.append(mangle_hemi(ln.strip())) surfs_table = np.load( os.path.join(subjdir, subj, 'fsrecon', 'label', 'surf_%s.table.npy' % parc)) sa = [int(surfs_table[roi_ord.index(roi)]) for roi in rois] normalization = (np.tile(sa, (np.size(sa), 1)) + np.tile(sa, (np.size(sa), 1)).T) print 'finished normalizing' connection_matrix = connection_matrix * 2 / normalization #np.save( os.path.join(subjdir, subj, 'linear_harmonic_connections.npy'), connection_matrix) #np.save( os.path.join(subjdir, subj, 'linear_normalization.npy'), normalization) np.fill_diagonal(connection_matrix, 0) np.save( os.path.join(subjdir, subj, 'linear_harmonic_%s_alph_%s.npy' % (parc, trk_stem)), connection_matrix)
def nib_load(file_name): proxy = nib.load(file_name) data = proxy.get_data().astype('float32') proxy.uncache() return data
from nibabel.processing import resample_to_output from tqdm import tqdm import numpy as np path_bis = "SpineWeb/SpineWeb_15_downsampled" if not os.path.isdir(path_bis): os.mkdir(path_bis) path_img = 'SpineWeb/SpineWeb_15' for folder in tqdm(os.listdir(path_img)): if "sub" in folder: im_file = os.path.join(path_img, folder) + "/" + folder + "_CT.nii.gz" label_file = os.path.join( path_img, folder) + "/" + folder + "_segmentation.nii.gz" im = nib.load(im_file) seg = nib.load(label_file) im = resample_to_output(im, (1, 1, 3), order=3) seg = resample_to_output(seg, (1, 1, 3), order=0) affine = seg.affine un = np.unique(seg) for i in range(1, len(un)): seg[seg == un[i]] = len(un) - i if folder == "sub-013": print("resampling 13") seg[seg < 4] = 0 seg[seg > 0] = seg[seg > 0] - 3 if folder == "sub-011":
def nii2cmu(nifti_file, mask_file=None, smooth=None, zscore=False, zscore_by_rest=False, rest_starts=None, rest_ends=None): if zscore_by_rest: rest_starts = rest_starts.strip('[]') rest_starts = [int(s) for s in rest_starts.split(',')] rest_ends = rest_ends.strip('[]') rest_ends = [int(s) for s in rest_ends.split(',')] with warnings.catch_warnings(): warnings.simplefilter("ignore") image = nib.load(nifti_file) mask = NiftiMasker(mask_strategy='background', smoothing_fwhm=smooth, standardize=False) if mask_file is None: mask.fit(nifti_file) else: mask.fit(mask_file) header = image.header sform = image.get_sform() voxel_size = header.get_zooms() voxel_activations = np.float64(mask.transform(nifti_file)).transpose() rest_activations = voxel_activations[:, rest_starts[0]:rest_ends[0]] for i in range(1, len(rest_starts)): rest_activations = np.hstack( (rest_activations, voxel_activations[:, rest_starts[i]:rest_ends[i]])) standard_transform = sklearn.preprocessing.StandardScaler().fit( rest_activations.T) voxel_activations = standard_transform.transform(voxel_activations.T).T voxel_coordinates = np.array(np.nonzero( mask.mask_img_.dataobj)).transpose() voxel_coordinates = np.hstack( (voxel_coordinates, np.ones((voxel_coordinates.shape[0], 1)))) voxel_locations = (voxel_coordinates @ sform.T)[:, :3] else: with warnings.catch_warnings(): warnings.simplefilter("ignore") image = nib.load(nifti_file) mask = NiftiMasker(mask_strategy='background', smoothing_fwhm=smooth, standardize=zscore) if mask_file is None: mask.fit(nifti_file) else: mask.fit(mask_file) header = image.header sform = image.get_sform() voxel_size = header.get_zooms() voxel_activations = np.float64(mask.transform(nifti_file)).transpose() voxel_coordinates = np.array(np.nonzero( mask.mask_img_.dataobj)).transpose() voxel_coordinates = np.hstack( (voxel_coordinates, np.ones((voxel_coordinates.shape[0], 1)))) voxel_locations = (voxel_coordinates @ sform.T)[:, :3] return {'data': voxel_activations, 'R': voxel_locations}
group_img, display_mode='yz', cut_coords=[-10, 10], colorbar=False, cmap='Spectral_r', threshold=90, vmin=90, vmax=300, #title=method, dim=1, annotate=False, draw_cross=False, black_bg=True, figure=fig, ) img_tmp = nb.load(template_gm) img_tmp = new_img_like(img_tmp, (img_tmp.get_data() >= 0.05).astype('int'), copy_header=True) display.add_contours(img_tmp, color='w') fig.savefig('%s/group_stdev_%s.svg' % (res_path, method)) stdev_values.append([method, group_img.get_data()]) # Plot histograms of voxel distribution above threshold sns.set_style('darkgrid') plt.style.use('seaborn-colorblind') threshold = 5 fig = plt.figure(figsize=(8, 4)) for m, t in stdev_values: sns.kdeplot(t[t > threshold], shade=True,
def group_reproducibility_metrics(mask_images, contrast_images, variance_images, thresholds, ngroups, method, cluster_threshold=10, number_of_samples=10, sigma=6., do_clusters=True, do_voxels=True, do_peaks=True, swap=False): """ Main function to perform reproducibility analysis, including nifti1 io Parameters ---------- threshold: list or 1-d array, the thresholds to be tested Returns ------- cluster_rep_results: dictionary, results of cluster-level reproducibility analysi voxel_rep_results: dictionary, results of voxel-level reproducibility analysis peak_rep_results: dictionary, results of peak-level reproducibility analysis """ from nibabel import load from ..mask import intersect_masks if ((len(variance_images) == 0) & (method is not 'crfx')): raise ValueError('Variance images are necessary') nsubj = len(contrast_images) # compute the group mask affine = get_affine(load(mask_images[0])) mask = intersect_masks(mask_images, threshold=0) > 0 domain = grid_domain_from_binary_array(mask, affine) # read the data group_con = [] group_var = [] for s in range(nsubj): group_con.append(load(contrast_images[s]).get_data()[mask]) if len(variance_images) > 0: group_var.append(load(variance_images[s]).get_data()[mask]) group_con = np.squeeze(np.array(group_con)).T group_con[np.isnan(group_con)] = 0 if len(variance_images) > 0: group_var = np.squeeze(np.array(group_var)).T group_var[np.isnan(group_var)] = 0 group_var = np.maximum(group_var, 1.e-15) # perform the analysis voxel_rep_results = {} cluster_rep_results = {} peak_rep_results = {} for ng in ngroups: if do_voxels: voxel_rep_results.update({ng: {}}) if do_clusters: cluster_rep_results.update({ng: {}}) if do_peaks: peak_rep_results.update({ng: {}}) for th in thresholds: kappa = [] cls = [] pk = [] kwargs = {'threshold': th, 'csize': cluster_threshold} for i in range(number_of_samples): if do_voxels: kappa.append( voxel_reproducibility(group_con, group_var, domain, ng, method, swap, **kwargs)) if do_clusters: cls.append( cluster_reproducibility(group_con, group_var, domain, ng, sigma, method, swap, **kwargs)) if do_peaks: pk.append( peak_reproducibility(group_con, group_var, domain, ng, sigma, method, swap, **kwargs)) if do_voxels: voxel_rep_results[ng].update({th: np.array(kappa)}) if do_clusters: cluster_rep_results[ng].update({th: np.array(cls)}) if do_peaks: peak_rep_results[ng].update({th: np.array(cls)}) return voxel_rep_results, cluster_rep_results, peak_rep_results
img_dir = 'E:\\abhivanth\\normalized_input' out_dir = 'in_patches_20_20_16' # x_shape = 20 # y_shape = 20 # z_shape = 16 x_shape = 20 y_shape = 20 z_shape = 16 #def main(): fns = glob(os.path.join(img_dir, '*.nii*')) for fn in fns: _, base, ext = split_filename(fn) img = nib.load(fn).get_data().astype(np.float32).squeeze() if img.ndim != 3: print( f'Only 3D data supported. File {base}{ext} has dimension {img.ndim}. Skipping.' ) continue input_filename = fn reader = itk.imread(input_filename, itk.F) reader.Update() image = reader # if (img.shape[0] % int(x_shape)) != 0: # print(f'File {base}{ext} does not ensure equal split of input image along x axis') # continue