docs/mindboggle_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img align=\"left\" style=\"padding-right:10px; width:150px;\" src=\"https://raw.githubusercontent.com/nipy/mindboggle-assets/master/images/mindboggle_logo_200px_600dpi.jpg\">\n",
    "This jupyter notebook provides a tutorial for the Mindboggle brain image analysis software.<br>&nbsp;&nbsp;&nbsp;&nbsp;Website: http://mindboggle.info<br>&nbsp;&nbsp;&nbsp;&nbsp;Reference: http://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1005350#sec007"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mindboggle tutorial\n",
    "\n",
    "1. [Mindboggle processing steps](#processing)\n",
    "2. [Run \"mindboggle --help\" on the command line](#help)\n",
    "3. [Mindboggle on the command line](#command)\n",
    "4. [Mindboggle Python library](#library)\n",
    "5. [Run individual functions](#functions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"processing\"></a>\n",
    "\n",
    "# Mindboggle processing steps\n",
    "\n",
    "<img style=\"padding-right:10px;\" src=\"https://raw.githubusercontent.com/nipy/mindboggle-assets/master/images/mindboggle_nipype_flow.png\">\n",
    "\n",
    "## Output\n",
    "Mindboggle takes in (FreeSurfer- and optionally ANTs-) preprocessed T1-weighted MRI data, and outputs nifti volumes, vtk surfaces, and csv tables containing label, feature, and shape information for further analysis:\n",
    "\n",
    "- **labels/**:  *integer-labeled vtk surfaces and nifti volumes*\n",
    "- **features/**:  *integer-labeled sulci or fundi on vtk surfaces*\n",
    "- **shapes/**:  *float shape value for every point on vtk surfaces*\n",
    "- **tables/**:  *csv tables of shape values for every label/feature/vertex*\n",
    "\n",
    "<br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Processing steps\n",
    "\n",
    "### 1. Combine FreeSurfer and ANTs gray/white segmentations:\n",
    "<br>\n",
    "<img style=\"padding-right:10px; width:600px;\" src=\"https://raw.githubusercontent.com/nipy/mindboggle-assets/master/images/papers/Figure2_FSvsANTs_segmentation_white_188mm_600dpi.png\">\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Fill hybrid segmentation with (FreeSurfer- or ANTs-registered) labels.\n",
    "### 3. Compute volume shape measures for each labeled region:\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;\n",
    "<b>volume</b>\n",
    "<br>\n",
    "<img style=\"padding-right:10px; width:600px;\" src=\"https://raw.githubusercontent.com/nipy/mindboggle-assets/master/images/posters/roygbiv-volume.png\">\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Compute surface shape measures for every cortical mesh vertex\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;\n",
    "<b>surface area</b>\n",
    "<br>\n",
    "<img style=\"padding-right:10px; width:600px;\" src=\"https://raw.githubusercontent.com/nipy/mindboggle-assets/master/images/papers/Figure4_area_182mm_300dpi.png\">\n",
    "<br><br>\n",
    "<img style=\"padding-right:10px; width:600px;\" src=\"https://raw.githubusercontent.com/nipy/mindboggle-assets/master/images/papers/HBM2015_ROYGBIV.png\">\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;\n",
    "<b>geodesic depth and travel depth</b>\n",
    "<br>\n",
    "<img style=\"padding-right:10px; width:600px;\" src=\"https://raw.githubusercontent.com/nipy/mindboggle-assets/master/images/papers/Figure6_geodesic_and_travel_depth_on_sulci_190mm_600dpi.png\">\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;\n",
    "<b>mean curvature</b>\n",
    "<br>\n",
    "<img style=\"padding-right:10px; width:600px;\" src=\"https://raw.githubusercontent.com/nipy/mindboggle-assets/master/images/papers/Mindboggle_bioRxiv2016_Fig5.png\">\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. Extract cortical surface features:\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;\n",
    "<b>folds</b> (left and upper right, with manual labels) \n",
    "<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;\n",
    "<b>sulci</b> (lower right)\n",
    "<br>\n",
    "<img style=\"padding-right:10px; width:600px;\" src=\"https://raw.githubusercontent.com/nipy/mindboggle-assets/master/images/papers/Mindboggle_bioRxiv2016_Fig7.png\">\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;\n",
    "<b>fundi</b>\n",
    "<img style=\"padding-right:10px; width:300px;\" src=\"https://raw.githubusercontent.com/nipy/mindboggle-assets/master/images/papers/Figure8_fundus_views_78mm_600dpi_rotated.png\">\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. For each cortical surface label/sulcus, compute:\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;\n",
    "<b>Zernike moments</b>\n",
    "<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;\n",
    "<b>Laplace-Beltrami spectrum</b> (2nd, 3rd, and 9th spectral components shown for two brains):\n",
    "<br>\n",
    "<br>\n",
    "<img style=\"padding-right:10px; width:600px;\" src=\"https://raw.githubusercontent.com/nipy/mindboggle-assets/master/images/papers/Figure9_LaplaceBeltrami3rd6th9thSpectralComponents_190mm_600dpi.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. Compute statistics for each shape measure across vertices for each label/feature:\n",
    "    - median\n",
    "    - median absolute deviation\n",
    "    - mean\n",
    "    - standard deviation\n",
    "    - skew\n",
    "    - kurtosis\n",
    "    - lower and upper quartiles\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"help\"></a>\n",
    "\n",
    "# Run \"mindboggle --help\" on the command line\n",
    "\n",
    "First, let's see what command-line options Mindboggle provides:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/bin/sh: mindboggle: command not found\r\n"
     ]
    }
   ],
   "source": [
    "! mindboggle --help"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"command\"></a>\n",
    "\n",
    "# Mindboggle on the command line\n",
    "\n",
    "The following command computes shape measures for cortical surface labels and sulci from [example FreeSurfer and ANTs data](https://osf.io/3xfb8/?action=download&version=1). Without adding more restrictive arguments, this command takes an hour or two to run.\n",
    "\n",
    "mindboggle /home/jovyan/work/mindboggle_input_example/freesurfer/subjects/arno<br>",
    "&nbsp;&nbsp;&nbsp;&nbsp; --ants /home/jovyan/work/mindboggle_input_example/ants/subjects/arno/antsBrainSegmentation.nii.gz<br>",
    "&nbsp;&nbsp;&nbsp;&nbsp; --out /home/jovyan/work/mindboggled<br>",
    "&nbsp;&nbsp;&nbsp;&nbsp; --roygbiv<br><br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"library\"></a>\n",
    "\n",
    "# Mindboggle Python library\n",
    "\n",
    "Rather than call Mindboggle from the command line, we can also call individual Python functions within the Mindboggle library, which includes the following files in mindboggle/mindboggle/:\n",
    "\n",
    "- **mio**/  *-- input/output functions*\n",
    "    - **[colors](https://github.com/nipy/mindboggle/blob/master/mindboggle/mio/colors.py)**.py  *-- colormap-related functions*\n",
    "    - **[convert_volumes](https://github.com/nipy/mindboggle/blob/master/mindboggle/mio/convert_volumes.py)**.py  *-- read/write nifti volume files*\n",
    "    - **[fetch_data](https://github.com/nipy/mindboggle/blob/master/mindboggle/mio/fetch_data.py)**.py  *-- fetch data from a URL or from third party software*\n",
    "    - **[labels](https://github.com/nipy/mindboggle/blob/master/mindboggle/mio/labels.py)**.py  *-- information about labeling protocols*\n",
    "    - **[plots](https://github.com/nipy/mindboggle/blob/master/mindboggle/mio/plots.py)**.py  *-- plot functions*\n",
    "    - **[tables](https://github.com/nipy/mindboggle/blob/master/mindboggle/mio/tables.py)**.py  *-- read/write tables*\n",
    "    - **[vtks](https://github.com/nipy/mindboggle/blob/master/mindboggle/mio/vtks.py)**.py  *-- read/write VTK surface files*\n",
    "\n",
    "- **guts**/  *-- the \"guts\" underlying feature extraction and labeling code*\n",
    "    - **[compute](https://github.com/nipy/mindboggle/blob/master/mindboggle/guts/compute.py)**.py  *-- compute distances, etc.*\n",
    "    - **[graph](https://github.com/nipy/mindboggle/blob/master/mindboggle/guts/graph.py)**.py  *-- graph operations*\n",
    "    - **[kernels](https://github.com/nipy/mindboggle/blob/master/mindboggle/guts/kernels.py)**.py  *-- kernels for graph operations*\n",
    "    - **[mesh](https://github.com/nipy/mindboggle/blob/master/mindboggle/guts/mesh.py)**.py  *-- operate on surface mesh vertices*\n",
    "    - **[paths](https://github.com/nipy/mindboggle/blob/master/mindboggle/guts/paths.py)**.py  *-- connect surface mesh vertices*\n",
    "    - **[rebound](https://github.com/nipy/mindboggle/blob/master/mindboggle/guts/rebound.py)**.py  *-- adjust label borders on a surface mesh*\n",
    "    - **[relabel](https://github.com/nipy/mindboggle/blob/master/mindboggle/guts/relabel.py)**.py  *-- relabel surface or volume files*\n",
    "    - **[segment](https://github.com/nipy/mindboggle/blob/master/mindboggle/guts/segment.py)**.py  *-- segment a surface mesh*\n",
    "\n",
    "- **shapes**/  *-- shape measurement functions\n",
    "    - **[surface_shapes](https://github.com/nipy/mindboggle/blob/master/mindboggle/shapes/surface_shapes.py)**.py  *-- compute surface shapes (calls C++ library below)*\n",
    "    - **[volume_shapes](https://github.com/nipy/mindboggle/blob/master/mindboggle/shapes/volume_shapes.py)**.py  *-- compute volumes and thicknesses*\n",
    "    - **[laplace_beltrami](https://github.com/nipy/mindboggle/blob/master/mindboggle/shapes/laplace_beltrami.py)**.py  *-- compute a Laplace-Beltrami spectrum*\n",
    "    - **[zernike/zernike](https://github.com/nipy/mindboggle/blob/master/mindboggle/shapes/zernike/zernike.py)**.py  *-- compute Zernike moments of a collection of vertices*\n",
    "    - **[likelihood](https://github.com/nipy/mindboggle/blob/master/mindboggle/shapes/likelihood.py)**.py  *-- compute (fundus) likelihood values*\n",
    "\n",
    "- **features**/  *-- higher-level feature extraction (folds, fundi, sulci)*\n",
    "    - **[folds](https://github.com/nipy/mindboggle/blob/master/mindboggle/features/folds.py)**.py  *-- extract surface folds*\n",
    "    - **[fundi](https://github.com/nipy/mindboggle/blob/master/mindboggle/features/fundi.py)**.py  *-- extract fundus curves from folds*\n",
    "    - **[sulci](https://github.com/nipy/mindboggle/blob/master/mindboggle/features/sulci.py)**.py  *-- extract sulci from folds*\n",
    "\n",
    "<!--\n",
    "    - **thirdparty/**  *-- third-party code*\n",
    "    - **[ants](https://github.com/nipy/mindboggle/blob/master/mindboggle/thirdparty/ants.py)**.py  *-- call ANTs commands*\n",
    "    - **[vtkviewer](https://github.com/nipy/mindboggle/blob/master/mindboggle/thirdparty/vtkviewer.py)**.py  *-- VTK viewer (by Hal Canary)*\n",
    "  - mindboggle/vtk_cpp_tools  *-- C++ tools for measuring shapes on VTK surface files*\n",
    "    - **[area](https://github.com/nipy/mindboggle/blob/master/vtk_cpp_tools/area/PointAreaMain.cpp)**/\n",
    "    - **[curvature](https://github.com/nipy/mindboggle/blob/master/vtk_cpp_tools/curvature/CurvatureMain.cpp)**/\n",
    "    - **[geodesic_depth](https://github.com/nipy/mindboggle/blob/master/vtk_cpp_tools/geodesic_depth/GeodesicDepthMain.cpp)**/\n",
    "    - **[travel_depth](https://github.com/nipy/mindboggle/tree/master/vtk_cpp_tools/travel_depth)**/\n",
    "    - **[gradient](https://github.com/nipy/mindboggle/blob/master/vtk_cpp_tools/gradient/GradientMain.cpp)**/\n",
    "    - **[surface_overlap](https://github.com/nipy/mindboggle/blob/master/vtk_cpp_tools/surface_overlap/SurfaceOverlapMain.cpp)**/\n",
    "-->\n",
    "<br>\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "<a id=\"functions\"></a>\n",
    "\n",
    "# Run individual functions\n",
    "\n",
    "Let's run some functions within Mindboggle's Python library.  The following code snippets are adapted from the above files' docstrings.\n",
    "\n",
    "## Example: Compute statistics of depth measures in sulcus folds\n",
    "### Measure travel depth for every vertex of a brain's left hemisphere\n",
    "Convert a FreeSurfer surface file to VTK format:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from mindboggle.mio.vtks import freesurfer_surface_to_vtk\n",
    "subject_path = '/home/jovyan/work/mindboggle_input_example/freesurfer/subjects/arno/'\n",
    "surface_file = freesurfer_surface_to_vtk(surface_file=subject_path + 'surf/lh.pial', \n",
    "                                         orig_file=subject_path + 'mri/orig.mgz',\n",
    "                                         output_vtk='lh.pial.vtk')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute travel_depth for every vertex of the mesh in the VTK file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import os\n",
    "from mindboggle.shapes.surface_shapes import travel_depth\n",
    "from mindboggle.mio.vtks import read_scalars\n",
    "ccode_path = '/opt/vtk_cpp_tools'\n",
    "command = os.path.join(ccode_path, 'travel_depth', 'TravelDepthMain')\n",
    "depth_file = travel_depth(command=command,\n",
    "                          surface_file=surface_file,\n",
    "                          verbose=True)\n",
    "depths, name = read_scalars(depth_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot the depth values in 3-D:  <b>UNDER CONSTRUCTION<b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import nilearn.plotting\n",
    "depths_array = np.asarray(depths)\n",
    "fs_surf_mesh = subject_path + 'surf/lh.pial'\n",
    "nilearn.plotting.plot_surf(surf_mesh=fs_surf_mesh, surf_map=depths_array,\n",
    "                           bg_map=None, hemi='left', view='lateral',\n",
    "                           cmap=None, colorbar=True,\n",
    "                           avg_method='mean', threshold=None,\n",
    "                           alpha='auto', bg_on_data=False, darkness=1,\n",
    "                           vmin=None, vmax=None, cbar_vmin=None, cbar_vmax=None,\n",
    "                           title=None, output_file=None, axes=None, figure=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extract folds based on depth and curvature\n",
    "Plot a histogram of the depth values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "from mindboggle.mio.plots import histograms_of_lists\n",
    "histograms_of_lists(columns=[depths],\n",
    "                    column_name='Depth values',\n",
    "                    ignore_columns=[],\n",
    "                    nbins=100,\n",
    "                    axis_limits=[],\n",
    "                    titles='depth values')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find a depth threshold to extract folds from the surface:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from mindboggle.features.folds import find_depth_threshold\n",
    "depth_threshold, bins, bin_edges = find_depth_threshold(depth_file=depth_file,\n",
    "                                                        min_vertices=10000,\n",
    "                                                        verbose=True)\n",
    "depth_threshold"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extract folds with the depth threshold:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from mindboggle.features.folds import extract_folds\n",
    "folds, n_folds, folds_file = extract_folds(depth_file=depth_file,\n",
    "                                           depth_threshold=depth_threshold,\n",
    "                                           min_fold_size=50,\n",
    "                                           save_file=True,\n",
    "                                           output_file='folds.vtk',\n",
    "                                           background_value=-1,\n",
    "                                           verbose=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remove all vertices but the folds:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from mindboggle.mio.vtks import rewrite_scalars\n",
    "rewrite_scalars(input_vtk=folds_file,\n",
    "                output_vtk='rewrite_scalars.vtk',\n",
    "                new_scalars=[folds],\n",
    "                new_scalar_names=['folds'],\n",
    "                filter_scalars=folds,\n",
    "                background_value=-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot the folds in 3-D:  <b>UNDER CONSTRUCTION<b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "folds_array = np.asarray(folds)\n",
    "nilearn.plotting.plot_surf(surf_mesh=fs_surf_mesh, surf_map=folds_array,\n",
    "                           bg_map=None, hemi='left', view='lateral',\n",
    "                           cmap=None, colorbar=True,\n",
    "                           avg_method='mean', threshold=None,\n",
    "                           alpha='auto', bg_on_data=False, darkness=1,\n",
    "                           vmin=None, vmax=None, cbar_vmin=None, cbar_vmax=None,\n",
    "                           title=None, output_file=None, axes=None, figure=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extract sulci from folds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load a FreeSurfer .annot file and save as a VTK format file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from mindboggle.mio.vtks import freesurfer_annot_to_vtk\n",
    "labels, label_file = freesurfer_annot_to_vtk(annot_file=subject_path + 'label/lh.aparc.annot',\n",
    "                                             vtk_file=surface_file,\n",
    "                                             output_vtk='lh.aparc.annot.vtk',\n",
    "                                             background_value=-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Relabel surface labels to match expected volume labels:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from mindboggle.guts.relabel import relabel_surface\n",
    "from mindboggle.mio.labels import DKTprotocol\n",
    "dkt = DKTprotocol()\n",
    "relabel_file = relabel_surface(vtk_file=label_file,\n",
    "                               hemi='lh', \n",
    "                               old_labels=dkt.DKT31_numbers, \n",
    "                               new_labels=[],\n",
    "                               erase_remaining=True, \n",
    "                               erase_labels=[0], \n",
    "                               erase_value=-1, \n",
    "                               output_file='relabeled.vtk')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extract sulci from folds using pairs of labels in the DKT labeling protocol (SLOW):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from mindboggle.features.sulci import extract_sulci\n",
    "sulci, n_sulci, sulci_file = extract_sulci(labels_file=relabel_file,\n",
    "                                           folds_or_file=folds,\n",
    "                                           hemi='lh',\n",
    "                                           min_boundary=10,\n",
    "                                           sulcus_names=[],\n",
    "                                           save_file=True,\n",
    "                                           output_file='sulci.vtk',\n",
    "                                           background_value=-1,\n",
    "                                           verbose=True)\n",
    "n_sulci"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot the sulci in 3-D:  <b>UNDER CONSTRUCTION<b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "sulci_array = np.asarray(sulci)\n",
    "nilearn.plotting.plot_surf(surf_mesh=fs_surf_mesh, surf_map=sulci_array,\n",
    "                           bg_map=None, hemi='left', view='lateral',\n",
    "                           cmap=None, colorbar=True,\n",
    "                           avg_method='mean', threshold=None,\n",
    "                           alpha='auto', bg_on_data=False, darkness=1,\n",
    "                           vmin=None, vmax=None, cbar_vmin=None, cbar_vmax=None,\n",
    "                           title=None, output_file=None, axes=None, figure=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Compute statistics on sulcus depth values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from mindboggle.mio.tables import write_shape_stats\n",
    "label_table, sulcus_table, fundus_table = write_shape_stats(labels_or_file=[], \n",
    "    sulci=sulci, fundi=[], affine_transform_files=[], inverse_booleans=[], \n",
    "    transform_format='itk', area_file='', normalize_by_area=False, \n",
    "    mean_curvature_file='',\n",
    "    travel_depth_file=depth_file, geodesic_depth_file='',\n",
    "    freesurfer_thickness_file='', freesurfer_curvature_file='',\n",
    "    freesurfer_sulc_file='',\n",
    "    labels_spectra=[], labels_spectra_IDs=[],\n",
    "    sulci_spectra=[], sulci_spectra_IDs=[],\n",
    "    labels_zernike=[], labels_zernike_IDs=[],\n",
    "    sulci_zernike=[], sulci_zernike_IDs=[],\n",
    "    exclude_labels=[-1], verbose=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Show statistical summary table of sulcus depth values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "pd.read_csv(sulcus_table)"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "celltoolbar": "Raw Cell Format",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}