{"cells": [{"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "slide"}}, "source": ["# 10 plotting libraries\n", "\n", "Review of plotting libraries."]}, {"cell_type": "markdown", "metadata": {}, "source": ["[Xavier Dupr\u00e9](http://www.xavierdupre.fr/)\n", "\n", "``xavier.dupre AT gmail.com``\n", "\n", "Senior Engineer at **Microsoft France** on [Azure ML](https://azure.microsoft.com/fr-fr/services/machine-learning/), **Teacher in Computer Science** at the [ENSAE](http://www.ensae.fr/)\n", "\n", "![Azure ML](logo_azureml.png) ![ENSAE](ENSAE_logo_developpe.jpg)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["**Objectives of this talk**\n", "\n", "Nobody makes plot without an existing library anymore. \n", "\n", "* How to choose a plotting library ?\n", "* List of available options\n", "* How to extend an existing library ?\n", "* How to wrap a javascript library ?"]}, {"cell_type": "code", "execution_count": 1, "metadata": {"slideshow": {"slide_type": "subslide"}}, "outputs": [{"data": {"text/html": ["<div id=\"my_id_menu_nb\">run previous cell, wait for 2 seconds</div>\n", "<script>\n", "function repeat_indent_string(n){\n", "    var a = \"\" ;\n", "    for ( ; n > 0 ; --n)\n", "        a += \"    \";\n", "    return a;\n", "}\n", "// look up into all sections and builds an automated menu //\n", "var update_menu_string = function(begin, lfirst, llast, sformat, send, keep_item, begin_format, end_format) {\n", "    var anchors = document.getElementsByClassName(\"section\");\n", "    if (anchors.length == 0) {\n", "        anchors = document.getElementsByClassName(\"text_cell_render rendered_html\");\n", "    }\n", "    var i,t;\n", "    var text_menu = begin;\n", "    var text_memo = \"<pre>\\nlength:\" + anchors.length + \"\\n\";\n", "    var ind = \"\";\n", "    var memo_level = 1;\n", "    var href;\n", "    var tags = [];\n", "    var main_item = 0;\n", "    var format_open = 0;\n", "    for (i = 0; i <= llast; i++)\n", "        tags.push(\"h\" + i);\n", "\n", "    for (i = 0; i < anchors.length; i++) {\n", "        text_memo += \"**\" + anchors[i].id + \"--\\n\";\n", "\n", "        var child = null;\n", "        for(t = 0; t < tags.length; t++) {\n", "            var r = anchors[i].getElementsByTagName(tags[t]);\n", "            if (r.length > 0) {\n", "child = r[0];\n", "break;\n", "            }\n", "        }\n", "        if (child == null) {\n", "            text_memo += \"null\\n\";\n", "            continue;\n", "        }\n", "        if (anchors[i].hasAttribute(\"id\")) {\n", "            // when converted in RST\n", "            href = anchors[i].id;\n", "            text_memo += \"#1-\" + href;\n", "            // passer \u00e0 child suivant (le chercher)\n", "        }\n", "        else if (child.hasAttribute(\"id\")) {\n", "            // in a notebook\n", "            href = child.id;\n", "            text_memo += \"#2-\" + href;\n", "        }\n", "        else {\n", "            text_memo += \"#3-\" + \"*\" + \"\\n\";\n", "            continue;\n", "        }\n", "        var title = child.textContent;\n", "        var level = parseInt(child.tagName.substring(1,2));\n", "\n", "        text_memo += \"--\" + level + \"?\" + lfirst + \"--\" + title + \"\\n\";\n", "\n", "        if ((level < lfirst) || (level > llast)) {\n", "            continue ;\n", "        }\n", "        if (title.endsWith('\u00b6')) {\n", "            title = title.substring(0,title.length-1).replace(\"<\", \"&lt;\")\n", "         .replace(\">\", \"&gt;\").replace(\"&\", \"&amp;\");\n", "        }\n", "        if (title.length == 0) {\n", "            continue;\n", "        }\n", "\n", "        while (level < memo_level) {\n", "            text_menu += end_format + \"</ul>\\n\";\n", "            format_open -= 1;\n", "            memo_level -= 1;\n", "        }\n", "        if (level == lfirst) {\n", "            main_item += 1;\n", "        }\n", "        if (keep_item != -1 && main_item != keep_item + 1) {\n", "            // alert(main_item + \" - \" + level + \" - \" + keep_item);\n", "            continue;\n", "        }\n", "        while (level > memo_level) {\n", "            text_menu += \"<ul>\\n\";\n", "            memo_level += 1;\n", "        }\n", "        text_menu += repeat_indent_string(level-2);\n", "        text_menu += begin_format + sformat.replace(\"__HREF__\", href).replace(\"__TITLE__\", title);\n", "        format_open += 1;\n", "    }\n", "    while (1 < memo_level) {\n", "        text_menu += end_format + \"</ul>\\n\";\n", "        memo_level -= 1;\n", "        format_open -= 1;\n", "    }\n", "    text_menu += send;\n", "    //text_menu += \"\\n\" + text_memo;\n", "\n", "    while (format_open > 0) {\n", "        text_menu += end_format;\n", "        format_open -= 1;\n", "    }\n", "    return text_menu;\n", "};\n", "var update_menu = function() {\n", "    var sbegin = \"\";\n", "    var sformat = '<a href=\"#__HREF__\">__TITLE__</a>';\n", "    var send = \"\";\n", "    var begin_format = '<li>';\n", "    var end_format = '</li>';\n", "    var keep_item = -1;\n", "    var text_menu = update_menu_string(sbegin, 2, 2, sformat, send, keep_item,\n", "       begin_format, end_format);\n", "    var menu = document.getElementById(\"my_id_menu_nb\");\n", "    menu.innerHTML=text_menu;\n", "};\n", "window.setTimeout(update_menu,2000);\n", "            </script>"], "text/plain": ["<IPython.core.display.HTML object>"]}, "execution_count": 2, "metadata": {}, "output_type": "execute_result"}], "source": ["from jyquickhelper import add_notebook_menu\n", "add_notebook_menu(last_level=2)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["**Material**\n", "\n", "* Notebooks for this talk: [http://www.xavierdupre.fr/...](http://www.xavierdupre.fr/app/jupytalk/helpsphinx/2016/pydata2016.html)\n", "* Azure ML: [Introducing Jupyter Notebooks in Azure ML Studio](https://blogs.technet.microsoft.com/machinelearning/2015/07/24/introducing-jupyter-notebooks-in-azure-ml-studio/)\n", "* Teachings at ENSAE: [Python pour un Data Scientist](http://www.xavierdupre.fr/app/ensae_teaching_cs/helpsphinx/td_2a.html)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["**Microsoft, Python and Open Source**\n", "\n", "* 2014/11: [.NET Core is Open Source](https://blogs.msdn.microsoft.com/dotnet/2014/11/12/net-core-is-open-source/)\n", "* 2015/07: [Introducing Jupyter Notebooks in Azure ML Studio](https://blogs.technet.microsoft.com/machinelearning/2015/07/24/introducing-jupyter-notebooks-in-azure-ml-studio/)\n", "* 2015/07: [Python Tools for Visual Studio](https://microsoft.github.io/PTVS/) moves to Github\n", "* 2016/02: [Creating web apps with Flask in Azure](https://azure.microsoft.com/en-us/documentation/articles/web-sites-python-create-deploy-flask-app/)\n", "* 2016/06: [Build Machine Learning applications to run on Apache Spark clusters on HDInsight Linux](https://azure.microsoft.com/en-us/documentation/articles/hdinsight-apache-spark-ipython-notebook-machine-learning/)\n", "* 2016/06: [azure-sdk-python 2.0.rc4](https://github.com/Azure/azure-sdk-for-python): Python interface to access Azure services\n", "\n", "![ptvs](img_ptvs.png)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["**Microsoft in Data Science**\n", "\n", "* [Developing the Next Wave of Data Scientists](https://blogs.technet.microsoft.com/machinelearning/2016/06/14/developing-the-next-wave-of-data-scientists/)\n", "* Microsoft is one of the sponsors of the [DataScienceGame](http://www.datasciencegame.com/sponsors)\n", "\n", "[![Microsoft - ENSAE - Hackathon](img_hack.png)](https://www.youtube.com/embed/Y1UKAbbExn8)\n", "\n"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "slide"}}, "source": ["## Elements of decision"]}, {"cell_type": "code", "execution_count": 2, "metadata": {"slideshow": {"slide_type": "fragment"}}, "outputs": [{"data": {"text/html": ["<div id=\"my_id_menu_nb0\">run previous cell, wait for 2 seconds</div>\n", "<script>\n", "function repeat_indent_string(n){\n", "    var a = \"\" ;\n", "    for ( ; n > 0 ; --n)\n", "        a += \"    \";\n", "    return a;\n", "}\n", "// look up into all sections and builds an automated menu //\n", "var update_menu_string = function(begin, lfirst, llast, sformat, send, keep_item, begin_format, end_format) {\n", "    var anchors = document.getElementsByClassName(\"section\");\n", "    if (anchors.length == 0) {\n", "        anchors = document.getElementsByClassName(\"text_cell_render rendered_html\");\n", "    }\n", "    var i,t;\n", "    var text_menu = begin;\n", "    var text_memo = \"<pre>\\nlength:\" + anchors.length + \"\\n\";\n", "    var ind = \"\";\n", "    var memo_level = 1;\n", "    var href;\n", "    var tags = [];\n", "    var main_item = 0;\n", "    var format_open = 0;\n", "    for (i = 0; i <= llast; i++)\n", "        tags.push(\"h\" + i);\n", "\n", "    for (i = 0; i < anchors.length; i++) {\n", "        text_memo += \"**\" + anchors[i].id + \"--\\n\";\n", "\n", "        var child = null;\n", "        for(t = 0; t < tags.length; t++) {\n", "            var r = anchors[i].getElementsByTagName(tags[t]);\n", "            if (r.length > 0) {\n", "child = r[0];\n", "break;\n", "            }\n", "        }\n", "        if (child == null) {\n", "            text_memo += \"null\\n\";\n", "            continue;\n", "        }\n", "        if (anchors[i].hasAttribute(\"id\")) {\n", "            // when converted in RST\n", "            href = anchors[i].id;\n", "            text_memo += \"#1-\" + href;\n", "            // passer \u00e0 child suivant (le chercher)\n", "        }\n", "        else if (child.hasAttribute(\"id\")) {\n", "            // in a notebook\n", "            href = child.id;\n", "            text_memo += \"#2-\" + href;\n", "        }\n", "        else {\n", "            text_memo += \"#3-\" + \"*\" + \"\\n\";\n", "            continue;\n", "        }\n", "        var title = child.textContent;\n", "        var level = parseInt(child.tagName.substring(1,2));\n", "\n", "        text_memo += \"--\" + level + \"?\" + lfirst + \"--\" + title + \"\\n\";\n", "\n", "        if ((level < lfirst) || (level > llast)) {\n", "            continue ;\n", "        }\n", "        if (title.endsWith('\u00b6')) {\n", "            title = title.substring(0,title.length-1).replace(\"<\", \"&lt;\")\n", "         .replace(\">\", \"&gt;\").replace(\"&\", \"&amp;\");\n", "        }\n", "        if (title.length == 0) {\n", "            continue;\n", "        }\n", "\n", "        while (level < memo_level) {\n", "            text_menu += end_format + \"</ul>\\n\";\n", "            format_open -= 1;\n", "            memo_level -= 1;\n", "        }\n", "        if (level == lfirst) {\n", "            main_item += 1;\n", "        }\n", "        if (keep_item != -1 && main_item != keep_item + 1) {\n", "            // alert(main_item + \" - \" + level + \" - \" + keep_item);\n", "            continue;\n", "        }\n", "        while (level > memo_level) {\n", "            text_menu += \"<ul>\\n\";\n", "            memo_level += 1;\n", "        }\n", "        text_menu += repeat_indent_string(level-2);\n", "        text_menu += begin_format + sformat.replace(\"__HREF__\", href).replace(\"__TITLE__\", title);\n", "        format_open += 1;\n", "    }\n", "    while (1 < memo_level) {\n", "        text_menu += end_format + \"</ul>\\n\";\n", "        memo_level -= 1;\n", "        format_open -= 1;\n", "    }\n", "    text_menu += send;\n", "    //text_menu += \"\\n\" + text_memo;\n", "\n", "    while (format_open > 0) {\n", "        text_menu += end_format;\n", "        format_open -= 1;\n", "    }\n", "    return text_menu;\n", "};\n", "var update_menu = function() {\n", "    var sbegin = \"\";\n", "    var sformat = '<a href=\"#__HREF__\">__TITLE__</a>';\n", "    var send = \"\";\n", "    var begin_format = '<li>';\n", "    var end_format = '</li>';\n", "    var keep_item = 0;\n", "    var text_menu = update_menu_string(sbegin, 2, 4, sformat, send, keep_item,\n", "       begin_format, end_format);\n", "    var menu = document.getElementById(\"my_id_menu_nb0\");\n", "    menu.innerHTML=text_menu;\n", "};\n", "window.setTimeout(update_menu,2000);\n", "            </script>"], "text/plain": ["<IPython.core.display.HTML object>"]}, "execution_count": 3, "metadata": {}, "output_type": "execute_result"}], "source": ["add_notebook_menu(keep_item=0)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["### Graph language\n", "\n", "We like them because we read them faster."]}, {"cell_type": "code", "execution_count": 3, "metadata": {"slideshow": {"slide_type": "skip"}}, "outputs": [], "source": ["%matplotlib inline"]}, {"cell_type": "code", "execution_count": 4, "metadata": {"slideshow": {"slide_type": "subslide"}}, "outputs": [{"data": {"image/png": "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\n", "text/plain": ["<Figure size 504x504 with 1 Axes>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["from jupytalk.talk_examples.pydata2016 import example_cartopy\n", "ax = example_cartopy()\n", "ax.set_title(\"map\", size=20);"]}, {"cell_type": "code", "execution_count": 5, "metadata": {"slideshow": {"slide_type": "subslide"}}, "outputs": [{"data": {"text/plain": ["Text(0.5,1,'outlier')"]}, "execution_count": 6, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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\n", "text/plain": ["<Figure size 432x288 with 1 Axes>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["import numpy, matplotlib.pyplot as plt\n", "N = 150\n", "x, y = numpy.random.normal(0, 1, N), numpy.random.normal(0, 1, N)\n", "x[-1], y[-1] = 8, 5\n", "plt.scatter(x, y, alpha=0.5)\n", "plt.title(\"outlier\", size=20)"]}, {"cell_type": "code", "execution_count": 6, "metadata": {"slideshow": {"slide_type": "subslide"}}, "outputs": [{"data": {"text/plain": ["Text(0.5,1,'correlation')"]}, "execution_count": 7, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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\n", "text/plain": ["<Figure size 432x288 with 1 Axes>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["import numpy, matplotlib.pyplot as plt\n", "N = 150\n", "x = numpy.random.normal(0, 1, N)\n", "y = x + numpy.random.normal(0, 0.5, N) + 1\n", "plt.scatter(x, y, alpha=0.5)\n", "plt.title(\"correlation\", size=20)"]}, {"cell_type": "code", "execution_count": 7, "metadata": {"slideshow": {"slide_type": "subslide"}}, "outputs": [{"data": {"text/plain": ["Text(0.5,1,'incertainty')"]}, "execution_count": 8, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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\n", "text/plain": ["<Figure size 360x360 with 1 Axes>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["from jupytalk.talk_examples.pydata2016 import example_confidence_interval\n", "ax = example_confidence_interval()\n", "# https://github.com/sdpython/jupytalk/blob/master/src/jupytalk/talk_examples/pydata2016.py\n", "ax.set_title(\"incertainty\", size=20)"]}, {"cell_type": "code", "execution_count": 8, "metadata": {"slideshow": {"slide_type": "subslide"}}, "outputs": [{"data": {"text/plain": ["Text(0.5,1,'network')"]}, "execution_count": 9, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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\n", "text/plain": ["<Figure size 360x360 with 1 Axes>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["from jupytalk.talk_examples.pydata2016 import example_networkx\n", "ax = example_networkx()\n", "# https://github.com/sdpython/jupytalk/blob/master/src/jupytalk/talk_examples/pydata2016.py\n", "ax.set_title(\"network\", size=20)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["### Why so many?\n", "\n", "* Every domain has its own data representation (statistics, machine learning, biology, maps...)\n", "* Many supports (images, web sites, notebooks)\n", "* High volume of data requires specific solution (maps)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["### Example: seaborn\n", "\n", "[seaborn](https://web.stanford.edu/~mwaskom/software/seaborn/index.html)\n", "\n", "* collection of plots used for any new projects\n", "* See [regplot](https://web.stanford.edu/~mwaskom/software/seaborn/generated/seaborn.regplot.html#seaborn.regplot)."]}, {"cell_type": "code", "execution_count": 9, "metadata": {"slideshow": {"slide_type": "subslide"}}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["c:\\python370_x64\\lib\\site-packages\\scipy\\stats\\stats.py:1713: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n", "  return np.add.reduce(sorted[indexer] * weights, axis=axis) / sumval\n"]}, {"data": {"text/plain": ["Text(0.5,1,'regplot')"]}, "execution_count": 10, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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\n", "text/plain": ["<Figure size 432x288 with 1 Axes>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["import seaborn; seaborn.set(color_codes=True)\n", "tips = seaborn.load_dataset(\"tips\")\n", "ax = seaborn.regplot(x=\"total_bill\", y=\"tip\", data=tips)\n", "ax.set_title(\"regplot\")"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["### Why using a programming language to plot?\n", "\n", "Justification | Case\n", "--------------|-----\n", "**automate** complex graph | **update** a presentation\n", "**share** customized graph | easier to read among a team, build a common **graph language**\n", "**combine** data processing and plotting | handle **huge volume** of data\n"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["### What did Internet change?\n", "\n", "* **Remote access:** interact with the graph cheaper than drawing again\n", "* Many plotting libraries: [javascript plotting libraries](https://www.bing.com/search?q=javascript+plotting+libraries&FORM=AWRE)\n", "* [20 best JavaScript charting libraries](http://thenextweb.com/dd/2015/06/12/20-best-javascript-chart-libraries/#gref)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["### Impact of notebook on Python\n", "\n", "* **Before:** graphs libraries were **mostly static** (images)\n", "* **After:** graphs are now **interactive**\n", "* Notebook can easily leverage javascript libraries"]}, {"cell_type": "markdown", "metadata": {"collapsed": true, "slideshow": {"slide_type": "subslide"}}, "source": ["### Decisions\n", "\n", "**Decision 1: the audience?**\n", "\n", "* The plot is just for you?\n", "* The plot will be inserted in a report? In a PowerPoint presentation?\n", "* The plot will be internally shared?\n", "* The plot will be shared with customers on a website?"]}, {"cell_type": "markdown", "metadata": {"collapsed": true, "slideshow": {"slide_type": "subslide"}}, "source": ["**Decision 2: which volume of data to plot?**\n", "\n", "* How many points to draw 10.000, 1M, 1B?\n", "* How fast do you need to draw?\n", "* Do you need to preprocess the data?"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["**Decision 3: which technology?**\n", "\n", "* **static** *(image, PDF, no zoom)*\n", "    * [matplotlib](http://matplotlib.org/) based\n", "    * [reportlab](http://www.reportlab.com/) based\n", "    * [Pillow](https://pillow.readthedocs.io/en/) based\n", "* **interactive** *(zoom, move, not always great in a book)*\n", "    * javascript based\n", "    * Python and javascript based\n", "* **pure javascript** *(if you don't find what you want)*\n", "    * from a notebook\n", "    * from a web page"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["**Final check: is the library maintained?**\n", "\n", "* License: is it free only for research?\n", "* Source are available on github: is the last commit recent?\n", "* The library was mentioned in a conference.\n", "* The library is used by many others to create customized graphs?\n", "* It works on many platforms.\n", "* The documentation is great."]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "slide"}}, "source": ["## - Libraries for static plots"]}, {"cell_type": "code", "execution_count": 10, "metadata": {"slideshow": {"slide_type": "fragment"}}, "outputs": [{"data": {"text/html": ["<div id=\"my_id_menu_nb1\">run previous cell, wait for 2 seconds</div>\n", "<script>\n", "function repeat_indent_string(n){\n", "    var a = \"\" ;\n", "    for ( ; n > 0 ; --n)\n", "        a += \"    \";\n", "    return a;\n", "}\n", "// look up into all sections and builds an automated menu //\n", "var update_menu_string = function(begin, lfirst, llast, sformat, send, keep_item, begin_format, end_format) {\n", "    var anchors = document.getElementsByClassName(\"section\");\n", "    if (anchors.length == 0) {\n", "        anchors = document.getElementsByClassName(\"text_cell_render rendered_html\");\n", "    }\n", "    var i,t;\n", "    var text_menu = begin;\n", "    var text_memo = \"<pre>\\nlength:\" + anchors.length + \"\\n\";\n", "    var ind = \"\";\n", "    var memo_level = 1;\n", "    var href;\n", "    var tags = [];\n", "    var main_item = 0;\n", "    var format_open = 0;\n", "    for (i = 0; i <= llast; i++)\n", "        tags.push(\"h\" + i);\n", "\n", "    for (i = 0; i < anchors.length; i++) {\n", "        text_memo += \"**\" + anchors[i].id + \"--\\n\";\n", "\n", "        var child = null;\n", "        for(t = 0; t < tags.length; t++) {\n", "            var r = anchors[i].getElementsByTagName(tags[t]);\n", "            if (r.length > 0) {\n", "child = r[0];\n", "break;\n", "            }\n", "        }\n", "        if (child == null) {\n", "            text_memo += \"null\\n\";\n", "            continue;\n", "        }\n", "        if (anchors[i].hasAttribute(\"id\")) {\n", "            // when converted in RST\n", "            href = anchors[i].id;\n", "            text_memo += \"#1-\" + href;\n", "            // passer \u00e0 child suivant (le chercher)\n", "        }\n", "        else if (child.hasAttribute(\"id\")) {\n", "            // in a notebook\n", "            href = child.id;\n", "            text_memo += \"#2-\" + href;\n", "        }\n", "        else {\n", "            text_memo += \"#3-\" + \"*\" + \"\\n\";\n", "            continue;\n", "        }\n", "        var title = child.textContent;\n", "        var level = parseInt(child.tagName.substring(1,2));\n", "\n", "        text_memo += \"--\" + level + \"?\" + lfirst + \"--\" + title + \"\\n\";\n", "\n", "        if ((level < lfirst) || (level > llast)) {\n", "            continue ;\n", "        }\n", "        if (title.endsWith('\u00b6')) {\n", "            title = title.substring(0,title.length-1).replace(\"<\", \"&lt;\")\n", "         .replace(\">\", \"&gt;\").replace(\"&\", \"&amp;\");\n", "        }\n", "        if (title.length == 0) {\n", "            continue;\n", "        }\n", "\n", "        while (level < memo_level) {\n", "            text_menu += end_format + \"</ul>\\n\";\n", "            format_open -= 1;\n", "            memo_level -= 1;\n", "        }\n", "        if (level == lfirst) {\n", "            main_item += 1;\n", "        }\n", "        if (keep_item != -1 && main_item != keep_item + 1) {\n", "            // alert(main_item + \" - \" + level + \" - \" + keep_item);\n", "            continue;\n", "        }\n", "        while (level > memo_level) {\n", "            text_menu += \"<ul>\\n\";\n", "            memo_level += 1;\n", "        }\n", "        text_menu += repeat_indent_string(level-2);\n", "        text_menu += begin_format + sformat.replace(\"__HREF__\", href).replace(\"__TITLE__\", title);\n", "        format_open += 1;\n", "    }\n", "    while (1 < memo_level) {\n", "        text_menu += end_format + \"</ul>\\n\";\n", "        memo_level -= 1;\n", "        format_open -= 1;\n", "    }\n", "    text_menu += send;\n", "    //text_menu += \"\\n\" + text_memo;\n", "\n", "    while (format_open > 0) {\n", "        text_menu += end_format;\n", "        format_open -= 1;\n", "    }\n", "    return text_menu;\n", "};\n", "var update_menu = function() {\n", "    var sbegin = \"\";\n", "    var sformat = '<a href=\"#__HREF__\">__TITLE__</a>';\n", "    var send = \"\";\n", "    var begin_format = '<li>';\n", "    var end_format = '</li>';\n", "    var keep_item = 1;\n", "    var text_menu = update_menu_string(sbegin, 2, 4, sformat, send, keep_item,\n", "       begin_format, end_format);\n", "    var menu = document.getElementById(\"my_id_menu_nb1\");\n", "    menu.innerHTML=text_menu;\n", "};\n", "window.setTimeout(update_menu,2000);\n", "            </script>"], "text/plain": ["<IPython.core.display.HTML object>"]}, "execution_count": 11, "metadata": {}, "output_type": "execute_result"}], "source": ["add_notebook_menu(keep_item=1)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["### Static never fails\n", "\n", "* Images works anywhere\n", "* Images are self contained\n", "* Easy to combine\n", "\n", "![combine](img_combine.png)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["### Five steps to plot\n", "\n", "1. Create a **figure**: pixel system.\n", "2. Create **Axis**: coordinate system.\n", "3. Draw **inside** the plotting area\n", "4. Add element **outside** the plotting area\n", "5. **Render** the image.\n", "\n", "![step5](img_step5.png)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["#### matplotlib for all\n", "\n", "[matplotlib](http://matplotlib.org/): the standard"]}, {"cell_type": "code", "execution_count": 11, "metadata": {"slideshow": {"slide_type": "fragment"}}, "outputs": [{"data": {"image/png": "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\n", "text/plain": ["<Figure size 432x288 with 1 Axes>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["import numpy as np, matplotlib.pyplot as plt\n", "N = 50\n", "x, y, colors = np.random.rand(N), np.random.rand(N), np.random.rand(N)\n", "area = np.pi * (15 * np.random.rand(N))**2\n", "fig, ax = plt.subplots()                       # steps 1, 2\n", "ax.scatter(x, y, s=area, c=colors, alpha=0.5)  # step 3\n", "ax.set_title(\"scatter plot\")                   # step 4\n", "fig.savefig(\"example_scatterplot.png\")         # step 5"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["#### networkx for networks\n", "\n", "[networkx](https://networkx.github.io/documentation/networkx-1.9.1/index.html)\n", "\n", "![networkx](img_networkx.png)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["#### seaborn for statistics\n", "\n", "[seaborn](https://web.stanford.edu/~mwaskom/software/seaborn/)\n", "\n", "![seaborn](img_seaborn.png)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["#### basemap for maps\n", "\n", "[basemap](http://matplotlib.org/basemap/) | .\n", "------------------------------------------|--\n", "![basemap](img_basemap.png) | ![basemap2](img_basemap2.png)\n", "\n", "See also [cartopy](https://github.com/SciTools/cartopy)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["#### ete3 for trees\n", "\n", "[ete3](http://etetoolkit.org/)\n", "\n", "![ete3](img_ete3.png)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["#### reportlab for pdf\n", "\n", "[reportlab](http://www.reportlab.com/): standard for PDF\n", "\n", "![reprotlab](img_reportlab.png)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["#### plotnine for the syntax\n", "\n", "[plotnine](https://github.com/has2k1/plotnine)\n", "\n", "![plotnine](img_ggplot_code.png)\n", "\n", "![plotnine](img_ggplot.png)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["#### missingno for the missing values\n", "\n", "[missingno](https://github.com/ResidentMario/missingno)\n", "\n", "![missingno](img_missingno.png)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["#### biopython for genes\n", "\n", "[biopython](http://biopython.org/wiki/Biopython)\n", "\n", "![biopyhon](img_biopython.png)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["#### lifelines for survival analysis\n", "\n", "[lifelines](http://lifelines.readthedocs.io/en/latest/Survival%20Analysis%20intro.html)\n", "\n", "![lifelines](img_lifelines.png)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["### In short\n", "\n", "* Many libraries available in many domains.\n", "* Many scripts available (github, stackoverflow)\n", "* Look for the gallery.\n", "* Pick the closest graph to your needs\n", "* Tweak"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "slide"}}, "source": ["## - Libraries for interactivity"]}, {"cell_type": "code", "execution_count": 12, "metadata": {"slideshow": {"slide_type": "fragment"}}, "outputs": [{"data": {"text/html": ["<div id=\"my_id_menu_nb2\">run previous cell, wait for 2 seconds</div>\n", "<script>\n", "function repeat_indent_string(n){\n", "    var a = \"\" ;\n", "    for ( ; n > 0 ; --n)\n", "        a += \"    \";\n", "    return a;\n", "}\n", "// look up into all sections and builds an automated menu //\n", "var update_menu_string = function(begin, lfirst, llast, sformat, send, keep_item, begin_format, end_format) {\n", "    var anchors = document.getElementsByClassName(\"section\");\n", "    if (anchors.length == 0) {\n", "        anchors = document.getElementsByClassName(\"text_cell_render rendered_html\");\n", "    }\n", "    var i,t;\n", "    var text_menu = begin;\n", "    var text_memo = \"<pre>\\nlength:\" + anchors.length + \"\\n\";\n", "    var ind = \"\";\n", "    var memo_level = 1;\n", "    var href;\n", "    var tags = [];\n", "    var main_item = 0;\n", "    var format_open = 0;\n", "    for (i = 0; i <= llast; i++)\n", "        tags.push(\"h\" + i);\n", "\n", "    for (i = 0; i < anchors.length; i++) {\n", "        text_memo += \"**\" + anchors[i].id + \"--\\n\";\n", "\n", "        var child = null;\n", "        for(t = 0; t < tags.length; t++) {\n", "            var r = anchors[i].getElementsByTagName(tags[t]);\n", "            if (r.length > 0) {\n", "child = r[0];\n", "break;\n", "            }\n", "        }\n", "        if (child == null) {\n", "            text_memo += \"null\\n\";\n", "            continue;\n", "        }\n", "        if (anchors[i].hasAttribute(\"id\")) {\n", "            // when converted in RST\n", "            href = anchors[i].id;\n", "            text_memo += \"#1-\" + href;\n", "            // passer \u00e0 child suivant (le chercher)\n", "        }\n", "        else if (child.hasAttribute(\"id\")) {\n", "            // in a notebook\n", "            href = child.id;\n", "            text_memo += \"#2-\" + href;\n", "        }\n", "        else {\n", "            text_memo += \"#3-\" + \"*\" + \"\\n\";\n", "            continue;\n", "        }\n", "        var title = child.textContent;\n", "        var level = parseInt(child.tagName.substring(1,2));\n", "\n", "        text_memo += \"--\" + level + \"?\" + lfirst + \"--\" + title + \"\\n\";\n", "\n", "        if ((level < lfirst) || (level > llast)) {\n", "            continue ;\n", "        }\n", "        if (title.endsWith('\u00b6')) {\n", "            title = title.substring(0,title.length-1).replace(\"<\", \"&lt;\")\n", "         .replace(\">\", \"&gt;\").replace(\"&\", \"&amp;\");\n", "        }\n", "        if (title.length == 0) {\n", "            continue;\n", "        }\n", "\n", "        while (level < memo_level) {\n", "            text_menu += end_format + \"</ul>\\n\";\n", "            format_open -= 1;\n", "            memo_level -= 1;\n", "        }\n", "        if (level == lfirst) {\n", "            main_item += 1;\n", "        }\n", "        if (keep_item != -1 && main_item != keep_item + 1) {\n", "            // alert(main_item + \" - \" + level + \" - \" + keep_item);\n", "            continue;\n", "        }\n", "        while (level > memo_level) {\n", "            text_menu += \"<ul>\\n\";\n", "            memo_level += 1;\n", "        }\n", "        text_menu += repeat_indent_string(level-2);\n", "        text_menu += begin_format + sformat.replace(\"__HREF__\", href).replace(\"__TITLE__\", title);\n", "        format_open += 1;\n", "    }\n", "    while (1 < memo_level) {\n", "        text_menu += end_format + \"</ul>\\n\";\n", "        memo_level -= 1;\n", "        format_open -= 1;\n", "    }\n", "    text_menu += send;\n", "    //text_menu += \"\\n\" + text_memo;\n", "\n", "    while (format_open > 0) {\n", "        text_menu += end_format;\n", "        format_open -= 1;\n", "    }\n", "    return text_menu;\n", "};\n", "var update_menu = function() {\n", "    var sbegin = \"\";\n", "    var sformat = '<a href=\"#__HREF__\">__TITLE__</a>';\n", "    var send = \"\";\n", "    var begin_format = '<li>';\n", "    var end_format = '</li>';\n", "    var keep_item = 2;\n", "    var text_menu = update_menu_string(sbegin, 2, 4, sformat, send, keep_item,\n", "       begin_format, end_format);\n", "    var menu = document.getElementById(\"my_id_menu_nb2\");\n", "    menu.innerHTML=text_menu;\n", "};\n", "window.setTimeout(update_menu,2000);\n", "            </script>"], "text/plain": ["<IPython.core.display.HTML object>"]}, "execution_count": 13, "metadata": {}, "output_type": "execute_result"}], "source": ["add_notebook_menu(keep_item=2)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["### Interactivity is javascript\n", "\n", "* A browser is needed\n", "* A server might be needed (bqplot)\n", "* Better to know javascript"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["### Steps to plot\n", "\n", "1. Create a figure: \n", "2. Create Axis: coordinate system\n", "3. Draw inside the plotting area\n", "4. Add elements outside the plotting area\n", "5. **Implement interactivity if not automated**\n", "6. Write the corresponding HTML, Javascript code"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["#### bokeh for all\n", "\n", "[bokeh](http://bokeh.pydata.org/) **default interactivity:** zoom, move, reset ; **custom** python, javascript\n", "\n", "![bokeh](img_bokeh.png)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["#### plotly for its design \n", "\n", "[plotly](https://plot.ly/) **default interactivity:** zoom, move, reset, text popup ; **plus** integration with pandas\n", "\n", "![plotly](img_plotly.png)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["#### mpld3 for matplotlib\n", "\n", "[mpld3](http://mpld3.github.io/) = matplotlib in javascript **default interactivity:** zoom, move, reset **custom** python, javascript (simple)\n", "\n", "![mpld3](img_mpld3.png)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["#### python-lightning for its simplicity\n", "\n", "[python-lightning](http://lightning-viz.org/) also works with R **default interactivity:** zoom, move, reset, text popup\n", "\n", "![lightning](img_lightning2.png)"]}, {"cell_type": "markdown", "metadata": {"collapsed": true, "slideshow": {"slide_type": "subslide"}}, "source": ["#### pygal, leather for SVG\n", "\n", "[pygal](http://www.pygal.org/en/stable/) [leather](http://leather.readthedocs.io/en/latest/index.html) **default interactivity:** text popup\n", "\n", "![pygal](img_pygal.png)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["#### vega for its simplicity\n", "\n", "[vega](https://github.com/vega/ipyvega) **default interactivity:** text popup\n", "\n", "![vega](img_vega2.png)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["#### folium for maps\n", "\n", "[folium](http://folium.readthedocs.io/en/latest/) = map with [OpenStreetMap](https://www.openstreetmap.org/) **default interactivity:** zoom, move, reset **custom** text popup, marker"]}, {"cell_type": "code", "execution_count": 13, "metadata": {"scrolled": false, "slideshow": {"slide_type": "fragment"}}, "outputs": [{"data": {"text/html": ["<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><iframe src=\"data:text/html;charset=utf-8;base64,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\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"], "text/plain": ["<folium.folium.Map at 0x28ecfb2dc88>"]}, "execution_count": 14, "metadata": {}, "output_type": "execute_result"}], "source": ["import folium\n", "center = [48.862, 2.346]\n", "paris = folium.Map(center, zoom_start=13)\n", "folium.Marker(center, popup='Les Halles').add_to(paris)\n", "paris"]}, {"cell_type": "markdown", "metadata": {"collapsed": true, "slideshow": {"slide_type": "subslide"}}, "source": ["#### pythreejs for 3D\n", "\n", "[pythreejs](https://github.com/jovyan/pythreejs) **default interactivity:** zoom, move, rotate, reset\n", "\n", "![pythreejs](screencast.gif)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["#### pydy for mechanics\n", "\n", "[pydy](http://pydy.readthedocs.io/en/stable/index.html) **default interactivity:** visualize a scene\n", "\n", "![pydy](img_pydy.png)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["### In short\n", "\n", "Are you looking for?\n", "\n", "* Standard interactivity (all of them)\n", "* Custom interactivity (Python, Javascript) (bokeh)\n", "* Easy export to websites (SVG, vega)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "slide"}}, "source": ["## - Libraries mixing Javascript, Python, ..."]}, {"cell_type": "code", "execution_count": 14, "metadata": {"slideshow": {"slide_type": "fragment"}}, "outputs": [{"data": {"text/html": ["<div id=\"my_id_menu_nb3\">run previous cell, wait for 2 seconds</div>\n", "<script>\n", "function repeat_indent_string(n){\n", "    var a = \"\" ;\n", "    for ( ; n > 0 ; --n)\n", "        a += \"    \";\n", "    return a;\n", "}\n", "// look up into all sections and builds an automated menu //\n", "var update_menu_string = function(begin, lfirst, llast, sformat, send, keep_item, begin_format, end_format) {\n", "    var anchors = document.getElementsByClassName(\"section\");\n", "    if (anchors.length == 0) {\n", "        anchors = document.getElementsByClassName(\"text_cell_render rendered_html\");\n", "    }\n", "    var i,t;\n", "    var text_menu = begin;\n", "    var text_memo = \"<pre>\\nlength:\" + anchors.length + \"\\n\";\n", "    var ind = \"\";\n", "    var memo_level = 1;\n", "    var href;\n", "    var tags = [];\n", "    var main_item = 0;\n", "    var format_open = 0;\n", "    for (i = 0; i <= llast; i++)\n", "        tags.push(\"h\" + i);\n", "\n", "    for (i = 0; i < anchors.length; i++) {\n", "        text_memo += \"**\" + anchors[i].id + \"--\\n\";\n", "\n", "        var child = null;\n", "        for(t = 0; t < tags.length; t++) {\n", "            var r = anchors[i].getElementsByTagName(tags[t]);\n", "            if (r.length > 0) {\n", "child = r[0];\n", "break;\n", "            }\n", "        }\n", "        if (child == null) {\n", "            text_memo += \"null\\n\";\n", "            continue;\n", "        }\n", "        if (anchors[i].hasAttribute(\"id\")) {\n", "            // when converted in RST\n", "            href = anchors[i].id;\n", "            text_memo += \"#1-\" + href;\n", "            // passer \u00e0 child suivant (le chercher)\n", "        }\n", "        else if (child.hasAttribute(\"id\")) {\n", "            // in a notebook\n", "            href = child.id;\n", "            text_memo += \"#2-\" + href;\n", "        }\n", "        else {\n", "            text_memo += \"#3-\" + \"*\" + \"\\n\";\n", "            continue;\n", "        }\n", "        var title = child.textContent;\n", "        var level = parseInt(child.tagName.substring(1,2));\n", "\n", "        text_memo += \"--\" + level + \"?\" + lfirst + \"--\" + title + \"\\n\";\n", "\n", "        if ((level < lfirst) || (level > llast)) {\n", "            continue ;\n", "        }\n", "        if (title.endsWith('\u00b6')) {\n", "            title = title.substring(0,title.length-1).replace(\"<\", \"&lt;\")\n", "         .replace(\">\", \"&gt;\").replace(\"&\", \"&amp;\");\n", "        }\n", "        if (title.length == 0) {\n", "            continue;\n", "        }\n", "\n", "        while (level < memo_level) {\n", "            text_menu += end_format + \"</ul>\\n\";\n", "            format_open -= 1;\n", "            memo_level -= 1;\n", "        }\n", "        if (level == lfirst) {\n", "            main_item += 1;\n", "        }\n", "        if (keep_item != -1 && main_item != keep_item + 1) {\n", "            // alert(main_item + \" - \" + level + \" - \" + keep_item);\n", "            continue;\n", "        }\n", "        while (level > memo_level) {\n", "            text_menu += \"<ul>\\n\";\n", "            memo_level += 1;\n", "        }\n", "        text_menu += repeat_indent_string(level-2);\n", "        text_menu += begin_format + sformat.replace(\"__HREF__\", href).replace(\"__TITLE__\", title);\n", "        format_open += 1;\n", "    }\n", "    while (1 < memo_level) {\n", "        text_menu += end_format + \"</ul>\\n\";\n", "        memo_level -= 1;\n", "        format_open -= 1;\n", "    }\n", "    text_menu += send;\n", "    //text_menu += \"\\n\" + text_memo;\n", "\n", "    while (format_open > 0) {\n", "        text_menu += end_format;\n", "        format_open -= 1;\n", "    }\n", "    return text_menu;\n", "};\n", "var update_menu = function() {\n", "    var sbegin = \"\";\n", "    var sformat = '<a href=\"#__HREF__\">__TITLE__</a>';\n", "    var send = \"\";\n", "    var begin_format = '<li>';\n", "    var end_format = '</li>';\n", "    var keep_item = 3;\n", "    var text_menu = update_menu_string(sbegin, 2, 4, sformat, send, keep_item,\n", "       begin_format, end_format);\n", "    var menu = document.getElementById(\"my_id_menu_nb3\");\n", "    menu.innerHTML=text_menu;\n", "};\n", "window.setTimeout(update_menu,2000);\n", "            </script>"], "text/plain": ["<IPython.core.display.HTML object>"]}, "execution_count": 15, "metadata": {}, "output_type": "execute_result"}], "source": ["add_notebook_menu(keep_item=3)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["### Hide the complexity\n", "\n", "* Mix of technologies\n", "* Wrapped in one module\n", "* Easy examples\n", "* But cryptic bugs for newbies"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["#### bqplot for the interactions in python\n", "\n", "[bqplot](https://github.com/bloomberg/bqplot)\n", "\n", "![bqplot](img_bqplot.png)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["#### brython, bythonmagic to avoid javascript\n", "\n", "Magic command ``%%brython%%``\n", "\n", "* easy to modify the notebook with Python\n", "* no javascript\n", "* place to start if you don't like javascript\n", "\n", "![brython](img_brython.png)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["#### geoplotlib for maps in a GUI\n", "\n", "[geoplotlib](https://github.com/andrea-cuttone/geoplotlib)\n", "\n", "![geoplotlib](img_geoplotlib.png)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["#### vispy for computational graphics\n", "\n", "[http://vispy.org/installation.html](vispy) creates graphs demanding heavy computation. It requires the knowledge of C++.\n", "\n", "![vispy](img_vispy_mandelbrot.png)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["### In short\n", "\n", "* Very suitable for research purpose\n", "* Uneasy to export the results"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "slide"}}, "source": ["## - Libraries for high volume of data"]}, {"cell_type": "code", "execution_count": 15, "metadata": {"slideshow": {"slide_type": "fragment"}}, "outputs": [{"data": {"text/html": ["<div id=\"my_id_menu_nb4\">run previous cell, wait for 2 seconds</div>\n", "<script>\n", "function repeat_indent_string(n){\n", "    var a = \"\" ;\n", "    for ( ; n > 0 ; --n)\n", "        a += \"    \";\n", "    return a;\n", "}\n", "// look up into all sections and builds an automated menu //\n", "var update_menu_string = function(begin, lfirst, llast, sformat, send, keep_item, begin_format, end_format) {\n", "    var anchors = document.getElementsByClassName(\"section\");\n", "    if (anchors.length == 0) {\n", "        anchors = document.getElementsByClassName(\"text_cell_render rendered_html\");\n", "    }\n", "    var i,t;\n", "    var text_menu = begin;\n", "    var text_memo = \"<pre>\\nlength:\" + anchors.length + \"\\n\";\n", "    var ind = \"\";\n", "    var memo_level = 1;\n", "    var href;\n", "    var tags = [];\n", "    var main_item = 0;\n", "    var format_open = 0;\n", "    for (i = 0; i <= llast; i++)\n", "        tags.push(\"h\" + i);\n", "\n", "    for (i = 0; i < anchors.length; i++) {\n", "        text_memo += \"**\" + anchors[i].id + \"--\\n\";\n", "\n", "        var child = null;\n", "        for(t = 0; t < tags.length; t++) {\n", "            var r = anchors[i].getElementsByTagName(tags[t]);\n", "            if (r.length > 0) {\n", "child = r[0];\n", "break;\n", "            }\n", "        }\n", "        if (child == null) {\n", "            text_memo += \"null\\n\";\n", "            continue;\n", "        }\n", "        if (anchors[i].hasAttribute(\"id\")) {\n", "            // when converted in RST\n", "            href = anchors[i].id;\n", "            text_memo += \"#1-\" + href;\n", "            // passer \u00e0 child suivant (le chercher)\n", "        }\n", "        else if (child.hasAttribute(\"id\")) {\n", "            // in a notebook\n", "            href = child.id;\n", "            text_memo += \"#2-\" + href;\n", "        }\n", "        else {\n", "            text_memo += \"#3-\" + \"*\" + \"\\n\";\n", "            continue;\n", "        }\n", "        var title = child.textContent;\n", "        var level = parseInt(child.tagName.substring(1,2));\n", "\n", "        text_memo += \"--\" + level + \"?\" + lfirst + \"--\" + title + \"\\n\";\n", "\n", "        if ((level < lfirst) || (level > llast)) {\n", "            continue ;\n", "        }\n", "        if (title.endsWith('\u00b6')) {\n", "            title = title.substring(0,title.length-1).replace(\"<\", \"&lt;\")\n", "         .replace(\">\", \"&gt;\").replace(\"&\", \"&amp;\");\n", "        }\n", "        if (title.length == 0) {\n", "            continue;\n", "        }\n", "\n", "        while (level < memo_level) {\n", "            text_menu += end_format + \"</ul>\\n\";\n", "            format_open -= 1;\n", "            memo_level -= 1;\n", "        }\n", "        if (level == lfirst) {\n", "            main_item += 1;\n", "        }\n", "        if (keep_item != -1 && main_item != keep_item + 1) {\n", "            // alert(main_item + \" - \" + level + \" - \" + keep_item);\n", "            continue;\n", "        }\n", "        while (level > memo_level) {\n", "            text_menu += \"<ul>\\n\";\n", "            memo_level += 1;\n", "        }\n", "        text_menu += repeat_indent_string(level-2);\n", "        text_menu += begin_format + sformat.replace(\"__HREF__\", href).replace(\"__TITLE__\", title);\n", "        format_open += 1;\n", "    }\n", "    while (1 < memo_level) {\n", "        text_menu += end_format + \"</ul>\\n\";\n", "        memo_level -= 1;\n", "        format_open -= 1;\n", "    }\n", "    text_menu += send;\n", "    //text_menu += \"\\n\" + text_memo;\n", "\n", "    while (format_open > 0) {\n", "        text_menu += end_format;\n", "        format_open -= 1;\n", "    }\n", "    return text_menu;\n", "};\n", "var update_menu = function() {\n", "    var sbegin = \"\";\n", "    var sformat = '<a href=\"#__HREF__\">__TITLE__</a>';\n", "    var send = \"\";\n", "    var begin_format = '<li>';\n", "    var end_format = '</li>';\n", "    var keep_item = 4;\n", "    var text_menu = update_menu_string(sbegin, 2, 4, sformat, send, keep_item,\n", "       begin_format, end_format);\n", "    var menu = document.getElementById(\"my_id_menu_nb4\");\n", "    menu.innerHTML=text_menu;\n", "};\n", "window.setTimeout(update_menu,2000);\n", "            </script>"], "text/plain": ["<IPython.core.display.HTML object>"]}, "execution_count": 16, "metadata": {}, "output_type": "execute_result"}], "source": ["add_notebook_menu(keep_item=4)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["### Challenge\n", "\n", "Two extremes:\n", "\n", "* Plotting huge volume takes time to process\n", "* Interactivity requires fast processing\n", "\n", "Compromise?"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["### + datashader\n", "\n", "[datashader](https://github.com/bokeh/datashader) = bokeh + Python interaction + data interpolation\n", "\n", "![datashader](img_datashader.png)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["### In short\n", "\n", "Work in progress."]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "slide"}}, "source": ["## Deeper into programming"]}, {"cell_type": "code", "execution_count": 16, "metadata": {"slideshow": {"slide_type": "fragment"}}, "outputs": [{"data": {"text/html": ["<div id=\"my_id_menu_nb5\">run previous cell, wait for 2 seconds</div>\n", "<script>\n", "function repeat_indent_string(n){\n", "    var a = \"\" ;\n", "    for ( ; n > 0 ; --n)\n", "        a += \"    \";\n", "    return a;\n", "}\n", "// look up into all sections and builds an automated menu //\n", "var update_menu_string = function(begin, lfirst, llast, sformat, send, keep_item, begin_format, end_format) {\n", "    var anchors = document.getElementsByClassName(\"section\");\n", "    if (anchors.length == 0) {\n", "        anchors = document.getElementsByClassName(\"text_cell_render rendered_html\");\n", "    }\n", "    var i,t;\n", "    var text_menu = begin;\n", "    var text_memo = \"<pre>\\nlength:\" + anchors.length + \"\\n\";\n", "    var ind = \"\";\n", "    var memo_level = 1;\n", "    var href;\n", "    var tags = [];\n", "    var main_item = 0;\n", "    var format_open = 0;\n", "    for (i = 0; i <= llast; i++)\n", "        tags.push(\"h\" + i);\n", "\n", "    for (i = 0; i < anchors.length; i++) {\n", "        text_memo += \"**\" + anchors[i].id + \"--\\n\";\n", "\n", "        var child = null;\n", "        for(t = 0; t < tags.length; t++) {\n", "            var r = anchors[i].getElementsByTagName(tags[t]);\n", "            if (r.length > 0) {\n", "child = r[0];\n", "break;\n", "            }\n", "        }\n", "        if (child == null) {\n", "            text_memo += \"null\\n\";\n", "            continue;\n", "        }\n", "        if (anchors[i].hasAttribute(\"id\")) {\n", "            // when converted in RST\n", "            href = anchors[i].id;\n", "            text_memo += \"#1-\" + href;\n", "            // passer \u00e0 child suivant (le chercher)\n", "        }\n", "        else if (child.hasAttribute(\"id\")) {\n", "            // in a notebook\n", "            href = child.id;\n", "            text_memo += \"#2-\" + href;\n", "        }\n", "        else {\n", "            text_memo += \"#3-\" + \"*\" + \"\\n\";\n", "            continue;\n", "        }\n", "        var title = child.textContent;\n", "        var level = parseInt(child.tagName.substring(1,2));\n", "\n", "        text_memo += \"--\" + level + \"?\" + lfirst + \"--\" + title + \"\\n\";\n", "\n", "        if ((level < lfirst) || (level > llast)) {\n", "            continue ;\n", "        }\n", "        if (title.endsWith('\u00b6')) {\n", "            title = title.substring(0,title.length-1).replace(\"<\", \"&lt;\")\n", "         .replace(\">\", \"&gt;\").replace(\"&\", \"&amp;\");\n", "        }\n", "        if (title.length == 0) {\n", "            continue;\n", "        }\n", "\n", "        while (level < memo_level) {\n", "            text_menu += end_format + \"</ul>\\n\";\n", "            format_open -= 1;\n", "            memo_level -= 1;\n", "        }\n", "        if (level == lfirst) {\n", "            main_item += 1;\n", "        }\n", "        if (keep_item != -1 && main_item != keep_item + 1) {\n", "            // alert(main_item + \" - \" + level + \" - \" + keep_item);\n", "            continue;\n", "        }\n", "        while (level > memo_level) {\n", "            text_menu += \"<ul>\\n\";\n", "            memo_level += 1;\n", "        }\n", "        text_menu += repeat_indent_string(level-2);\n", "        text_menu += begin_format + sformat.replace(\"__HREF__\", href).replace(\"__TITLE__\", title);\n", "        format_open += 1;\n", "    }\n", "    while (1 < memo_level) {\n", "        text_menu += end_format + \"</ul>\\n\";\n", "        memo_level -= 1;\n", "        format_open -= 1;\n", "    }\n", "    text_menu += send;\n", "    //text_menu += \"\\n\" + text_memo;\n", "\n", "    while (format_open > 0) {\n", "        text_menu += end_format;\n", "        format_open -= 1;\n", "    }\n", "    return text_menu;\n", "};\n", "var update_menu = function() {\n", "    var sbegin = \"\";\n", "    var sformat = '<a href=\"#__HREF__\">__TITLE__</a>';\n", "    var send = \"\";\n", "    var begin_format = '<li>';\n", "    var end_format = '</li>';\n", "    var keep_item = 5;\n", "    var text_menu = update_menu_string(sbegin, 2, 4, sformat, send, keep_item,\n", "       begin_format, end_format);\n", "    var menu = document.getElementById(\"my_id_menu_nb5\");\n", "    menu.innerHTML=text_menu;\n", "};\n", "window.setTimeout(update_menu,2000);\n", "            </script>"], "text/plain": ["<IPython.core.display.HTML object>"]}, "execution_count": 17, "metadata": {}, "output_type": "execute_result"}], "source": ["add_notebook_menu(keep_item=5)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["### Extend an existing library\n", "\n", "* Follow existing design\n", "* Constraints:\n", "\n", "    * Add the plot to an existing one\n", "    * Add complementery elements"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["#### Wrong design\n", "\n", "![wrong](img_wrong2.png)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["#### Right design\n", "\n", "![right](img_right.png)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["#### Parameter ``ax``\n", "\n", "![subplots](img_subplots.png)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["### Wrapping a javascript library\n", "\n", "* Chosen from [10 JavaScript libraries to draw your own diagrams](http://modeling-languages.com/javascript-drawing-libraries-diagrams/)\n", "* Search for ``python + <library>``\n", "* [JoinJS](http://jointjs.com/demos/charts)\n", "* [ChartJS](http://www.chartjs.org/docs/)\n"]}, {"cell_type": "markdown", "metadata": {"collapsed": true, "slideshow": {"slide_type": "subslide"}}, "source": ["#### Dummy example with treant\n", "\n", "* [treant-js](http://fperucic.github.io/treant-js/): [tennis draw](http://fperucic.github.io/treant-js/examples/tennis-draw/)\n", "* [notebook](http://www.xavierdupre.fr/app/jupytalk/helpsphinx/_downloads/jsonly_treant.html)\n", "* [code](https://github.com/sdpython/jupytalk/blob/master/src/jupytalk/talk_examples/treant_wrapper.py)\n", "\n", "![treant](img_treant.png)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["#### Part 1: HTML\n", "\n", "* a DIV with an id\n", "* a script for the library\n", "\n", "![html](img_thtml.png)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["#### Part 2: Json data\n", "\n", "* JSON most of the time\n", "\n", "![json](img_tdata.png)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["#### Part 3: javascript\n", "\n", "![js](img_tjs2.png)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["### In short\n", "\n", "* Pratice with existing libraries first\n", "* Think about others users"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "slide"}}, "source": ["## Conclusion\n", "\n", "* Static images are not obsolete!\n", "* Interactivity still requires a bit of work.\n", "* Huge volume of data is still a work in progress\n", "* Easy to create your own library\n", "\n", "**Un bon croquis vaut mieux qu\u2019un long discours.** *Napol\u00e9on Bonaparte*\n"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["**This is only the beginning**\n", "\n", "*Thank you*\n", "\n", "* http://www.xavierdupre.fr/\n", "* ``xavier.dupre AT gmail.com``"]}], "metadata": {"celltoolbar": "Slideshow", "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.0"}}, "nbformat": 4, "nbformat_minor": 2}