def write_trk(fname, streamlines, affine=None, shape=None): """ Write out a .trk file Parameters ---------- fname : str Full path to save the file into streamlines : list A list of arrays of 3D coordinates affine : array (4,4), optional. An affine transformation associated with the streamlines. Defaults to identity. shape : 3-element tuple, optional Spatial dimensions of an image associated with the streamlines. Defaults to not be set in the file header. """ if affine is None: affine = np.eye(4) zooms = np.sqrt((affine * affine).sum(0)) streamlines = dtu.move_streamlines(streamlines, affine) data = ((s, None, None) for s in streamlines) voxel_order = nib.orientations.aff2axcodes(affine) voxel_order = "".join(voxel_order) hdr = nib.trackvis.empty_header() hdr['voxel_size'] = zooms[:3] hdr['voxel_order'] = voxel_order hdr['vox_to_ras'] = affine if shape is not None: hdr['dim'] = shape trackvis.write(fname, data, hdr, points_space="rasmm")
def write_trk(fname, streamlines, affine=None, shape=None): """ Write out a .trk file Parameters ---------- fname : str Full path to save the file into streamlines : list A list of arrays of 3D coordinates affine : array (4,4), optional. An affine transformation associated with the streamlines. Defaults to identity. shape : 3-element tuple, optional Spatial dimensions of an image associated with the streamlines. Defaults to not be set in the file header. """ if affine is None: affine = np.eye(4) zooms = np.sqrt((affine * affine).sum(0)) streamlines = move_streamlines(streamlines, affine) data = ((s, None, None) for s in streamlines) voxel_order = nib.orientations.aff2axcodes(affine) voxel_order = "".join(voxel_order) hdr = nib.trackvis.empty_header() hdr['voxel_size'] = zooms[:3] hdr['voxel_order'] = voxel_order hdr['vox_to_ras'] = affine if shape is not None: hdr['dim'] = shape trackvis.write(fname, data, hdr, points_space="rasmm")
def _run_interface(self, runtime): dx, dy, dz = get_data_dims(self.inputs.image_file) vx, vy, vz = get_vox_dims(self.inputs.image_file) image_file = nb.load(self.inputs.image_file) affine = image_file.get_affine() out_filename = op.abspath(self.inputs.out_filename) # Reads MRTrix tracks header, streamlines = read_mrtrix_tracks(self.inputs.in_file, as_generator=True) iflogger.info("MRTrix Header:") iflogger.info(header) # Writes to Trackvis trk_header = nb.trackvis.empty_header() trk_header["dim"] = [dx, dy, dz] trk_header["voxel_size"] = [vx, vy, vz] trk_header["n_count"] = header["count"] if isdefined(self.inputs.matrix_file) and isdefined(self.inputs.registration_image_file): iflogger.info("Applying transformation from matrix file {m}".format(m=self.inputs.matrix_file)) xfm = np.genfromtxt(self.inputs.matrix_file) iflogger.info(xfm) registration_image_file = nb.load(self.inputs.registration_image_file) reg_affine = registration_image_file.get_affine() r_dx, r_dy, r_dz = get_data_dims(self.inputs.registration_image_file) r_vx, r_vy, r_vz = get_vox_dims(self.inputs.registration_image_file) iflogger.info("Using affine from registration image file {r}".format(r=self.inputs.registration_image_file)) iflogger.info(reg_affine) trk_header["vox_to_ras"] = reg_affine trk_header["dim"] = [r_dx, r_dy, r_dz] trk_header["voxel_size"] = [r_vx, r_vy, r_vz] affine = np.dot(affine, np.diag(1.0 / np.array([vx, vy, vz, 1]))) transformed_streamlines = transform_to_affine(streamlines, trk_header, affine) aff = affine_from_fsl_mat_file(xfm, [vx, vy, vz], [r_vx, r_vy, r_vz]) iflogger.info(aff) axcode = aff2axcodes(reg_affine) trk_header["voxel_order"] = axcode[0] + axcode[1] + axcode[2] final_streamlines = move_streamlines(transformed_streamlines, aff) trk_tracks = ((ii, None, None) for ii in final_streamlines) trk.write(out_filename, trk_tracks, trk_header) iflogger.info("Saving transformed Trackvis file as {out}".format(out=out_filename)) iflogger.info("New TrackVis Header:") iflogger.info(trk_header) else: iflogger.info( "Applying transformation from scanner coordinates to {img}".format(img=self.inputs.image_file) ) axcode = aff2axcodes(affine) trk_header["voxel_order"] = axcode[0] + axcode[1] + axcode[2] trk_header["vox_to_ras"] = affine transformed_streamlines = transform_to_affine(streamlines, trk_header, affine) trk_tracks = ((ii, None, None) for ii in transformed_streamlines) trk.write(out_filename, trk_tracks, trk_header) iflogger.info("Saving Trackvis file as {out}".format(out=out_filename)) iflogger.info("TrackVis Header:") iflogger.info(trk_header) return runtime
def _run_interface(self, runtime): dx, dy, dz = get_data_dims(self.inputs.image_file) vx, vy, vz = get_vox_dims(self.inputs.image_file) image_file = nb.load(self.inputs.image_file) affine = image_file.get_affine() out_filename = op.abspath(self.inputs.out_filename) #Reads MRTrix tracks header, streamlines = read_mrtrix_tracks(self.inputs.in_file, as_generator=True) iflogger.info('MRTrix Header:') iflogger.info(header) # Writes to Trackvis trk_header = nb.trackvis.empty_header() trk_header['dim'] = [dx,dy,dz] trk_header['voxel_size'] = [vx,vy,vz] trk_header['n_count'] = header['count'] if isdefined(self.inputs.matrix_file) and isdefined(self.inputs.registration_image_file): iflogger.info('Applying transformation from matrix file {m}'.format(m=self.inputs.matrix_file)) xfm = np.genfromtxt(self.inputs.matrix_file) iflogger.info(xfm) registration_image_file = nb.load(self.inputs.registration_image_file) reg_affine = registration_image_file.get_affine() r_dx, r_dy, r_dz = get_data_dims(self.inputs.registration_image_file) r_vx, r_vy, r_vz = get_vox_dims(self.inputs.registration_image_file) iflogger.info('Using affine from registration image file {r}'.format(r=self.inputs.registration_image_file)) iflogger.info(reg_affine) trk_header['vox_to_ras'] = reg_affine trk_header['dim'] = [r_dx,r_dy,r_dz] trk_header['voxel_size'] = [r_vx,r_vy,r_vz] affine = np.dot(affine,np.diag(1./np.array([vx, vy, vz, 1]))) transformed_streamlines = transform_to_affine(streamlines, trk_header, affine) aff = affine_from_fsl_mat_file(xfm, [vx,vy,vz], [r_vx,r_vy,r_vz]) iflogger.info(aff) axcode = aff2axcodes(reg_affine) trk_header['voxel_order'] = axcode[0]+axcode[1]+axcode[2] final_streamlines = move_streamlines(transformed_streamlines, aff) trk_tracks = ((ii,None,None) for ii in final_streamlines) trk.write(out_filename, trk_tracks, trk_header) iflogger.info('Saving transformed Trackvis file as {out}'.format(out=out_filename)) iflogger.info('New TrackVis Header:') iflogger.info(trk_header) else: iflogger.info('Applying transformation from scanner coordinates to {img}'.format(img=self.inputs.image_file)) axcode = aff2axcodes(affine) trk_header['voxel_order'] = axcode[0]+axcode[1]+axcode[2] trk_header['vox_to_ras'] = affine transformed_streamlines = transform_to_affine(streamlines, trk_header, affine) trk_tracks = ((ii,None,None) for ii in transformed_streamlines) trk.write(out_filename, trk_tracks, trk_header) iflogger.info('Saving Trackvis file as {out}'.format(out=out_filename)) iflogger.info('TrackVis Header:') iflogger.info(trk_header) return runtime
def dump_qsdr2MNI_track_lookup(self, output, savetrk=False): """Converts from trackvis voxmm to ijk. Parameters: =========== output:str .pkl file where the voxel to streamline id mapping is saved savetrk:str path to where the trackvis file will be saved. NOTE: ===== REQUIRES that this trackdataset came from a trk file, as the header is essential to transforming tracks to ijk. From experience, tracks brought into alignment with the MNI152 template via DTK's track_transform appear as LAS -> LPS in trackvis's dataset info panel. I have been able to get qsdr2MNI to look correct in trackvis by converting it to LAS ordering. LAS also relates voxmm coordinates to MNI152 ijk by a scalar factor. """ # index tracks by the voxels they pass through mni_voxel_size = np.array([2.]*3) tracks_at_ijk = defaultdict(set) output_voxmm = [] for trknum, trk in enumerate(self.tracks): data = set([trknum]) # convert voxmm to LAS ijk = self.voxmm_to_ijk(trk, to_order="LAS") pretty_ijk = self.voxmm_to_ijk(trk, to_order="LAS", floor=False) # QSDR from DSI Studio has a different bounding box. ijk = ijk + np.array([6,7,11]) pretty_ijk = pretty_ijk + np.array([6,7,11]) output_voxmm.append(pretty_ijk*mni_voxel_size) # Floor at the end? unq = track_math.remove_duplicates(ijk).astype(np.int32) for _ijk in unq: tracks_at_ijk[tuple(_ijk)].update(data) self.tracks_at_ijk = tracks_at_ijk print "original", self.tracks.shape, "tracks" self.tracks = np.array(output_voxmm) print "replaced by", self.tracks.shape, "tracks" # Save the hash dump fop = open(output,"wb") pickle.dump(self,fop,pickle.HIGHEST_PROTOCOL) fop.close() # Write out a new trackvis file if savetrk: # Actually write a trk file so we can check against the # MNI brain in trackvis trackvis.write( savetrk, ((stream*mni_hdr['voxel_size'],None,None) for stream in output_voxmm), np.array(mni_hdr) )
def dump_qsdr2MNI_track_lookup(self, output, savetrk=False): """Converts from trackvis voxmm to ijk. Parameters: =========== output:str .pkl file where the voxel to streamline id mapping is saved savetrk:str path to where the trackvis file will be saved. NOTE: ===== REQUIRES that this trackdataset came from a trk file, as the header is essential to transforming tracks to ijk. From experience, tracks brought into alignment with the MNI152 template via DTK's track_transform appear as LAS -> LPS in trackvis's dataset info panel. I have been able to get qsdr2MNI to look correct in trackvis by converting it to LAS ordering. LAS also relates voxmm coordinates to MNI152 ijk by a scalar factor. """ # index tracks by the voxels they pass through mni_voxel_size = np.array([2.] * 3) tracks_at_ijk = defaultdict(set) output_voxmm = [] for trknum, trk in enumerate(self.tracks): data = set([trknum]) # convert voxmm to LAS ijk = self.voxmm_to_ijk(trk, to_order="LAS") pretty_ijk = self.voxmm_to_ijk(trk, to_order="LAS", floor=False) # QSDR from DSI Studio has a different bounding box. ijk = ijk + np.array([6, 7, 11]) pretty_ijk = pretty_ijk + np.array([6, 7, 11]) output_voxmm.append(pretty_ijk * mni_voxel_size) # Floor at the end? unq = track_math.remove_duplicates(ijk).astype(np.int32) for _ijk in unq: tracks_at_ijk[tuple(_ijk)].update(data) self.tracks_at_ijk = tracks_at_ijk print "original", self.tracks.shape, "tracks" self.tracks = np.array(output_voxmm) print "replaced by", self.tracks.shape, "tracks" # Save the hash dump fop = open(output, "wb") pickle.dump(self, fop, pickle.HIGHEST_PROTOCOL) fop.close() # Write out a new trackvis file if savetrk: # Actually write a trk file so we can check against the # MNI brain in trackvis trackvis.write(savetrk, ((stream * mni_hdr['voxel_size'], None, None) for stream in output_voxmm), np.array(mni_hdr))
def _run_interface(self, runtime): nii_hdr = nb.load(self.inputs.reference_file).get_header() hdr = self._create_trackvis_header(nii_hdr) fobj = open(self.inputs.out_file, 'w') tv.write(fobj, self._read_tracts(nii_hdr), hdr) fobj.close() return runtime
def save_streamlines(self, streamlines, save_streamlines_to): trk_hdr = empty_header() voxel_order = orientation_to_string(nib.io_orientation(self.affine)) trk_hdr['voxel_order'] = voxel_order trk_hdr['voxel_size'] = self.voxel_size trk_hdr['vox_to_ras'] = self.affine trk_hdr['dim'] = self.shape trk_tracks = ((ii, None, None) for ii in streamlines) write(save_streamlines_to, trk_tracks, trk_hdr) pickle.dump(self, open(save_streamlines_to + '.p', 'wb'))
def _run_interface(self, runtime): nii_hdr = nb.load(self.inputs.reference_file).get_header() hdr = self._create_trackvis_header(nii_hdr) fobj=open(self.inputs.out_file,'w') tv.write(fobj,self._read_tracts(nii_hdr),hdr) fobj.close() return runtime
def filter_fibers(intrk, outtrk='', fiber_cutoff_lower=20, fiber_cutoff_upper=500): """Filters a tractogram based on lower / upper cutoffs. Parameters ---------- intrk : TRK file Path to a tractogram file in TRK format outtrk : TRK file Output path for the filtered tractogram fiber_cutoff_lower : int Lower number of fibers cutoff (Default: 20) fiber_cutoff_upper : int Upper number of fibers cutoff (Default: 500) """ print("Cut Fiber Filtering") print("===================") print("Input file for fiber cutting is: %s" % intrk) if outtrk == '': _, filename = os.path.split(intrk) base, ext = os.path.splitext(filename) outtrk = os.path.abspath(base + '_cutfiltered' + ext) # compute length array le = compute_length_array(intrk) # cut the fibers smaller than value reducedidx = np.where((le > fiber_cutoff_lower) & (le < fiber_cutoff_upper))[0] # load trackfile (downside, needs everything in memory) fibold, hdrold = tv.read(intrk) # rewrite the track vis file with the reduced number of fibers outstreams = [] for i in reducedidx: outstreams.append(fibold[i]) n_fib_out = len(outstreams) hdrnew = hdrold.copy() hdrnew['n_count'] = n_fib_out # print("Compute length array for cutted fibers") # le = compute_length_array(streams=outstreams) print("Write out file: %s" % outtrk) print("Number of fibers out : %d" % hdrnew['n_count']) tv.write(outtrk, outstreams, hdrnew) print("File wrote : %d" % os.path.exists(outtrk))
def save(self, fname, use_mni_header=False, use_qsdr_header=False): """Save the object as a .trk file""" if use_mni_header: header = mni_hdr elif use_qsdr_header: header = qsdr_hdr else: header = self.header trackvis.write(fname, ((stream, None, None) for stream in self), np.array(header))
def write(self, filename, **kwargs): endianness = kwargs.get('endianness', None) hdr_mapping = kwargs.get('hdr_mapping', self.hdr) points_space = kwargs.get('points_space', 'voxel') streamlines = kwargs.get('streamlines', self.fibers) def streamlines_gen(streamlines): for streamline in streamlines: yield (streamline, None, None) trackvis.write(filename, streamlines_gen(streamlines), hdr_mapping=hdr_mapping, endianness=endianness, points_space=points_space)
def save_trk(tract_name, test_tractogram, segmented_tract_LAP, hdr, prefix): """Save the segmented tract estimated from the LAP """ filedir = os.path.dirname('data/segmented_tract/') if not os.path.exists(filedir): os.makedirs(filedir) save_segmented_tract_LAP_filename = '%s/%s_%s_%s.trk'%\ (filedir, test_tractogram, tract_name, prefix) strmR_A = ((sl, None, None) for sl in segmented_tract_LAP ) trackvis.write( save_segmented_tract_LAP_filename ,strmR_A , hdr)
def save(self,fname,use_mni_header=False,use_qsdr_header=False): """Save the object as a .trk file""" if use_mni_header: header = mni_hdr elif use_qsdr_header: header=qsdr_hdr else: header= self.header trackvis.write( fname, ((stream,None,None) for stream in self), np.array(header) )
def bundle_tracks(in_file, dist_thr=40., pts=16, skip=80.): import subprocess import os.path as op from nibabel import trackvis as tv from dipy.segment.quickbundles import QuickBundles streams, hdr = tv.read(in_file) streamlines = [i[0] for i in streams] qb = QuickBundles(streamlines, float(dist_thr), int(pts)) clusters = qb.clustering #scalars = [i[0] for i in streams] out_files = [] name = "quickbundle_" n_clusters = clusters.keys() print("%d clusters found" % len(n_clusters)) new_hdr = tv.empty_header() new_hdr['n_scalars'] = 1 for cluster in clusters: cluster_trk = op.abspath(name + str(cluster) + ".trk") print("Writing cluster %d to %s" % (cluster, cluster_trk)) out_files.append(cluster_trk) clust_idxs = clusters[cluster]['indices'] new_streams = [streamlines[i] for i in clust_idxs] for_save = [(sl, None, None) for sl in new_streams] tv.write(cluster_trk, for_save, hdr) out_merged_file = "MergedBundles.trk" command_list = ["track_merge"] command_list.extend(out_files) command_list.append(out_merged_file) subprocess.call(command_list) out_scene_file = write_trackvis_scene(out_merged_file, n_clusters=len(clusters), skip=skip, names=None, out_file="NewScene.scene") print("Merged track file written to %s" % out_merged_file) print("Scene file written to %s" % out_scene_file) return out_files, out_merged_file, out_scene_file
def _run_interface(self, runtime): tracts, hdr = tv.read(self.inputs.trackvis_file, as_generator=True) self.stat_files_data = [] self.max_maps_data = [] self.mean_maps_data = [] for stat_file in self.inputs.stat_files: fmri_nii = nb.load(stat_file) self.stat_files_data.append(fmri_nii.get_data()) self.max_maps_data.append(np.zeros(fmri_nii.get_header().get_data_shape())) self.mean_maps_data.append(np.zeros(fmri_nii.get_header().get_data_shape())) hdr = hdr.copy() if isdefined(self.inputs.stat_labels) and len(self.inputs.stat_labels) == len(self.inputs.stat_files): for i, label in enumerate(self.inputs.stat_labels): hdr['property_name'][i] = ('max_%s'%label)[0:19] #hdr['property_name'][1+i*2] = 'stat_mean_%s'%label else: for i in range(len(self.inputs.stat_files)): hdr['property_name'][i] = ('max%d'%i)[0:19] #hdr['property_name'][1+i*2] = 'stat_mean%d'%i tv.write(self.inputs.out_tracks, self._gen_annotate_tracts(tracts, hdr), hdr) if isdefined(self.inputs.stat_labels) and len(self.inputs.stat_labels) == len(self.inputs.stat_files): for i, label in enumerate(self.inputs.stat_labels): nb.save(nb.Nifti1Image(self.max_maps_data[i], fmri_nii.get_affine(), fmri_nii.get_header()), self.inputs.out_max_map_prefix + "_%s"%label + '.nii') nb.save(nb.Nifti1Image(self.mean_maps_data[i], fmri_nii.get_affine(), fmri_nii.get_header()), self.inputs.out_mean_map_prefix + "_%s"%label + '.nii') else: for i in range(len(self.inputs.stat_files)): nb.save(nb.Nifti1Image(self.max_maps_data[i], fmri_nii.get_affine(), fmri_nii.get_header()), self.inputs.out_max_map_prefix + str(i) + '.nii') nb.save(nb.Nifti1Image(self.mean_maps_data[i], fmri_nii.get_affine(), fmri_nii.get_header()), self.inputs.out_mean_map_prefix + str(i) + '.nii') del self.mean_maps_data del self.max_maps_data del self.stat_files_data return runtime
def get_offspring(tractogram_fn, output_dir, subject, tract_name, points_per_sl): # Load (using old TractSeg dataset <=V1.1.0 https://github.com/MIC-DKFZ/TractSeg/blob/17b33b37bafad7566de6372a534a14a1ef5a7384/resources/utility_scripts/trk_2_binary.py) streams, header = trackvis.read(tractogram_fn) # Re-sample each streamline to have the required number of points # Since trackvis.read returns a tuple for each streamline (with streamline coordinates being # the first element in that list, first we need to extract those actual coordinates) only_streamlines = [sl[0] for sl in streams] # extract the actual coordinates resampled_points = set_number_of_points(only_streamlines, points_per_sl) # Now store these resampled coordinates into the streamline tuples # Since you can't modify tuples, we need to re-write the tuples entirely for sl_num in range(len(streams)): streams[sl_num] = (resampled_points[sl_num], streams[sl_num][1], streams[sl_num][2]) # Note, new header not needed since # of streamlines is automatically updated when the file is saved trackvis.write(output_dir + "/" + subject + "_" + tract_name + ".trk", streamlines=streams, hdr_mapping=header)
def filter_fibers(applied_spline=False): log.info("Cut Fiber Filtering") log.info("===================") log.info("Was spline filtering applied? %s" % applied_spline) if applied_spline: intrk = op.join(gconf.get_cmp_fibers(), 'streamline_splinefiltered.trk') else: intrk = op.join(gconf.get_cmp_fibers(), 'streamline.trk') log.info("Input file for fiber cutting is: %s" % intrk) outtrk = op.join(gconf.get_cmp_fibers(), 'streamline_cutfiltered.trk') # compute length array le = compute_length_array(intrk, savefname = 'lengths_beforecutfiltered.npy') # cut the fibers smaller than value reducedidx = np.where((le>gconf.fiber_cutoff_lower) & (le<gconf.fiber_cutoff_upper))[0] # load trackfile (downside, needs everything in memory) fibold, hdrold = tv.read(intrk) # rewrite the track vis file with the reduced number of fibers outstreams = [] for i in reducedidx: outstreams.append( fibold[i] ) n_fib_out = len(outstreams) hdrnew = hdrold.copy() hdrnew['n_count'] = n_fib_out log.info("Compute length array for cutted fibers") le = compute_length_array(streams=outstreams) log.info("Write out file: %s" % outtrk) tv.write(outtrk, outstreams, hdrnew)
def bundle_tracks(in_file, dist_thr=40., pts = 16, skip=80.): import subprocess import os.path as op from nibabel import trackvis as tv from dipy.segment.quickbundles import QuickBundles streams, hdr = tv.read(in_file) streamlines = [i[0] for i in streams] qb = QuickBundles(streamlines, float(dist_thr), int(pts)) clusters = qb.clustering #scalars = [i[0] for i in streams] out_files = [] name = "quickbundle_" n_clusters = clusters.keys() print("%d clusters found" % len(n_clusters)) new_hdr = tv.empty_header() new_hdr['n_scalars'] = 1 for cluster in clusters: cluster_trk = op.abspath(name + str(cluster) + ".trk") print("Writing cluster %d to %s" % (cluster, cluster_trk)) out_files.append(cluster_trk) clust_idxs = clusters[cluster]['indices'] new_streams = [ streamlines[i] for i in clust_idxs ] for_save = [(sl, None, None) for sl in new_streams] tv.write(cluster_trk, for_save, hdr) out_merged_file = "MergedBundles.trk" command_list = ["track_merge"] command_list.extend(out_files) command_list.append(out_merged_file) subprocess.call(command_list) out_scene_file = write_trackvis_scene(out_merged_file, n_clusters=len(clusters), skip=skip, names=None, out_file = "NewScene.scene") print("Merged track file written to %s" % out_merged_file) print("Scene file written to %s" % out_scene_file) return out_files, out_merged_file, out_scene_file
def filter_fibers(intrk, outtrk='', fiber_cutoff_lower=20, fiber_cutoff_upper=500): print("Cut Fiber Filtering") print("===================") print("Input file for fiber cutting is: %s" % intrk) if outtrk == '': path, filename = os.path.split(intrk) base, ext = os.path.splitext(filename) outtrk = os.path.abspath(base + '_cutfiltered' + ext) # compute length array le = compute_length_array(intrk) # cut the fibers smaller than value reducedidx = np.where((le>fiber_cutoff_lower) & (le<fiber_cutoff_upper))[0] # load trackfile (downside, needs everything in memory) fibold, hdrold = tv.read(intrk) # rewrite the track vis file with the reduced number of fibers outstreams = [] for i in reducedidx: outstreams.append( fibold[i] ) n_fib_out = len(outstreams) hdrnew = hdrold.copy() hdrnew['n_count'] = n_fib_out #print("Compute length array for cutted fibers") #le = compute_length_array(streams=outstreams) print("Write out file: %s" % outtrk) print("Number of fibers out : %d" % hdrnew['n_count']) tv.write(outtrk, outstreams, hdrnew) print("File wrote : %d" % os.path.exists(outtrk))
""" Perform QuickBundles clustering with a 10mm distance threshold after having downsampled the streamlines to have only 12 points. """ print("Computing bundles") qb = QuickBundles(streamlines, dist_thr=int(sys.argv[3]), pts=int(sys.argv[4])) print("Completed") """ qb has attributes like `centroids` (cluster representatives), `total_clusters` (total number of clusters) and methods like `partitions` (complete description of all clusters) and `label2tracksids` (provides the indices of the streamlines which belong in a specific cluster). """ centroids = qb.centroids print(len(centroids)) streamlines = [i[0] for i in streams] for i, centroid in enumerate(centroids): print(i) inds = qb.label2tracksids(i) list1 = [] for number in range(1, len(inds)): list1.append((streamlines[inds[number]], None, None)) saveTo = sys.argv[2] + '/' + ` i ` + '.trk' tv.write(saveTo, list(list1)) print("Process COMPLETED") os.system( 'python /home/manu/Desktop/TESI2PARTE/tractconverter-master/scripts/WalkingTractConverter.py -i ' + sys.argv[2] + ' -trk2tck -o ' + sys.argv[2] + ' -a ' + sys.argv[5])
aff = np.eye(4) aff[0, 0] = -1 img = nib.Nifti1Image(counts_trackvis.astype('int16'), aff) nib.save(img, 'counts_trackvis.nii.gz') img = nib.Nifti1Image(counts_nifti.astype('int16'), aff) nib.save(img, 'counts_nifti.nii.gz') hdr = empty_header() hdr['voxel_size'] = (1, 1, 1) hdr['voxel_order'] = 'las' hdr['vox_to_ras'] = aff hdr['dim'] = counts_nifti.shape #Treat these streamlines like they are in trackvis format and save them streamlines_trackvis = ((ii, None, None) for ii in streamlines) write('slAsTrackvis.trk', streamlines_trackvis, hdr) #Move these streamlines from nifti to trackvis format and save them streamlines_nifti = ((ii + .5, None, None) for ii in streamlines) write('slAsNifti.trk', streamlines_nifti, hdr) """ Trackvis: A------------ | C | | | ----B-------- | | | | ------------- | | | | ------------D A = [0, 0]
def run_LiFE(subject): print 'Process subject ' + subject if os.path.isfile( os.path.join(path_saveing, subject, 'Lamyg2LpMFG_LIFE_started.txt')) == False: print "LiFE Files do not exist for this subject, start calculation." if os.path.isfile( os.path.join( path_saveing, subject, 'Lamyg2LpMFG_clustered.trk')) == True and os.path.isfile( os.path.join(path_saveing, subject, '2M_SIFT.trk')) == True: print "All neccessary files there, continue ..." print "Show other processes that this subject is processed" done = np.array([1]) np.savetxt(os.path.join(path_saveing, subject, 'Lamyg2LpMFG_LIFE_started.txt'), done, delimiter=',') try: directory_output = os.path.join(path_saveing, subject) print "Start calculation for subject %s" % subject f_streamlines = os.path.join(path_saveing, subject, 'Lamyg2LpMFG_clustered.trk') f_in_nifti = os.path.join(path, subject, 'T1w/Diffusion/data.nii.gz') streams, hdr = tv.read(f_streamlines, points_space='voxel') streamlines = [i[0] for i in streams] data, affine, gtab, header, shell_mask = load_hcp_data( path, subject) dim = header['dim'][1:4] # Otherwise all weights are NaN data[data <= 0.0] = 1.0 print "Calculating neighborhood with LiFE" fiber_model_neighborhood = life.FiberModel(gtab) fiber_fit_neighborhood = fiber_model_neighborhood.fit( data, streamlines, affine=np.eye(4)) indices_neighborhood = fiber_fit_neighborhood.vox_coords neighborhood = np.zeros(dim, dtype=bool) for i in range(indices_neighborhood.shape[0]): neighborhood[indices_neighborhood[i][0], indices_neighborhood[i][1], indices_neighborhood[i][2]] = 1 save_as_nifti( path_saveing + subject + "/Lamyg2LpMFG_neighborhood", neighborhood.astype(np.int), affine) print 'Find fiber that pass through neighborhood' f_streamlines_whole_brain = path_saveing + subject + "/2M_SIFT.trk" streams_whole_brain, hdr_whole_brain = tv.read( f_streamlines_whole_brain, points_space='voxel') streamlines_whole_brain = [i[0] for i in streams_whole_brain] neighborhood_streamlines = utils.target( streamlines_whole_brain, neighborhood, affine=np.eye(4)) neighborhood_streamlines = list(neighborhood_streamlines) strm = ((sl, None, None) for sl in neighborhood_streamlines) tv.write(path_saveing + subject + "/Lamyg2LpMFG_2M_SIFT_without_path.trk", strm, hdr_mapping=hdr_whole_brain, points_space='voxel') print "Combine streamlines" streamlines_together = neighborhood_streamlines + streamlines strm_together = ((sl, None, None) for sl in streamlines_together) tv.write(path_saveing + subject + "/Lamyg2LpMFG_2M_SIFT_with_path.trk", strm_together, hdr_mapping=hdr_whole_brain, points_space='voxel') print "Start LiFE optimization with new path" fiber_model_together = life.FiberModel(gtab) fiber_fit_together = fiber_model_together.fit( data, streamlines_together, affine=np.eye(4)) model_predict_together = fiber_fit_together.predict() indices_together = fiber_fit_together.vox_coords mask_with = np.zeros(dim, dtype=bool) whole_brain_together = np.zeros(header['dim'][1:5]) for i in range(indices_together.shape[0]): whole_brain_together[ indices_together[i][0], indices_together[i][1], indices_together[i][2]] = model_predict_together[i] mask_with[indices_together[i][0], indices_together[i][1], indices_together[i][2]] = 1 save_as_nifti( path_saveing + subject + "/Lamyg2LpMFG_LiFE_prediction_with_path", whole_brain_together, affine) save_as_matlab_file(path_saveing + subject + "/Lamyg2LpMFG_LiFE_betas_with_path", beta=fiber_fit_together.beta) save_as_nifti( path_saveing + subject + "/Lamyg2LpMFG_LiFE_mask_with_path", mask_with.astype(np.int), affine) print "Calculate RMSE with" model_error_together = model_predict_together - fiber_fit_together.data model_rmse_together = np.sqrt( np.mean(model_error_together[..., ~gtab.b0s_mask]**2, -1)) whole_brain_rmse_together = np.zeros(dim) for i in range(indices_together.shape[0]): whole_brain_rmse_together[ indices_together[i][0], indices_together[i][1], indices_together[i][2]] = model_rmse_together[i] save_as_nifti( path_saveing + subject + "/Lamyg2LpMFG_LiFE_rmse_with_path", whole_brain_rmse_together, affine) print "Start LiFE optimization without new path" fiber_fit = copy.deepcopy(fiber_fit_together) fiber_fit.beta[-len(streamlines):] = 0 model_predict = fiber_fit.predict() indices = fiber_fit.vox_coords whole_brain = np.zeros(header['dim'][1:5]) mask_without = np.zeros(dim, dtype=bool) for i in range(indices.shape[0]): whole_brain[indices[i][0], indices[i][1], indices[i][2]] = model_predict[i] mask_without[indices[i][0], indices[i][1], indices[i][2]] = 1 save_as_nifti( path_saveing + subject + "/Lamyg2LpMFG_LiFE_prediction_without_path", whole_brain, affine) save_as_matlab_file(path_saveing + subject + "/Lamyg2LpMFG_LiFE_betas_without_path", beta=fiber_fit.beta) save_as_nifti( path_saveing + subject + "/Lamyg2LpMFG_LiFE_mask_without_path", mask_without.astype(np.int), affine) print "Calculate RMSE without" model_error = model_predict - fiber_fit.data model_rmse = np.sqrt( np.mean(model_error[..., ~gtab.b0s_mask]**2, -1)) whole_brain_rmse = np.zeros(dim) for i in range(indices.shape[0]): whole_brain_rmse[indices[i][0], indices[i][1], indices[i][2]] = model_rmse[i] save_as_nifti( path_saveing + subject + "/Lamyg2LpMFG_LiFE_rmse_without_path", whole_brain_rmse, affine) print "All done" except: print "An error occured while computing LiFE. Skip this subject." else: print "Some input files are missing, skip this subject." else: print "LiFE Files exist already for this subject, skip calculation." return 0
del streams#,hdr if not os.path.isfile(C_fname): print 'Starting LARCH ...' tim=time.clock() C,atracks=tl.larch(tracks,[50.**2,20.**2,5.**2],True,True) #tracks=[tm.downsample(t,3) for t in tracks] #C=pf.local_skeleton_clustering(tracks,20.) print 'Done in total of ',time.clock()-tim,'seconds.' print 'Saving result...' pkl.save_pickle(C_fname,C) streams=[(i,None,None)for i in atracks] tv.write(appr_fname,streams,hdr) else: print 'Loading result...' C=pkl.load_pickle(C_fname) skel=[] for c in C: skel.append(C[c]['repz']) print 'Showing dataset after clustering...' r=fos.ren() fos.clear(r) colors=np.zeros((len(skel),3)) for (i,s) in enumerate(skel):
def get_streamlines(seed, mid, ends, num_sl, points_per_sl): result = [] for i in range(num_sl): # Generate start, middle, and end points seed_offset = np.random.normal(loc=0, scale=3, size=3) mid_offset = np.random.normal(loc=0, scale=3, size=3) end_offset = np.random.normal(loc=0, scale=3, size=3) sl = np.array([ seed + seed_offset, mid + mid_offset, ends[randint(0, len(ends) - 1)] + end_offset ]) # Upscale to desired number of points streamlines = set_number_of_points([sl], points_per_sl) sl = streamlines[0] # Add noise to non-keypoints noise = np.random.normal(loc=0, scale=0.35, size=sl.shape) noise[0], noise[len(noise) // 2], noise[-1] = [0, 0, 0] # don't change the seed points sl += noise # Add translation to all points curr_seed, curr_mid, curr_end = sl[0], sl[len(sl) // 2], sl[-1] t = np.random.uniform(low=-5, high=5, size=3) sl += t # Restore the keypoints to before translation sl[0], sl[len(sl) // 2], sl[-1] = curr_seed, curr_mid, curr_end result.append(sl) fn = "../../../data/PRE_SAMPLED/tractograms/599469_0_CST_left.trk" _, header = trackvis.read(fn) streams = [(sl, None, None) for sl in result] trackvis.write('result1.trk', streams, header) streamlines = result coords = np.reshape(streamlines, (-1, 3)) x, y, z = coords[:, 0], coords[:, 1], coords[:, 2] fig = plt.figure() ax = Axes3D(fig) ax.scatter(list(x), list(y), list(z)) ax.set_xlim([-50, 0]) ax.set_ylim([-40, 0]) ax.set_zlim([-60, 70]) plt.show() #print(x) colors, i = [], 0 for sl in streamlines: colors.extend([i for x in range(len(sl))]) i += 1 colors = np.array(colors) #fig = px.line_3d(x=x, y=y, z=z, color=colors, range_x=[-50,10], range_y=[-50,10], range_z=[-60,60]) fig = px.line_3d(x=x, y=y, z=z, color=colors) #fig.add_trace(px.scatter_3d(x=x, y=y, z=z, color=np.array([1 for i in range(len(x))])).data[0]) fig.show() """
def tractography_to_trackvis_file(filename, tractography, affine=None, image_dimensions=None): trk_header = trackvis.empty_header() if affine is not None: pass elif hasattr(tractography, 'affine'): affine = tractography.affine else: raise ValueError("Affine transform has to be provided") trackvis.aff_to_hdr(affine, trk_header, True, True) trk_header['origin'] = 0. if image_dimensions is not None: trk_header['dim'] = image_dimensions elif hasattr(tractography, 'image_dimensions'): trk_header['dim'] = tractography.image_dimensions else: raise ValueError("Image dimensions needed to save a trackvis file") orig_data = tractography.tracts_data() data = {} for k, v in orig_data.items(): if not isinstance(v[0], numpy.ndarray): continue if (v[0].ndim > 1 and any(d > 1 for d in v[0].shape[1:])): warn( "Scalar data %s ignored as trackvis " "format does not handle multivalued data" % k ) else: data[k] = v #data_new = {} # for k, v in data.iteritems(): # if (v[0].ndim > 1 and v[0].shape[1] > 1): # for i in xrange(v[0].shape[1]): # data_new['%s_%02d' % (k, i)] = [ # v_[:, i] for v_ in v # ] # else: # data_new[k] = v trk_header['n_count'] = len(tractography.tracts()) trk_header['n_properties'] = 0 trk_header['n_scalars'] = len(data) if len(data) > 10: raise ValueError('At most 10 scalars permitted per point') trk_header['scalar_name'][:len(data)] = numpy.array( [n[:20] for n in data], dtype='|S20' ) trk_tracts = [] for i, sl in enumerate(tractography.tracts()): scalars = None if len(data) > 0: scalars = numpy.vstack([ data[k.decode('utf8')][i].squeeze() for k in trk_header['scalar_name'][:len(data)] ]).T trk_tracts.append((sl, scalars, None)) trackvis.write(filename, trk_tracts, trk_header, points_space='rasmm')
streamlines = cPickle.load(pkl_file) print type(streamlines) hdr = tv.empty_header() nifti_filename = 'dtifit__FA.nii' nii_hdr = nb.load(nifti_filename).get_header() hdr['dim'] = np.array(nii_hdr.get_data_shape()) hdr['voxel_size'] = np.array(nii_hdr.get_zooms()) aff = np.eye(4) aff[0:3, 0:3] *= np.array(nii_hdr.get_zooms()) hdr['vox_to_ras'] = aff print hdr['version'] for i in range(len(streamlines)): points_arr = streamlines[i][0] #invert y points_arr[:, 1] = nii_hdr.get_data_shape()[1] - points_arr[:, 1] #move to mm dim with 0,0,0 origin points_arr = points_arr * nii_hdr.get_zooms() streamlines[i] = (points_arr, None, None) f = 'test.trk' fobj = open(f, 'w') tv.write(fobj, streamlines, hdr) fobj.close()
def _run_interface(self, runtime): from dipy.tracking.utils import move_streamlines, affine_from_fsl_mat_file dx, dy, dz = get_data_dims(self.inputs.image_file) vx, vy, vz = get_vox_dims(self.inputs.image_file) image_file = nb.load(self.inputs.image_file) affine = image_file.affine out_filename = op.abspath(self.inputs.out_filename) # Reads MRTrix tracks header, streamlines = read_mrtrix_tracks(self.inputs.in_file, as_generator=True) iflogger.info("MRTrix Header:") iflogger.info(header) # Writes to Trackvis trk_header = nb.trackvis.empty_header() trk_header["dim"] = [dx, dy, dz] trk_header["voxel_size"] = [vx, vy, vz] trk_header["n_count"] = header["count"] if isdefined(self.inputs.matrix_file) and isdefined( self.inputs.registration_image_file): iflogger.info("Applying transformation from matrix file %s", self.inputs.matrix_file) xfm = np.genfromtxt(self.inputs.matrix_file) iflogger.info(xfm) registration_image_file = nb.load( self.inputs.registration_image_file) reg_affine = registration_image_file.affine r_dx, r_dy, r_dz = get_data_dims( self.inputs.registration_image_file) r_vx, r_vy, r_vz = get_vox_dims( self.inputs.registration_image_file) iflogger.info( "Using affine from registration image file %s", self.inputs.registration_image_file, ) iflogger.info(reg_affine) trk_header["vox_to_ras"] = reg_affine trk_header["dim"] = [r_dx, r_dy, r_dz] trk_header["voxel_size"] = [r_vx, r_vy, r_vz] affine = np.dot(affine, np.diag(1.0 / np.array([vx, vy, vz, 1]))) transformed_streamlines = transform_to_affine( streamlines, trk_header, affine) aff = affine_from_fsl_mat_file(xfm, [vx, vy, vz], [r_vx, r_vy, r_vz]) iflogger.info(aff) axcode = aff2axcodes(reg_affine) trk_header["voxel_order"] = axcode[0] + axcode[1] + axcode[2] final_streamlines = move_streamlines(transformed_streamlines, aff) trk_tracks = ((ii, None, None) for ii in final_streamlines) trk.write(out_filename, trk_tracks, trk_header) iflogger.info("Saving transformed Trackvis file as %s", out_filename) iflogger.info("New TrackVis Header:") iflogger.info(trk_header) else: iflogger.info( "Applying transformation from scanner coordinates to %s", self.inputs.image_file, ) axcode = aff2axcodes(affine) trk_header["voxel_order"] = axcode[0] + axcode[1] + axcode[2] trk_header["vox_to_ras"] = affine transformed_streamlines = transform_to_affine( streamlines, trk_header, affine) trk_tracks = ((ii, None, None) for ii in transformed_streamlines) trk.write(out_filename, trk_tracks, trk_header) iflogger.info("Saving Trackvis file as %s", out_filename) iflogger.info("TrackVis Header:") iflogger.info(trk_header) return runtime
beta_with = load_matlab_file( path_saveing + subject + "/RVLPFC2FIRSTamyg_bigRight_LiFE_betas_with_path")['beta'] streams, hdr = tv.read(path_saveing + subject + "/RVLPFC2FIRSTamyg_bigRight_clustered.trk" ) #, points_space='voxel' streamlines = [i[0] for i in streams] weights_with = np.squeeze(beta_with[:, -len(streamlines):]) optimized_with = streamlines[-len(streamlines):] try: optimized_sl = list( np.array(optimized_with)[np.where(weights_with > 0)]) optimized_save = ((sl, None, None) for sl in optimized_sl) tv.write(os.path.join( path_saveing, subject, 'RVLPFC2FIRSTamyg_bigRight_optimized.trk'), optimized_save, hdr_mapping=hdr) except: print "Could not save streamlines, 0 streamlines detected" else: print " Not all necessary files exist, skip subject" else: print "Strength of Evidence Exists already, skip subject" # In[ ]:
streamlines = [i[0] for i in streams] """ Perform QuickBundles clustering with a 10mm distance threshold after having downsampled the streamlines to have only 12 points. """ print ("Computing bundles") qb = QuickBundles(streamlines, dist_thr=int(sys.argv[3]), pts=int(sys.argv[4])) print ("Completed") """ qb has attributes like `centroids` (cluster representatives), `total_clusters` (total number of clusters) and methods like `partitions` (complete description of all clusters) and `label2tracksids` (provides the indices of the streamlines which belong in a specific cluster). """ centroids = qb.centroids print(len(centroids)) streamlines = [i[0] for i in streams] for i, centroid in enumerate(centroids): print (i) inds = qb.label2tracksids(i) list1 = [] for number in range(1,len(inds)): list1.append((streamlines[inds[number]], None, None)) saveTo = sys.argv[2]+'/' + `i` + '.trk' tv.write(saveTo, list(list1)) print("Process COMPLETED") os.system('python /home/manu/Desktop/TESI2PARTE/tractconverter-master/scripts/WalkingTractConverter.py -i '+sys.argv[2]+' -trk2tck -o '+sys.argv[2]+' -a '+sys.argv[5])
print " Calculate optimized Fibers" beta_with = load_matlab_file( path_saveing + subject + "/RLamyg2LpMFG_LiFE_betas_with_path")['beta'] streams, hdr = tv.read( path_saveing + subject + "/Lamyg2LpMFG_clustered.trk") #, points_space='voxel' streamlines = [i[0] for i in streams] weights_with = np.squeeze(beta_with[:, -len(streamlines):]) optimized_with = streamlines[-len(streamlines):] try: optimized_sl = list( np.array(optimized_with)[np.where(weights_with > 0)]) optimized_save = ((sl, None, None) for sl in optimized_sl) tv.write(os.path.join(path_saveing, subject, 'Lamyg2LpMFG_optimized.trk'), optimized_save, hdr_mapping=hdr) except: print "Could not save streamlines, 0 streamlines detected" else: print " Not all necessary files exist, skip subject" else: print "Strength of Evidence Exists already, skip subject" # In[ ]:
def tractography_to_trackvis_file(filename, tractography, affine=None, image_dimensions=None): trk_header = trackvis.empty_header() if affine is not None: pass elif hasattr(tractography, 'affine'): affine = tractography.affine else: raise ValueError("Affine transform has to be provided") trackvis.aff_to_hdr(affine, trk_header, True, True) trk_header['origin'] = 0. if image_dimensions is not None: trk_header['dim'] = image_dimensions elif hasattr(tractography, 'image_dimensions'): trk_header['dim'] = tractography.image_dimensions else: raise ValueError("Image dimensions needed to save a trackvis file") orig_data = tractography.tracts_data() data = {} for k, v in orig_data.items(): if not isinstance(v[0], numpy.ndarray): continue if (v[0].ndim > 1 and any(d > 1 for d in v[0].shape[1:])): warn("Scalar data %s ignored as trackvis " "format does not handle multivalued data" % k) else: data[k] = v #data_new = {} # for k, v in data.iteritems(): # if (v[0].ndim > 1 and v[0].shape[1] > 1): # for i in xrange(v[0].shape[1]): # data_new['%s_%02d' % (k, i)] = [ # v_[:, i] for v_ in v # ] # else: # data_new[k] = v trk_header['n_count'] = len(tractography.tracts()) trk_header['n_properties'] = 0 trk_header['n_scalars'] = len(data) if len(data) > 10: raise ValueError('At most 10 scalars permitted per point') trk_header['scalar_name'][:len(data)] = numpy.array([n[:20] for n in data], dtype='|S20') trk_tracts = [] for i, sl in enumerate(tractography.tracts()): scalars = None if len(data) > 0: scalars = numpy.vstack([ data[k.decode('utf8')][i].squeeze() for k in trk_header['scalar_name'][:len(data)] ]).T trk_tracts.append((sl, scalars, None)) trackvis.write(filename, trk_tracts, trk_header, points_space='rasmm')
print " Strength of Evidence : %.2f" % strength np.savetxt(os.path.join(path_saveing, subject, 'RVLPFC2FIRSTamyg_bigRight_Strength_of_Evidence2.txt'), np.array([strength]), delimiter=',') print " Calculate optimized Fibers" beta_with = load_matlab_file(path_saveing + subject + "/RVLPFC2FIRSTamyg_bigRight_LiFE_betas_with_path")['beta'] streams, hdr = tv.read(path_saveing + subject + "/RVLPFC2FIRSTamyg_bigRight_clustered.trk")#, points_space='voxel' streamlines = [i[0] for i in streams] weights_with = np.squeeze(beta_with[:, -len(streamlines):]) optimized_with = streamlines[-len(streamlines):] try: optimized_sl = list(np.array(optimized_with)[np.where(weights_with > 0)]) optimized_save = ((sl, None, None) for sl in optimized_sl) tv.write(os.path.join(path_saveing, subject, 'RVLPFC2FIRSTamyg_bigRight_optimized.trk'), optimized_save, hdr_mapping=hdr) except: print "Could not save streamlines, 0 streamlines detected" else: print " Not all necessary files exist, skip subject" else: print "Strength of Evidence Exists already, skip subject" # In[ ]:
def run_LiFE(subject): print 'Process subject ' + subject if os.path.isfile(os.path.join(path_saveing, subject, 'RVLPFC2FIRSTamyg_bigRight_LIFE_started2.txt')) == False: print "LiFE Files do not exist for this subject, start calculation." if os.path.isfile(os.path.join(path_saveing, subject, 'RVLPFC2FIRSTamyg_bigRight_clustered.trk')) == True and os.path.isfile(os.path.join(path_saveing, subject, '2M_SIFT.trk')) == True: print "All neccessary files there, continue ..." print "Show other processes that this subject is processed" done = np.array([1]) np.savetxt(os.path.join(path_saveing, subject, 'RVLPFC2FIRSTamyg_bigRight_LIFE_started2.txt'), done, delimiter=',') try: directory_output = os.path.join(path_saveing, subject) print "Start calculation for subject %s" % subject f_streamlines = os.path.join(path_saveing, subject, 'RVLPFC2FIRSTamyg_bigRight_clustered.trk') f_in_nifti = os.path.join(path, subject, 'T1w/Diffusion/data.nii.gz') streams, hdr = tv.read(f_streamlines, points_space='voxel') streamlines = [i[0] for i in streams] data, affine, gtab, header, shell_mask = load_hcp_data(path, subject) dim = header['dim'][1:4] # Otherwise all weights are NaN data[data <= 0.0] = 1.0 print "Calculating neighborhood with LiFE" fiber_model_neighborhood = life.FiberModel(gtab) fiber_fit_neighborhood = fiber_model_neighborhood.fit(data, streamlines, affine=np.eye(4)) indices_neighborhood = fiber_fit_neighborhood.vox_coords neighborhood = np.zeros(dim, dtype=bool) for i in range(indices_neighborhood.shape[0]): neighborhood[indices_neighborhood[i][0], indices_neighborhood[i][1], indices_neighborhood[i][2]] = 1 save_as_nifti(path_saveing + subject + "/RVLPFC2FIRSTamyg_bigRight_neighborhood", neighborhood.astype(np.int), affine) print 'Find fiber that pass through neighborhood' f_streamlines_whole_brain = path_saveing + subject + "/2M_SIFT.trk" streams_whole_brain, hdr_whole_brain = tv.read(f_streamlines_whole_brain, points_space='voxel') streamlines_whole_brain = [i[0] for i in streams_whole_brain] neighborhood_streamlines = utils.target(streamlines_whole_brain, neighborhood, affine=np.eye(4)) neighborhood_streamlines = list(neighborhood_streamlines) strm = ((sl, None, None) for sl in neighborhood_streamlines) tv.write(path_saveing + subject + "/RVLPFC2FIRSTamyg_bigRight_2M_SIFT_without_path.trk", strm, hdr_mapping=hdr_whole_brain, points_space='voxel') print "Combine streamlines" streamlines_together = neighborhood_streamlines + streamlines strm_together = ((sl, None, None) for sl in streamlines_together) tv.write(path_saveing + subject + "/RVLPFC2FIRSTamyg_bigRight_2M_SIFT_with_path.trk", strm_together, hdr_mapping=hdr_whole_brain, points_space='voxel') print "Start LiFE optimization with new path" fiber_model_together = life.FiberModel(gtab) fiber_fit_together = fiber_model_together.fit(data, streamlines_together, affine=np.eye(4)) model_predict_together = fiber_fit_together.predict() indices_together = fiber_fit_together.vox_coords mask_with = np.zeros(dim, dtype=bool) whole_brain_together = np.zeros(header['dim'][1:5]) for i in range(indices_together.shape[0]): whole_brain_together[indices_together[i][0], indices_together[i][1], indices_together[i][2]] = model_predict_together[i] mask_with[indices_together[i][0], indices_together[i][1], indices_together[i][2]] = 1 save_as_nifti(path_saveing + subject + "/RVLPFC2FIRSTamyg_bigRight_LiFE_prediction_with_path", whole_brain_together, affine) save_as_matlab_file(path_saveing + subject + "/RVLPFC2FIRSTamyg_bigRight_LiFE_betas_with_path", beta = fiber_fit_together.beta) save_as_nifti(path_saveing + subject + "/RVLPFC2FIRSTamyg_bigRight_LiFE_mask_with_path", mask_with.astype(np.int), affine) print "Calculate RMSE with" model_error_together = model_predict_together - fiber_fit_together.data model_rmse_together = np.sqrt(np.mean(model_error_together[..., ~gtab.b0s_mask] ** 2, -1)) whole_brain_rmse_together = np.zeros(dim) for i in range(indices_together.shape[0]): whole_brain_rmse_together[indices_together[i][0], indices_together[i][1], indices_together[i][2]] = model_rmse_together[i] save_as_nifti(path_saveing + subject + "/RVLPFC2FIRSTamyg_bigRight_LiFE_rmse_with_path", whole_brain_rmse_together, affine) print "Start LiFE optimization without new path" fiber_fit = copy.deepcopy(fiber_fit_together) fiber_fit.beta[-len(streamlines):] = 0 model_predict = fiber_fit.predict() indices = fiber_fit.vox_coords whole_brain = np.zeros(header['dim'][1:5]) mask_without = np.zeros(dim, dtype=bool) for i in range(indices.shape[0]): whole_brain[indices[i][0], indices[i][1], indices[i][2]] = model_predict[i] mask_without[indices[i][0], indices[i][1], indices[i][2]] = 1 save_as_nifti(path_saveing + subject + "/RVLPFC2FIRSTamyg_bigRight_LiFE_prediction_without_path", whole_brain, affine) save_as_matlab_file(path_saveing + subject + "/RVLPFC2FIRSTamyg_bigRight_LiFE_betas_without_path", beta = fiber_fit.beta) save_as_nifti(path_saveing + subject + "/RVLPFC2FIRSTamyg_bigRight_LiFE_mask_without_path", mask_without.astype(np.int), affine) print "Calculate RMSE without" model_error = model_predict - fiber_fit.data model_rmse = np.sqrt(np.mean(model_error[..., ~gtab.b0s_mask] ** 2, -1)) whole_brain_rmse = np.zeros(dim) for i in range(indices.shape[0]): whole_brain_rmse[indices[i][0], indices[i][1], indices[i][2]] = model_rmse[i] save_as_nifti(path_saveing + subject + "/RVLPFC2FIRSTamyg_bigRight_LiFE_rmse_without_path", whole_brain_rmse, affine) print "All done" except: print "An error occured while computing LiFE. Skip this subject." else: print "Some input files are missing, skip this subject." else: print "LiFE Files exist already for this subject, skip calculation." return 0
feature = ResampleFeature(nb_points=50) metric = AveragePointwiseEuclideanMetric( feature=feature) qb = QuickBundles(threshold=10., metric=metric) clusters = qb.cluster(streamlines) major_cluster = clusters > 60 major_path = [] for j in range(len(clusters)): if major_cluster[j] == True: major_path.append([ streamlines[i] for i in clusters[j].indices ]) major_streams = list(itertools.chain(*major_path)) strm = ((sl, None, None) for sl in major_streams) tv.write(f_out_clustered, strm, hdr_mapping=hdr) print ' All done' except: print ' Could not Cluster streams' else: print " Could not load raw diffusion data, skip conversion and clustering." else: print " Some input files are missing, skip this subject." else: print " Clustered File exists already for this subject, skip calculation." # In[ ]:
streamlines = [i[0] for i in streams] feature = ResampleFeature(nb_points=50) metric = AveragePointwiseEuclideanMetric(feature=feature) qb = QuickBundles(threshold=10., metric=metric) clusters = qb.cluster(streamlines) major_cluster = clusters > 60 major_path = [] for j in range(len(clusters)): if major_cluster[j] == True: major_path.append([streamlines[i] for i in clusters[j].indices]) major_streams = list(itertools.chain(*major_path)) strm = ((sl, None, None) for sl in major_streams) tv.write(f_out_clustered, strm, hdr_mapping=hdr) print ' All done' except: print ' Could not Cluster streams' else: print " Could not load raw diffusion data, skip conversion and clustering." else: print " Some input files are missing, skip this subject." else: print " Clustered File exists already for this subject, skip calculation." # In[ ]:
def _run_interface(self, runtime): tracts, hdr = tv.read(self.inputs.trackvis_file, as_generator=True) self.stat_files_data = [] self.max_maps_data = [] self.mean_maps_data = [] for stat_file in self.inputs.stat_files: fmri_nii = nb.load(stat_file) self.stat_files_data.append(fmri_nii.get_data()) self.max_maps_data.append( np.zeros(fmri_nii.get_header().get_data_shape())) self.mean_maps_data.append( np.zeros(fmri_nii.get_header().get_data_shape())) hdr = hdr.copy() if isdefined(self.inputs.stat_labels) and len( self.inputs.stat_labels) == len(self.inputs.stat_files): for i, label in enumerate(self.inputs.stat_labels): hdr['property_name'][i] = ('max_%s' % label)[0:19] #hdr['property_name'][1+i*2] = 'stat_mean_%s'%label else: for i in range(len(self.inputs.stat_files)): hdr['property_name'][i] = ('max%d' % i)[0:19] #hdr['property_name'][1+i*2] = 'stat_mean%d'%i tv.write(self.inputs.out_tracks, self._gen_annotate_tracts(tracts, hdr), hdr) if isdefined(self.inputs.stat_labels) and len( self.inputs.stat_labels) == len(self.inputs.stat_files): for i, label in enumerate(self.inputs.stat_labels): nb.save( nb.Nifti1Image(self.max_maps_data[i], fmri_nii.get_affine(), fmri_nii.get_header()), self.inputs.out_max_map_prefix + "_%s" % label + '.nii') nb.save( nb.Nifti1Image(self.mean_maps_data[i], fmri_nii.get_affine(), fmri_nii.get_header()), self.inputs.out_mean_map_prefix + "_%s" % label + '.nii') else: for i in range(len(self.inputs.stat_files)): nb.save( nb.Nifti1Image(self.max_maps_data[i], fmri_nii.get_affine(), fmri_nii.get_header()), self.inputs.out_max_map_prefix + str(i) + '.nii') nb.save( nb.Nifti1Image(self.mean_maps_data[i], fmri_nii.get_affine(), fmri_nii.get_header()), self.inputs.out_mean_map_prefix + str(i) + '.nii') del self.mean_maps_data del self.max_maps_data del self.stat_files_data return runtime
del streams #,hdr if not os.path.isfile(C_fname): print 'Starting LARCH ...' tim = time.clock() C, atracks = tl.larch(tracks, [50.**2, 20.**2, 5.**2], True, True) #tracks=[tm.downsample(t,3) for t in tracks] #C=pf.local_skeleton_clustering(tracks,20.) print 'Done in total of ', time.clock() - tim, 'seconds.' print 'Saving result...' pkl.save_pickle(C_fname, C) streams = [(i, None, None) for i in atracks] tv.write(appr_fname, streams, hdr) else: print 'Loading result...' C = pkl.load_pickle(C_fname) skel = [] for c in C: skel.append(C[c]['repz']) print 'Showing dataset after clustering...' r = fos.ren() fos.clear(r) colors = np.zeros((len(skel), 3)) for (i, s) in enumerate(skel):
def _run_interface(self, runtime): from dipy.tracking.utils import move_streamlines, \ affine_from_fsl_mat_file dx, dy, dz = get_data_dims(self.inputs.image_file) vx, vy, vz = get_vox_dims(self.inputs.image_file) image_file = nb.load(self.inputs.image_file) affine = image_file.affine out_filename = op.abspath(self.inputs.out_filename) # Reads MRTrix tracks header, streamlines = read_mrtrix_tracks( self.inputs.in_file, as_generator=True) iflogger.info('MRTrix Header:') iflogger.info(header) # Writes to Trackvis trk_header = nb.trackvis.empty_header() trk_header['dim'] = [dx, dy, dz] trk_header['voxel_size'] = [vx, vy, vz] trk_header['n_count'] = header['count'] if isdefined(self.inputs.matrix_file) and isdefined( self.inputs.registration_image_file): iflogger.info('Applying transformation from matrix file %s', self.inputs.matrix_file) xfm = np.genfromtxt(self.inputs.matrix_file) iflogger.info(xfm) registration_image_file = nb.load( self.inputs.registration_image_file) reg_affine = registration_image_file.affine r_dx, r_dy, r_dz = get_data_dims( self.inputs.registration_image_file) r_vx, r_vy, r_vz = get_vox_dims( self.inputs.registration_image_file) iflogger.info('Using affine from registration image file %s', self.inputs.registration_image_file) iflogger.info(reg_affine) trk_header['vox_to_ras'] = reg_affine trk_header['dim'] = [r_dx, r_dy, r_dz] trk_header['voxel_size'] = [r_vx, r_vy, r_vz] affine = np.dot(affine, np.diag(1. / np.array([vx, vy, vz, 1]))) transformed_streamlines = transform_to_affine( streamlines, trk_header, affine) aff = affine_from_fsl_mat_file(xfm, [vx, vy, vz], [r_vx, r_vy, r_vz]) iflogger.info(aff) axcode = aff2axcodes(reg_affine) trk_header['voxel_order'] = axcode[0] + axcode[1] + axcode[2] final_streamlines = move_streamlines(transformed_streamlines, aff) trk_tracks = ((ii, None, None) for ii in final_streamlines) trk.write(out_filename, trk_tracks, trk_header) iflogger.info('Saving transformed Trackvis file as %s', out_filename) iflogger.info('New TrackVis Header:') iflogger.info(trk_header) else: iflogger.info( 'Applying transformation from scanner coordinates to %s', self.inputs.image_file) axcode = aff2axcodes(affine) trk_header['voxel_order'] = axcode[0] + axcode[1] + axcode[2] trk_header['vox_to_ras'] = affine transformed_streamlines = transform_to_affine( streamlines, trk_header, affine) trk_tracks = ((ii, None, None) for ii in transformed_streamlines) trk.write(out_filename, trk_tracks, trk_header) iflogger.info('Saving Trackvis file as %s', out_filename) iflogger.info('TrackVis Header:') iflogger.info(trk_header) return runtime
def rectify(tractogram_fn, out_fn): # Open file and extract streamlines streams, header = trackvis.read(tractogram_fn) streamlines = [s[0] for s in streams] # Get extrema beginnings = [s[0] for s in streamlines] #endings = [s[-1] for s in streamlines] # Run KMeans to cluster beginnings and endings both into 2 clusters kmeans_beginnings = KMeans(n_clusters=2).fit(beginnings) #kmeans_endings = KMeans(n_clusters = 2).fit(endings) beginnings_centers = kmeans_beginnings.cluster_centers_ #endings_centers = kmeans_endings.cluster_centers_ # Find the axis with the largest difference between extreme coordinates and diff_X = abs(beginnings_centers[0][0] - beginnings_centers[1][0]) diff_Y = abs(beginnings_centers[0][1] - beginnings_centers[1][1]) diff_Z = abs(beginnings_centers[0][2] - beginnings_centers[1][2]) # Assign the cluster with the largest value for this axis to be the seed cluster max_val = max(diff_X, diff_Y, diff_Z) if diff_X == max_val: max_index = 0 elif diff_Y == max_val: max_index = 1 else: max_index = 2 if beginnings_centers[0][max_index] > beginnings_centers[1][max_index]: beginnings_beginnings = 0 beginnings_endings = 1 else: beginnings_beginnings = 1 beginnings_endings = 0 """ # Assign the more populous cluster for beginnings to be the beginnings pred_beginnings = kmeans_beginnings.predict(beginnings) beginnings_sum = np.sum(pred_beginnings) / len(pred_beginnings) if beginnings_sum > 0.5: #beginnings_beginnings = beginnings_centers[1] #beginnings_endings = beginnings_centers[0] beginnings_beginnings = 1 beginnings_endings = 0 else: #beginnings_beginnings = beginnings_centers[0] #beginnings_endings = beginnings_centers[1] beginnings_beginnings = 0 beginnings_endings = 1 """ # Assign the more populous cluster for endings to be the endings #pred_endings = kmeans_endings.predict(endings) #endings_sum = np.sum(pred_endings) / len(pred_endings) #if endings_sum > 0.5: # endings_endings = 1 # endings_beginnings = 0 #else: # endings_endings = 0 # endings_beginnings = 1 # For each streamline, run kmeans.fit() on the beginning point and reverse it if appropriate new_streamlines = [] for sl in streamlines: seed = np.array([sl[0]], dtype=float) result = kmeans_beginnings.predict(seed) # If assigned to beginnings_endings, reverse the streamline if result[0] == beginnings_endings: reversed_sl = sl[::-1] new_streamlines.append(reversed_sl) else: new_streamlines.append(sl) #fig = plt.figure() #ax = Axes3D(fig) #seeds = np.array([s[0] for s in new_streamlines]) #x, y, z = seeds[:,0], seeds[:,1], seeds[:,2] #ax.scatter(list(x), list(y), list(z), c='#003cff') #seeds = np.array([s[-1] for s in new_streamlines]) #x, y, z = seeds[:,0], seeds[:,1], seeds[:,2] #ax.scatter(list(x), list(y), list(z), c='#aabbff') #plt.show() new_streamlines = [(s, None, None) for s in new_streamlines] trackvis.write(out_fn, streamlines=new_streamlines, hdr_mapping=header)
# Open the file and extract streamlines streams, header = trackvis.read(tractogram_fn) streamlines = [sl[0] for sl in streams] # Run quickbundles with chosen parameters feature = ResampleFeature(nb_points=points_per_sl) metric = AveragePointwiseEuclideanMetric(feature) qb = QuickBundles(threshold=10., max_nb_clusters=max_num_centroids, metric=metric) clusters = qb.cluster(streamlines) # Extract the centroids centroids = [cluster.centroid for cluster in clusters] # If not enough generated, fill with empty streamlines diff = max_num_centroids - len(centroids) if diff > 0: print( "Not enough centroids generated, so generating empty streamlines for padding." ) empty_sl = np.zeros((points_per_sl, 3), dtype=np.float32) for num in range(diff): centroids.append(empty_sl) # Convert to TrackVis format and write to file centroids = [(c, None, None) for c in centroids] out_fn = output_dir + '/' + subject + '_' + tract_name + '.trk' trackvis.write(out_fn, centroids, header)
aff = np.eye(4) aff[0, 0] = -1 img = nib.Nifti1Image(counts_trackvis.astype('int16'), aff) nib.save(img, 'counts_trackvis.nii.gz') img = nib.Nifti1Image(counts_nifti.astype('int16'), aff) nib.save(img, 'counts_nifti.nii.gz') hdr = empty_header() hdr['voxel_size'] = (1,1,1) hdr['voxel_order'] = 'las' hdr['vox_to_ras'] = aff hdr['dim'] = counts_nifti.shape #Treat these streamlines like they are in trackvis format and save them streamlines_trackvis = ((ii,None,None) for ii in streamlines) write('slAsTrackvis.trk', streamlines_trackvis, hdr) #Move these streamlines from nifti to trackvis format and save them streamlines_nifti = ((ii+.5,None,None) for ii in streamlines) write('slAsNifti.trk', streamlines_nifti, hdr) """ Trackvis: A------------ | C | | | ----B-------- | | | | ------------- | | | | ------------D