Simple measurements of brain folding.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Simple measurements of brain folding\n",
    "====================================\n",
    "*Roberto Toro, August 2014*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Abstract\n",
    "Brain folding is an important neuroanatomical phenotype related to brain evolution, development and neuropathology. Here we discuss some simple global and local measurements of brain folding, and then study their variation in human neocortex. Computer code implementing these measurements is made available open-source."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "\n",
    "Brain folding is an important neuroanatomical phenotype, related to brain evolution, development and neuropathology. The degree of neocortical folding correlates strongly with total brain volume. Whereas the neocortex of small mammals such as mice, shrews and squirrels is smooth (lissencephalic), the neocortex of large mammals such as humans and dolphins is profusely folded (gyrencephalic). During development the neocortex is initially smooth and undifferentiated. In gyrencephalic mammals, the time of the formation of cortical folds corresponds with the time of the greatest neocortical expansion, the development of cytoarchitectonic fields and cortico-cortical connectivity. Several neurodevelopmental and neuropsychiatric disorders present with characteristic abnormalities in cortical folding. Defects in neurogenesis and neuronal migration can lead to lissencephaly of microgyri: the pathological absence or overabundance of neocortical folding. Finally, more subtle variations in the degree of neocortical folding have been reported in several neuropsychiatric disorders such as autism, attention-deficit hyperactivity disorder, schizophrenia or bipolar disorder. The resolution provided by clinical structural magnetic resonance images (MRI) is sufficient to capture brain folding accurately, and despite the sensibility of these measurements to the site-specific acquisition parametres, structural MRI remains the most easily comparable brain imaging sequence in multi-centric studies.\n",
    "\n",
    "Brain folding is easy to observe but not trivial to measure. Several indices of brain folding have been proposed through the years. Zilles, Luders, Van Essen, Schaer, Germanaud. Many of them share a common limitation: they are unable to distinguish between a brain with few deep folds and a brain with many superficial ones. Methods based on a spectral decomposition, such as Germanaud, are able to overcome this limitation. When analysing brains with exactly the same number of fold but of different depth these methods will only produce different histograms of eigenvalues, whose interpretation in terms of number and depth of folds is unclear.\n",
    "\n",
    "Here we start by introducing several simple, global, measurements to understand and measure the relationship between cortical surface area, gyral length, gyral depth, and the total length of folds. Next, we define local versions of all these measurements. Finally, we show how these measurements are distributed and related in neocortical surface reconstructions from the open-access dataset XXXX. We have made available Freesurfer-compatible, open-source implementations of these measurements on github: http://github.com/neuroanatomia/brainfolding."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Brain folding\n",
    "\n",
    "We start from a reconstruction of the brain surface, obtained for example with Freesurfer or Civet. Here, for the sake of illustration, we load the cortical surface reconstruction of an adult ferret, located at http://braincatalogue.org/data/Ferret/mesh.ply. The reconstruction is a list of vertices and a list of triangles constructed from these vertices. The topology of the reconstruction is that of a sphere. We first read the number of vertices, the number of triangles, and then the list of vertices and the list of triangles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import urllib2 as url\n",
    "import re\n",
    "import numpy as np\n",
    "\n",
    "mesh_url=\"http://braincatalogue.org/data/Ferret/mesh.ply\"\n",
    "response=url.urlopen(mesh_url)\n",
    "text=response.read()\n",
    "text=text.split(\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading 9991 vertices and 20000 triangles.\n"
     ]
    }
   ],
   "source": [
    "parser=re.compile(\"\\d+\")\n",
    "for line in text:\n",
    "    if \"element vertex\" in line:\n",
    "        nv=int(parser.findall(line)[0])\n",
    "    if \"element face\" in line:\n",
    "        nt=int(parser.findall(line)[0])\n",
    "    if \"end_header\" in line:\n",
    "        off=text.index(line)+1\n",
    "        break\n",
    "print \"Reading\",nv,\"vertices and\",nt,\"triangles.\"\n",
    "\n",
    "p=np.array([])\n",
    "for i in range(off,off+nv):\n",
    "    p=np.concatenate([p,np.fromstring(text[i],dtype=float,sep=\" \")])\n",
    "p=p.reshape(nv,3)\n",
    "\n",
    "t=np.array([])\n",
    "for i in range(off+nv,off+nv+nt):\n",
    "    tr=np.fromstring(text[i],dtype=int,sep=\" \");\n",
    "    t=np.concatenate([t,[tr[1],tr[2],tr[3]]])\n",
    "t=t.reshape(nt,3)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We define the following basic measurements:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Total surface area, $S$\n",
    "The total surface area of the brain is approximated by the sum of the surface area of each triangle of its surface reconstruction:\n",
    "\n",
    "\\begin{equation}\n",
    "S=\\sum_{i=1}^{N_t}{A(T_i)},\n",
    "\\end{equation}\n",
    "\n",
    "where $A(T_i)$ is the surface area of the $i$-th triangle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Surface area: 2802.16156937\n"
     ]
    }
   ],
   "source": [
    "def A(p0,p1,p2):\n",
    "    #a,b,c    // side lengths\n",
    "    #s        // semiperimeter\n",
    "    a=np.linalg.norm(p0-p1);\n",
    "    b=np.linalg.norm(p1-p2);\n",
    "    c=np.linalg.norm(p2-p0);\n",
    "    s=(a+b+c)/2.0;\n",
    "    return np.sqrt(s*(s-a)*(s-b)*(s-c))\n",
    "\n",
    "S=0\n",
    "for i in range(0,nt):\n",
    "    S+=A(p[t[i][0]],p[t[i][1]],p[t[i][2]])\n",
    "print \"Surface area:\",S"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Total volume, $V$\n",
    "The volume of the reconstruction, computed for example using the sum of the signed volume of each triangle in the reconstruction:\n",
    "\n",
    "\\begin{equation}\n",
    "V=\\frac 1 6 \\sum_{i=1}^{N_t}{det(P(T_i))}\n",
    "\\end{equation}\n",
    "\n",
    "where $det(P(T_i))/6$ is the signed volume of the tetrahedron formed by the vertices of the $i$-th triangle and the origin of the coordinates system."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Volume: 3579.84197093\n"
     ]
    }
   ],
   "source": [
    "# Based on code by S. Melax from http://www.melax.com/volint/\n",
    "def volume(p0,p1,p2):\n",
    "    return np.linalg.det([p0,p1,p2])/6.0\n",
    "\n",
    "V=0\n",
    "for i in range(0,nt):\n",
    "    V+=volume(p[t[i][0]],p[t[i][1]],p[t[i][2]])\n",
    "print \"Volume:\",V"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Absolute folding, $F$\n",
    "We can obtain a first global index of folding from these two values, that we call the absolute folding index, $F$. We define absolute folding as the ratio between the total surface area of the reconstruction, $S$, and $S_{sphere}$, the surface of a sphere with the same volume of the reconstruction, $V$:\n",
    "\n",
    "\\begin{equation}\n",
    "F=\\frac S {S_\\text{sphere}},\n",
    "\\end{equation}\n",
    "\n",
    "because\n",
    "\n",
    "\\begin{equation}\n",
    "S_\\text{sphere}=(36 \\pi)^{1/3} V^{2/3},\n",
    "\\end{equation}\n",
    "\n",
    "then\n",
    "\n",
    "\\begin{equation}\n",
    "F=\\frac {S} {(36 \\pi)^{1/3} V^{2/3}}.\n",
    "\\end{equation}\n",
    "\n",
    "Several researchers have defined similar indices of global folding where the total surface area $S$ is divided by the surface of a smooth envelope of the reconstruction. In those cases, the index obtained will depend on the method used to compute that smooth envelope, a convex hull for example. But because different brains will have different smooth envelopes, the baseline for comparison will change each time. In our case, the surface of the sphere with the same volume of the reconstruction is the smallest possible surface for that volume, which provides an absolute measurement of the degree of folding. Figure \\ref{fig:absoluteFolding} shows the value of $F$ for several geometric objects as well as neocortical reconstructions of different mammalian species.\n",
    "\n",
    "\\begin{figure}\n",
    "\\centering\n",
    "\\includegraphics[width=0.3\\textwidth]{frog.jpg}\n",
    "\\caption{\\label{fig:absoluteFolding}This frog was uploaded to writeLaTeX via the project menu, and holds the place of a figure showing the absolute folding index of different geometric solids and brains of different mammals.}\n",
    "\\end{figure}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Absolute folding: 2.47609029391\n"
     ]
    }
   ],
   "source": [
    "def absFolding(s,v):\n",
    "    return s/(v**(2/3.0)*(36.0*np.pi)**(1/3.0))\n",
    "#print absFolding(4*np.pi,(4/3.0)*np.pi) #test for a sphere\n",
    "\n",
    "F=absFolding(S,V)\n",
    "print \"Absolute folding:\",F\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Folding perimeter, $P$\n",
    "The absolute folding index $F$ suffers from the same issue of indices based on a ratio of surfaces: it cannot distinguish between a surface with few deep folds and a surface with many superficial ones. Several alternative methods have been proposed in the past to provide an idea of the frequency of folding, and to then disentangle sulcal depth and abundance. Among these methods are, for example, those based on spectral decompositions of surface shape, using for example spherical harmonics (REF: Machin) or an eigen decomposition of the Laplace-Beltrami operator of the surface (REF: Germanaud et al) or analyses of curvature (REF: Luders, Van Essen). Whereas these methods allow one to effectively differentiate sulcal depth and abundance, the values they produce are not easy to interprete.\n",
    "\n",
    "A more intuitive measurement of the profusion of folding, independent of their depth, can be obtained by measuring the total folding perimeter, $P$. We define the folding perimeter as the length of the curve of zero mean curvature of the complete reconstruction:\n",
    "\n",
    "\\begin{equation}\n",
    "P=\\sum_{\\text{mean curvature}=0} \\Delta L\n",
    "\\end{equation}\n",
    "\n",
    "Figure \\ref{fig:foldingLength} illustrates the measurement of the folding perimeter for several surfaces. A surface without any fold, strictly convex, will have the minimum value of the folding perimeter, $P=0$. The accuracy of the folding perimeter measurement depends on the smoothness of the surface reconstruction. If the reconstruction is irregular, there may be many changes changes in curvature which will produce spurious edges. A Laplacian smoothing could prevent these irregularities, but also shrink the reconstruction. A Taubin $\\lambda|\\mu$ smoothing (Taubin 2000), which filters-our irregularities with less shrinking of the reconstruction mesh may be preferable.\n",
    "\n",
    "\\begin{figure}\n",
    "\\centering\n",
    "\\includegraphics[width=0.3\\textwidth]{frog.jpg}\n",
    "\\caption{\\label{fig:foldingLength} This frog was uploaded to writeLaTeX via the project menu, and holds the place of a figure showing the computation of the folding length in different solids and brains.}\n",
    "\\end{figure}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# First, we compute the mean curvature of the surface\n",
    "def normal(neig):\n",
    "    ve=[np.cross(p[n[1]]-p[n[0]],p[n[2]]-p[n[0]]) for n in neig]\n",
    "    no=[v/np.linalg.norm(v) for v in ve]\n",
    "    return np.mean(no,axis=0)\n",
    "def barycentre(neig,i):\n",
    "    v=[]\n",
    "    for n in neig:\n",
    "        v=v+[n[0],n[1],n[2]]\n",
    "    bar=np.mean(p[v],axis=0)\n",
    "    # bar=p0*n/3n+2(p1...pn)/(3n)\n",
    "    # and what I want to compute is bar_2=(3bar-p0)/2\n",
    "    return (3*bar-p[i])/2.0\n",
    "def curvature(i): # curvature at vertex i\n",
    "    # We estimate the mean curvature at vertex i as the dot product\n",
    "    # of its unitary normal vector and a normal vector pointing\n",
    "    # toward the barycentre of the vertex's immediate neighbours.\n",
    "    neig=[tr for tr in t if i in tr] # the neighbours of vertex i\n",
    "    nor=normal(neig)\n",
    "    bar=barycentre(neig,i)-p[i]\n",
    "    bar=bar/np.linalg.norm(bar)\n",
    "    return np.dot(nor,bar)\n",
    "\n",
    "c=[]\n",
    "for i in range(0,nv):\n",
    "    c=c+[curvature(i)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Folding perimeter: 923.504811922\n"
     ]
    }
   ],
   "source": [
    "# Then, we compute the folding perimeter P.\n",
    "# The algorithm looks for all edges in which the mean curvature\n",
    "# changes sign, from a vertex where the normal and barycentre vector\n",
    "# point to the same direction, to a vertex where they point in\n",
    "# opposite directions. We then compute for each triangle the length\n",
    "# of the edge where the mean curvature should be 0.\n",
    "P=0\n",
    "for tr in t:\n",
    "    x=[]\n",
    "    if(c[int(tr[0])]*c[int(tr[1])]<0):\n",
    "        a=np.abs(c[int(tr[0])]);\n",
    "        s=a/(a+np.abs(c[int(tr[1])]));\n",
    "        x=x+[p[tr[0]]*(1-s)+p[tr[1]]*s]\n",
    "    if(c[int(tr[1])]*c[int(tr[2])]<0):\n",
    "        a=np.abs(c[int(tr[1])]);\n",
    "        s=a/(a+np.abs(c[int(tr[2])]));\n",
    "        x=x+[p[tr[1]]*(1-s)+p[tr[2]]*s]\n",
    "    if(c[int(tr[2])]*c[int(tr[0])]<0):\n",
    "        a=np.abs(c[int(tr[2])]);\n",
    "        s=a/(a+np.abs(c[int(tr[0])]));\n",
    "        x=x+[p[tr[2]]*(1-s)+p[tr[0]]*s]\n",
    "    if(len(x)==2):\n",
    "       P=P+np.linalg.norm(x[0]-x[1])\n",
    "\n",
    "print \"Folding perimeter:\",P"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Folding width and depth, $W$ and $D$\n",
    "For a folded surface, the folding perimeter will increase depending on the number of folds present, but independently of their depth. In other words, two surfaces with the same number of folds but of different depth may have the same folding perimeter $P$. These could be distinguished, however, based on their absolute folding index $F$, which will be larger in case of the surface with more folds. Ideally, however, one would like to have direct measurements of the length, width and depth of each gyrus and sulcus. But even if the idea of folding width and sulcal depth seems straightforward, measuring it in practice is hard to do automatically and time-consuming to do manually. Even more, there are many cases where it is not clear what the width of a gyrus is. For example, how do we measure the width of the region where a gyrus branches into two gyri? Or how do we measure the depth of a sulcus within the insula? Relative to the external lateral surface or relative to the local gyral crowns? Here we will see that we can, however, combine folding perimeter and absolute folding to provide global estimations of the folding width and depth (later we will also obtain local estimations).\n",
    "\n",
    "We'll call $L$ the sum of the length of all sulci in the brain, and $W$ and $D$ their average width and depth, respectively. If $L \\gg W$, then $L$ could be approximated by $L_1=P/2$. If the folds were very shallow, we could approximate folding width by $W_1=S/L_1$. If we approximate the lissencephalic reference of our brain by a sphere, then the folding index $F$ quantifies the surface excess relative to the sphere. We can then deduct a second approximation to folding width as\n",
    "\n",
    "\\begin{equation}\n",
    "W_2=\\frac S {F L_1}.\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Folding length (1st approximation): 461.752405961\n",
      "Folding width (2nd approximation): 2.45085449199\n"
     ]
    }
   ],
   "source": [
    "L1=P/2.0;\n",
    "W2=S/(F*L1);\n",
    "print \"Folding length (1st approximation):\",L1\n",
    "print \"Folding width (2nd approximation):\",W2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, we can decomposed the cross-section of a fold parallel to its main axis as the sum of its width $W$ and twice its depth $D$ (which in the case of very shallow folds would be close to 0). Then\n",
    "\n",
    "\\begin{eqnarray}\n",
    "L(W+2D) &=& S,\\\\\n",
    "D &=& \\frac 1 2 \\left( \\frac S L - W \\right).\n",
    "\\end{eqnarray}\n",
    "\n",
    "If we combine both equations, we obtain a relationship between the folding index, folding width and depth, from where we can derive a first approximation to the global folding depth:\n",
    "\n",
    "\\begin{equation}\n",
    "D=\\frac{W (F-1)}2.\n",
    "\\end{equation}\n",
    "\n",
    "If the model is just folded, then $F \\rightarrow 1$, and $D \\rightarrow 0$. As the depth of folds increases, so do $F$ and $D$. All similar ratios $D_1/W_1$ will produce the same absolute folding index $F$, with $F$ directly proportional to folding depth and inversely proportional to folding width.\n",
    "\n",
    "Early during development, when folds just start to develop, their shape is relatively sinusoidal. As the brain matures and folds become deeper, opposite gyral walls tend to approach one another, gyral crowns flatten (likely because of the contact with the skull), and folds acquire a more flat, squared shape. The previous equation for $D$ supposes a fold with a squared profile, it is a lower limit for folding depth, and will especially under-estimate the depth of folds with an immature shape. An upper boundary for fold depth can be obtained by supposing a triangular profile, and then that\n",
    "\n",
    "\\begin{eqnarray}\n",
    "2L\\sqrt{\\left(\\frac W 2\\right)^2+D^2} &=& S, \\\\\n",
    "D &=& \\frac 1 4 \\sqrt{\\left(\\frac S L\\right)^2-W^2}.\n",
    "\\end{eqnarray}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'W2' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-1-d4d528cc7444>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mD\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mW2\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mF\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0;32mprint\u001b[0m \u001b[0;34m\"Folding depth:\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mD\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'W2' is not defined"
     ]
    }
   ],
   "source": [
    "D=W2*(F-1)/2\n",
    "print \"Folding depth:\",D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our estimation $L_1$ of the folding length disregarded the contribution of folding width to the folding perimeter. If there were n folds of average width $W$ and folding length $L$ then\n",
    "\n",
    "\\begin{equation}\n",
    "P=2L_1=2(L+nW).\n",
    "\\end{equation}\n",
    "\n",
    "A better approximation of folding length would be\n",
    "\n",
    "\\begin{equation}\n",
    "L_2=\\frac {P-2nW} 2.\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Folding length (2nd approximation): 437.243861041\n"
     ]
    }
   ],
   "source": [
    "L2=(P-2*10*W2)/2\n",
    "print \"Folding length (2nd approximation):\",L2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The more folding is \"spotty\" (increasing number of disconnected folds), the more $L_1 \\gt L$. In the extreme case where the width and length of folds is the same, $L_1=2 L$, and $W_1=W/2$. Then, an index of \"spottiness\" could be $Sp=\\log_2(W/W_1)$, with $S_p=0$ if the is a single fold, and $S_p=1$ if there are many spots. As far as folds are only branches of other folds, the $L \\gg W$ approximation holds. So, if we count the number of different folds (connected regions with negative/positive curvature), a 2nd approximation of $W$, $W_2$, could be\n",
    "\n",
    "\\begin{equation}\n",
    "W_2=\\frac S {F (L-n W_1)}.\n",
    "\\end{equation}\n",
    "\n",
    "Finally, if we measure the area $A$ and perimeter $p$ of a fold ($P=\\sum^n p$), then we can approximate the width $a$ and length $b$ by\n",
    "\n",
    "\\begin{equation}\n",
    "b=\\frac p 4 (1+ \\sqrt{1-A (4/p)^2}),\n",
    "\\end{equation}\n",
    "\n",
    "and\n",
    "\n",
    "\\begin{equation}\n",
    "a=(p/2)-b.\n",
    "\\end{equation}\n",
    "\n",
    "In the extreme case were folds are completely spotty, then $a~b$, and $A=(p/4)^2$. So if we define\n",
    "\n",
    "\\begin{equation}\n",
    "b=(p/4) g,\n",
    "\\end{equation}\n",
    "\n",
    "then\n",
    "\n",
    "\\begin{equation}\n",
    "g=1+\\sqrt{1-A (4/p)^2},\n",
    "\\end{equation}\n",
    "\n",
    "is an index of how longilineal a fold is."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[in a folded surface, the surface area of the fold will mix sulcal depth and width. It should be possible to flatten the fold, probably computing the minimal surface delimited by the folding curve, or just correct the fold area using the folding index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "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.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}