def save_streamlines(streamlines: list, path: str, to_lps=True, binary=False): """ Saves the given streamlines to a file Parameters ---------- streamlines The streamlines we want to save path The path we save the streamlines to to_lps A boolean indicating whether we want to save them in the LPS format instead of RAS (True by default) binary If True, the file will be written in a binary format. Returns ------- """ save_vtk_streamlines(streamlines, path, to_lps=to_lps, binary=binary)
for p in range(0, pointsPerLine[i]): #if( np.isnan(np.sum(points[p]))==0): templine.append(points[p]) if (len(templine) > 1): # and len(templine) == pointsPerLine[i]): streamlines.append(templine) first = first + pointsPerLine[i] return streamlines #path="/home/uzair/PycharmProjects/Unfolding/data/diffusionSimulations_nonConformal_scale/" ntracking = loc_track(path ,default_sphere) coords = coordinates.coordinates(path,'') utracking = loc_track(path+'Unfolded/',default_sphere,coords=coords,npath=path,UParams=Uparams) u2n_streamlines=unfold2nativeStreamlines(utracking,coords) streamline.save_vtk_streamlines(ntracking.streamlines, path+"native_streamlines.vtk") streamline.save_vtk_streamlines(utracking.streamlines, path + "Unfolded/unfold_streamlines.vtk") streamline.save_vtk_streamlines(u2n_streamlines, path + "from_unfold_streamlines.vtk") def plot_streamlines(streamlines): if has_fury: # Prepare the display objects. color = colormap.line_colors(streamlines) streamlines_actor = actor.line(streamlines, colormap.line_colors(streamlines)) # Create the 3D display.
def save_to_file(self, path): """Save the calculated streamlines to file""" if self.streamlines is None: raise StreamlinesNotTrackedError(self) from None save_vtk_streamlines(self.streamlines, path)
def track(self, ang_thr=None, default_sphere=default_sphere): default_sphere = default_sphere.subdivide() default_sphere = default_sphere.subdivide() default_sphere = default_sphere.subdivide() default_sphere.vertices = np.append(default_sphere.vertices, [[1, 0, 0]]) default_sphere.vertices = np.append(default_sphere.vertices, [[-1, 0, 0]]) default_sphere.vertices = np.append(default_sphere.vertices, [[0, 1, 0]]) default_sphere.vertices = np.append(default_sphere.vertices, [[0, -1, 0]]) default_sphere.vertices = default_sphere.vertices.reshape([-1, 3]) # this needs to be moved into tracking class (in unfoldTracking) def loc_track(path, default_sphere, coords=None, npath=None, UParams=None, ang_thr=None): data, affine = load_nifti(path + 'data.nii.gz') data[np.isnan(data) == 1] = 0 mask, affine = load_nifti(path + 'nodif_brain_mask.nii.gz') mask[np.isnan(mask) == 1] = 0 mask[:, :, 1:] = 0 stopper = copy.deepcopy(mask) #stopper[:, :, :] = 1 gtab = gradient_table(path + 'bvals', path + 'bvecs') csa_model = CsaOdfModel(gtab, smooth=1, sh_order=12) peaks = peaks_from_model(csa_model, data, default_sphere, relative_peak_threshold=0.99, min_separation_angle=25, mask=mask) if ang_thr is not None: peaks.ang_thr = ang_thr if os.path.exists(path + 'grad_dev.nii.gz'): gd, affine_g = load_nifti(path + 'grad_dev.nii.gz') nmask, naffine = load_nifti(npath + 'nodif_brain_mask.nii.gz') nmask[np.isnan(nmask) == 1] = 0 nmask[:, :, 1:] = 0 seedss = copy.deepcopy(nmask) seedss = utils.seeds_from_mask(seedss, naffine, [2, 2, 2]) useed = [] UParams = coords.Uparams for seed in seedss: us = coords.rFUa_xyz(seed[0], seed[1], seed[2]) vs = coords.rFVa_xyz(seed[0], seed[1], seed[2]) ws = coords.rFWa_xyz(seed[0], seed[1], seed[2]) condition = us >= UParams.min_a and us <= UParams.max_a and vs >= UParams.min_b and vs <= UParams.max_b \ and ws >= UParams.min_c and ws <= UParams.max_c if condition == True: useed.append([float(us), float(vs), float(ws)]) seeds = np.asarray(useed) else: gd = None seedss = copy.deepcopy(mask) seeds = utils.seeds_from_mask(seedss, affine, [2, 2, 2]) stopping_criterion = BinaryStoppingCriterion(stopper) tracked = tracking(peaks, stopping_criterion, seeds, affine, graddev=gd, sphere=default_sphere) tracked.localTracking() return tracked # this needs to be moved to unfoldStreamlines (in unfoldTracking) def unfold2nativeStreamlines(tracking, coords): points, X = getPointsData(coords.X_uvwa_nii) points, Y = getPointsData(coords.Y_uvwa_nii) points, Z = getPointsData(coords.Z_uvwa_nii) allLines = tracking.streamlines.get_data() x = coords.rFX_uvwa(allLines[:, 0], allLines[:, 1], allLines[:, 2]) y = coords.rFY_uvwa(allLines[:, 0], allLines[:, 1], allLines[:, 2]) z = coords.rFZ_uvwa(allLines[:, 0], allLines[:, 1], allLines[:, 2]) allLines = np.asarray([x, y, z]).T pointsPerLine = tracking.NpointsPerLine streamlines = [] first = 0 for i in range(0, len(pointsPerLine) - 1): templine = [] points = allLines[first:first + pointsPerLine[i]] for p in range(0, pointsPerLine[i]): if (np.isnan(np.sum(points[p])) == 0): templine.append(points[p]) if (len(templine) > 1): # and len(templine) == pointsPerLine[i]): streamlines.append(templine) first = first + pointsPerLine[i] return streamlines # path="/home/uzair/PycharmProjects/Unfolding/data/diffusionSimulations_nonConformal_scale/" ntracking = loc_track(self.npath, default_sphere, ang_thr=ang_thr) coords = coordinates.coordinates(self.npath, '') utracking = loc_track(self.upath, default_sphere, coords=coords, npath=self.npath, UParams=self.Uparams, ang_thr=ang_thr) u2n_streamlines = unfold2nativeStreamlines(utracking, coords) streamline.save_vtk_streamlines(ntracking.streamlines, self.npath + "native_streamlines.vtk") streamline.save_vtk_streamlines(utracking.streamlines, self.upath + "unfold_streamlines.vtk") streamline.save_vtk_streamlines( u2n_streamlines, self.npath + "from_unfold_streamlines.vtk")
return out base = "/home/u2hussai/scratch/simulations/diffusionSimulations_LambdaStep-k-60_scale-50_res-" npath=base + str(int(res[i_io] * 1000)) + "_um-drt-" +str(int(drt[l_io] * 100)) +"_w-"+\ str(int(round(w[j_io],5)*1000))+"_angthr-" + str(int(ang_thr[k_io])) + "_beta-"+str(int(beta[b]*100))+"/" maskpath=base + str(int(res[0] * 1000)) + "_um-drt-" +str(int(drt[l_io] * 100)) +"_w-"+\ str(int(round(w[j_io],5)*1000))+"_angthr-" + str(int(ang_thr[k_io])) + "_beta-"+str(int(beta[b]*100))+"/" nlines = lines(npath + 'native_streamlines.vtk') ulines = lines(npath + 'from_unfold_streamlines.vtk') simlines = linesFromSims(npath, nlines, ulines, phi, phiInv, drt[l_io], maskpath) simlines.filter(simlines.nlines, dphi) simlines.filter(simlines.ulines, dphi) save_vtk_streamlines(simlines.nlines.seedlines, npath + 'seedlines_tang_native.vtk') save_vtk_streamlines(simlines.ulines.seedlines, npath + 'seedlines_tang_unfold.vtk') sens_roc[ttt, 0], spec_roc[ttt, 0], tangCount[0], radCount[ 0] = simlines.thresholdSenSpec(simlines.nlines, thres[ttt]) sens_roc[ttt, 1], spec_roc[ttt, 1], tangCount[1], radCount[ 1] = simlines.thresholdSenSpec(simlines.ulines, thres[ttt]) #print(sens_roc) tangCountPara[0] = len(simlines.ntanglines) tangCountPara[1] = len(simlines.utanglines) radCountPara[0] = len(simlines.nradlines) radCountPara[1] = len(simlines.uradlines)