Plotly-Mesh3d.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotly Alpha Shapes as Mesh3d instances ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Starting with a finite set of 3D points, Plotly can generate a [`Mesh3d`](https://plot.ly/python/reference/#mesh3d)  object, that  depending on a key value can be the convex hull of that set, its Delaunay triangulation or an alpha set. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook is devoted to the presentation of the  alpha shape as a computational geometric object, its interpretation, and visualization with Plotly.\n",
    "\n",
    "Alpha shape of a finite point set $S$ is a [polytope](https://en.wikipedia.org/wiki/Polytope) whose structure depends only on the set $S$ and a parameter $\\alpha$.\n",
    "\n",
    "Although it is less known in comparison to other computational geometric objects,  it has been used in many  practical applications in pattern recognition, surface reconstruction, molecular structure modeling, porous media, astrophysics."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "In order to understand how the algorithm underlying `Mesh3d` works,  we present shortly a few notions of Computational Geometry."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Simplicial complexes and Delaunay triangulation ###"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let S be a finite set of 2D or 3D points. A point is called $0$-simplex or vertex. The [convex hull](https://en.wikipedia.org/wiki/Convex_hull) of:\n",
    " - two distinct points is  a 1-simplex or edge;\n",
    " - three non-colinear points is a 2-simplex or triangle;\n",
    " - four non-coplanar points in $\\mathbb{R}^3$  is a 3-simplex or tetrahedron;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"800\"\n",
       "            height=\"350\"\n",
       "            src=\"https://plot.ly/~empet/13475/\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x1e8e6686b70>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import IFrame\n",
    "IFrame('https://plot.ly/~empet/13475/',  width=800, height=350)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If $T$ is the set of points defining a $k$-simplex, then any proper subset of $T$ defines an $\\ell$-simplex, $\\ell<k$.\n",
    "These $\\ell$-simplexes (or $\\ell$-simplices) are called faces. \n",
    "\n",
    "A 2-simplex has three $1$-simplexes, and three 0-simplexes as faces, whereas a tetrahedron has as faces three  2-simplexes, six 1-simplexes and four zero simplexes. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "k-simplexes are building blocks for different structures in Computational Geometry, mainly for creating meshes from point clouds."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let $S$ be a finite set in $\\mathbb{R}^d$, $d=2,3$ (i.e. a set of 2D or 3D points). A collection  $\\mathcal{K}$ of k-simplexes, $0\\leq k\\leq d$,  having as vertices  the  points of $S$,\n",
    " is a *simplicial complex* if its simplexes have the following properties:\n",
    "  1. If $\\sigma$ is a simplex in $\\mathcal{K}$, then all its faces are also simplexes in $\\mathcal{K}$;\n",
    "  2. If $\\sigma, \\tau$ are two simplexes in $\\mathcal{K}$, then their intersection is either empty or a face in both simplexes.\n",
    "                                      "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next figure illustrates a simplicial complex(left), and a collection of $k$-simplexes (right), $0\\leq k\\leq 2$\n",
    "that do not form a simplicial complex because the condition 2 in the definition above is violated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"600\"\n",
       "            height=\"475\"\n",
       "            src=\"https://plot.ly/~empet/13503/\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x1e8e66b12b0>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IFrame('https://plot.ly/~empet/13503/',  width=600, height=475)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Triangular meshes used in computer graphics are examples of simplicial complexes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The underlying space of a simplicial complex, $\\mathcal{K}$, denoted $|\\mathcal{K}|$,\n",
    "is the union of its simplexes, i.e. it is a region in plane or in the 3D space, depending on whether d=2 or 3.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A *subcomplex* of the simplicial complex $\\mathcal{K}$ is a collection, $\\mathcal{L}$, of simplexes in $\\mathcal{K}$ that also form a simplicial complex."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The points of a finite set $S$ in $\\mathbb{R}^2$ (respectively $\\mathbb{R}^3$) are in *general position* if no $3$ (resp 4)  points are collinear (coplanar), and no 4 (resp 5) points lie on the same circle (sphere)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A particular simplicial complex associated to a finite set of 2D or 3D points,  in general position, is the *Delaunay triangulation*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A triangulation of a finite point set $S \\subset \\mathbb{R}^2$ (or $\\mathbb{R}^3$)\n",
    "is a collection $\\mathcal{T}$ of triangles (tetrahedra),\n",
    "such that:\n",
    "  1. The union of all triangles (tetrahedra) in $\\mathcal{T}$ is the convex hull of $S$.\n",
    "  2. The union of all  vertices of triangles (tetrahedra) in  $\\mathcal{T}$ is the set  $S$.\n",
    "  3. For every distinct pair $\\sigma, \\tau \\in \\mathcal{T}$, the intersection $\\sigma \\cap \\tau$ is either empty or  a common  face  of $\\sigma$ and $\\tau$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A Delaunay triangulation of the set $S\\subset\\mathbb{R}^2$ ($\\mathbb{R}^3$) is a triangulation with the property\n",
    "that  the open balls bounded by the  circumcircles (circumspheres) of the triangulation\n",
    " triangles (tetrahedra) contain no point in $S$. One says that these balls are empty."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the points of $S$ are in general position, then the Delaunay triangulation of $S$ is unique."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is an example of Delaunay triangulation of a set of ten 2D points. It illustrates the emptiness of two balls bounded by circumcircles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"550\"\n",
       "            height=\"550\"\n",
       "            src=\"https://plot.ly/~empet/13497/\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x1e8e66b1278>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IFrame('https://plot.ly/~empet/13497/',  width=550, height=550)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Alpha shape of a finite set of points ###"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " The notion of Alpha Shape was introduced by [Edelsbrunner](https://users.cs.duke.edu/~edels/Papers/1983-J-06-ShapeSetPoints.pdf) with the aim to give  a mathematical description of the  shape of  a point set.\n",
    " In this notebook we give a constructive definition of this geometric structure. A more detailed approach of 3D alpha shapes can be found in the original [paper](https://users.cs.duke.edu/~edels/Papers/1994-J-04-3DAlphaShapes.pdf). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An intuitive description of the alpha shape was given by Edelsbrunner and his coauthor \n",
    "in  a preprint of the last paper mentioned above:  \n",
    "    \n",
    "A huge mass of ice-cream fills a region in the 3D space,\n",
    "and the point set $S$ consists in hard chocolate pieces spread in the ice-cream mass.\n",
    "Using a sphere-formed ice-cream spoon we carve out the ice-cream such that to avoid  bumping into\n",
    "chocolate pieces.  At the end of this operation the region  containing the ciocolate pieces\n",
    "and the remaining ice cream is bounded by caps, arcs and points of chocolate. Straightening\n",
    "all round faces to triangles and line segments we get the intuitive image of the\n",
    "alpha shape of the point set $S$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we give the steps of the computational alpha shape construction."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let  $S$ be a finite set of points from $\\mathbb{R}^d$, in general position,  $\\mathcal{D}$ its Delaunay triangulation\n",
    "and $\\alpha$ a positive number.\n",
    "\n",
    "Select the d-simplexes of $\\mathcal{D}$ (i.e.  triangles in the case d=2, respectively  tetrahedra\n",
    "for d=3) whose circumsphere has the radius less than $\\alpha$. These simplexes and their faces form\n",
    "a simplicial subcomplex of the Delaunay triangulation, $\\mathcal{D}$.\n",
    "It is denoted $\\mathcal{C}_\\alpha$, and called  $\\alpha$-complex. \n",
    "\n",
    "The $\\alpha$-shape of the set $S$ is defined by its authors, either as the underlying space of the $\\alpha$-complex,\n",
    "i.e. the union of all its simplexes or as the boundary of the $\\alpha$-complex.\n",
    "\n",
    "The boundary of the $\\alpha$-complex is the subcomplex consisting in all k-simplexes,  $0\\leq k<d$, that are faces of a single $d$-simplex (these are called external faces).\n",
    "\n",
    "\n",
    "\n",
    "In the ice-cream example the alpha shape was defined as the boundary of the alpha-complex.\n",
    "\n",
    "The underlying space of the $\\alpha$-complex is the region where the ice-cream spoon has no access, because its  radius ($\\alpha$) exceeds the radius of circumscribed spheres to tetrahedra formed by  pieces of chocolate.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get insight into the process of construction of an alpha shape we illustrate it first  for a set of 2D points.\n",
    "\n",
    "The following panel displays the  Delaunay triangulation of a set of 2D points, and a sequence of $\\alpha$-complexes (and alpha shapes):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"825\"\n",
       "            height=\"950\"\n",
       "            src=\"https://plot.ly/~empet/13479/\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x1e8e66b1588>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IFrame('https://plot.ly/~empet/13479/',  width=825, height=950)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We notice that the Delaunay triangulation has as boundary a convex set (it is a triangulation of the convex hull\n",
    "                                                                        of the given point set)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each $\\alpha$-complex is obtained from the Delaunay triangulation, removing  the triangles whose circumcircle has radius greater or equal to alpha. \n",
    "\n",
    "In the last subplot the triangles of the  $0.115$-complex are filled in with light blue. The filled in region  is the underlying space of the $0.115$-complex. \n",
    "\n",
    "The $0.115$-alpha shape of the given point set can be considered either the filled in region or its boundary.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This example illustrates that the underlying space of an  $\\alpha$-complex in neither convex nor necessarily connected. It can consist in many connected components (in our illustration above, $|\\mathcal{C}_{0.115}|$ has three components)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In a family of alpha shapes, the parameter $\\alpha$ controls the level of detail of the associated alpha shape.  If $\\alpha$ decreases to zero, the corresponding alpha shape degenerates to the point set, $S$, while  if it tends to infinity the alpha shape tends to the convex hull of the set $S$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotly `Mesh3d` ###"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to generate the alpha shape of a given set of 3D points corresponding to a parameter $\\alpha$,\n",
    "the Delaunay triagulation or the convex hull we define an instance of the  `go.Mesh3d` class. The real value\n",
    "of the key `alphahull` points out the mesh type to be generated:\n",
    "    \n",
    "`alphahull`=$1/\\alpha$    generates the $\\alpha$-shape, -1 corresponds to the Delaunay\n",
    "triangulation and 0, to the convex hull of the point set.\n",
    "\n",
    "The other parameters in the definition of a `Mesh3d` are given [here](https://plot.ly/python/reference/#mesh3d).\n",
    "\n",
    "`Mesh3d` generates and displays an $\\alpha$-shape as the boundary of the $\\alpha$-complex."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An intuitive idea on the topological structure modification, as $\\alpha=1/$`alphahull` varies can be gained from the following three different alpha shapes of the same point set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"900\"\n",
       "            height=\"950\"\n",
       "            src=\"https://plot.ly/~empet/13481/\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x1e8e66b1470>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IFrame('https://plot.ly/~empet/13481/',  width=900, height=950)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We notice in the subplots above that as `alphahull` increases, i.e. $\\alpha$ decreases, some parts of the alpha shape shrink and\n",
    "develop enclosed void regions. The last plotted alpha shape points out a polytope that contains faces of tetrahedra,\n",
    "and patches of triangles.\n",
    "\n",
    "In some cases as $\\alpha$ varies it is also possible to develop  components that are strings of edges and even isolated points. \n",
    "\n",
    "Such experimental results suggested the use of alpha shapes in modeling molecular structure.\n",
    "A search on WEB gives many results related to applications of alpha shapes in structural molecular biology.\n",
    "\n",
    "[Here](https://plot.ly/~empet/13485/molecular-like-structure-defined-as-an-alpha-shape-alphahull1730/)\n",
    "is an alpha shape illustrating a molecular-like structure associated to a point set of 5000 points."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generating an alpha shape with `Mesh3d` ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import plotly.plotly as py\n",
    "import plotly.graph_objs as go\n",
    "from plotly import tools as tls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "pts = np.loadtxt('Data/data-file.txt')\n",
    "x, y, z = zip(*pts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define two traces: one for plotting the point set and another for the alpha shape:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "points = go.Scatter3d(mode='markers',\n",
    "                      name='',\n",
    "                      x =x,\n",
    "                      y= y, \n",
    "                      z= z,\n",
    "                      marker=dict(size=2, color='#458B00'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "simplexes = go.Mesh3d(alphahull =10.0,    \n",
    "                      name = '',\n",
    "                      x =x,\n",
    "                      y= y, \n",
    "                      z= z,\n",
    "                      color='#90EE90',\n",
    "                      opacity=0.15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "axis = dict(showbackground=True, \n",
    "            backgroundcolor=\"rgb(245, 245, 245)\",\n",
    "            gridcolor=\"rgb(255, 255, 255)\",  \n",
    "            gridwidth=2,\n",
    "            zerolinecolor=\"rgb(255, 255, 255)\", \n",
    "            tickfont=dict(size=11),\n",
    "            titlefont =dict(size=12))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_style = dict(axis, range=[-2.85, 4.25], tickvals=np.linspace(-2.85, 4.25, 5)[1:].round(1))\n",
    "y_style = dict(axis, range=[-2.65, 1.32], tickvals=np.linspace(-2.65, 1.32, 4)[1:].round(1))\n",
    "z_style = dict(axis, range=[-3.67,1.4], tickvals=np.linspace(-3.67, 1.4, 5).round(1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "layout = go.Layout(title='Alpha shape of a set of 3D points. Alpha=0.1',\n",
    "                   width=500,\n",
    "                   height=500,\n",
    "                   scene=dict(xaxis=x_style, \n",
    "                              yaxis=y_style, \n",
    "                              zaxis=z_style))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = go.FigureWidget(data=[points, simplexes], layout=layout)\n",
    "#fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'https://plot.ly/~empet/13499'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fig = go.FigureWidget(data=[points, simplexes], layout=layout)\n",
    "#py.plot(fig, filename='3D-AlphaS-ex')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"550\"\n",
       "            height=\"550\"\n",
       "            src=\"https://plot.ly/~empet/13499/\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x1e8eb41fb00>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IFrame('https://plot.ly/~empet/13499/',  width=550, height=550) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Generating the alpha shape of a set  of 2D points ###"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We construct the alpha shape of a set of 2D points from the Delaunay triangulation, \n",
    "defined as a `scipy.spatial.Delaunay object`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.spatial import Delaunay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sq_norm(v): #squared norm \n",
    "    return np.linalg.norm(v)**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute the circumcenter and circumradius of a triangle (see their definitions [here](https://en.wikipedia.org/wiki/Circumscribed_circle#Circumcircle_equations)):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def circumcircle(points,simplex):\n",
    "    A = [points[simplex[k]] for k in range(3)]\n",
    "    M = [[1.0]*4]\n",
    "    M += [[sq_norm(A[k]), A[k][0], A[k][1], 1.0 ] for k in range(3)] \n",
    "    M = np.asarray(M, dtype=np.float32) \n",
    "    S = np.array([0.5*np.linalg.det(M[1:, [0,2,3]]), -0.5*np.linalg.det(M[1:, [0,1,3]])]) \n",
    "    a = np.linalg.det(M[1:, 1:]) \n",
    "    b = np.linalg.det(M[1:, [0,1,2]]) \n",
    "    return S/a,  np.sqrt(b/a + sq_norm(S)/a**2) #center=S/a, radius=np.sqrt(b/a+sq_norm(S)/a**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Filter out the Delaunay triangulation to get the $\\alpha$-complex:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_alpha_complex(alpha, points, simplexes):\n",
    "    #alpha is the parameter for the alpha shape\n",
    "    #points are given data points \n",
    "    #simplexes is the  list of indices in the array of points \n",
    "    #that define 2-simplexes in the Delaunay triangulation\n",
    "    \n",
    "    return filter(lambda simplex: circumcircle(points,simplex)[1] < alpha, simplexes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "pts = np.loadtxt('Data/data-ex-2d.txt')\n",
    "tri = Delaunay(pts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "colors = ['#C0223B', '#404ca0', 'rgba(173,216,230, 0.5)']# colors for vertices, edges and 2-simplexes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get data for the Plotly plot of a subcomplex of the Delaunay triangulation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Plotly_data(points, complex_s):\n",
    "    #points are the given data points, \n",
    "    #complex_s is the list of indices in the array of points defining 2-simplexes(triangles) \n",
    "    #in the simplicial complex to be plotted\n",
    "    X = []\n",
    "    Y = []\n",
    "    for s in complex_s:\n",
    "        X += [points[s[k]][0] for k in [0,1,2,0]] + [None]\n",
    "        Y += [points[s[k]][1] for k in [0,1,2,0]] + [None]\n",
    "    return X, Y    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_trace(x, y,  point_color=colors[0], line_color=colors[1]):# define the trace\n",
    "                                                                   #for an alpha complex\n",
    "    return go.Scatter(mode='markers+lines', #vertices and \n",
    "                                            #edges of the alpha-complex\n",
    "                      name='',\n",
    "                      x=x,\n",
    "                      y=y,\n",
    "                      marker=dict(size=6.5, color=point_color),\n",
    "                      line=dict(width=1.25, color=line_color))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is the format of your plot grid:\n",
      "[ (1,1) x1,y1 ]  [ (1,2) x2,y2 ]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "figure = tls.make_subplots(rows=1, cols=2,\n",
    "                           subplot_titles=('Delaunay triangulation',  'Alpha shape, alpha=0.15'),\n",
    "                           horizontal_spacing=0.1, \n",
    "                          )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "title = 'Delaunay triangulation and Alpha Complex/Shape for a Set of 2D Points'\n",
    "\n",
    "figure.layout.update(title=title,                                 \n",
    "                     font=dict(family=\"Open Sans, sans-serif\"),\n",
    "                     showlegend=False,     \n",
    "                     hovermode='closest',  \n",
    "                     autosize=False,       \n",
    "                     width=800,       \n",
    "                     height=460,\n",
    "                     margin=dict(l=65,\n",
    "                                 r=65,\n",
    "                                 b=85,\n",
    "                                 t=120));   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "axis_style = dict(showline=True, \n",
    "                  mirror=True,\n",
    "                  zeroline=False,\n",
    "                  showgrid=False,\n",
    "                  showticklabels=True,\n",
    "                  range=[-0.1,1.1],\n",
    "                  tickvals=[0, 0.2, 0.4, 0.6, 0.8, 1.0],\n",
    "                  ticklen=5\n",
    "                 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "for s in range(1,3):   \n",
    "    figure.layout.update({'xaxis{}'.format(s): axis_style})\n",
    "    figure.layout.update({'yaxis{}'.format(s): axis_style})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "alpha_complex = list(get_alpha_complex(0.15, pts, tri.simplices))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "X, Y = Plotly_data(pts, tri.simplices)# get data for Delaunay triangulation\n",
    "figure.append_trace(make_trace(X, Y), 1, 1) \n",
    "\n",
    "X, Y = Plotly_data(pts, alpha_complex)# data for alpha complex\n",
    "figure.append_trace(make_trace(X, Y), 1, 2) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "shapes = []\n",
    "for s in alpha_complex: #fill in the triangles of the alpha complex\n",
    "    A = pts[s[0]]\n",
    "    B = pts[s[1]]\n",
    "    C = pts[s[2]]\n",
    "    shapes.append(dict(path=f'M {A[0]}, {A[1]} L {B[0]}, {B[1]} L {C[0]}, {C[1]} Z',\n",
    "                       fillcolor='rgba(173, 216, 230, 0.5)',\n",
    "                       line=dict(color=colors[1], width=1.25),\n",
    "                       xref='x2',\n",
    "                       yref='y2'\n",
    "                       ))\n",
    "figure.layout.shapes=shapes                                     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'https://plot.ly/~empet/13501'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "py.plot(figure, filename='2D-AlphaS-ex', width=850)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"800\"\n",
       "            height=\"460\"\n",
       "            src=\"https://plot.ly/~empet/13501\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x1e8ec700390>"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IFrame('https://plot.ly/~empet/13501',  width=800, height=460) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}