tracking.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ferret DWI tractography"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using matplotlib backend: Qt5Agg\n",
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    }
   ],
   "source": [
    "%pylab"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports & Plotting function "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from __future__ import division, print_function, absolute_import\n",
    "\n",
    "import numpy as np\n",
    "import nibabel as nib\n",
    "from dipy.reconst.peaks import peaks_from_model, PeaksAndMetrics\n",
    "from dipy.core.sphere import Sphere\n",
    "from dipy.data import get_sphere\n",
    "from dipy.io.gradients import read_bvals_bvecs\n",
    "from dipy.core.gradients import gradient_table\n",
    "from dipy.tracking import utils\n",
    "from common import load_nifti, save_trk, save_peaks, load_peaks, save_trk_old_style\n",
    "from dipy.viz import actor, window, fvtk\n",
    "\n",
    "#from ipdb import set_trace\n",
    "\n",
    "def show_results(streamlines, vol, affine, world_coords=True, opacity=0.6):\n",
    "\n",
    "    from dipy.viz import actor, window, widget\n",
    "\n",
    "    shape = data.shape\n",
    "\n",
    "    if not world_coords:\n",
    "        from dipy.tracking.streamline import transform_streamlines\n",
    "        streamlines = transform_streamlines(streamlines, np.linalg.inv(affine))\n",
    "\n",
    "    ren = window.Renderer()\n",
    "    if streamlines is not None:\n",
    "        stream_actor = actor.line(streamlines)\n",
    "\n",
    "    if not world_coords:\n",
    "        image_actor = actor.slicer(vol, affine=np.eye(4))\n",
    "    else:\n",
    "        image_actor = actor.slicer(vol, affine)\n",
    "\n",
    "    slicer_opacity = opacity #.6\n",
    "    image_actor.opacity(slicer_opacity)\n",
    "\n",
    "    if streamlines is not None:\n",
    "        ren.add(stream_actor)\n",
    "    ren.add(image_actor)\n",
    "\n",
    "    show_m = window.ShowManager(ren, size=(1200, 900))\n",
    "    show_m.initialize()\n",
    "\n",
    "    def change_slice(obj, event):\n",
    "        z = int(np.round(obj.get_value()))\n",
    "        image_actor.display_extent(0, shape[0] - 1,\n",
    "                                   0, shape[1] - 1, z, z)\n",
    "\n",
    "    slider = widget.slider(show_m.iren, show_m.ren,\n",
    "                           callback=change_slice,\n",
    "                           min_value=0,\n",
    "                           max_value=shape[2] - 1,\n",
    "                           value=shape[2] / 2,\n",
    "                           label=\"Move slice\",\n",
    "                           right_normalized_pos=(.98, 0.6),\n",
    "                           size=(120, 0), label_format=\"%0.lf\",\n",
    "                           color=(1., 1., 1.),\n",
    "                           selected_color=(0.86, 0.33, 1.))\n",
    "\n",
    "    global size\n",
    "    size = ren.GetSize()\n",
    "\n",
    "    def win_callback(obj, event):\n",
    "        global size\n",
    "        if size != obj.GetSize():\n",
    "\n",
    "            slider.place(ren)\n",
    "            size = obj.GetSize()\n",
    "\n",
    "    show_m.initialize()\n",
    "\n",
    "    show_m.add_window_callback(win_callback)\n",
    "    show_m.render()\n",
    "    show_m.start()\n",
    "\n",
    "    # ren.zoom(1.5)\n",
    "    # ren.reset_clipping_range()\n",
    "\n",
    "    # window.record(ren, out_path='bundles_and_a_slice.png', size=(1200, 900),\n",
    "    #               reset_camera=False)\n",
    "\n",
    "    del show_m\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "source": [
    "### Simple viewers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def simple_viewer(streamlines, vol, affine):\n",
    "\n",
    "    renderer = window.Renderer()\n",
    "    renderer.add(actor.line(streamlines))\n",
    "    renderer.add(actor.slicer(vol, affine))\n",
    "    window.show(renderer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def show_gradients(gtab):\n",
    "    \n",
    "    renderer = window.Renderer()\n",
    "    renderer.add(fvtk.point(gtab.gradients, (1,0,0), point_radius=100))\n",
    "    renderer.add(fvtk.point(-gtab.gradients, (1,0,0), point_radius=100))\n",
    "    \n",
    "    window.show(renderer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tracking set of functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following set of code allows to do the tracktography of Diffusion Weighted Images. \n",
    "\n",
    "The inputs necessary are: \n",
    "* a nifti file of the raw data\n",
    "* its associated bvals and bvecs\n",
    "* (optional) a mask in nifti\n",
    "\n",
    "Output:\n",
    "* FA, evecs & rgb nifti files\n",
    "* .trk file containing the streamlines\n",
    "* (annexes) image (png) of the tensor using elipsoids \n",
    "\n",
    "Parameters:\n",
    "* own mask or masking based on the DWI data (median_otsu)\n",
    "* type of model used. Here TensorModel (DTI). Can also be ConstrainedSphericalDeconvModel (CSD) or others\n",
    "* type of fiting of the model. Here (by default) Weighted Least Square (WLS). Can be Ordinary Least Square (OLS) or others\n",
    "* seed density. To increase the number of streamlines\n",
    "* threshold of the streamline length filter "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Input file paths and loading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "dname = 'E:/Celine/Ferret_b2n/P2_F25/'\n",
    "\n",
    "fdwi = dname + 'F25_P2_rot.nii.gz' #nii from 2dseq in dsi_studio\n",
    "\n",
    "data, affine = load_nifti(fdwi)\n",
    "\n",
    "fbval = dname + 'bvals' #from dsi_studio\n",
    "fbvec = dname + 'bvecs'\n",
    "\n",
    "bvals, bvecs = read_bvals_bvecs(fbval, fbvec)\n",
    "\n",
    "gtab = gradient_table(bvals, bvecs, b0_threshold=50)\n",
    "\n",
    "fmask = None #dname + 'mask_extern.nii' #None if wish to get an automated mask from dwi data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Modify Gradients (optional)\n",
    "# permute columns \n",
    "gtab.gradients[:,[1,0]] = gtab.gradients[:,[0,1]]\n",
    "# inverse sign of a column\n",
    "gtab.gradients[:,1] *= -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B-values shape (201,)\n",
      "         min 0.000000 \n",
      "         max 2129.790000 \n",
      "B-vectors shape (201, 3)\n",
      "         min -0.996431 \n",
      "         max 0.999656 \n",
      "None\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11e9e2f50>]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#checks for gtab\n",
    "show_gradients(gtab)\n",
    "np.sum(gtab.b0s_mask)\n",
    "print(gtab.info)\n",
    "plot(np.sort(gtab.bvals))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hand-made mask or autogenerated mask from the DWI data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\cdelettre\\Anaconda2\\lib\\site-packages\\skimage\\filter\\__init__.py:6: skimage_deprecation: The `skimage.filter` module has been renamed to `skimage.filters`.  This placeholder module will be removed in v0.13.\n",
      "  warn(skimage_deprecation('The `skimage.filter` module has been renamed '\n"
     ]
    }
   ],
   "source": [
    "if fmask is None: \n",
    "    from dipy.segment.mask import median_otsu\n",
    "    b0_mask, mask = median_otsu(data)  # TODO: check parameters to improve the mask\n",
    "else: \n",
    "    mask, mask_affine = load_nifti(fmask)\n",
    "    mask = np.squeeze(mask) #fix mask dimensions "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### DTI Model computation and fitting (further for CSD--not tested)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# compute DTI model\n",
    "from dipy.reconst.dti import TensorModel\n",
    "tenmodel = TensorModel(gtab)#, fit_method='OLS') #, min_signal=5000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# fit the dti model\n",
    "tenfit = tenmodel.fit(data, mask=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### DWI indicators computation and saving in nifti files (FA, first eigen vector, rgb tensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# save fa\n",
    "ffa = dname + 'tensor_fa.nii.gz'\n",
    "\n",
    "fa_img = nib.Nifti1Image(tenfit.fa.astype(np.float32), affine)\n",
    "nib.save(fa_img, ffa)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# save first eigen vector\n",
    "evecs_img = nib.Nifti1Image(tenfit.evecs.astype(np.float32), affine)\n",
    "nib.save(evecs_img, dname+'tensor_evecs.nii.gz')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# compute and save rgb\n",
    "from dipy.reconst.dti import color_fa\n",
    "RGB = color_fa(tenfit.fa, tenfit.evecs)\n",
    "nib.save(nib.Nifti1Image(np.array(255 * RGB, 'uint8'), affine), dname+'tensor_rgb.nii.gz')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "sh_order = 8 #TODO: check what that does\n",
    "if data.shape[-1] < 15:\n",
    "    raise ValueError('You need at least 15 unique DWI volumes to '\n",
    "                     'compute fiber ODFs. You currently have: {0}'\n",
    "                     ' DWI volumes.'.format(data.shape[-1]))\n",
    "elif data.shape[-1] < 30:\n",
    "    sh_order = 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# compute the response equation ?\n",
    "from dipy.reconst.csdeconv import auto_response\n",
    "\n",
    "response, ratio = auto_response(gtab, data)\n",
    "\n",
    "response = list(response)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# for CSD\n",
    "\n",
    "from dipy.reconst.csdeconv import ConstrainedSphericalDeconvModel\n",
    "model = ConstrainedSphericalDeconvModel(gtab, response,\n",
    "                                        sh_order=sh_order)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "peaks_sphere = get_sphere('symmetric362')#symmetric362\n",
    "\n",
    "#TODO: check what that does\n",
    "peaks_csd = peaks_from_model(model=tenmodel,\n",
    "                             data=data,\n",
    "                             sphere=peaks_sphere,\n",
    "                             relative_peak_threshold=.5, #.5\n",
    "                             min_separation_angle=30, #25\n",
    "                             mask=mask,\n",
    "                             return_sh=True,\n",
    "                             sh_order=sh_order,\n",
    "                             normalize_peaks=True,\n",
    "                             parallel=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "peaks_csd.affine = affine\n",
    "\n",
    "fpeaks = dname + 'peaks.npz'\n",
    "\n",
    "save_peaks(fpeaks, peaks_csd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from dipy.io.trackvis import save_trk\n",
    "from dipy.tracking import utils\n",
    "from dipy.tracking.local import (ThresholdTissueClassifier,\n",
    "                                 LocalTracking)\n",
    "\n",
    "stopping_thr = 0.1   #0.25\n",
    "\n",
    "pam = load_peaks(fpeaks)\n",
    "\n",
    "#ffa = dname + 'tensor_fa_nomask.nii.gz'\n",
    "fa, fa_affine = load_nifti(ffa)\n",
    "\n",
    "classifier = ThresholdTissueClassifier(fa,\n",
    "                                       stopping_thr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# seeds \n",
    "\n",
    "seed_density = 1\n",
    "\n",
    "seed_mask = fa > 0.1 #0.4 #TODO: check this parameter\n",
    "\n",
    "seeds = utils.seeds_from_mask(\n",
    "    seed_mask,\n",
    "    density=seed_density,\n",
    "    affine=affine)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#TODO: check what that does\n",
    "\n",
    "#if use_sh:\n",
    "#    detmax_dg = \\\n",
    "#        DeterministicMaximumDirectionGetter.from_shcoeff(\n",
    "#            pam.shm_coeff,\n",
    "#            max_angle=30.,\n",
    "#            sphere=pam.sphere)\n",
    "#\n",
    "#    streamlines = \\\n",
    "#        LocalTracking(detmax_dg, classifier, seeds, affine,\n",
    "#                      step_size=.5)\n",
    "#\n",
    "#else:\n",
    "\n",
    "\n",
    "# tractography, if affine then in world coordinates\n",
    "streamlines = LocalTracking(pam, classifier,\n",
    "                            seeds, affine=affine, step_size=.12) #.5\n",
    "\n",
    "# Compute streamlines and store as a list.\n",
    "streamlines = list(streamlines)\n",
    "\n",
    "#ftractogram = dname + 'tractogram.trk'\n",
    "\n",
    "#save .trk\n",
    "#save_trk_old_style(ftractogram, streamlines, affine, fa.shape)\n",
    "\n",
    "#render\n",
    "show_results(streamlines, fa, fa_affine)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ftractogram = dname + 'tractogram_dsiStudioNii_modifiedGrad_maskAuto.trk'\n",
    "\n",
    "#save .trk\n",
    "save_trk_old_style(ftractogram, streamlines, affine, fa.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "36.96\n",
      "0.24\n"
     ]
    }
   ],
   "source": [
    "# threshold on streamline length\n",
    "\n",
    "from dipy.tracking.utils import length\n",
    "lengths = list(length(streamlines))\n",
    "\n",
    "print(max(length(streamlines)))\n",
    "print(min(length(streamlines)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "new_streamlines = [ s for s, l in zip(streamlines, lengths) if l > 1. ] #3.5\n",
    "\n",
    "new_streamlines = list(new_streamlines)\n",
    "new_lengths = list(length(new_streamlines))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "387272\n",
      "300478\n",
      "39.24\n",
      "0.24\n",
      "39.24\n",
      "0.24\n"
     ]
    }
   ],
   "source": [
    "# info length streamlines\n",
    "\n",
    "print(len(streamlines))\n",
    "print(len(new_streamlines))\n",
    "\n",
    "print(max(length(streamlines)))\n",
    "print(min(length(streamlines)))\n",
    "\n",
    "print(max(length(new_streamlines)))\n",
    "print(min(length(new_streamlines)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# show new tracto\n",
    "\n",
    "fnew_tractogram = dname + 'filteredtractogram.trk'\n",
    "#save_trk_old_style(fnew_tractogram, new_streamlines, affine, fa.shape)\n",
    "\n",
    "show_results(new_streamlines, fa, fa_affine, opacity=0.6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "fig_hist, ax = plt.subplots(1)\n",
    "ax.hist(lengths, color='burlywood')\n",
    "ax.set_xlabel('Length')\n",
    "ax.set_ylabel('Count')\n",
    "plt.show()\n",
    "plt.legend()\n",
    "#plt.savefig('length_histogram.png')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "fig_hist, ax = plt.subplots(1)\n",
    "ax.hist(new_lengths, color='burlywood')\n",
    "ax.set_xlabel('Length')\n",
    "ax.set_ylabel('Count')\n",
    "plt.show()\n",
    "plt.legend()\n",
    "#plt.savefig('length_histogram.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Annexes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(120, 160, 80, 201)"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Computing tensor ellipsoids in a part of the splenium of the CC\n"
     ]
    }
   ],
   "source": [
    "print('Computing tensor ellipsoids in a part of the splenium of the CC')\n",
    "\n",
    "from dipy.data import get_sphere\n",
    "sphere = get_sphere('symmetric724')\n",
    "\n",
    "from dipy.viz import fvtk\n",
    "ren = fvtk.ren()\n",
    "\n",
    "evals = tenfit.evals[40:80,40:120,39:40] #[13:43, 44:74, 28:29]\n",
    "evecs = tenfit.evecs[40:80,40:120,39:40]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/ghfc/anaconda/lib/python2.7/site-packages/dipy/viz/fvtk.py:998: RuntimeWarning: invalid value encountered in true_divide\n",
      "  ea /= ea.max()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving illustration as tensor_ellipsoids.png\n"
     ]
    }
   ],
   "source": [
    "cfa = RGB[40:80,40:120,39:40]\n",
    "cfa /= cfa.max()\n",
    "\n",
    "fvtk.add(ren, fvtk.tensor(evals, evecs, cfa, sphere))\n",
    "\n",
    "print('Saving illustration as tensor_ellipsoids.png')\n",
    "fvtk.record(ren, n_frames=1, out_path=dname+'tensor_ellipsoids.png', size=(1000, 1000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "fvtk.record(ren, n_frames=1, out_path=dname+'tensor_ellipsoids.png', size=(1000, 1500))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# first endpoint of the first streamline\n",
    "streamlines[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# other endpoint of the first streamline\n",
    "streamlines[0][-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [conda root]",
   "language": "python",
   "name": "conda-root-py"
  },
  "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": 0
}