def map_wine_vectors(tfidf, model, names, col_dict): vec_dim = model.syn0.shape[1] wine_vectors = np.zeros((len(names), vec_dim)) for i in range(len(names)): row = tfidf[i, :] (_, j_s, vals) = sparse_find(row) vecs = np.zeros((len(j_s), vec_dim)) for k, j in enumerate(j_s): if col_dict[j] in model: vecs[k, :] = model[col_dict[j]] print i vec = np.average(vecs, axis=0, weights=vals) wine_vectors[i, :] = vec return wine_vectors
def get_shared_voxels(subject, xfmname, hemi="both", merge=True, use_astar=True): '''Return voxels that are shared by multiple vertices, and for each such voxel, also returns the mutually farthest pair of vertices mapping to the voxel Parameters ---------- subject : str Name of the subject xfmname : str Name of the transform hemi : str, optional Which hemisphere to return. For now, only 'lh' or 'rh' merge : bool, optinal Join the hemispheres, if requesting both use_astar: bool, optional Toggle to decide whether to use A* seach or geodesic paths for the shortest paths Returns ------- vox_vert_array: np.array, array of dimensions # voxels X 3, columns being: (vox_idx, farthest_pair[0], farthest_pair[1]) ''' from scipy.sparse import find as sparse_find import networkx as nx Lmask, Rmask = get_mapper( subject, xfmname).masks # Get masks for left and right hemisphere if hemi == 'both': hemispheres = ['lh', 'rh'] else: hemispheres = [hemi] out = [] for hem in hemispheres: if hem == 'lh': mask = Lmask else: mask = Rmask all_voxels = mask.tolil().transpose().rows # Map from voxels to verts vert_to_vox_map = dict( zip(*(sparse_find(mask)[:2]))) # From verts to vox pts_fid, polys_fid = db.get_surf(subject, 'fiducial', hem) # Get the fiducial surface surf = Surface(pts_fid, polys_fid) #Get the fiducial surface graph = surf.graph _set_edge_distance_graph_attribute(graph, pts_fid, polys_fid) l2_distance = lambda v1, v2: np.linalg.norm(pts_fid[v1] - pts_fid[v2]) heuristic = l2_distance # A* heuristic if use_astar: shortest_path = lambda a, b: nx.astar_path( graph, a, b, heuristic=heuristic, weight='distance' ) # Find approximate shortest paths using A* search else: shortest_path = surf.geodesic_path # Find shortest paths using geodesic distances vox_vert_list = [] for vox_idx, vox in enumerate(all_voxels): if len(vox) > 1: # If the voxel maps to multiple vertices vox = np.array(vox).astype(int) for v1 in range(vox.size - 1): vert1 = vox[v1] if vert1 in vert_to_vox_map: # If the vertex is a valid vertex for v2 in range(v1 + 1, vox.size): vert2 = vox[v2] if vert2 in vert_to_vox_map: # If the vertex is a valid vertex path = shortest_path(vert1, vert2) # Test whether any vertex in path goes out of the voxel stays_in_voxel = all([ (v in vert_to_vox_map) and (vert_to_vox_map[v] == vox_idx) for v in path ]) if not stays_in_voxel: vox_vert_list.append( [vox_idx, vert1, vert2]) tmp = np.array(vox_vert_list) # Add offset for right hem voxels if hem == 'rh': tmp[:, 1:3] += Lmask.shape[0] out.append(tmp) if hemi in ('lh', 'rh'): return out[0] else: if merge: return np.vstack(out) else: return tuple(out)
def get_shared_voxels(subject, xfmname, hemi="both", merge=True, use_astar=True): '''Return voxels that are shared by multiple vertices, and for each such voxel, also returns the mutually farthest pair of vertices mapping to the voxel Parameters ---------- subject : str Name of the subject xfmname : str Name of the transform hemi : str, optional Which hemisphere to return. For now, only 'lh' or 'rh' merge : bool, optinal Join the hemispheres, if requesting both use_astar: bool, optional Toggle to decide whether to use A* seach or geodesic paths for the shortest paths Returns ------- vox_vert_array: np.array, array of dimensions # voxels X 3, columns being: (vox_idx, farthest_pair[0], farthest_pair[1]) ''' from scipy.sparse import find as sparse_find import networkx as nx Lmask, Rmask = get_mapper(subject, xfmname).masks # Get masks for left and right hemisphere if hemi == 'both': hemispheres = ['lh', 'rh'] else: hemispheres = [hemi] out = [] for hem in hemispheres: if hem == 'lh': mask = Lmask else: mask = Rmask all_voxels = mask.tolil().transpose().rows # Map from voxels to verts vert_to_vox_map = dict(zip(*(sparse_find(mask)[:2]))) # From verts to vox pts_fid, polys_fid = db.get_surf(subject, 'fiducial', hem) # Get the fiducial surface surf = Surface(pts_fid, polys_fid) #Get the fiducial surface graph = surf.graph _set_edge_distance_graph_attribute(graph, pts_fid, polys_fid) l2_distance = lambda v1, v2: np.linalg.norm(pts_fid[v1] - pts_fid[v2]) heuristic = l2_distance # A* heuristic if use_astar: shortest_path = lambda a, b: nx.astar_path(graph, a, b, heuristic=heuristic, weight='distance') # Find approximate shortest paths using A* search else: shortest_path = surf.geodesic_path # Find shortest paths using geodesic distances vox_vert_list = [] for vox_idx, vox in enumerate(all_voxels): if len(vox) > 1: # If the voxel maps to multiple vertices vox = np.array(vox).astype(int) for v1 in range(vox.size-1): vert1 = vox[v1] if vert1 in vert_to_vox_map: # If the vertex is a valid vertex for v2 in range(v1+1, vox.size): vert2 = vox[v2] if vert2 in vert_to_vox_map: # If the vertex is a valid vertex path = shortest_path(vert1, vert2) # Test whether any vertex in path goes out of the voxel stays_in_voxel = all([(v in vert_to_vox_map) and (vert_to_vox_map[v] == vox_idx) for v in path]) if not stays_in_voxel: vox_vert_list.append([vox_idx, vert1, vert2]) tmp = np.array(vox_vert_list) # Add offset for right hem voxels if hem=='rh': tmp[:, 1:3] += Lmask.shape[0] out.append(tmp) if hemi in ('lh', 'rh'): return out[0] else: if merge: return np.vstack(out) else: return tuple(out)