def make_ica_maps(data, imgs, img_size_x, img_size_y, num_ica_colors, color_map, colors_ica): reference = data.seriesMean().pack() maps = Colorize(cmap=color_map, colors = colors_ica[0:np.size(imgs,0)], scale=num_ica_colors).transform(abs(imgs),background=reference, mixing=1.5) #Count number of unique colors in the images #Get number of planes based on map dimesnions if len(maps.shape)==3: num_planes = 1 else: num_planes = np.size(maps,2) unique_clrs = [] for ii in xrange(0, np.size(colors_ica[0:np.size(imgs,0)])): unique_clrs.append( np.round(np.array(webcolors.name_to_rgb(colors_ica[ii]), dtype=np.float)/255)) #From maps get number of pixel matches with color for each plane matched_pixels = np.zeros((np.size(unique_clrs,0),num_planes)) array_maps = np.round(maps.astype(np.float16)) matched_pixels = np.zeros((np.size(unique_clrs,0),num_planes)) if len(maps.shape) == 3: array_maps_plane = np.reshape(array_maps, (np.size(array_maps,0)*np.size(array_maps,1),3)) matched_pixels[:,0] = [np.size(np.where((np.array(array_maps_plane) == match).all(axis=1))) for match in unique_clrs] else: for ii in xrange(0,num_planes): array_maps_plane = np.reshape(array_maps[:,:,ii,:], (np.size(array_maps,0)*np.size(array_maps,1),3)) matched_pixels[:,ii] = [np.size(np.where((np.array(array_maps_plane) == match).all(axis=1))) for match in unique_clrs] return maps, matched_pixels
def plot_all_together_inseperateplot(self, fig1, gs, regressors, rsq, b, colors, brightness_scale=3, gridspecs='[0, 0]'): b_pos = b * (b > 0) # Get positive beta values # Set up colorize function c = Colorize(cmap='indexed', scale=brightness_scale, flag_scale=1) b_pos_list = [] color_mat = [] for ii in xrange(0, len(regressors)): b_pos_list.append(b_pos[ii, :, :]) color_mat.append(colors[ii]) ax1 = eval('fig1.add_subplot(gs' + gridspecs + ')') c.colors = color_mat img = c.transform(b_pos_list, mask=rsq, background=self.reference, mixing=0.5) self.image(img)
def plot_regressors_as_RGB(self, fig1, gs, regressors, rsq, b, colors, brightness_scale=3): b_pos = b * (b > 0) # Get positive beta values # Set up colorize function c = Colorize(cmap="indexed", scale=brightness_scale, flag_scale=1) for ii in xrange(0, len(regressors)): ax1 = fig1.add_subplot(gs[0, ii]) c.colors = [colors[ii]] img = c.transform([b_pos[ii, :, :]], mask=rsq, background=self.reference, mixing=0.5) self.image(img) # Plot the unique stimuli in subplots subplot_count = 0 for ii in self.unique_stimuli: b_pos_list = [] color_mat = [] for keys in regressors.iterkeys(): if ii in keys: index = regressors.keys().index(keys) b_pos_list.append(b_pos[index, :, :]) color_mat.append(colors[index]) ax1 = fig1.add_subplot(gs[1, subplot_count]) c.colors = color_mat img = c.transform(b_pos_list, mask=rsq, background=self.reference, mixing=0.5) self.image(img) subplot_count += 1 # Plot the different stimuli parameters in subplots for ii in self.parameters: b_pos_list = [] color_mat = [] for keys in regressors.iterkeys(): if ii in keys: index = regressors.keys().index(keys) b_pos_list.append(b_pos[index, :, :]) color_mat.append(colors[index]) ax1 = fig1.add_subplot(gs[1, subplot_count]) c.colors = color_mat img = c.transform(b_pos_list, mask=rsq, background=self.reference, mixing=0.5) self.image(img) subplot_count += 1 # Plot all together b_pos_list = [] color_mat = [] for ii in xrange(0, len(regressors)): b_pos_list.append(b_pos[ii, :, :]) color_mat.append(colors[ii]) ax1 = fig1.add_subplot(gs[2:4, 1:3]) c.colors = color_mat img = c.transform(b_pos_list, mask=rsq, background=self.reference, mixing=0.5) self.image(img) subplot_count += 1 ax1 = fig1.add_subplot(gs[2, 0]) self.create_colorbar(ax1, regressors, colors)
def make_ica_maps(data, imgs, img_size_x, img_size_y, num_ica_colors, color_map, colors_ica): reference = data.seriesMean().pack() maps = Colorize(cmap=color_map, colors=colors_ica[0:np.size(imgs, 0)], scale=num_ica_colors).transform(abs(imgs), background=reference, mixing=1.5) #Count number of unique colors in the images #Get number of planes based on map dimesnions if len(maps.shape) == 3: num_planes = 1 else: num_planes = np.size(maps, 2) unique_clrs = [] for ii in xrange(0, np.size(colors_ica[0:np.size(imgs, 0)])): unique_clrs.append( np.round( np.array(webcolors.name_to_rgb(colors_ica[ii]), dtype=np.float) / 255)) #From maps get number of pixel matches with color for each plane matched_pixels = np.zeros((np.size(unique_clrs, 0), num_planes)) array_maps = np.round(maps.astype(np.float16)) matched_pixels = np.zeros((np.size(unique_clrs, 0), num_planes)) if len(maps.shape) == 3: array_maps_plane = np.reshape( array_maps, (np.size(array_maps, 0) * np.size(array_maps, 1), 3)) matched_pixels[:, 0] = [ np.size(np.where( (np.array(array_maps_plane) == match).all(axis=1))) for match in unique_clrs ] else: for ii in xrange(0, num_planes): array_maps_plane = np.reshape( array_maps[:, :, ii, :], (np.size(array_maps, 0) * np.size(array_maps, 1), 3)) matched_pixels[:, ii] = [ np.size( np.where( (np.array(array_maps_plane) == match).all(axis=1))) for match in unique_clrs ] return maps, matched_pixels
def plot_all_together_inseperateplot( self, fig1, gs, regressors, rsq, b, colors, brightness_scale=3, gridspecs="[0, 0]" ): b_pos = b * (b > 0) # Get positive beta values # Set up colorize function c = Colorize(cmap="indexed", scale=brightness_scale, flag_scale=1) b_pos_list = [] color_mat = [] for ii in xrange(0, len(regressors)): b_pos_list.append(b_pos[ii, :, :]) color_mat.append(colors[ii]) ax1 = eval("fig1.add_subplot(gs" + gridspecs + ")") c.colors = color_mat img = c.transform(b_pos_list, mask=rsq, background=self.reference, mixing=0.5) self.image(img)
def masks(self, dims=None, binary=True, outline=False, base=None): """ Composite masks combined across sources as an iamge. Parameters ---------- dims : list or tuple, optional, default = None Dimensions of image in which to create masks, must either provide these or provide a base image binary : boolean, optional, deafult = True Whether to incoporate values or only show a binary mask outline : boolean, optional, deafult = False Whether to only show outlines (derived using binary dilation) base : array-like, optional, deafult = None Base background image on which to put masks. """ from thunder import Colorize if dims is None and base is None: raise Exception( "Must provide image dimensions for composite masks " "or provide a base image.") if base is not None and isinstance(base, SourceModel): outline = True if dims is None and base is not None: dims = asarray(base).shape combined = zeros(dims) for s in self.sources: combined = maximum(s.mask(dims, binary, outline), combined) if base is not None: if isinstance(base, SourceModel): base = base.masks(dims) baseColor = 'silver' else: baseColor = 'white' clr = Colorize(cmap='indexed', colors=[baseColor, 'deeppink']) combined = clr.transform([base, combined]) return combined
def masks(self, dims=None, binary=True, outline=False, base=None): """ Composite masks combined across sources as an iamge. Parameters ---------- dims : list or tuple, optional, default = None Dimensions of image in which to create masks, must either provide these or provide a base image binary : boolean, optional, deafult = True Whether to incoporate values or only show a binary mask outline : boolean, optional, deafult = False Whether to only show outlines (derived using binary dilation) base : array-like, optional, deafult = None Base background image on which to put masks. """ from thunder import Colorize if dims is None and base is None: raise Exception("Must provide image dimensions for composite masks " "or provide a base image.") if base is not None and isinstance(base, SourceModel): outline = True if dims is None and base is not None: dims = asarray(base).shape combined = zeros(dims) for s in self.sources: combined = maximum(s.mask(dims, binary, outline), combined) if base is not None: if isinstance(base, SourceModel): base = base.masks(dims) baseColor = 'silver' else: baseColor = 'white' clr = Colorize(cmap='indexed', colors=[baseColor, 'deeppink']) combined = clr.transform([base, combined]) return combined
def createbrainmap_withcmap(self, fig1, gs, colormap, img_labels, img_sim, mixing_parameter, gridspecs): brainmap = Colorize(cmap=colormap).transform(img_labels, mask=img_sim, background=self.reference, mixing=mixing_parameter) ax1 = eval('fig1.add_subplot(gs' + gridspecs + ')') ax1.imshow(brainmap) ax1.axis('off')
def make_NMF_maps(self, imgs, mixing_parameter, ignore_clusters=0): new_NMF_colors = copy(self.NMF_colors) if ignore_clusters != 0: new_NMF_colors[:, ignore_clusters] = 0, 0, 0 maps = Colorize(cmap=self.color_map, colors=new_NMF_colors, scale=self.num_NMF_colors).transform( imgs, background=self.reference, mixing=mixing_parameter) return maps
def mask(self, dims=None, binary=True, outline=False, color=None): """ Construct a mask from a source, either locally or within a larger image. Parameters ---------- dims : list or tuple, optional, default = None Dimensions of large image in which to draw mask. If none, will restrict to the bounding box of the region. binary : boolean, optional, deafult = True Whether to incoporate values or only show a binary mask outline : boolean, optional, deafult = False Whether to only show outlines (derived using binary dilation) color : str or array-like RGB triplet (from 0 to 1) or named color (e.g. 'red', 'blue') """ from thunder import Colorize coords = self.coordinates if dims is None: extent = self.bbox[len(self.center):] - self.bbox[0:len(self.center )] + 1 m = zeros(extent) coords = (coords - self.bbox[0:len(self.center)]) else: m = zeros(dims) if hasattr(self, 'values') and self.values is not None and binary is False: m[coords.T.tolist()] = self.values else: m[coords.T.tolist()] = 1 if outline: from skimage.morphology import binary_dilation m = binary_dilation(m, ones((3, 3))) - m if color is not None: m = Colorize(cmap='indexed', colors=[color]).transform([m]) return m
def createbrainmap_withcmap(self, fig1, gs, mixing_parameter, gridspecs, **kwargs): if 'cmap' in kwargs: colormap = ListedColormap(list(kwargs['cmap']), name='braincmap') else: colormap = ListedColormap(list(self.centered_cmap), name='braincmap') brainmap = Colorize(cmap=colormap).transform( self.img_labels, mask=self.img_sim, background=self.reference_image, mixing=mixing_parameter) ax1 = eval('fig1.add_subplot(gs' + gridspecs + ')') ax1.imshow(brainmap) ax1.axis('off') ax1.get_xaxis().set_visible(False) ax1.get_yaxis().set_visible(False) return brainmap
def createbrainmap_withcmap(self, fig1, gs, colormap, img_labels, img_sim, mixing_parameter, gridspecs): """ Create the spatial brainmap again using specified colormap Parameters ---------- fig1 : Figure handle gs : Gridspecs handle colormap : Colormap to make spatial maps img_sim : obtained using the Similarity method of thunder's KMeansModel. img_labels : Predicted label for each pixel, acquired as an image of labels mixing_parameter : mixing controls relative scale of the background. gridspecs : Grid to plot in """ brainmap = Colorize(cmap=colormap).transform(img_labels, mask=img_sim, background=self.reference, mixing=mixing_parameter) ax1 = eval('fig1.add_subplot(gs' + gridspecs + ')') ax1.imshow(brainmap) ax1.axis('off')
def createbrainmap_withcmap_forcombining(self, fig1, gs, gridspecs='[0, :]', **kwargs): if 'cmap' in kwargs: colormap = ListedColormap(list(kwargs['cmap']), name='braincmap') else: colormap = ListedColormap(list(self.centered_cmap), name='braincmap') brainmap = Colorize(cmap=colormap).transform(self.img_labels, mask=self.img_sim) ax1 = eval('fig1.add_subplot(gs' + gridspecs + ')') ax1.imshow(brainmap) ax1.axis('off') ax1.get_xaxis().set_visible(False) ax1.get_yaxis().set_visible(False) return brainmap
def colorize(self, data, cmap="rainbow", scale=1, vmin=0, vmax=30): if data is None or len(data) == 0: return None print "In colorize, data.shape: %s" % str(data.shape) return Colorize(cmap=cmap, scale=scale, vmin=vmin, vmax=vmax).transform(data)
def masks(self, dims=None, binary=True, outline=False, base=None, color=None, values=None, inds=None): """ Composite masks combined across sources as an image. Parameters ---------- dims : list or tuple, optional, default = None Dimensions of image in which to create masks, must either provide these or provide a base image binary : boolean, optional, deafult = True Whether to incoporate values or only show a binary mask outline : boolean, optional, deafult = False Whether to only show outlines (derived using binary dilation) base : SourceModel or array-like, optional, deafult = None Base background image on which to put masks, or another set of sources (usually for comparisons). color : str or LinearSegmentedColormap, optional, deafult = None Color to assign regions or colormap, will used named colormap or use the provided colormap, or assign randomly if 'random' values : array-like List of values to use with colormap inds : array-like, optional, deafult = None List of indices if only showing a subset """ from thunder import Colorize from matplotlib.cm import get_cmap from matplotlib.colors import LinearSegmentedColormap if inds is None: inds = range(0, self.count) if dims is None and base is None: raise Exception( "Must provide image dimensions for composite masks " "or provide a base image.") if base is not None and isinstance(base, SourceModel): outline = True if dims is None and base is not None: dims = asarray(base).shape if isinstance(base, SourceModel): base = base.masks(dims, color='silver') elif isinstance(base, ndarray): base = Colorize(cmap='indexed', colors=['white']).transform([base]) if base is not None and color is None: color = 'deeppink' if isinstance(color, LinearSegmentedColormap) and values is not None: combined = zeros(list(dims) + [3]) colors = color(values)[:, 0:3] for i in inds: combined = maximum( self.sources[i].mask(dims, binary, outline, colors[i]), combined) if isinstance(color, str) and values is not None and not color == 'random': combined = zeros(list(dims) + [3]) colors = get_cmap(color, self.count)(values)[:, 0:3] for i in inds: combined = maximum( self.sources[i].mask(dims, binary, outline, colors[i]), combined) if color == 'random': combined = zeros(list(dims) + [3]) ncolors = min(self.count, 20) colors = get_cmap('rainbow', ncolors)(range(0, ncolors, 1))[:, 0:3] for i in inds: combined = maximum( self.sources[i].mask(dims, binary, outline, colors[i % len(colors)]), combined) elif values is None: combined = zeros(dims) for i in inds: combined = maximum(self.sources[i].mask(dims, binary, outline), combined) if isinstance(color, str) and color != 'random' and values is None: combined = Colorize(cmap='indexed', colors=[color]).transform([combined]) if base is not None: combined = maximum(base, combined) return combined
def make_pca_maps(data, pca, imgs, required_pcs, img_size_x, img_size_y, num_pca_colors, num_samples, thresh_pca, color_map): reference = data.seriesMean().pack() if required_pcs == 0: maps = Colorize(cmap=color_map, scale=num_pca_colors).transform(imgs, background=reference, mixing=0.3) else: maps = Colorize(cmap=color_map, scale=num_pca_colors).transform(imgs, background=reference, mixing=0.3) pts = pca.scores.subset(num_samples, thresh=thresh_pca, stat='norm') if required_pcs == 0: pca_pts = list() for ii in xrange(1, size(pca.comps.T, 1)): pca_pts.append(pts[:, ii][:, newaxis]) clrs = Colorize(cmap=color_map, scale=num_pca_colors).transform(pca_pts).squeeze() else: pca_pts = list() for ii in xrange(0, size(required_pcs)): pca_pts.append(pts[:, required_pcs[ii]][:, newaxis]) clrs = Colorize(cmap=color_map, scale=num_pca_colors).transform(pca_pts).squeeze() #Reconstruct the scores using the pca components if required_pcs == 0: recon = asarray( map( lambda x: (x[1] * pca.comps[1, :] + x[2] * pca.comps[2, :] + x[ 3] * pca.comps[3, :]).tolist(), pts)) else: pts_list = pts.tolist() recon = zeros((size(pts_list, 0), size(pca.comps, 1))) for ii in range(0, size(pts_list, 0)): for jj in range(0, size(required_pcs)): recon[ii, :] += pts_list[ii][required_pcs[jj]] * pca.comps[ required_pcs[jj], :] #Count number of unique colors in the images #Get number of planes based on map dimesnions if len(maps.shape) == 3: num_planes = 1 else: num_planes = size(maps, 2) num_time = size(pca.comps.T, 0) #Get specific color matches across animals and get mean and standard deviation array1 = [map(int, single_dim) for single_dim in clrs] #Convert the colors to RGB integers new_array = [tuple(row) for row in array1] unique_clrs = list(set(new_array)) #Get unique combination of colors unique_clrs.remove((0, 0, 0)) matches = [ where((array(array1) == match).all(axis=1)) for match in unique_clrs ] #Match the colors with the original rows matches_black = [ where((array(array1) == match).all(axis=1)) for match in [0] ] pts_nonblack = delete(pts, matches_black, axis=0) clrs_nonblack = delete(clrs, matches_black, axis=0) #From maps get number of pixel matches with color for each plane matched_pixels = zeros((size(unique_clrs, 0), num_planes)) # while sum(matched_pixels) == 0 : array_maps = round(maps.astype(float16)) matched_pixels = zeros((size(unique_clrs, 0), num_planes)) if len(maps.shape) == 3: array_maps_plane = reshape( array_maps, (size(array_maps, 0) * size(array_maps, 1), 3)) matched_pixels[:, 0] = [ size(where((array(array_maps_plane) == match).all(axis=1))) for match in unique_clrs ] else: for ii in xrange(0, num_planes): array_maps_plane = reshape( array_maps[:, :, ii, :], (size(array_maps, 0) * size(array_maps, 1), 3)) matched_pixels[:, ii] = [ size(where((array(array_maps_plane) == match).all(axis=1))) for match in unique_clrs ] #Find stats based on the color - but only use the subset of pixels in recon matched_signals = [ structtype() for i in range(size(matches, 0) * num_planes) ] mean_signal = zeros((size(matches, 0), num_planes, num_time)) sem_signal = zeros((size(matches, 0), num_planes, num_time)) for ii in xrange(0, size(matches, 0)): temp_ele = array(matches[ii]) matched_signals[ii].clr_grped_signal = [ array(recon[ele]) for ele in temp_ele[0, :] ] #Get signals from the reconstruction that match the colors mean_signal[ii, :] = mean(matched_signals[ii].clr_grped_signal, axis=0) sem_signal[ii, :] = stats.sem(matched_signals[ii].clr_grped_signal, axis=0) return maps, pts, pts_nonblack, clrs, clrs_nonblack, recon, unique_clrs, matched_pixels, matched_signals, mean_signal, sem_signal
def plot_regressors_as_RGB(self, fig1, gs, regressors, rsq, b, colors, brightness_scale=3): b_pos = b * (b > 0) # Get positive beta values # Set up colorize function c = Colorize(cmap='indexed', scale=brightness_scale, flag_scale=1) for ii in xrange(0, len(regressors)): ax1 = fig1.add_subplot(gs[0, ii]) c.colors = [colors[ii]] img = c.transform([b_pos[ii, :, :]], mask=rsq, background=self.reference, mixing=0.5) self.image(img) # Plot the unique stimuli in subplots subplot_count = 0 for ii in self.unique_stimuli: b_pos_list = [] color_mat = [] for keys in regressors.iterkeys(): if ii in keys: index = regressors.keys().index(keys) b_pos_list.append(b_pos[index, :, :]) color_mat.append(colors[index]) ax1 = fig1.add_subplot(gs[1, subplot_count]) c.colors = color_mat img = c.transform(b_pos_list, mask=rsq, background=self.reference, mixing=0.5) self.image(img) subplot_count += 1 # Plot the different stimuli parameters in subplots for ii in self.parameters: b_pos_list = [] color_mat = [] for keys in regressors.iterkeys(): if ii in keys: index = regressors.keys().index(keys) b_pos_list.append(b_pos[index, :, :]) color_mat.append(colors[index]) ax1 = fig1.add_subplot(gs[1, subplot_count]) c.colors = color_mat img = c.transform(b_pos_list, mask=rsq, background=self.reference, mixing=0.5) self.image(img) subplot_count += 1 # Plot all together b_pos_list = [] color_mat = [] for ii in xrange(0, len(regressors)): b_pos_list.append(b_pos[ii, :, :]) color_mat.append(colors[ii]) ax1 = fig1.add_subplot(gs[2:4, 1:3]) c.colors = color_mat img = c.transform(b_pos_list, mask=rsq, background=self.reference, mixing=0.5) self.image(img) subplot_count += 1 ax1 = fig1.add_subplot(gs[2, 0]) self.create_colorbar(ax1, regressors, colors)
def make_pca_maps(self, pca, imgs, required_pcs, mixing_parameter): """ Make maps and scatter plots of the pca scores with colormaps for plotting Parameters ---------- pca: PCA model imgs : scores required_pcs: List contianing indices of required PCA components. Specify 0 if you need all mixing_parameter : mixing controls relative scale of the background. Returns ------- maps: Images of PCA scores plotted using a colormap pts_nonblack: Pixels that are not black (not part of the background) clrs_nonblack: Colors that are not black recon: PCA reconstructed using user specified components unique_clrs: Colors that are unique from the images of the PCA scores matched_pixels: Pixels that correspond to the colors obtained in unique_clrs matched_signals: Individual time traces from the matched_pixels mean_signal: Mean of matched_signals sem_signal: Sem of matched_signals """ maps = Colorize(cmap=self.color_map, scale=self.num_pca_colors).transform( imgs, background=self.reference, mixing=mixing_parameter) pts = pca.scores.subset(self.num_samples, thresh=self.thresh_pca, stat='norm') if required_pcs == 0: pca_pts = list() for ii in xrange(0, size(pca.comps.T, 1)): pca_pts.append(pts[:, ii][:, newaxis]) clrs = Colorize( cmap=self.color_map, scale=self.num_pca_colors).transform(pca_pts).squeeze() else: pca_pts = list() for ii in xrange(0, size(required_pcs)): pca_pts.append(pts[:, required_pcs[ii]][:, newaxis]) clrs = Colorize( cmap=self.color_map, scale=self.num_pca_colors).transform(pca_pts).squeeze() # Reconstruct the scores using the pca components if required_pcs == 0: recon = asarray( map( lambda x: (x[0] * pca.comps[0, :] + x[1] * pca.comps[1, :] + x[2] * pca.comps[2, :]).tolist(), pts)) else: pts_list = pts.tolist() recon = zeros((size(pts_list, 0), size(pca.comps, 1))) for ii in range(0, size(pts_list, 0)): for jj in range(0, size(required_pcs)): recon[ii, :] += pts_list[ii][required_pcs[jj]] * pca.comps[ required_pcs[jj], :] # Count number of unique colors in the images # Get number of planes based on map dimensions if len(maps.shape) == 3: num_planes = 1 else: num_planes = size(maps, 2) num_time = size(pca.comps.T, 0) # Get specific color matches across animals and get mean and standard deviation array1 = [map(int, single_dim) for single_dim in clrs] # Convert the colors to RGB integers new_array = [tuple(row) for row in array1] unique_clrs = list(set(new_array)) # Get unique combination of colors if (0, 0, 0) in unique_clrs: unique_clrs.remove((0, 0, 0)) matches = [ where((array(array1) == match).all(axis=1)) for match in unique_clrs ] # Match the colors with the original rows matches_black = [ where((array(array1) == match).all(axis=1)) for match in [0] ] pts_nonblack = delete(pts, matches_black, axis=0) clrs_nonblack = delete(clrs, matches_black, axis=0) # From maps get number of pixel matches with color for each plane array_maps = round(maps.astype(float16)) matched_pixels = zeros((size(unique_clrs, 0), num_planes)) array_maps_plane = reshape( array_maps, (size(array_maps, 0) * size(array_maps, 1), 3)) matched_pixels[:, 0] = [ size(where((array(array_maps_plane) == match).all(axis=1))) for match in unique_clrs ] # Find stats based on the color - but only use the subset of pixels in recon matched_signals = [ structtype() for i in range(size(matches, 0) * num_planes) ] mean_signal = zeros((size(matches, 0), num_planes, num_time)) sem_signal = zeros((size(matches, 0), num_planes, num_time)) for ii in xrange(0, size(matches, 0)): temp_ele = array(matches[ii]) matched_signals[ii].clr_grped_signal = [ array(recon[ele]) for ele in temp_ele[0, :] ] mean_signal[ii, :] = mean(matched_signals[ii].clr_grped_signal, axis=0) sem_signal[ii, :] = stats.sem(matched_signals[ii].clr_grped_signal, axis=0) return maps, pts_nonblack, clrs_nonblack, recon, unique_clrs, matched_pixels, \ matched_signals, mean_signal, sem_signal
def make_pca_maps(data,pca, imgs, required_pcs, img_size_x, img_size_y, num_pca_colors, num_samples, thresh_pca, color_map): reference = data.seriesMean().pack() maps = Colorize(cmap=color_map, scale=num_pca_colors).transform(imgs,background=reference, mixing=2) pts = pca.scores.subset(num_samples, thresh=thresh_pca, stat='norm') if required_pcs == 0: clrs = Colorize(cmap=color_map, scale=num_pca_colors).transform([pts[:,0][:,newaxis], pts[:,1][:,newaxis]]).squeeze() else: clrs = Colorize(cmap=color_map, scale=num_pca_colors).transform([pts[:,required_pcs[0]][:,newaxis], pts[:,required_pcs[1]][:,newaxis]]).squeeze() #Reconstruct the scores using the pca components if required_pcs == 0: recon = asarray(map(lambda x: (x[1] * pca.comps[1, :] + x[2] * pca.comps[2, :] + x[3] * pca.comps[3, :]).tolist(), pts)) else: pts_list = pts.tolist() recon = zeros((size(pts_list,0),size(pca.comps,1))) for ii in range(0,size(pts_list,0)): for jj in range(0, size(required_pcs)): recon[ii,:] += pts_list[ii][required_pcs[jj]]*pca.comps[required_pcs[jj],:] #Count number of unique colors in the images #Get number of planes based on map dimesnions if len(maps.shape)==3: num_planes = 1 else: num_planes = size(maps,2) num_time = size(pca.comps.T,0) #Get specific color matches across animals and get mean and standard deviation array1 = [map(int,single_dim) for single_dim in clrs] #Convert the colors to RGB integers new_array = [tuple(row) for row in array1] unique_clrs = list(set(new_array)) #Get unique combination of colors unique_clrs.remove((0,0,0)) matches = [where((array(array1) == match).all(axis=1)) for match in unique_clrs] #Match the colors with the original rows matches_black = [where((array(array1) == match).all(axis=1)) for match in [0]] pts_nonblack = delete(pts, matches_black, axis=0) clrs_nonblack = delete(clrs, matches_black, axis=0) #From maps get number of pixel matches with color for each plane matched_pixels = zeros((size(unique_clrs,0),num_planes)) # while sum(matched_pixels) == 0 : array_maps = round(maps.astype(float16)) matched_pixels = zeros((size(unique_clrs,0),num_planes)) if len(maps.shape) == 3: array_maps_plane = reshape(array_maps, (size(array_maps,0)*size(array_maps,1),3)) matched_pixels[:,0] = [size(where((array(array_maps_plane) == match).all(axis=1))) for match in unique_clrs] else: for ii in xrange(0,num_planes): array_maps_plane = reshape(array_maps[:,:,ii,:], (size(array_maps,0)*size(array_maps,1),3)) matched_pixels[:,ii] = [size(where((array(array_maps_plane) == match).all(axis=1))) for match in unique_clrs] #Find stats based on the color - but only use the subset of pixels in recon matched_signals = [structtype() for i in range(size(matches,0)*num_planes)] mean_signal = zeros((size(matches,0), num_planes, num_time)) sem_signal = zeros((size(matches,0), num_planes, num_time)) for ii in xrange(0,size(matches,0)): temp_ele = array(matches[ii]) matched_signals[ii].clr_grped_signal = [array(recon[ele]) for ele in temp_ele[0,:]] #Get signals from the reconstruction that match the colors mean_signal[ii,:] = mean(matched_signals[ii].clr_grped_signal,axis=0) sem_signal[ii,:] = stats.sem(matched_signals[ii].clr_grped_signal,axis=0) return maps, pts, pts_nonblack, clrs, clrs_nonblack, recon, unique_clrs, matched_pixels, matched_signals, mean_signal, sem_signal
def make_kmeans_maps(self, kmeans_clusters, img_labels, img_sim, mixing_parameter=0.8, std_threshold=0.5, ignore_clusters=0, model_center=0): # Only plot those clusters where the standard deviation is greater than 0.1 - thus getting rid of noisy clusters interesting_clusters = array( where( logical_and( std(kmeans_clusters, 0) > std_threshold, max(kmeans_clusters, 0) > 0.01))) print 'Standard deviation of clusters is..', std(kmeans_clusters, 0) print 'Interesting clusters after STD are..', interesting_clusters if ignore_clusters != 0: for ii in ignore_clusters: index = where(squeeze(interesting_clusters) == ii)[0] interesting_clusters = delete(interesting_clusters, index) print 'Interesting clusters after user specified clusters..', interesting_clusters # Update kmeans clusters with those with higher standard deviation kmeans_clusters_updated = zeros((shape(kmeans_clusters))) kmeans_clusters_updated[:, interesting_clusters] = kmeans_clusters[:, interesting_clusters] # Brewer colors newclrs_brewer = ListedColormap(sns.color_palette("Paired", n_colors=size( kmeans_clusters, 1)), name='from_list') # newclrs_brewer = (eval('palettable.colorbrewer.qualitative.' + string_cmap + '.mpl_colors')) # newclrs_brewer = ListedColormap(newclrs_brewer, name='from_list') newclrs_updated_brewer = self.update_colors(newclrs_brewer, ignore_clusters, interesting_clusters) # RGB colors newclrs_rgb = ListedColormap(sns.color_palette( "husl", n_colors=size(kmeans_clusters, 1) + 1)[:-1], name='from_list') newclrs_updated_rgb = self.update_colors(newclrs_rgb, ignore_clusters, interesting_clusters) newclrs_updated_rgb.colors = round(newclrs_updated_rgb.colors) # Create maps brainmap = Colorize(cmap=newclrs_updated_brewer).transform( img_labels, mask=img_sim, background=self.reference, mixing=mixing_parameter) brainmap_for_finding_pixels = Colorize( cmap=newclrs_updated_rgb).transform(img_labels, mask=img_sim) # Count number of unique colors in the images # Get number of planes based on map dimensions if len(brainmap.shape) == 3: num_planes = 1 else: num_planes = size(brainmap, 2) # Get specific color matches across animals and get mean and standard deviation round_clrs = round(newclrs_updated_rgb.colors) new_array = [tuple(row) for row in round_clrs] unique_clrs = (list(set(new_array)) ) # Get unique combination of colors ## remove black color if it exists elem = (0, 0, 0) unique_clrs = [ value for key, value in enumerate(unique_clrs) if elem != value ] unique_clrs = round(unique_clrs) # From maps get number of pixel matches with color for each plane array_maps = brainmap_for_finding_pixels matched_pixels = zeros((size(unique_clrs, 0), num_planes)) array_maps_plane = reshape( array_maps, (size(array_maps, 0) * size(array_maps, 1), 3)) matched_pixels[:, 0] = [ size(where((array(round(array_maps_plane)) == match).all(axis=1))) for match in unique_clrs ] # print matched_pixels, unique_clrs # Get brewer colors for plotting matched pixels elem = [0, 0, 0] a = unique_clrs.tolist() b = newclrs_updated_rgb.colors.tolist() c = newclrs_updated_brewer.colors.tolist() d1 = [value for key, value in enumerate(b) if elem != value] d2 = [value for key, value in enumerate(c) if elem != value] unique_clrs_brewer = zeros(shape(unique_clrs)) for ii in xrange(0, size(unique_clrs, 0)): unique_clrs_brewer[ii, :] = d2[a.index(d1[ii])] return brainmap, unique_clrs_brewer, newclrs_updated_rgb, newclrs_updated_brewer, matched_pixels, \ kmeans_clusters_updated
def make_kmeans_maps(self, kmeans_clusters, img_labels, img_sim, mixing_parameter=0.8, std_threshold=0.5, ignore_clusters=0, model_center=0): """ Make color maps using the clusters and labels and calculate number of pixels corresponding to each cluster Parameters ---------- kmeans_clusters : Clusters obtained from kmeans img_sim : obtained using the Similarity method of thunder's KMeansModel. img_labels : Predicted label for each pixel, acquired as an image of labels mixing_parameter : mixing controls relative scale of the background. std_threshold : If the standard deviation of the cluster trace is below the threshold, it is not used to make maps ignore_clusters : List of clusters to ignore. Ignored clusters are colored black in the map model_center : Whether to color clusters and maps by similarity of cluster centers Returns ------- brainmap : Color map of kmean clusters, this is produced using brewer colors unique_clrs_brewer: Using brewer colors newclrs_updated_rgb: Using rgb colors, updated to exclude ignore clusters newclrs_updated_brewer: Using brewer colors, updated to exclude ignore clusters matched_pixels: Pixels that correspond to the colors obtained in unique_clrs kmeans_clusters_updated: Updted clusters, updated to exclude the ignore clusters """ interesting_clusters = array(where(logical_and(std(kmeans_clusters, 0) > std_threshold, max(kmeans_clusters, 0) > 0.01))) print 'Standard deviation of clusters is..', std(kmeans_clusters, 0) print 'Interesting clusters after STD are..', interesting_clusters if ignore_clusters != 0: for ii in ignore_clusters: index = where(squeeze(interesting_clusters) == ii)[0] interesting_clusters = delete(interesting_clusters, index) print 'Interesting clusters after user specified clusters..', interesting_clusters # Update kmeans clusters with those with higher standard deviation kmeans_clusters_updated = zeros((shape(kmeans_clusters))) kmeans_clusters_updated[:, interesting_clusters] = kmeans_clusters[:, interesting_clusters] # Brewer colors string_cmap = 'Paired_' + str(size(kmeans_clusters, 1)) newclrs_brewer = (eval('palettable.colorbrewer.qualitative.' + string_cmap + '.mpl_colors')) newclrs_brewer = ListedColormap(newclrs_brewer, name='from_list') newclrs_updated_brewer = self.update_colors(newclrs_brewer, ignore_clusters, interesting_clusters) # RGB colors newclrs_rgb = ListedColormap(sns.color_palette("bright", size(kmeans_clusters, 1)), name='from_list') newclrs_updated_rgb = self.update_colors(newclrs_rgb, ignore_clusters, interesting_clusters) newclrs_updated_rgb.colors = round(newclrs_updated_rgb.colors) # Create maps brainmap = Colorize(cmap=newclrs_updated_brewer).transform(img_labels, mask=img_sim, background=self.reference, mixing=mixing_parameter) brainmap_for_finding_pixels = Colorize(cmap=newclrs_updated_rgb).transform(img_labels, mask=img_sim) # Count number of unique colors in the images # Get number of planes based on map dimensions if len(brainmap.shape) == 3: num_planes = 1 else: num_planes = size(brainmap, 2) # Get specific color matches across animals and get mean and standard deviation round_clrs = round(newclrs_updated_rgb.colors) new_array = [tuple(row) for row in round_clrs] unique_clrs = (list(set(new_array))) # Get unique combination of colors ## remove black color if it exists elem = (0, 0, 0) unique_clrs = [value for key, value in enumerate(unique_clrs) if elem != value] unique_clrs = round(unique_clrs) # From maps get number of pixel matches with color for each plane array_maps = brainmap_for_finding_pixels matched_pixels = zeros((size(unique_clrs, 0), num_planes)) array_maps_plane = reshape(array_maps, (size(array_maps, 0) * size(array_maps, 1), 3)) matched_pixels[:, 0] = [size(where((array(round(array_maps_plane)) == match).all(axis=1))) for match in unique_clrs] # Get brewer colors for plotting matched pixels elem = [0, 0, 0] a = unique_clrs.tolist() b = newclrs_updated_rgb.colors.tolist() c = newclrs_updated_brewer.colors.tolist() d1 = [value for key, value in enumerate(b) if elem != value] d2 = [value for key, value in enumerate(c) if elem != value] unique_clrs_brewer = zeros(shape(unique_clrs)) for ii in xrange(0, size(unique_clrs, 0)): unique_clrs_brewer[ii, :] = d2[a.index(d1[ii])] return brainmap, unique_clrs_brewer, newclrs_updated_rgb, newclrs_updated_brewer, matched_pixels, \ kmeans_clusters_updated
def plot_kmeans_components(self, fig1, gs, kmeans_clusters, uncentered_clrs, plot_title='Hb', num_subplots=1, flag_separate=1, gridspecs=[0, 0], model_center=0, removeclusters=0): with sns.axes_style('darkgrid'): if flag_separate: ax1 = fig1.add_subplot(2, 1, num_subplots) else: ax1 = eval('fig1.add_subplot(gs' + gridspecs + ')') if model_center == 1: # Models colors according to trace clrs_cmap = Colorize.optimize(kmeans_clusters.T, asCmap=True) clrs = clrs_cmap.colors else: clrs_cmap = uncentered_clrs clrs = clrs_cmap.colors # Update kmeans if clusters were removed kmeans_clusters_new = copy(kmeans_clusters) if removeclusters != 0: newclrs_updated = copy(clrs_cmap) for index, value in enumerate(clrs_cmap.colors): if index in removeclusters: newclrs_updated.colors[index] = [0, 0, 0] clrs_cmap = newclrs_updated clrs = clrs_cmap.colors for ii in removeclusters: print ii kmeans_clusters_new[:, ii] = zeros(size(kmeans_clusters, 0)) plt.gca().set_color_cycle(clrs) # remove those clusters that are ignored before plotting for ii in xrange(0, size(kmeans_clusters_new, 1)): plt.plot(kmeans_clusters_new[:, ii], lw=4, label=str(ii)) plt.locator_params(axis='y', nbins=4) ax1.set(xlabel="Time (seconds)", ylabel="a.u") ax1.legend(prop={'size': 14}, loc='center left', bbox_to_anchor=(1, 0.5), ncol=1, fancybox=True, shadow=True) plt.title(plot_title, fontsize=14) plt.ylim((min(kmeans_clusters_new) - 0.0001, max(kmeans_clusters_new) + 0.0001)) plt.xlim((0, size(kmeans_clusters_new, 0))) plt.axhline(y=0, linestyle='-', color='k', linewidth=1) self.plot_vertical_lines_onset() self.plot_vertical_lines_offset() self.plot_stimulus_patch(ax1) return clrs_cmap
def make_kmeans_maps(data, kmeans_cluster_centers, img_labels, img_sim, img_size_x, img_size_y, ignore_clusters): reference = data.seriesMean().pack() #Only plot those clusters where the standard deviation is greater than 0.1 - thus getting rid of noisy clusters interesting_clusters = np.array(np.where(np.logical_and(np.std(kmeans_cluster_centers,0)>0.0001,\ np.max(kmeans_cluster_centers,0)>0.00001))) if ignore_clusters != 0: for ii in ignore_clusters: index = np.where(np.squeeze(interesting_clusters) == ii)[0] interesting_clusters = np.delete(interesting_clusters, index) # newclrs_rgb, newclrs_brewer = Colorize.optimize(kmeans_cluster_centers.T, asCmap=True) #Brewer colors string_cmap = 'Set1_' + str(np.size(kmeans_cluster_centers, 1)) newclrs_brewer = eval('palettable.colorbrewer.qualitative.' + string_cmap + '.mpl_colors') newclrs_brewer = ListedColormap(newclrs_brewer, name='from_list') newclrs_updated_brewer = update_colors(newclrs_brewer, interesting_clusters) #RGB colors newclrs_rgb = ListedColormap(sns.color_palette( "bright", np.size(kmeans_cluster_centers, 1)), name='from_list') newclrs_updated_rgb = update_colors(newclrs_rgb, interesting_clusters) newclrs_updated_rgb.colors = np.round(newclrs_updated_rgb.colors) #Update kmeans clusters with those with higher standard deviation kmeans_cluster_centers_updated = np.zeros( (np.shape(kmeans_cluster_centers))) kmeans_cluster_centers_updated[:, interesting_clusters] = kmeans_cluster_centers[:, interesting_clusters] #Create maps brainmap = Colorize(cmap=newclrs_updated_brewer).transform( img_labels, mask=img_sim, background=reference, mixing=1.0) brainmap_for_finding_pixels = Colorize(cmap=newclrs_updated_rgb).transform( img_labels, mask=img_sim) #Count number of unique colors in the images #Get number of planes based on map dimesnions if len(brainmap.shape) == 3: num_planes = 1 else: num_planes = np.size(brainmap, 2) #Get specific color matches across animals and get mean and standard deviation round_clrs = np.round(newclrs_updated_rgb.colors) new_array = [tuple(row) for row in round_clrs] unique_clrs = (list(set(new_array))) #Get unique combination of colors ## remove black color if it exists elem = (0, 0, 0) X = unique_clrs.index(elem) if elem in unique_clrs else -1 if X != -1: unique_clrs.remove(elem) unique_clrs = np.round(unique_clrs) #From maps get number of pixel matches with color for each plane matched_pixels = np.zeros((np.size(unique_clrs, 0), num_planes)) # while sum(matched_pixels) == 0 : array_maps = brainmap_for_finding_pixels matched_pixels = np.zeros((np.size(unique_clrs, 0), num_planes)) if len(brainmap.shape) == 3: array_maps_plane = np.reshape( array_maps, (np.size(array_maps, 0) * np.size(array_maps, 1), 3)) matched_pixels[:, 0] = [ np.size( np.where((np.array( np.round(array_maps_plane)) == match).all(axis=1))) for match in unique_clrs ] else: for ii in xrange(0, num_planes): array_maps_plane = np.reshape( array_maps[:, :, ii, :], (np.size(array_maps, 0) * np.size(array_maps, 1), 3)) matched_pixels[:, ii] = [ np.size( np.where((np.array( np.round(array_maps_plane)) == match).all(axis=1))) for match in unique_clrs ] return brainmap, unique_clrs, newclrs_updated_rgb, newclrs_updated_brewer, matched_pixels, kmeans_cluster_centers_updated