Plotly-Slice-in-volumetric-data.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Slice in volumetric data, via Plotly ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A volume included in a parallelepiped is described by the values of  a scalar field, $f(x,y,z)$, with $x\\in[a,b]$, $y\\in [c,d]$, $z\\in[e,f]$.\n",
    "A slice in this volume is visualized by coloring the surface of the slice, according to the values of the function f, restricted to that surface.\n",
    "\n",
    "In order to plot a planar or a nonlinear slice of equation z=s(x,y) one proceeds as follows:\n",
    "\n",
    "- define a meshgrid in x,y;\n",
    "- evaluate z=s(x,y)\n",
    "- define an instance of the Plotly Surface class, that represents the surface z=s(x,y)\n",
    "- this surface is colored according to the values,  f(x,y,z), at its points. More precisely, the normalized values of the function f  are mapped to a colormap/colorscale."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With obvious modications we get slices of equation $x=s(y,z), y=s(z,x)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import plotly.plotly as py\n",
    "from plotly.graph_objs import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "py.sign_in('empet', 'my_api_key')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we are working with the following colorscale:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "pl_BrBG=[[0.0, 'rgb(84, 48, 5)'],\n",
    "         [0.1, 'rgb(138, 80, 9)'],\n",
    "         [0.2, 'rgb(191, 129, 45)'],\n",
    "         [0.3, 'rgb(222, 192, 123)'],\n",
    "         [0.4, 'rgb(246, 232, 195)'],\n",
    "         [0.5, 'rgb(244, 244, 244)'],\n",
    "         [0.6, 'rgb(199, 234, 229)'],\n",
    "         [0.7, 'rgb(126, 203, 192)'],\n",
    "         [0.8, 'rgb(53, 151, 143)'],\n",
    "         [0.9, 'rgb(0, 101, 93)'],\n",
    "         [1.0, 'rgb(0, 60, 48)']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a function that returns a slice as a Plotly Surface:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def get_the_slice(x,y,z, surfacecolor,  colorscale=pl_BrBG, showscale=False):\n",
    "    return Surface(x=x,# https://plot.ly/python/reference/#surface\n",
    "                   y=y,\n",
    "                   z=z,\n",
    "                   surfacecolor=surfacecolor,\n",
    "                   colorscale=colorscale,\n",
    "                   showscale=showscale)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def get_lims_colors(surfacecolor):# color limits for a slice\n",
    "    return np.min(surfacecolor), np.max(surfacecolor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us plot the slices z=0 and y=-0.5 in the volume defined by:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "volume=lambda x,y,z: x*np.exp(-x**2-y**2-z**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=np.linspace(-2,2, 50)\n",
    "y=np.linspace(-2,2, 50)\n",
    "x,y=np.meshgrid(x,y)\n",
    "z=np.zeros(x.shape)\n",
    "surfcolor_z=volume(x,y,z)\n",
    "sminz, smaxz=get_lims_colors(surfcolor_z)\n",
    "\n",
    "slice_z=get_the_slice(x,y,z, surfcolor_z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=np.linspace(-2,2, 50)\n",
    "z=np.linspace(-2,2, 50)\n",
    "x,z=np.meshgrid(x,y)\n",
    "y=-0.5*np.ones(x.shape)\n",
    "surfcolor_y=volume(x,y,z)\n",
    "sminy, smaxy=get_lims_colors(surfcolor_y)\n",
    "vmin=min([sminz, sminy])\n",
    "vmax=max([smaxz, smaxy])\n",
    "slice_y=get_the_slice(x,y,z, surfcolor_y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to be able to compare  the two slices, we choose a unique interval of values to be mapped to the colorscale:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "slice_z.update(cmin=vmin, cmax=vmax)\n",
    "slice_y.update(cmin=vmin, cmax=vmax, showscale=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "axis = dict(showbackground=True, \n",
    "            backgroundcolor=\"rgb(230, 230,230)\",\n",
    "            gridcolor=\"rgb(255, 255, 255)\",      \n",
    "            zerolinecolor=\"rgb(255, 255, 255)\",  \n",
    "            )\n",
    "\n",
    "\n",
    "layout = Layout(\n",
    "         title='Slices in volumetric data', \n",
    "         width=700,\n",
    "         height=700,\n",
    "         scene=Scene(xaxis=XAxis(axis),\n",
    "                     yaxis=YAxis(axis), \n",
    "                     zaxis=ZAxis(axis, range=[-2,2]), \n",
    "                     aspectratio=dict(x=1,\n",
    "                                      y=1, \n",
    "                                      z=1\n",
    "                                     ),\n",
    "                    )\n",
    "        )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig=Figure(data=Data([slice_z,slice_y]), layout=layout)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<iframe id=\"igraph\" scrolling=\"no\" style=\"border:none;\" seamless=\"seamless\" src=\"https://plot.ly/~empet/13862.embed\" height=\"700px\" width=\"700px\"></iframe>"
      ],
      "text/plain": [
       "<plotly.tools.PlotlyDisplay object>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "py.iplot(fig, filename='Slice-volumetric-1')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Oblique slice in volumetric data ###"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As an example we plot comparatively two slices: a slice through $z=0$ and an oblique planar slice, that is defined by rotating the plane z=0 by $\\alpha=\\pi/5$, about Oy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Rotating the plane $z=c$ about Oy (from Oz towards Ox) with $\\alpha$ radians we get the plane of equation\n",
    "$z=c/\\cos(\\alpha)-x\\tan(\\alpha)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "alpha=np.pi/5\n",
    "x=np.linspace(-2,2, 50)\n",
    "y=np.linspace(-2,2, 50)\n",
    "x,y=np.meshgrid(x,y)\n",
    "z=-x*np.tan(alpha)\n",
    "\n",
    "surfcolor_obl=volume(x,y,z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "smino, smaxo=get_lims_colors(surfcolor_obl)\n",
    "vmin=min([sminz, smino])\n",
    "vmax=max([smaxz, smaxo])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "slice_obl=get_the_slice(x,y,z, surfcolor_obl)\n",
    "slice_obl.update( cmin=vmin, cmax=vmax, showscale=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "slice_z.update( cmin=vmin,\n",
    "                cmax=vmax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<iframe id=\"igraph\" scrolling=\"no\" style=\"border:none;\" seamless=\"seamless\" src=\"https://plot.ly/~empet/13864.embed\" height=\"700px\" width=\"700px\"></iframe>"
      ],
      "text/plain": [
       "<plotly.tools.PlotlyDisplay object>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fig=Figure(data=Data([slice_z, slice_obl]), layout=layout)\n",
    "py.iplot(fig, filename='Slice-volumetric-2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Nonlinear slices in volumetric data ###"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the same volume as above we define two parabolic slices and a planar one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=np.linspace(-2,2, 50)\n",
    "y=np.linspace(-2,2, 50)\n",
    "x,y=np.meshgrid(x,y)\n",
    "z=-1.0*np.ones(x.shape)\n",
    "surfcolor_zm1=volume(x,y,z)\n",
    "slice_zm1=get_the_slice(x,y,z, surfcolor_zm1)\n",
    "smin1, smax1=get_lims_colors(surfcolor_zm1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<iframe id=\"igraph\" scrolling=\"no\" style=\"border:none;\" seamless=\"seamless\" src=\"https://plot.ly/~empet/14225.embed\" height=\"700px\" width=\"700px\"></iframe>"
      ],
      "text/plain": [
       "<plotly.tools.PlotlyDisplay object>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z=-0.98+x**2+y**2\n",
    "surfcolor_parab1=volume(x,y,z)\n",
    "sminp1, smaxp1=get_lims_colors(surfcolor_parab1)\n",
    "slice_parab1=get_the_slice(x,y,z, surfcolor_parab1)\n",
    "\n",
    "z=0.75+x**2+y**2\n",
    "surfcolor_parab2=volume(x,y,z)\n",
    "sminp2, smaxp2=get_lims_colors(surfcolor_parab2)\n",
    "slice_parab2=get_the_slice(x,y,z, surfcolor_parab2)\n",
    "\n",
    "vmin=min([smin1, sminp1, sminp2])\n",
    "vmax=max([smax1, smaxp1, smaxp2])\n",
    "slice_zm1.update(cmin=vmin, cmax=vmax)\n",
    "slice_parab1.update(cmin=vmin, cmax=vmax)\n",
    "slice_parab2.update(cmin=vmin, cmax=vmax, showscale=True)\n",
    "fig=dict(data=[slice_zm1, slice_parab1, slice_parab2], layout=layout)\n",
    "py.iplot(fig, filename='Nonlinear-slice')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here [http://nbviewer.jupyter.org/github/empet/Plotly-plots/blob/master/Isosurface-in-volumetric-data.ipynb](http://nbviewer.jupyter.org/github/empet/Plotly-plots/blob/master/Isosurface-in-volumetric-data.ipynb) is defined  an isosurface in the same volumetric data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       "    /*body {\n",
       "        background-color: #F5F5F5;\n",
       "    }*/\n",
       "    div.cell{\n",
       "        width: 900px;\n",
       "        margin-left: 13% !important;\n",
       "        margin-right: auto;\n",
       "    }\n",
       "    #notebook li { /* More space between bullet points */\n",
       "    margin-top:0.8em;\n",
       "    }\n",
       "\n",
       "    h1 {\n",
       "        font-family: 'Alegreya Sans', sans-serif;\n",
       "    }\n",
       "    .text_cell_render h1 {\n",
       "        font-weight: 200;\n",
       "        font-size: 40pt;\n",
       "        line-height: 100%;\n",
       "        color: rgb(8, 66, 133);\n",
       "        margin-bottom: 0em;\n",
       "        margin-top: 0em;\n",
       "        display: block;\n",
       "    }\n",
       "    h2 {\n",
       "        font-family: 'Fenix', serif;\n",
       "        text-indent:1em;\n",
       "        text-align:center;\n",
       "    }\n",
       "    .text_cell_render h2 {\n",
       "        font-weight: 200;\n",
       "        font-size: 28pt;\n",
       "        line-height: 100%;\n",
       "        color: rgb(8, 66, 133);\n",
       "        margin-bottom: 1.5em;\n",
       "        margin-top: 0.5em;\n",
       "        display: block;\n",
       "    }\n",
       "    h3 {\n",
       "        font-family: 'Fenix', serif;\n",
       "        %margin-top:12px;\n",
       "        %margin-bottom: 3px;\n",
       "    }\n",
       "    .text_cell_render h3 {\n",
       "        font-weight: 300;\n",
       "        font-size: 18pt;\n",
       "        line-height: 100%;\n",
       "        color: rgb(8, 66, 133);\n",
       "        margin-bottom: 0.5em;\n",
       "        margin-top: 2em;\n",
       "        display: block;\n",
       "    }\n",
       "    h4 {\n",
       "        font-family: 'Fenix', serif;\n",
       "    }\n",
       "    .text_cell_render h4 {\n",
       "        font-weight: 300;\n",
       "        font-size: 16pt;\n",
       "        color: rgb(8, 66, 133);\n",
       "        margin-bottom: 0.5em;\n",
       "        margin-top: 0.5em;\n",
       "        display: block;\n",
       "    }\n",
       "    h5 {\n",
       "        font-family: 'Alegreya Sans', sans-serif;\n",
       "    }\n",
       "    .text_cell_render h5 {\n",
       "        font-weight: 300;\n",
       "        font-style: normal;\n",
       "        font-size: 16pt;\n",
       "        margin-bottom: 0em;\n",
       "        margin-top: 1.5em;\n",
       "        display: block;\n",
       "        }\n",
       "    div.text_cell_render{\n",
       "        font-family: 'Alegreya Sans',Computer Modern, \"Helvetica Neue\", Arial, Helvetica, Geneva, sans-serif;\n",
       "        line-height: 145%;\n",
       "        font-size: 130%;\n",
       "        width:900px;\n",
       "        margin-left:auto;\n",
       "        margin-right:auto;\n",
       "        %text-align:justify;\n",
       "        %text-justify:inter-word;\n",
       "    }\n",
       "    \n",
       "    \n",
       "    code{\n",
       "      font-size: 78%;\n",
       "    }\n",
       "    .rendered_html code{\n",
       "        background-color: transparent;\n",
       "        white-space: inherit;   \n",
       "    }\n",
       "    .prompt{\n",
       "        display: None;\n",
       "     }\n",
       "    .rendered_html code{\n",
       "    background-color: transparent;\n",
       "    }\n",
       "\n",
       "    blockquote{\n",
       "      display:block;\n",
       "      background: #f3f3f3;\n",
       "      font-family: \"Open sans\",verdana,arial,sans-serif;\n",
       "      width:610px;\n",
       "      padding: 15px 15px 15px 15px;\n",
       "      text-align:justify;\n",
       "      text-justify:inter-word;\n",
       "      }\n",
       "      blockquote p {\n",
       "        margin-bottom: 0;\n",
       "        line-height: 125%;\n",
       "        font-size: 100%;\n",
       "      }\n",
       "   /* element.style {\n",
       "    } */\n",
       "</style>\n",
       "<script>\n",
       "    MathJax.Hub.Config({\n",
       "                        TeX: {\n",
       "                           extensions: [\"AMSmath.js\"]\n",
       "                           },\n",
       "                tex2jax: {\n",
       "                    inlineMath: [ [\"$\",\"$\"], [\"\\\\(\",\"\\\\)\"] ],\n",
       "                    displayMath: [ [\"$$\",\"$$\"], [\"\\\\[\",\"\\\\]\"] ]\n",
       "                },\n",
       "                displayAlign: \"center\", // Change this to \"center\" to center equations.\n",
       "                \"HTML-CSS\": {\n",
       "                    styles: {\".MathJax_Display\": {\"margin\": 4}}\n",
       "                }\n",
       "        });\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.display import HTML\n",
    "def  css_styling():\n",
    "    styles = open(\"./custom.css\", \"r\").read()\n",
    "    return HTML(styles)\n",
    "css_styling()"
   ]
  }
 ],
 "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}