def test_vmin_none_in_dataview2d(): data = np.arange(np.product(volshape)).reshape(volshape, order='C') view = cortex.Volume2D(data, data + 1, subject=subj, xfmname=xfmname) cortex.quickshow(view) data = np.arange(nverts) view = cortex.Vertex2D(data, data + 1, subject=subj) cortex.quickshow(view)
def test_int64_in_dataviewrgb(): data = np.arange(np.product(volshape)).reshape(volshape, order='C') view = cortex.VolumeRGB(data, data + 1, data + 2, subject=subj, xfmname=xfmname) cortex.quickshow(view) data = np.arange(nverts) view = cortex.VertexRGB(data, data + 1, data + 2, subject=subj) cortex.quickshow(view)
def minimal_plot(sub, dat, zeronan, fig, savefig, fname): if zeronan == True: dat[dat == 0] = np.nan light = cortex.Vertex(dat, subject=sub, vmin=np.nanmin(dat), vmax=np.nanmax(dat), cmap='plasma') mfig = cortex.quickshow(light, with_curvature=True, fig=fig, with_colorbar=True, with_rois=False) if savefig == True: mfig.savefig(fname, dpi=300, facecolor='w', edgecolor='w', orientation='portrait', papertype=None, format='png', transparent=False)
def alphaplot(sub, dat, R2, thresh, fig, save, fname): light = cortex.Vertex2D(dat, R2, subject=sub, vmin=np.nanmin(dat), vmax=np.nanmax(dat), vmin2=thresh, vmax2=1, cmap='plasma_alpha') mfig = cortex.quickshow(light, with_curvature=True, fig=fig) sp.savefig(fname, dpi=300, facecolor='w', edgecolor='w', orientation='portrait', papertype=None, format='png', transparent=False, bbox_inches=None, pad_inches=0.1, frameon=None)
lsurf, rsurf = [Surface(*d) for d in cortex.db.get_surf(subject, "fiducial")] # Let's choose a few points and generate data for them selected_pts = np.arange(len(lsurf.pts), step=5000) num_selected_pts = len(selected_pts) sparse_data = np.random.randn(num_selected_pts) # Then interpolate interp_data = lsurf.interp(selected_pts, sparse_data) # Plot the result # interp_data is only for the left hemisphere, but the Vertex constructor # infers that and fills the right hemisphere with zeros interp_vertex = cortex.Vertex(interp_data[:,0], subject, vmin=-2, vmax=2, cmap='RdBu_r') cortex.quickshow(interp_vertex, with_labels=False, with_rois=False) # plot the locations of the points we selected originally # nudge=True puts both left and right hemispheres in the same space, moving them # so that they don't overlap. These are the coordinates used in quickflat (lflatpts, lpolys), (rflatpts, rpolys) = cortex.db.get_surf(subject, "flat", nudge=True) ax = plt.gca() # zorder is set to 10 to make sure points go on top of other quickflat layers ax.scatter(lflatpts[selected_pts,0], lflatpts[selected_pts,1], s=50, c=sparse_data, vmin=-2, vmax=2, cmap=plt.cm.RdBu_r, zorder=10)
""" ======================= Get Vertices for an ROI ======================= In this example we show how to get the vertices that are inside an ROI that was defined in the SVG ROI file (see :doc:`/rois.rst`). """ import cortex # get vertices for fusiform face area FFA in subject S1 roi_verts = cortex.get_roi_verts('S1', 'FFA') # roi_verts is a dictionary (in this case with only one entry) ffa_verts = roi_verts['FFA'] # this includes indices from both hemispheres # let's create an empty Vertex object and fill FFA ffa_map = cortex.Vertex.empty('S1', cmap='plasma') ffa_map.data[ffa_verts] = 1.0 cortex.quickshow(ffa_map)
""" import cortex import cortex.polyutils import numpy as np import matplotlib.pyplot as plt subject = "S1" # First we need to import the surfaces for this subject surfs = [cortex.polyutils.Surface(*d) for d in cortex.db.get_surf(subject, "fiducial")] numl = surfs[0].pts.shape[0] # Now we need to pick the start and end points of the line we will draw pt_a = 100 pt_b = 50000 # Then we find the geodesic path between these points path = surfs[0].geodesic_path(pt_a, pt_b) # In order to plot this on the cortical surface, we need an array that is the # same size as the number of vertices in the left hemisphere path_data = np.zeros(numl) for v in path: path_data[v] = 1 # And now plot these distances onto the cortical surface path_verts = cortex.Vertex(path_data, subject, cmap="Blues_r") cortex.quickshow(path_verts, with_colorbar=False) plt.show()
and you will also need a flatmap for them. """ import six import cortex import matplotlib.pyplot as plt if six.PY2: from urllib import urlretrieve elif six.PY3: from urllib.request import urlretrieve # Download the dataset and load it _ = urlretrieve("http://gallantlab.org/pycortex/S1_retinotopy.hdf", "S1_retinotopy.hdf") ret_data = cortex.load("S1_retinotopy.hdf") # The retinotopy data has to be divided into left and right hemispheres left_data = ret_data.angle_left cortex.quickshow(left_data, with_curvature=True, curvature_contrast=0.5, curvature_brightness=0.5, curvature_threshold=True) plt.show() right_data = ret_data.angle_right cortex.quickshow(right_data, with_curvature=True, curvature_contrast=0.5, curvature_brightness=0.5, curvature_threshold=True) plt.show()
pixel will only have the value NaN if every voxel between pia and white matter has the value NaN. """ import cortex import numpy as np from matplotlib import pyplot as plt # create dataset with volume of all 1's vol = cortex.Volume.empty('S1', 'fullhead', vmin=0, vmax=2) + 1 # set 20% of the values in the dataset to NaN vol.data[np.random.rand(*vol.data.shape) > 0.8] = np.nan # plot the volume with nanmean=False # here a nan in ANY layer of the thickness mapping will result in a nan # in the final image # so this image should have many, many holes that show curvature # and all the non-hole points should have value of 1 _ = cortex.quickshow(vol, nanmean=False, with_curvature=True) plt.show() # plot the volume with nanmean=True # here there should only be a nan in the final image if EVERY layer of the # thickness mapping has a nan for the given pixel # so this image should have many fewer holes that show curvature # and, again, all the non-hole points should have value of 1 _ = cortex.quickshow(vol, nanmean=True, with_curvature=True) plt.show()
np.random.seed(1234) import matplotlib.pyplot as plt subject = 'S1' # In order to get the number of vertices in this subject's cortical surface # we have to load in their surfaces and get the number of points in each surfs = [cortex.polyutils.Surface(*d) for d in cortex.db.get_surf(subject, "fiducial")] # This is the total number of vertices in both hemispheres combined num_verts = surfs[0].pts.shape[0] + surfs[1].pts.shape[0] # Creating a random dataset with one entry for each vertex test_data = np.random.randn(num_verts) # This creates a Vertex object for our subject and test dataset vertex_data = cortex.Vertex(test_data, subject) # And now we can display it on a flatmap cortex.quickshow(vertex_data) plt.show() # We can also plot just the left hemisphere data numl = surfs[0].pts.shape[0] # This creates a Vertex object with an array only as long as the number of # vertices in the left hemisphere, and the right hemisphere will be filled # in with zeros vertex_data_left = cortex.Vertex(test_data[:numl], subject) cortex.quickshow(vertex_data_left) plt.show()
import matplotlib.pyplot as plt subject = "S1" xfm = "fullhead" # Creating two different test datasets that are both the same shape as this # transform with one entry for each voxel # The matrices have just been reordered in different ways so that they make # gradients across the brain in different directions test_data1 = np.arange(31 * 100 * 100).reshape((31, 100, 100), order='C') test_data2 = np.arange(31 * 100 * 100).reshape((31, 100, 100), order='F') # This creates a 2D Volume object for both of our test datasets for the given # subject and transform vol_data = cortex.Volume2D(test_data1, test_data2, subject, xfm) cortex.quickshow(vol_data, with_colorbar=False) plt.show() # You can alter the minimum and maximum values shown on the colorbar and this # can be done separately for the two different datasets vol_data = cortex.Volume2D(test_data1, test_data2, subject, xfm, vmin=np.mean(test_data1), vmax=np.max(test_data1), vmin2=np.min(test_data2), vmax2=np.mean(test_data2)) cortex.quickshow(vol_data, with_colorbar=False) plt.show()
def cv_report(results, model_name=None, subject=None, transform=None, ridges=None, cmap='viridis', save_dir=None, performance_histogram=True, global_vs_local=False, ridge_histogram=True, performance_flatmap=True, ridge_flatmap=True, file_label=''): """create diagnostic plots for results of cv_ridge() - specify subject and transform parameters to create flatmaps - specify save_dir to save figures to a directory Parameters ---------- - results: dict of results from cv_ridge() - model_name: str of model name, added to titles of plots - subject: str subject surface name - transform: str transform name - performance_histogram: bool of whether to plot histogram of voxel performance - global_vs_local: bool of whether to plot 2d histogram of global vs local - ridge_histogram: bool of whether to plot histogram """ if model_name is None: model_name = '' else: model_name += ' ' if save_dir is not None: outputs = { 'performance_histogram': '{file_label}performance_histogram.png', 'global_vs_local': '{file_label}global_vs_local.png', 'ridge_histogram': '{file_label}ridge_histogram.png', 'performance_flatmap': '{file_label}performance_flatmap.png', 'ridge_flatmap': '{file_label}ridge_flatmap.png', } outputs = { name: os.path.join(save_dir, path) for name, path in outputs.items() } if not os.path.exists(save_dir): os.makedirs(save_dir) # test set performance plots if performance_histogram: histograms = {} if 'global_performance' in results: histograms['global'] = results['global_performance'] if 'local_performance' in results: histograms['local'] = results['local_performance'] plot_utils.hists1d( histograms, title=(model_name + 'test set performance'), ) if save_dir is not None: plt.savefig(outputs['performance_histogram']) plt.show() if global_vs_local: plot_utils.hist2d( results['global_performance'], results['local_performance'], xlabel='global', ylabel='local', clabel='# regressands', title=(model_name + 'global vs local test set performance'), ) if save_dir is not None: plt.savefig(outputs['global_vs_local']) plt.show() # ridge parameter histogram plots if ridge_histogram: bin_counts, (x_bin_bounds, y_bin_bounds) = plot_utils.hist1d( results['local_optimal_ridge'], stacked_data=results['local_performance'], log_x=True, n_bins=len(ridges), n_stacked_bins=10, stacked_cmap='spectral', xlabel='ridge parameter', ylabel='regressands', title=(model_name + 'ridge parameters'), stacked_label='test performance', ) global_optimum = results['global_optimal_ridge'] global_index = np.nonzero(x_bin_bounds <= global_optimum)[0][-1] bounds = x_bin_bounds plt.plot( scipy.stats.gmean([bounds[global_index], bounds[global_index + 1]]), bin_counts.sum(1)[global_index], '.k', marker='*', markersize=15, label='global optimum', ) plt.legend(numpoints=1, fontsize=20) if save_dir is not None: plt.savefig(outputs['ridge_histogram']) plt.show() # fMRI-specific reports if subject is not None and transform is not None: import cortex # performance flatmap if performance_flatmap: volume = cortex.Volume( results['local_performance'], subject=subject, xfmname=transform, cmap=cmap, vmin=0, vmax=.5, colorbar_ticklabelsize=15, ) cortex.quickshow(volume) plt.title(model_name + 'test performance', fontsize=30) if save_dir is not None: plt.savefig(outputs['performance_flatmap']) plt.show() # ridge parameter flatmap if ridge_flatmap: volume = cortex.Volume( -np.log(results['local_optimal_ridge']), subject=subject, xfmname=transform, cmap=cmap, vmin=-np.log(ridges[-1]), vmax=-np.log(ridges[0]), ) if len(ridges) > 5: ticks = np.logspace( np.log10(ridges[0]), np.log10(ridges[-1]), 5, ) else: ticks = ridges cortex.quickshow( volume, colorbar_ticks=-np.log(ticks), colorbar_ticklabels=['{:0.2f}'.format(tick) for tick in ticks], colorbar_ticklabelsize=15, ) plt.title(model_name + 'ridge parameters', fontsize=30) if save_dir is not None: plt.savefig(outputs['ridge_flatmap']) plt.show()
normal arithmetic operators like +, -, *, /, and ** """ import cortex import numpy as np np.random.seed(1234) import matplotlib.pyplot as plt subject = 'S1' xfm = 'fullhead' # Creating a random dataset that is the shape for this transform with one # entry for each voxel test_data = np.random.randn(31, 100, 100) # This creates a Volume object for our test dataset for the given subject # and transform vol_data = cortex.Volume(test_data, subject, xfm, vmin=-2, vmax=2) cortex.quickshow(vol_data) plt.show() # Now you can do arithmetic with the Volume vol_plus = vol_data + 1 cortex.quickshow(vol_plus) plt.show() # You can also do multiplication vol_mult = vol_data * 4 cortex.quickshow(vol_mult) plt.show()
""" import six import cortex import matplotlib.pyplot as plt if six.PY2: from urllib import urlretrieve elif six.PY3: from urllib.request import urlretrieve # Download the dataset and load it _ = urlretrieve("http://gallantlab.org/pycortex/S1_retinotopy.hdf", "S1_retinotopy.hdf") ret_data = cortex.load("S1_retinotopy.hdf") # The retinotopy data has to be divided into left and right hemispheres left_data = ret_data.angle_left cortex.quickshow(left_data, with_curvature=True, curvature_contrast=0.5, curvature_brightness=0.5, curvature_threshold=True) plt.show() right_data = ret_data.angle_right cortex.quickshow(right_data, with_curvature=True, curvature_contrast=0.5, curvature_brightness=0.5, curvature_threshold=True) plt.show()
axis[1].axvline(x=mot_quant,c='k',linestyle='--') axis[1].set_title('Histogram of normalized R values from soma fit') fig.savefig(os.path.join(figure_out,'histogram_combined_R_normalized_%.2f-quantile.svg'%quantile), dpi=100,bbox_inches = 'tight') # make flatmaps of the above distributions ########## print('making flatmaps') images = {} # make and save rsq flatmaps for each task images['rsq_visual_norm'] = cortex.Vertex(rsq_visual_norm,'fsaverage_gross', vmin=0, vmax=1, cmap='Reds') cortex.quickshow(images['rsq_visual_norm'],with_curvature=True,with_sulci=True) filename = os.path.join(figure_out,'flatmap_space-fsaverage_type-rsquared-normalized_visual.svg') print('saving %s' %filename) _ = cortex.quickflat.make_png(filename, images['rsq_visual_norm'], recache=False,with_colorbar=True,with_curvature=True,with_sulci=True) images['rsq_motor_norm'] = cortex.Vertex(rsq_motor_norm,'fsaverage_gross', vmin=0, vmax=1, cmap='Blues') cortex.quickshow(images['rsq_motor_norm'],with_curvature=True,with_sulci=True) filename = os.path.join(figure_out,'flatmap_space-fsaverage_type-rsquared-normalized_motor.svg') print('saving %s' %filename) _ = cortex.quickflat.make_png(filename, images['rsq_motor_norm'], recache=False,with_colorbar=True,with_curvature=True,with_sulci=True) images['rsq_combined'] = cortex.Vertex2D(rsq_visual_norm,rsq_motor_norm, subject='fsaverage_gross',
def zoom_to_roi(subject, roi, hem, margin=10.0): roi_verts = cortex.get_roi_verts(subject, roi)[roi] roi_map = cortex.Vertex.empty(subject) roi_map.data[roi_verts] = 1 (lflatpts, lpolys), (rflatpts, rpolys) = cortex.db.get_surf(subject, "flat", nudge=True) sel_pts = dict(left=lflatpts, right=rflatpts)[hem] roi_pts = sel_pts[np.nonzero(getattr(roi_map, hem))[0], :2] xmin, ymin = roi_pts.min(0) - margin xmax, ymax = roi_pts.max(0) + margin plt.axis([xmin, xmax, ymin, ymax]) # Create dataset data = cortex.Volume.random('S1', 'fullhead') # Plot it using quickflat cortex.quickshow(data) # Zoom on just one region zoom_to_roi('S1', 'AC', 'left') # notice that the quality of this figure is now quite poor/grainy # we can improve this by changing the 'height' argument to quickflat cortex.quickshow(data, height=2048) zoom_to_roi('S1', 'AC', 'left')
selected_pts = np.arange(len(lsurf.pts), step=5000) num_selected_pts = len(selected_pts) sparse_data = np.random.randn(num_selected_pts) # Then interpolate interp_data = lsurf.interp(selected_pts, sparse_data) # Plot the result # interp_data is only for the left hemisphere, but the Vertex constructor # infers that and fills the right hemisphere with zeros interp_vertex = cortex.Vertex(interp_data[:, 0], subject, vmin=-2, vmax=2, cmap='RdBu_r') cortex.quickshow(interp_vertex, with_labels=False, with_rois=False) # plot the locations of the points we selected originally # nudge=True puts both left and right hemispheres in the same space, moving them # so that they don't overlap. These are the coordinates used in quickflat (lflatpts, lpolys), (rflatpts, rpolys) = cortex.db.get_surf(subject, "flat", nudge=True) ax = plt.gca() # zorder is set to 10 to make sure points go on top of other quickflat layers ax.scatter(lflatpts[selected_pts, 0], lflatpts[selected_pts, 1], s=50, c=sparse_data,
voxels and then create a cortex.Volume object. Then, you get a mapper to go between voxels and vertices for the specific subject and transform you are working with. Pass the voxel volume through the mapper and you get out a vertex mapping of that data. You can plot both of these as you normally would. """ import cortex import cortex.polyutils import numpy as np np.random.seed(1234) import matplotlib.pyplot as plt subject = 'S1' xfm = 'fullhead' # First create example voxel data for this subject and transform voxel_data = np.random.randn(31, 100, 100) voxel_vol = cortex.Volume(voxel_data, subject, xfm) # Then we have to get a mapper from voxels to vertices for this transform mapper = cortex.get_mapper(subject, xfm, 'line_nearest', recache=True) # Just pass the voxel data through the mapper to get vertex data vertex_map = mapper(voxel_vol) # You can plot both as you would normally plot Volume and Vertex data cortex.quickshow(voxel_vol) plt.show() cortex.quickshow(vertex_map) plt.show()
subject = "S1" xfm = "fullhead" # Creating three test datasets that are the same shape as this transform with # one entry for this voxel # The first two are gradients going in different directions across the brain # and the third is stripes across certain slices of the brain test1 = np.arange(31. * 100 * 100).reshape((31, 100, 100), order='C') test2 = np.arange(31. * 100 * 100).reshape((31, 100, 100), order='F') test3 = np.zeros((31, 100, 100)) test3[::3, :, :] = 1 # Scaling the three datasets to be between 0-255 test1_scaled = test1 / np.max(test1) * 255 test2_scaled = test2 / np.max(test2) * 255 test3_scaled = test3 / np.max(test3) * 255 # Creating three cortex.Volume objects with the test data as np.uint8 red = cortex.Volume(test1_scaled.astype(np.uint8), 'S1', 'fullhead') green = cortex.Volume(test2_scaled.astype(np.uint8), 'S1', 'fullhead') blue = cortex.Volume(test3_scaled.astype(np.uint8), 'S1', 'fullhead') # This creates an RGB Volume from the three different color channels for # this subject # Note that you do not need to specify the transform when creating this as it # is already specified in the red, green, and blue channels vol_data = cortex.VolumeRGB(red, green, blue, subject) cortex.quickshow(vol_data, with_colorbar=False) plt.show()
for j, stat in enumerate(['phase_wedge', 'phase_ring']): lh = os.path.join(write_dir, '%s_lh.gii' % stat) rh = os.path.join(write_dir, '%s_rh.gii' % stat) output_file = os.path.join(write_dir, '%s.png' % stat) x1 = np.ravel([darrays.data for darrays in load(lh).darrays]) x2 = np.ravel([darrays.data for darrays in load(rh).darrays]) x = np.hstack((x1, x2)) x[x == 0] = np.nan vertex_data = cortex.Vertex(x, 'fsaverage') ax = plt.subplot(12, 2, i * 2 + j + 1) fig = cortex.quickshow(vertex_data, with_colorbar=False, with_rois=False, with_labels=False, with_curvature=True, curvature_contrast=0.5, curvature_brightness=0.5, curvature_threshold=True, fig=ax) #fig.set_size_inches((8, 4.5)) #fig.savefig(output_file) # ax = plt.axes([.46, .96 - i * 1. * .0815, .08, .04]) ax.text(.01, .2, subject) ax.axis('off') plt.subplots_adjust(left=.01, right=.99, top=.99, bottom=.01,
Creating a flatmap from a folded cortical surface always introduces some distortion. This is similar to what happens when a map of the globe is flattened into a 2-D map like a Mercator projection. For the cortical surface the amount and type of distortion will depend on the curvature of the surface (i.e. whether it is on a gyrus or a sulcus) and on the distance to the nearest cut. In general, we recommend examining data both in flattened and original 3-D space using the interactive webGL viewer, but it is also informative to visualize the distortion directly. One method to show distortion is to visualize how geodesic discs, which contain all of the points within some geodesic distance of a central point, appear on the flattened cortical surface. This technique is traditionally used to characterize and visualize distortions introduced by flattening the globe onto a map: .. image::https://upload.wikimedia.org/wikipedia/commons/8/87/Tissot_mercator.png """ import cortex import matplotlib.pyplot as plt tissot = cortex.db.get_surfinfo("S1", "tissots_indicatrix", radius=10, spacing=30) tissot.cmap = 'plasma' cortex.quickshow(tissot, with_labels=False, with_rois=False, with_colorbar=False) plt.show()
import numpy as np np.random.seed(1234) # Create a random pycortex Volume volume = cortex.Volume.random(subject='S1', xfmname='retinotopy') # Plot a flatmap with the data projected onto the surface # By default ROIs and their labels will be overlaid to the plot # Also a colorbar will be added _ = cortex.quickflat.make_figure(volume) plt.show() # The cortex.quickshow method is a pointer to quickflat.make_figure # and will plot exactly the same as the above plot _ = cortex.quickshow(volume) plt.show() # Highlight the curvature _ = cortex.quickflat.make_figure(volume, with_curvature=True) plt.show() # Remove ROI labels from the plot _ = cortex.quickflat.make_figure(volume, with_curvature=True, with_labels=False) plt.show() # Remove ROIs from the plot _ = cortex.quickflat.make_figure(volume, with_curvature=True,
def draw_cortex_vertex(subject,xfmname,data,vmin,vmax,description,cmap='Viridis',cbar = 'discrete',cmap_steps = 255,\ alpha = None,depth = 1,thick = 1,height = 1024,sampler = 'nearest',\ with_curvature = True,with_labels = False,with_colorbar = False,\ with_borders = False,curv_brightness = 0.95,curv_contrast = 0.05,add_roi = False,\ roi_name = 'empty',col_offset = 0, zoom_roi = None, zoom_hem = None, zoom_margin = 0.0,): """ Plot brain data onto a previously saved flatmap. Parameters ---------- subject : subject id (e.g. 'sub-001') xfmname : xfm transform data : the data you would like to plot on a flatmap cmap : colormap that shoudl be used for plotting vmins : minimal values of 1D 2D colormap [0] = 1D, [1] = 2D vmaxs : minimal values of 1D/2D colormap [0] = 1D, [1] = 2D description : plot title cbar : color bar layout cmap_steps : number of colormap bins alpha : alpha map depth : Value between 0 and 1 for how deep to sample the surface for the flatmap (0 = gray/white matter boundary, 1 = pial surface) thick : Number of layers through the cortical sheet to sample. Only applies for pixelwise = True height : Height of the image to render. Automatically scales the width for the aspect of the subject's flatmap sampler : Name of sampling function used to sample underlying volume data. Options include 'trilinear', 'nearest', 'lanczos' with_curvature : Display the rois, labels, colorbar, annotated flatmap borders, or cross-hatch dropout? with_labels : Display labels? with_colorbar : Display pycortex' colorbar? with_borders : Display borders? curv_brightness : Mean brightness of background. 0 = black, 1 = white, intermediate values are corresponding grayscale values. curv_contrast : Contrast of curvature. 1 = maximal contrast (black/white), 0 = no contrast (solid color for curvature equal to curvature_brightness). add_roi : add roi -image- to overlay.svg roi_name : roi name col_offset : colormap offset between 0 and 1 zoom_roi : name of the roi on which to zoom on zoom_hem : hemifield fo the roi zoom zoom_margin : margin in mm around the zoom Returns ------- vertex_rgb - pycortex vertex file """ import cortex import numpy as np import matplotlib.pyplot as plt import matplotlib.colors as colors from matplotlib import cm import matplotlib as mpl # import ipdb # deb = ipdb.set_trace # define colormap base = cortex.utils.get_cmap(cmap) val = np.linspace(0, 1,cmap_steps+1,endpoint=False) colmap = colors.LinearSegmentedColormap.from_list('my_colmap',base(val), N = cmap_steps) # convert data to RGB vrange = float(vmax) - float(vmin) norm_data = ((data-float(vmin))/vrange)*cmap_steps mat = colmap(norm_data.astype(int))*255.0 alpha = alpha*255.0 # define volume RGB volume = cortex.VolumeRGB( channel1 = mat[...,0].T.astype(np.uint8), channel2 = mat[...,1].T.astype(np.uint8), channel3 = mat[...,2].T.astype(np.uint8), alpha = alpha.T.astype(np.uint8), subject = subject, xfmname = xfmname) volume_fig = cortex.quickshow( braindata = volume, depth = depth, thick = thick, height = height, sampler = sampler, with_curvature = with_curvature, with_labels = with_labels, with_colorbar = with_colorbar, with_borders = with_borders, curvature_brightness = curv_brightness, curvature_contrast = curv_contrast) if cbar == 'polar': base = cortex.utils.get_cmap(cmap) val = np.arange(1,cmap_steps+1)/cmap_steps - (1/(cmap_steps*2)) val = np.fmod(val+col_offset,1) colmap = colors.LinearSegmentedColormap.from_list('my_colmap',base(val),N = cmap_steps) cbar_axis = volume_fig.add_axes([0.5, 0.07, 0.8, 0.2], projection='polar') norm = colors.Normalize(0, 2*np.pi) t = np.linspace(0,2*np.pi,200,endpoint=True) r = [0,1] rg, tg = np.meshgrid(r,t) im = cbar_axis.pcolormesh(t, r, tg.T,norm= norm, cmap = colmap) cbar_axis.set_yticklabels([]) cbar_axis.set_xticklabels([]) cbar_axis.set_theta_zero_location("W") cbar_axis.spines['polar'].set_visible(False) elif cbar == 'ecc': # Ecc color bar colorbar_location = [0.5, 0.07, 0.8, 0.2] n = 200 cbar_axis = volume_fig.add_axes(colorbar_location, projection='polar') t = np.linspace(0,2*np.pi, n) r = np.linspace(0,1, n) rg, tg = np.meshgrid(r,t) c = tg im = cbar_axis.pcolormesh(t, r, c, norm = mpl.colors.Normalize(0, 2*np.pi), cmap = colmap) cbar_axis.tick_params(pad = 1,labelsize = 15) cbar_axis.spines['polar'].set_visible(False) # superimpose new axis for dva labeling box = cbar_axis.get_position() cbar_axis.set_yticklabels([]) cbar_axis.set_xticklabels([]) axl = volume_fig.add_axes( [1.8*box.xmin, 0.5*(box.ymin+box.ymax), box.width/600, box.height*0.5]) axl.spines['top'].set_visible(False) axl.spines['right'].set_visible(False) axl.spines['bottom'].set_visible(False) axl.yaxis.set_ticks_position('right') axl.xaxis.set_ticks_position('none') axl.set_xticklabels([]) axl.set_yticklabels(np.linspace(vmin,vmax,3),size = 'x-large') axl.set_ylabel('$dva$\t\t', rotation = 0, size = 'x-large') axl.yaxis.set_label_coords(box.xmax+30,0.4) axl.patch.set_alpha(0.5) elif cbar == 'discrete': # Discrete color bars # ------------------- colorbar_location= [0.9, 0.05, 0.03, 0.25] cmaplist = [colmap(i) for i in range(colmap.N)] # define the bins and normalize bounds = np.linspace(vmin, vmax, cmap_steps + 1) bounds_label = np.linspace(vmin, vmax, 3) norm = mpl.colors.BoundaryNorm(bounds, colmap.N) cbar_axis = volume_fig.add_axes(colorbar_location) cb = mpl.colorbar.ColorbarBase(cbar_axis,cmap = colmap,norm = norm,ticks = bounds_label,boundaries = bounds) # add to overalt if add_roi == True: cortex.utils.add_roi( data = volume, name = roi_name, open_inkscape = False, add_path = False, depth = depth, thick = thick, sampler = sampler, with_curvature = with_curvature, with_colorbar = with_colorbar, with_borders = with_borders, curvature_brightness = curv_brightness, curvature_contrast = curv_contrast) return volume
# the polys (triangles) are the same for the fiducial and flat surfaces (lfidpts, lpolys), _ = cortex.db.get_surf(subject, "fiducial") # load flattened surfaces (lflatpts, lpolys), _ = cortex.db.get_surf(subject, "flat") # Create the Distortion object dist = Distortion(lflatpts, lfidpts, lpolys) # Compute areal distortion # this returns an array of values for each vertex, which we will put into # a Vertex object for plotting areal_dist = cortex.Vertex(dist.areal, subject, vmin=-2, vmax=2) # areal distortion is in log_2 units (e.g. -1 is half the area, 1 is double) cortex.quickshow(areal_dist, with_rois=False, with_labels=False) # Next compute metric distortion metric_dist = cortex.Vertex(dist.metric, subject, vmin=-2, vmax=2) # metric distortion is in mm (e.g. -1 means flatmap edge is 1 mm shorter) cortex.quickshow(metric_dist, with_rois=False, with_labels=False) # Both of these distortion metrics can also be fetched easily via the pycortex # database # these also return Vertex objects like those we created above areal_dist_2 = cortex.db.get_surfinfo(subject, "distortion", dist_type="areal") metric_dist_2 = cortex.db.get_surfinfo(subject, "distortion", dist_type="metric")
""" import cortex import numpy as np np.random.seed(1234) import matplotlib.pyplot as plt subject = 'S1' xfm = 'fullhead' # Creating a random dataset that is the shape for this transform with one # entry for each voxel test_data = np.random.randn(31, 100, 100) # This creates a Volume object for our test dataset for the given subject # and transform vol_data = cortex.Volume(test_data, subject, xfm) cortex.quickshow(vol_data) plt.show() # Can also alter the minimum and maximum values shown on the colorbar vol_data_thresh = cortex.Volume(test_data, subject, xfm, vmin=-1, vmax=1) cortex.quickshow(vol_data_thresh) plt.show() # If you have NaN values, those voxels show up transparent on the brain test_data[10:15, :, :] = np.nan vol_data_nan = cortex.Volume(test_data, subject, xfm) cortex.quickshow(vol_data_nan) plt.show()
# hemisphere based on vertex number test1 = np.hstack((np.arange(num_verts[0]), np.arange(num_verts[1]))) # Picking a different vertex in each hemisphere to create another fake # gradient away from that vertex second_verts = [n / 4 for n in num_verts] test2 = np.hstack((np.abs(np.arange(num_verts[0]) - second_verts[0]), np.abs(np.arange(num_verts[1]) - second_verts[1]))) # Creating a third dataset that is random stripes third_verts = np.random.randint(num_verts[0] + num_verts[1], size=(20, )) test3 = np.zeros(num_verts[0] + num_verts[1]) for v in third_verts: test3[v - 1000:v + 1000] = 1 # Scaling the three datasets to be between 0-255 test1_scaled = test1 / np.max(test1) * 255 test2_scaled = test2 / np.max(test2) * 255 test3_scaled = test3 / np.max(test3) * 255 # Creating three cortex.Volume objects with the test data as np.uint8 red = cortex.Vertex(test1_scaled, subject) green = cortex.Vertex(test2_scaled, subject) blue = cortex.Vertex(test3_scaled, subject) # This creates a 2D Vertex object with both of our test datasets for the # given subject vertex_data = cortex.VertexRGB(red, green, blue, subject) cortex.quickshow(vertex_data, with_colorbar=False) plt.show()
import matplotlib.pyplot as plt subject = "S1" # First we need to import the surfaces for this subject surfs = [cortex.polyutils.Surface(*d) for d in cortex.db.get_surf(subject, "fiducial")] # Then we will pick one vertex in each hemisphere to find distances to vert = 10000 dists = [s.geodesic_distance(vert) for s in surfs] # Now we can plot these distances onto a flatmap all_dists = np.hstack((dists[0], dists[1])) dist_map = cortex.Vertex(all_dists, subject, cmap="hot") cortex.quickshow(dist_map) plt.show() # Alternatively, you can find the minimum distance from a set of points to the # surface # Here, we use an example of an ROI all_eba = cortex.utils.get_roi_verts(subject, "EBA")["EBA"] # We have to then separate these vertices by hemisphere numl = surfs[0].pts.shape[0] eba_verts = [all_eba[all_eba < numl], all_eba[all_eba >= numl] - numl] # Now look at geodesic distances for each hemisphere separately dists = [s.geodesic_distance(verts) for s, verts in zip(surfs, eba_verts)] all_dists = np.hstack((dists[0], dists[1]))
# First let's load the surface and compute the distortion directly using the # Distortion class # load fiducial (mid-cortical) surfaces # we're ignoring the right hemisphere surface here # the polys (triangles) are the same for the fiducial and flat surfaces _, (rfidpts, rpolys) = cortex.db.get_surf(subject, "fiducial") # load flattened surfaces _, (rflatpts, rpolys) = cortex.db.get_surf(subject, "flat") # Create the Distortion object dist = Distortion(rflatpts, rfidpts, rpolys) # Compute areal distortion # this returns an array of values for each vertex, which we will put into # a Vertex object for plotting areal_dist = cortex.Vertex(dist.areal, subject, vmin=-2, vmax=2) # areal distortion is in log_2 units (e.g. -1 is half the area, 1 is double) # Next compute metric distortion metric_dist = cortex.Vertex(dist.metric, subject, vmin=-2, vmax=2) # metric distortion is in mm (e.g. -1 means flatmap edge is 1 mm shorter) cortex.quickshow(areal_dist, with_rois=False, with_labels=False) cortex.quickshow(metric_dist, with_rois=False, with_labels=False) # these also return Vertex objects like those we created above plt.show()
import cortex.polyutils import numpy as np import matplotlib.pyplot as plt subject = "S1" # First we need to import the surfaces for this subject surfs = [ cortex.polyutils.Surface(*d) for d in cortex.db.get_surf(subject, "fiducial") ] numl = surfs[0].pts.shape[0] # Now we need to pick the start and end points of the line we will draw pt_a = 100 pt_b = 50000 # Then we find the geodesic path between these points path = surfs[0].geodesic_path(pt_a, pt_b) # In order to plot this on the cortical surface, we need an array that is the # same size as the number of vertices in the left hemisphere path_data = np.zeros(numl) for v in path: path_data[v] = 1 # And now plot these distances onto the cortical surface path_verts = cortex.Vertex(path_data, subject, cmap="Blues_r") cortex.quickshow(path_verts, with_colorbar=False) plt.show()