def cmat(intrk, roi_volumes, parcellation_scheme, compute_curvature=True, additional_maps={}, output_types=['gPickle'], atlas_info = {}): """ Create the connection matrix for each resolution using fibers and ROIs. """ # create the endpoints for each fibers en_fname = 'endpoints.npy' en_fnamemm = 'endpointsmm.npy' #ep_fname = 'lengths.npy' curv_fname = 'meancurvature.npy' #intrk = op.join(gconf.get_cmp_fibers(), 'streamline_filtered.trk') print('Opening file :' + intrk) fib, hdr = nibabel.trackvis.read(intrk, False) if parcellation_scheme != "Custom": resolutions = get_parcellation(parcellation_scheme) else: resolutions = atlas_info # Previously, load_endpoints_from_trk() used the voxel size stored # in the track hdr to transform the endpoints to ROI voxel space. # This only works if the ROI voxel size is the same as the DSI/DTI # voxel size. In the case of DTI, it is not. # We do, however, assume that all of the ROI images have the same # voxel size, so this code just loads the first one to determine # what it should be firstROIFile = roi_volumes[0] firstROI = nibabel.load(firstROIFile) roiVoxelSize = firstROI.get_header().get_zooms() (endpoints,endpointsmm) = create_endpoints_array(fib, roiVoxelSize, True) np.save(en_fname, endpoints) np.save(en_fnamemm, endpointsmm) # only compute curvature if required if compute_curvature: meancurv = compute_curvature_array(fib) np.save(curv_fname, meancurv) print("========================") n = len(fib) #resolution = gconf.parcellation.keys() streamline_wrote = False for parkey, parval in resolutions.items(): #if parval['number_of_regions'] != 83: # continue print("Resolution = "+parkey) # create empty fiber label array fiberlabels = np.zeros( (n, 2) ) final_fiberlabels = [] final_fibers_idx = [] # Open the corresponding ROI print("Open the corresponding ROI") for vol in roi_volumes: if parkey in vol: roi_fname = vol print roi_fname #roi_fname = roi_volumes[r] #r += 1 roi = nibabel.load(roi_fname) roiData = roi.get_data() # Create the matrix nROIs = parval['number_of_regions'] print("Create the connection matrix (%s rois)" % nROIs) G = nx.Graph() # add node information from parcellation gp = nx.read_graphml(parval['node_information_graphml']) for u,d in gp.nodes_iter(data=True): G.add_node(int(u), d) # compute a position for the node based on the mean position of the # ROI in voxel coordinates (segmentation volume ) G.node[int(u)]['dn_position'] = tuple(np.mean( np.where(roiData== int(d["dn_correspondence_id"]) ) , axis = 1)) dis = 0 # prepare: compute the measures t = [c[0] for c in fib] h = np.array(t, dtype = np.object ) mmap = additional_maps mmapdata = {} for k,v in mmap.items(): da = nibabel.load(v) mmapdata[k] = (da.get_data(), da.get_header().get_zooms() ) print("Create the connection matrix") pc = -1 for i in range(n): # n: number of fibers # Percent counter pcN = int(round( float(100*i)/n )) if pcN > pc and pcN%1 == 0: pc = pcN print('%4.0f%%' % (pc)) # ROI start => ROI end try: startROI = int(roiData[endpoints[i, 0, 0], endpoints[i, 0, 1], endpoints[i, 0, 2]]) # endpoints from create_endpoints_array endROI = int(roiData[endpoints[i, 1, 0], endpoints[i, 1, 1], endpoints[i, 1, 2]]) except IndexError: print("An index error occured for fiber %s. This means that the fiber start or endpoint is outside the volume. Continue." % i) continue # Filter if startROI == 0 or endROI == 0: dis += 1 fiberlabels[i,0] = -1 continue if startROI > nROIs or endROI > nROIs: # print("Start or endpoint of fiber terminate in a voxel which is labeled higher") # print("than is expected by the parcellation node information.") # print("Start ROI: %i, End ROI: %i" % (startROI, endROI)) # print("This needs bugfixing!") continue # Update fiber label # switch the rois in order to enforce startROI < endROI if endROI < startROI: tmp = startROI startROI = endROI endROI = tmp fiberlabels[i,0] = startROI fiberlabels[i,1] = endROI final_fiberlabels.append( [ startROI, endROI ] ) final_fibers_idx.append(i) # Add edge to graph if G.has_edge(startROI, endROI): G.edge[startROI][endROI]['fiblist'].append(i) else: G.add_edge(startROI, endROI, fiblist = [i]) print("Found %i (%f percent out of %i fibers) fibers that start or terminate in a voxel which is not labeled. (orphans)" % (dis, dis*100.0/n, n) ) print("Valid fibers: %i (%f percent)" % (n-dis, 100 - dis*100.0/n) ) # create a final fiber length array finalfiberlength = [] for idx in final_fibers_idx: # compute length of fiber finalfiberlength.append( length(fib[idx][0]) ) # convert to array final_fiberlength_array = np.array( finalfiberlength ) # make final fiber labels as array final_fiberlabels_array = np.array(final_fiberlabels, dtype = np.int32) # update edges # measures to add here for u,v,d in G.edges_iter(data=True): G.remove_edge(u,v) di = { 'number_of_fibers' : len(d['fiblist']), } # additional measures # compute mean/std of fiber measure idx = np.where( (final_fiberlabels_array[:,0] == int(u)) & (final_fiberlabels_array[:,1] == int(v)) )[0] di['fiber_length_mean'] = float( np.mean(final_fiberlength_array[idx]) ) di['fiber_length_std'] = float( np.std(final_fiberlength_array[idx]) ) # this is indexed into the fibers that are valid in the sense of touching start # and end roi and not going out of the volume idx_valid = np.where( (fiberlabels[:,0] == int(u)) & (fiberlabels[:,1] == int(v)) )[0] for k,vv in mmapdata.items(): val = [] for i in idx_valid: # retrieve indices try: idx2 = (h[i]/ vv[1] ).astype( np.uint32 ) val.append( vv[0][idx2[:,0],idx2[:,1],idx2[:,2]] ) except IndexError, e: print "Index error occured when trying extract scalar values for measure", k print "--> Discard fiber with index", i, "Exception: ", e print "----" da = np.concatenate( val ) di[k + '_mean'] = float(da.mean()) di[k + '_std'] = float(da.std()) del da del val G.add_edge(u,v, di) # storing network if 'gPickle' in output_types: nx.write_gpickle(G, 'connectome_%s.gpickle' % parkey) if 'mat' in output_types: # edges size_edges = (parval['number_of_regions'],parval['number_of_regions']) edge_keys = G.edges(data=True)[0][2].keys() edge_struct = {} for edge_key in edge_keys: edge_struct[edge_key] = nx.to_numpy_matrix(G,weight=edge_key) # nodes size_nodes = parval['number_of_regions'] node_keys = G.nodes(data=True)[0][1].keys() node_struct = {} for node_key in node_keys: if node_key == 'dn_position': node_arr = np.zeros([size_nodes,3],dtype=np.float) else: node_arr = np.zeros(size_nodes,dtype=np.object_) node_n = 0 for _,node_data in G.nodes(data=True): node_arr[node_n] = node_data[node_key] node_n += 1 node_struct[node_key] = node_arr scipy.io.savemat('connectome_%s.mat' % parkey, mdict={'sc':edge_struct,'nodes':node_struct}) if 'graphml' in output_types: g2 = nx.Graph() for u_gml,v_gml,d_gml in G.edges_iter(data=True): g2.add_edge(u_gml,v_gml,d_gml) for u_gml,d_gml in G.nodes(data=True): g2.add_node(u_gml,{'dn_correspondence_id':d_gml['dn_correspondence_id'], 'dn_fsname':d_gml['dn_fsname'], 'dn_hemisphere':d_gml['dn_hemisphere'], 'dn_name':d_gml['dn_name'], 'dn_position_x':float(d_gml['dn_position'][0]), 'dn_position_y':float(d_gml['dn_position'][1]), 'dn_position_z':float(d_gml['dn_position'][2]), 'dn_region':d_gml['dn_region']}) nx.write_graphml(g2,'connectome_%s.graphml' % parkey) print("Storing final fiber length array") fiberlabels_fname = 'final_fiberslength_%s.npy' % str(parkey) np.save(fiberlabels_fname, final_fiberlength_array) print("Storing all fiber labels (with orphans)") fiberlabels_fname = 'filtered_fiberslabel_%s.npy' % str(parkey) np.save(fiberlabels_fname, np.array(fiberlabels, dtype = np.int32), ) print("Storing final fiber labels (no orphans)") fiberlabels_noorphans_fname = 'final_fiberlabels_%s.npy' % str(parkey) np.save(fiberlabels_noorphans_fname, final_fiberlabels_array) if not streamline_wrote: print("Filtering tractography - keeping only no orphan fibers") finalfibers_fname = 'streamline_final.trk' save_fibers(hdr, fib, finalfibers_fname, final_fibers_idx)
def prob_cmat(intrk, roi_volumes, parcellation_scheme, output_types=['gPickle'], atlas_info = {}): print("Filling probabilistic connectivity matrices:") if parcellation_scheme != "Custom": resolutions = get_parcellation(parcellation_scheme) else: resolutions = atlas_info firstROIFile = roi_volumes[0] firstROI = nibabel.load(firstROIFile) roiVoxelSize = firstROI.get_header().get_zooms() for parkey, parval in resolutions.items(): print("Resolution = "+parkey) # Open the corresponding ROI print("Open the corresponding ROI") for vol in roi_volumes: if parkey in vol: roi_fname = vol print roi_fname roi = nibabel.load(roi_fname) roiData = roi.get_data() # Create the matrix nROIs = parval['number_of_regions'] print("Create the connection matrix (%s rois)" % nROIs) G = nx.Graph() # add node information from parcellation gp = nx.read_graphml(parval['node_information_graphml']) for u,d in gp.nodes_iter(data=True): G.add_node(int(u), d) # compute a position for the node based on the mean position of the # ROI in voxel coordinates (segmentation volume ) G.node[int(u)]['dn_position'] = tuple(np.mean( np.where(roiData== int(d["dn_correspondence_id"]) ) , axis = 1)) graph_matrix = np.zeros((nROIs,nROIs),dtype = int) pc = -1 for intrk_i in range(0,len(intrk)): pcN = int(round( float(100*intrk_i)/len(intrk) )) if pcN > pc and pcN%20 == 0: pc = pcN print('%4.0f%%' % (pc)) fib, hdr = nibabel.trackvis.read(intrk[intrk_i], False) (endpoints,endpointsmm) = create_endpoints_array(fib, roiVoxelSize, False) n = len(fib) dis = 0 pc = -1 for i in range(n): # n: number of fibers # ROI start => ROI end try: startROI = int(roiData[endpoints[i, 0, 0], endpoints[i, 0, 1], endpoints[i, 0, 2]]) # endpoints from create_endpoints_array endROI = int(roiData[endpoints[i, 1, 0], endpoints[i, 1, 1], endpoints[i, 1, 2]]) except IndexError: print("An index error occured for fiber %s. This means that the fiber start or endpoint is outside the volume. Continue." % i) continue # Filter if startROI == 0 or endROI == 0: dis += 1 #fiberlabels[i,0] = -1 continue if startROI > nROIs or endROI > nROIs: # print("Start or endpoint of fiber terminate in a voxel which is labeled higher") # print("than is expected by the parcellation node information.") # print("Start ROI: %i, End ROI: %i" % (startROI, endROI)) # print("This needs bugfixing!") continue # Update fiber label # switch the rois in order to enforce startROI < endROI if endROI < startROI: tmp = startROI startROI = endROI endROI = tmp # Add edge to graph if G.has_edge(startROI, endROI): G.edge[startROI][endROI]['n_tracks'] += 1 else: G.add_edge(startROI, endROI, n_tracks = 1) graph_matrix[startROI-1][endROI-1] +=1 tot_tracks = graph_matrix.sum() for u,v,d in G.edges_iter(data=True): G.remove_edge(u,v) di = { 'number_of_fibers' : (float(d['n_tracks']) / tot_tracks.astype(float))} G.add_edge(u,v, di) # storing network if 'gPickle' in output_types: nx.write_gpickle(G, 'connectome_%s.gpickle' % parkey) if 'mat' in output_types: # edges size_edges = (parval['number_of_regions'],parval['number_of_regions']) edge_keys = G.edges(data=True)[0][2].keys() edge_struct = {} for edge_key in edge_keys: edge_struct[edge_key] = nx.to_numpy_matrix(G,weight=edge_key) # nodes size_nodes = parval['number_of_regions'] node_keys = G.nodes(data=True)[0][1].keys() node_struct = {} for node_key in node_keys: if node_key == 'dn_position': node_arr = np.zeros([size_nodes,3],dtype=np.float) else: node_arr = np.zeros(size_nodes,dtype=np.object_) node_n = 0 for _,node_data in G.nodes(data=True): node_arr[node_n] = node_data[node_key] node_n += 1 node_struct[node_key] = node_arr scipy.io.savemat('connectome_%s.mat' % parkey, mdict={'sc':edge_struct,'nodes':node_struct}) if 'graphml' in output_types: g2 = nx.Graph() for u_gml,v_gml,d_gml in G.edges_iter(data=True): g2.add_edge(u_gml,v_gml,d_gml) for u_gml,d_gml in G.nodes(data=True): g2.add_node(u_gml,{'dn_correspondence_id':d_gml['dn_correspondence_id'], 'dn_fsname':d_gml['dn_fsname'], 'dn_hemisphere':d_gml['dn_hemisphere'], 'dn_name':d_gml['dn_name'], 'dn_position_x':float(d_gml['dn_position'][0]), 'dn_position_y':float(d_gml['dn_position'][1]), 'dn_position_z':float(d_gml['dn_position'][2]), 'dn_region':d_gml['dn_region']}) nx.write_graphml(g2,'connectome_%s.graphml' % parkey)
def probtrackx_cmat(voxel_connectivity_files, roi_volumes, parcellation_scheme, output_types=['gPickle'], atlas_info = {}): print("Filling probabilistic connectivity matrices:") if parcellation_scheme != "Custom": resolutions = get_parcellation(parcellation_scheme) else: resolutions = atlas_info #firstROIFile = roi_volumes[0] #firstROI = nibabel.load(firstROIFile) #roiVoxelSize = firstROI.get_header().get_zooms() for parkey, parval in resolutions.items(): print("Resolution = "+parkey) # Open the corresponding ROI print("Open the corresponding ROI") for vol in roi_volumes: if parkey in vol: roi_fname = vol print roi_fname roi = nibabel.load(roi_fname) roiData = roi.get_data() # Create the matrix nROIs = parval['number_of_regions'] print("Create the connection matrix (%s rois)" % nROIs) G = nx.Graph() # Match ROI indexes to matrix indexes ROI_idx = np.unique(roiData[roiData != 0]).astype('int32') # add node information from parcellation gp = nx.read_graphml(parval['node_information_graphml']) for u,d in gp.nodes_iter(data=True): G.add_node(int(u), d) # compute a position for the node based on the mean position of the # ROI in voxel coordinates (segmentation volume ) G.node[int(u)]['dn_position'] = tuple(np.mean( np.where(roiData== int(d["dn_correspondence_id"]) ) , axis = 1)) tot_tracks = 0 pc = -1 for voxmat_i in range(0,len(voxel_connectivity_files)): pcN = int(round( float(100*voxmat_i)/len(voxel_connectivity_files) )) if pcN > pc and pcN%20 == 0: pc = pcN print('%4.0f%%' % (pc)) #fib, hdr = nibabel.trackvis.read(voxel_connectivity[voxmat_i], False) #(endpoints,endpointsmm) = create_endpoints_array(fib, roiVoxelSize, False) #n = len(fib) startROI = int(ROI_idx[voxmat_i]) voxmat = np.loadtxt(voxel_connectivity_files[voxmat_i]).astype('int32') if len(voxmat.shape) > 1: ROImat = np.sum(voxmat,0) else: ROImat = voxmat for target in range(0,len(ROI_idx)): endROI = int(ROI_idx[target]) if startROI != endROI: # Excludes loops (connections within the same ROI) # Add edge to graph if G.has_edge(startROI, endROI): G.edge[startROI][endROI]['n_tracks'] += ROImat[target] else: G.add_edge(startROI, endROI, n_tracks = ROImat[target]) tot_tracks += ROImat[target] for u,v,d in G.edges_iter(data=True): G.remove_edge(u,v) di = { 'number_of_fibers' : (float(d['n_tracks']) / tot_tracks.astype(float))} G.add_edge(u,v, di) # storing network if 'gPickle' in output_types: nx.write_gpickle(G, 'connectome_%s.gpickle' % parkey) if 'mat' in output_types: # edges size_edges = (parval['number_of_regions'],parval['number_of_regions']) edge_keys = G.edges(data=True)[0][2].keys() edge_struct = {} for edge_key in edge_keys: edge_struct[edge_key] = nx.to_numpy_matrix(G,weight=edge_key) # nodes size_nodes = parval['number_of_regions'] node_keys = G.nodes(data=True)[0][1].keys() node_struct = {} for node_key in node_keys: if node_key == 'dn_position': node_arr = np.zeros([size_nodes,3],dtype=np.float) else: node_arr = np.zeros(size_nodes,dtype=np.object_) node_n = 0 for _,node_data in G.nodes(data=True): node_arr[node_n] = node_data[node_key] node_n += 1 node_struct[node_key] = node_arr scipy.io.savemat('connectome_%s.mat' % parkey, mdict={'sc':edge_struct,'nodes':node_struct}) if 'graphml' in output_types: g2 = nx.Graph() for u_gml,v_gml,d_gml in G.edges_iter(data=True): g2.add_edge(u_gml,v_gml,d_gml) for u_gml,d_gml in G.nodes(data=True): g2.add_node(u_gml,{'dn_correspondence_id':d_gml['dn_correspondence_id'], 'dn_fsname':d_gml['dn_fsname'], 'dn_hemisphere':d_gml['dn_hemisphere'], 'dn_name':d_gml['dn_name'], 'dn_position_x':float(d_gml['dn_position'][0]), 'dn_position_y':float(d_gml['dn_position'][1]), 'dn_position_z':float(d_gml['dn_position'][2]), 'dn_region':d_gml['dn_region']}) nx.write_graphml(g2,'connectome_%s.graphml' % parkey)
def cmat(intrk, roi_volumes, parcellation_scheme, compute_curvature=True, additional_maps={}, output_types=['gPickle'], atlas_info={}): """ Create the connection matrix for each resolution using fibers and ROIs. """ # create the endpoints for each fibers en_fname = 'endpoints.npy' en_fnamemm = 'endpointsmm.npy' #ep_fname = 'lengths.npy' curv_fname = 'meancurvature.npy' #intrk = op.join(gconf.get_cmp_fibers(), 'streamline_filtered.trk') print('Opening file :' + intrk) fib, hdr = nibabel.trackvis.read(intrk, False) if parcellation_scheme != "Custom": resolutions = get_parcellation(parcellation_scheme) else: resolutions = atlas_info # Previously, load_endpoints_from_trk() used the voxel size stored # in the track hdr to transform the endpoints to ROI voxel space. # This only works if the ROI voxel size is the same as the DSI/DTI # voxel size. In the case of DTI, it is not. # We do, however, assume that all of the ROI images have the same # voxel size, so this code just loads the first one to determine # what it should be firstROIFile = roi_volumes[0] firstROI = nibabel.load(firstROIFile) roiVoxelSize = firstROI.get_header().get_zooms() (endpoints, endpointsmm) = create_endpoints_array(fib, roiVoxelSize, True) np.save(en_fname, endpoints) np.save(en_fnamemm, endpointsmm) # only compute curvature if required if compute_curvature: meancurv = compute_curvature_array(fib) np.save(curv_fname, meancurv) print("========================") n = len(fib) #resolution = gconf.parcellation.keys() streamline_wrote = False for parkey, parval in resolutions.items(): #if parval['number_of_regions'] != 83: # continue print("Resolution = " + parkey) # create empty fiber label array fiberlabels = np.zeros((n, 2)) final_fiberlabels = [] final_fibers_idx = [] # Open the corresponding ROI print("Open the corresponding ROI") for vol in roi_volumes: if parkey in vol: roi_fname = vol print roi_fname #roi_fname = roi_volumes[r] #r += 1 roi = nibabel.load(roi_fname) roiData = roi.get_data() # Create the matrix nROIs = parval['number_of_regions'] print("Create the connection matrix (%s rois)" % nROIs) G = nx.Graph() # add node information from parcellation gp = nx.read_graphml(parval['node_information_graphml']) for u, d in gp.nodes_iter(data=True): G.add_node(int(u), d) # compute a position for the node based on the mean position of the # ROI in voxel coordinates (segmentation volume ) G.node[int(u)]['dn_position'] = tuple( np.mean(np.where(roiData == int(d["dn_correspondence_id"])), axis=1)) dis = 0 # prepare: compute the measures t = [c[0] for c in fib] h = np.array(t, dtype=np.object) mmap = additional_maps mmapdata = {} for k, v in mmap.items(): da = nibabel.load(v) mmapdata[k] = (da.get_data(), da.get_header().get_zooms()) print("Create the connection matrix") pc = -1 for i in range(n): # n: number of fibers # Percent counter pcN = int(round(float(100 * i) / n)) if pcN > pc and pcN % 1 == 0: pc = pcN print('%4.0f%%' % (pc)) # ROI start => ROI end try: startROI = int(roiData[ endpoints[i, 0, 0], endpoints[i, 0, 1], endpoints[i, 0, 2]]) # endpoints from create_endpoints_array endROI = int(roiData[endpoints[i, 1, 0], endpoints[i, 1, 1], endpoints[i, 1, 2]]) except IndexError: print( "An index error occured for fiber %s. This means that the fiber start or endpoint is outside the volume. Continue." % i) continue # Filter if startROI == 0 or endROI == 0: dis += 1 fiberlabels[i, 0] = -1 continue if startROI > nROIs or endROI > nROIs: # print("Start or endpoint of fiber terminate in a voxel which is labeled higher") # print("than is expected by the parcellation node information.") # print("Start ROI: %i, End ROI: %i" % (startROI, endROI)) # print("This needs bugfixing!") continue # Update fiber label # switch the rois in order to enforce startROI < endROI if endROI < startROI: tmp = startROI startROI = endROI endROI = tmp fiberlabels[i, 0] = startROI fiberlabels[i, 1] = endROI final_fiberlabels.append([startROI, endROI]) final_fibers_idx.append(i) # Add edge to graph if G.has_edge(startROI, endROI): G.edge[startROI][endROI]['fiblist'].append(i) else: G.add_edge(startROI, endROI, fiblist=[i]) print( "Found %i (%f percent out of %i fibers) fibers that start or terminate in a voxel which is not labeled. (orphans)" % (dis, dis * 100.0 / n, n)) print("Valid fibers: %i (%f percent)" % (n - dis, 100 - dis * 100.0 / n)) # create a final fiber length array finalfiberlength = [] for idx in final_fibers_idx: # compute length of fiber finalfiberlength.append(length(fib[idx][0])) # convert to array final_fiberlength_array = np.array(finalfiberlength) # make final fiber labels as array final_fiberlabels_array = np.array(final_fiberlabels, dtype=np.int32) # update edges # measures to add here for u, v, d in G.edges_iter(data=True): G.remove_edge(u, v) di = { 'number_of_fibers': len(d['fiblist']), } # additional measures # compute mean/std of fiber measure idx = np.where((final_fiberlabels_array[:, 0] == int(u)) & (final_fiberlabels_array[:, 1] == int(v)))[0] di['fiber_length_mean'] = float( np.mean(final_fiberlength_array[idx])) di['fiber_length_std'] = float(np.std( final_fiberlength_array[idx])) # this is indexed into the fibers that are valid in the sense of touching start # and end roi and not going out of the volume idx_valid = np.where((fiberlabels[:, 0] == int(u)) & (fiberlabels[:, 1] == int(v)))[0] for k, vv in mmapdata.items(): val = [] for i in idx_valid: # retrieve indices try: idx2 = (h[i] / vv[1]).astype(np.uint32) val.append(vv[0][idx2[:, 0], idx2[:, 1], idx2[:, 2]]) except IndexError, e: print "Index error occured when trying extract scalar values for measure", k print "--> Discard fiber with index", i, "Exception: ", e print "----" da = np.concatenate(val) di[k + '_mean'] = float(da.mean()) di[k + '_std'] = float(da.std()) del da del val G.add_edge(u, v, di) # storing network if 'gPickle' in output_types: nx.write_gpickle(G, 'connectome_%s.gpickle' % parkey) if 'mat' in output_types: # edges size_edges = (parval['number_of_regions'], parval['number_of_regions']) edge_keys = G.edges(data=True)[0][2].keys() edge_struct = {} for edge_key in edge_keys: edge_struct[edge_key] = nx.to_numpy_matrix(G, weight=edge_key) # nodes size_nodes = parval['number_of_regions'] node_keys = G.nodes(data=True)[0][1].keys() node_struct = {} for node_key in node_keys: if node_key == 'dn_position': node_arr = np.zeros([size_nodes, 3], dtype=np.float) else: node_arr = np.zeros(size_nodes, dtype=np.object_) node_n = 0 for _, node_data in G.nodes(data=True): node_arr[node_n] = node_data[node_key] node_n += 1 node_struct[node_key] = node_arr scipy.io.savemat('connectome_%s.mat' % parkey, mdict={ 'sc': edge_struct, 'nodes': node_struct }) if 'graphml' in output_types: g2 = nx.Graph() for u_gml, v_gml, d_gml in G.edges_iter(data=True): g2.add_edge(u_gml, v_gml, d_gml) for u_gml, d_gml in G.nodes(data=True): g2.add_node( u_gml, { 'dn_correspondence_id': d_gml['dn_correspondence_id'], 'dn_fsname': d_gml['dn_fsname'], 'dn_hemisphere': d_gml['dn_hemisphere'], 'dn_name': d_gml['dn_name'], 'dn_position_x': float(d_gml['dn_position'][0]), 'dn_position_y': float(d_gml['dn_position'][1]), 'dn_position_z': float(d_gml['dn_position'][2]), 'dn_region': d_gml['dn_region'] }) nx.write_graphml(g2, 'connectome_%s.graphml' % parkey) print("Storing final fiber length array") fiberlabels_fname = 'final_fiberslength_%s.npy' % str(parkey) np.save(fiberlabels_fname, final_fiberlength_array) print("Storing all fiber labels (with orphans)") fiberlabels_fname = 'filtered_fiberslabel_%s.npy' % str(parkey) np.save( fiberlabels_fname, np.array(fiberlabels, dtype=np.int32), ) print("Storing final fiber labels (no orphans)") fiberlabels_noorphans_fname = 'final_fiberlabels_%s.npy' % str(parkey) np.save(fiberlabels_noorphans_fname, final_fiberlabels_array) if not streamline_wrote: print("Filtering tractography - keeping only no orphan fibers") finalfibers_fname = 'streamline_final.trk' save_fibers(hdr, fib, finalfibers_fname, final_fibers_idx)
def prob_cmat(intrk, roi_volumes, parcellation_scheme, output_types=['gPickle'], atlas_info={}): print("Filling probabilistic connectivity matrices:") if parcellation_scheme != "Custom": resolutions = get_parcellation(parcellation_scheme) else: resolutions = atlas_info firstROIFile = roi_volumes[0] firstROI = nibabel.load(firstROIFile) roiVoxelSize = firstROI.get_header().get_zooms() for parkey, parval in resolutions.items(): print("Resolution = " + parkey) # Open the corresponding ROI print("Open the corresponding ROI") for vol in roi_volumes: if parkey in vol: roi_fname = vol print roi_fname roi = nibabel.load(roi_fname) roiData = roi.get_data() # Create the matrix nROIs = parval['number_of_regions'] print("Create the connection matrix (%s rois)" % nROIs) G = nx.Graph() # add node information from parcellation gp = nx.read_graphml(parval['node_information_graphml']) for u, d in gp.nodes_iter(data=True): G.add_node(int(u), d) # compute a position for the node based on the mean position of the # ROI in voxel coordinates (segmentation volume ) G.node[int(u)]['dn_position'] = tuple( np.mean(np.where(roiData == int(d["dn_correspondence_id"])), axis=1)) graph_matrix = np.zeros((nROIs, nROIs), dtype=int) pc = -1 for intrk_i in range(0, len(intrk)): pcN = int(round(float(100 * intrk_i) / len(intrk))) if pcN > pc and pcN % 20 == 0: pc = pcN print('%4.0f%%' % (pc)) fib, hdr = nibabel.trackvis.read(intrk[intrk_i], False) (endpoints, endpointsmm) = create_endpoints_array(fib, roiVoxelSize, False) n = len(fib) dis = 0 pc = -1 for i in range(n): # n: number of fibers # ROI start => ROI end try: startROI = int(roiData[ endpoints[i, 0, 0], endpoints[i, 0, 1], endpoints[i, 0, 2]]) # endpoints from create_endpoints_array endROI = int(roiData[endpoints[i, 1, 0], endpoints[i, 1, 1], endpoints[i, 1, 2]]) except IndexError: print( "An index error occured for fiber %s. This means that the fiber start or endpoint is outside the volume. Continue." % i) continue # Filter if startROI == 0 or endROI == 0: dis += 1 #fiberlabels[i,0] = -1 continue if startROI > nROIs or endROI > nROIs: # print("Start or endpoint of fiber terminate in a voxel which is labeled higher") # print("than is expected by the parcellation node information.") # print("Start ROI: %i, End ROI: %i" % (startROI, endROI)) # print("This needs bugfixing!") continue # Update fiber label # switch the rois in order to enforce startROI < endROI if endROI < startROI: tmp = startROI startROI = endROI endROI = tmp # Add edge to graph if G.has_edge(startROI, endROI): G.edge[startROI][endROI]['n_tracks'] += 1 else: G.add_edge(startROI, endROI, n_tracks=1) graph_matrix[startROI - 1][endROI - 1] += 1 tot_tracks = graph_matrix.sum() for u, v, d in G.edges_iter(data=True): G.remove_edge(u, v) di = { 'number_of_fibers': (float(d['n_tracks']) / tot_tracks.astype(float)) } G.add_edge(u, v, di) # storing network if 'gPickle' in output_types: nx.write_gpickle(G, 'connectome_%s.gpickle' % parkey) if 'mat' in output_types: # edges size_edges = (parval['number_of_regions'], parval['number_of_regions']) edge_keys = G.edges(data=True)[0][2].keys() edge_struct = {} for edge_key in edge_keys: edge_struct[edge_key] = nx.to_numpy_matrix(G, weight=edge_key) # nodes size_nodes = parval['number_of_regions'] node_keys = G.nodes(data=True)[0][1].keys() node_struct = {} for node_key in node_keys: if node_key == 'dn_position': node_arr = np.zeros([size_nodes, 3], dtype=np.float) else: node_arr = np.zeros(size_nodes, dtype=np.object_) node_n = 0 for _, node_data in G.nodes(data=True): node_arr[node_n] = node_data[node_key] node_n += 1 node_struct[node_key] = node_arr scipy.io.savemat('connectome_%s.mat' % parkey, mdict={ 'sc': edge_struct, 'nodes': node_struct }) if 'graphml' in output_types: g2 = nx.Graph() for u_gml, v_gml, d_gml in G.edges_iter(data=True): g2.add_edge(u_gml, v_gml, d_gml) for u_gml, d_gml in G.nodes(data=True): g2.add_node( u_gml, { 'dn_correspondence_id': d_gml['dn_correspondence_id'], 'dn_fsname': d_gml['dn_fsname'], 'dn_hemisphere': d_gml['dn_hemisphere'], 'dn_name': d_gml['dn_name'], 'dn_position_x': float(d_gml['dn_position'][0]), 'dn_position_y': float(d_gml['dn_position'][1]), 'dn_position_z': float(d_gml['dn_position'][2]), 'dn_region': d_gml['dn_region'] }) nx.write_graphml(g2, 'connectome_%s.graphml' % parkey)
def probtrackx_cmat(voxel_connectivity_files, roi_volumes, parcellation_scheme, output_types=['gPickle'], atlas_info={}): print("Filling probabilistic connectivity matrices:") if parcellation_scheme != "Custom": resolutions = get_parcellation(parcellation_scheme) else: resolutions = atlas_info #firstROIFile = roi_volumes[0] #firstROI = nibabel.load(firstROIFile) #roiVoxelSize = firstROI.get_header().get_zooms() for parkey, parval in resolutions.items(): print("Resolution = " + parkey) # Open the corresponding ROI print("Open the corresponding ROI") for vol in roi_volumes: if parkey in vol: roi_fname = vol print roi_fname roi = nibabel.load(roi_fname) roiData = roi.get_data() # Create the matrix nROIs = parval['number_of_regions'] print("Create the connection matrix (%s rois)" % nROIs) G = nx.Graph() # Match ROI indexes to matrix indexes ROI_idx = np.unique(roiData[roiData != 0]).astype('int32') # add node information from parcellation gp = nx.read_graphml(parval['node_information_graphml']) for u, d in gp.nodes_iter(data=True): G.add_node(int(u), d) # compute a position for the node based on the mean position of the # ROI in voxel coordinates (segmentation volume ) G.node[int(u)]['dn_position'] = tuple( np.mean(np.where(roiData == int(d["dn_correspondence_id"])), axis=1)) tot_tracks = 0 pc = -1 for voxmat_i in range(0, len(voxel_connectivity_files)): pcN = int( round(float(100 * voxmat_i) / len(voxel_connectivity_files))) if pcN > pc and pcN % 20 == 0: pc = pcN print('%4.0f%%' % (pc)) #fib, hdr = nibabel.trackvis.read(voxel_connectivity[voxmat_i], False) #(endpoints,endpointsmm) = create_endpoints_array(fib, roiVoxelSize, False) #n = len(fib) startROI = int(ROI_idx[voxmat_i]) voxmat = np.loadtxt( voxel_connectivity_files[voxmat_i]).astype('int32') if len(voxmat.shape) > 1: ROImat = np.sum(voxmat, 0) else: ROImat = voxmat for target in range(0, len(ROI_idx)): endROI = int(ROI_idx[target]) if startROI != endROI: # Excludes loops (connections within the same ROI) # Add edge to graph if G.has_edge(startROI, endROI): G.edge[startROI][endROI]['n_tracks'] += ROImat[target] else: G.add_edge(startROI, endROI, n_tracks=ROImat[target]) tot_tracks += ROImat[target] for u, v, d in G.edges_iter(data=True): G.remove_edge(u, v) di = { 'number_of_fibers': (float(d['n_tracks']) / tot_tracks.astype(float)) } G.add_edge(u, v, di) # storing network if 'gPickle' in output_types: nx.write_gpickle(G, 'connectome_%s.gpickle' % parkey) if 'mat' in output_types: # edges size_edges = (parval['number_of_regions'], parval['number_of_regions']) edge_keys = G.edges(data=True)[0][2].keys() edge_struct = {} for edge_key in edge_keys: edge_struct[edge_key] = nx.to_numpy_matrix(G, weight=edge_key) # nodes size_nodes = parval['number_of_regions'] node_keys = G.nodes(data=True)[0][1].keys() node_struct = {} for node_key in node_keys: if node_key == 'dn_position': node_arr = np.zeros([size_nodes, 3], dtype=np.float) else: node_arr = np.zeros(size_nodes, dtype=np.object_) node_n = 0 for _, node_data in G.nodes(data=True): node_arr[node_n] = node_data[node_key] node_n += 1 node_struct[node_key] = node_arr scipy.io.savemat('connectome_%s.mat' % parkey, mdict={ 'sc': edge_struct, 'nodes': node_struct }) if 'graphml' in output_types: g2 = nx.Graph() for u_gml, v_gml, d_gml in G.edges_iter(data=True): g2.add_edge(u_gml, v_gml, d_gml) for u_gml, d_gml in G.nodes(data=True): g2.add_node( u_gml, { 'dn_correspondence_id': d_gml['dn_correspondence_id'], 'dn_fsname': d_gml['dn_fsname'], 'dn_hemisphere': d_gml['dn_hemisphere'], 'dn_name': d_gml['dn_name'], 'dn_position_x': float(d_gml['dn_position'][0]), 'dn_position_y': float(d_gml['dn_position'][1]), 'dn_position_z': float(d_gml['dn_position'][2]), 'dn_region': d_gml['dn_region'] }) nx.write_graphml(g2, 'connectome_%s.graphml' % parkey)