plot_seeds.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plot seeds rois from nifti images\n",
    "This notebook plots the provided seeds on a single image, each seed being specified as a nifti image.\n",
    "\n",
    "Author: Stephen Larroque\n",
    "Creation date: 2018-03-18\n",
    "Version 1.0.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "# BEWARE: autoreload works on functions and on general code, but NOT on new class methods:\n",
    "# if you add or change the name of a method, you have to reload the kernel!\n",
    "# also it will fail if you use super() calls in the classes you change\n",
    "# ALSO AUTORELOAD SHOULD BE THE FIRST LINE EVER EXECUTED IN YOUR IPYTHON NOTEBOOK!!!\n",
    "\n",
    "# Profilers:\n",
    "# http://pynash.org/2013/03/06/timing-and-profiling/\n",
    "# http://mortada.net/easily-profile-python-code-in-jupyter.html\n",
    "# use %lprun -m module func(*args, **kwargs)\n",
    "try:\n",
    "    %load_ext line_profiler\n",
    "    %load_ext memory_profiler\n",
    "except ImportError as exc:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate figure inside IPython Notebook (must be called before any import of matplotlib, direct or indirect!)\n",
    "%matplotlib inline\n",
    "\n",
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.colors as pltcol\n",
    "import numpy as np\n",
    "import nibabel as nib\n",
    "from nilearn import image\n",
    "from nilearn import plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# PARAMETERS - EDIT ME\n",
    "rois_filepath = ['DMN_Raichle_MPFC_10--1_54_27.nii', 'DMN_Raichle_Cerebellum_R_10-25_-81_-33.nii', 'DMN_Raichle_Cerebellum_L_10--25_-81_-33.nii', 'Boveroux_Thalamus_R_4-4_-12_0.nii', 'Boveroux_Thalamus_L_4--4_-12_0.nii', 'AUD_Maudoux_STG_R_10-44_-6_11.nii', 'AUD_Maudoux_STG_L_10--44_-6_11.nii']  # specify here the filenames to the nifti files of the rois\n",
    "atlas_cmap = pltcol.ListedColormap(['r', 'b', 'b', 'g', 'g', 'm', 'm'], name='from_list', N=None)  # colormap to use for ROIs, specify the colors in the same order as the rois filenames, or use plt.cm.Set1 if you want to assign random colors\n",
    "show_center = False # show a black dot at the center of each ROI?\n",
    "show_colorbar = False  # display the colorbar on the brain image?\n",
    "dpi_resolution = 300  # dpi resolution when saving on-disk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_maps(list_imgs, voxel_threshold=None):\n",
    "    if voxel_threshold is None:\n",
    "        voxel_threshold = 0.0001 # minimum threshold to consider as a voxel and not just background noise (because background voxels can be 0.000001 for example), can be float or str ('1%' to give a percentage). TODO: autodetect minimum value (can be -4, 0.02, etc) as the background and use it as the threshold value.\n",
    "    # Load masks and resample to first\n",
    "    imgs = []\n",
    "    for img in list_imgs:\n",
    "        im = image.load_img(img)\n",
    "        if imgs:\n",
    "            if im.shape != imgs[0].shape:\n",
    "                im = image.resample_to_img(im, imgs[0])\n",
    "        im = image.threshold_img(im, voxel_threshold)\n",
    "        imgs.append(im)\n",
    "    return imgs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check filepaths are lists and not just string\n",
    "if isinstance(rois_filepath, str):\n",
    "    rois_filepath = [rois_filepath]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_cluster_center(im, mricron=False):\n",
    "    from nilearn.image.resampling import reorder_img, coord_transform\n",
    "    # Project coordinates to reduced space\n",
    "    if mricron:\n",
    "        im2 = reorder_img(im, resample='continuous')  # DO NOT USE: this will convert to MRIcron coordinates space (ie, [0, 100]) but it will mess things up for nilearn!\n",
    "        # Get indices of nonzero values\n",
    "        matches = im2.get_data().nonzero()\n",
    "    else:\n",
    "        # Get indices of nonzero values\n",
    "        matches = im.get_data().nonzero()\n",
    "    # Compute the euclidian middle of the cluster, from the nonzero values indices (= coordinates)\n",
    "    center = np.mean(matches, axis=1)\n",
    "    # Project center coordinates to brain space (ie, instead of [0, 100] range, it will be [-50, 50] -- I picked these numbers randomly, you see the idea)\n",
    "    if not mricron:\n",
    "        center = coord_transform(center[0], center[1], center[2], im.affine)  # disable this to get MRIcron space\n",
    "    return center"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot ROIs on glass brain images!\n",
    "if rois_filepath:\n",
    "    nb_rois = len(rois_filepath)\n",
    "    imgs = load_maps(rois_filepath)\n",
    "\n",
    "    #plotting.plot_prob_atlas(imgs, view_type=\"filled_contours\",\n",
    "    #                    title=\"lala\", colorbar=True, cut_coords=(0,0,0), draw_cross=True, cmap=pltcol.ListedColormap(['b', 'g', 'r', 'c', 'm'], name='from_list', N=None))\n",
    "    #plotting.plot_roi(imgs[0])\n",
    "\n",
    "    centers = []\n",
    "    fig = plotting.plot_glass_brain(None, cmap=atlas_cmap, alpha=0.5)  # initialize the glass brain images\n",
    "    for c, im in enumerate(imgs):\n",
    "        # For each ROI\n",
    "        # Get the center (to plot the marker)\n",
    "        center = find_cluster_center(im)\n",
    "        centers.append(center)\n",
    "        print('Center found at: ' + str(center))\n",
    "        # Assign a unique value to this cluster's voxels (to get a different color)\n",
    "        imdata = im.get_data()  # Convert to numpy structure\n",
    "        imdata[imdata != 0] = c+1  # Assign unique value\n",
    "        im2 = nib.Nifti1Image(imdata, affine=im.affine)  # convert back to a nifti file in-memory to supply to nilearn\n",
    "        # Show colorbar?\n",
    "        cbar = False\n",
    "        if show_colorbar and c == (nb_rois-1):\n",
    "            # Can only plot the colorbar at the last iteration, else nilearn will spit an error (cannot use multiple colorbars)\n",
    "            cbar = True\n",
    "        # Plot the clusters\n",
    "        fig.add_overlay(im2, vmin=1, vmax=nb_rois, cmap=atlas_cmap, colorbar=cbar)\n",
    "        # Plot the markers (clusters' centers)\n",
    "        if show_center:\n",
    "            fig.add_markers([center], marker_color=['k'], marker_size=20)\n",
    "\n",
    "# Save figure\n",
    "fig.savefig('rois_glass_brain.png', dpi=dpi_resolution)\n",
    "print('Image saved in rois_glass_brain.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [default]",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}