Matplotlib-concepts.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ce qui suit a été construit à partir de la page https://matplotlib.org/tutorials/introductory/usage.html#sphx-glr-tutorials-introductory-usage-py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Documentation\n",
    "\n",
    "Intro générale : https://matplotlib.org/index.html\n",
    "\n",
    "User's Guide : https://matplotlib.org/users/index.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Concepts de base\n",
    "Un \"graphique\" est strucutré de la manière suivante :\n",
    "- `Figure` est l'objet de plus haut niveau : \"coquille externe\" du graphique\n",
    "- `Axes` contient l'objet graphique en lui-même\n",
    "- `Axis` est un axe du graphique (contrôle des labels, xmin, xmax, etc.)\n",
    "- `Artist` est chaque élément dessiné sur un graphique (ligne, titre, etc)\n",
    "- `Canvas` est la zone de tracé du graphe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les données à tracer doivent être de type `array` de `numpy`. (np.array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Toute utilisation de matplotlib commence donc toujours par importer les modules `matplotlib.pyplot` et `numpy` sous la forme usuelle ci-dessous :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le module `pyplot` crée automatiquement (et de façon transparente) les objets `figure` et `axes` nécessaires à la construction d'un graphique. Chaque \"élément\" qu'on rajoute par la suite (ex : plt.plot() ou plt.title()) s'ajoute à la `figure` et l'`axe` actif."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour visualiser la figure créée, il faut utiliser la commande `plt.show()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Des conseils de bon usage\n",
    "For non-interactive plotting it is suggested to use pyplot to create the figures and then the OO interface for plotting.\n",
    "https://matplotlib.org/api/api_overview.html\n",
    "\n",
    "L'utilisation de pyplot est plus simple (mais permet de faire des choses moins précises) que l'utilisation de matplotlib de façon orientée objet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0, 2, 100)\n",
    "\n",
    "plt.plot(x, x, label='linéaire')\n",
    "plt.plot(x, x**2, label='carré')\n",
    "plt.plot(x, x**3, label='cube')\n",
    "\n",
    "plt.xlabel('abscisses')\n",
    "plt.ylabel('ordonnées')\n",
    "\n",
    "plt.title(\"Graphique basique\")\n",
    "\n",
    "plt.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Backend"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`matplotlib` peut être utilisé dans beaucoup de situations différentes et nécessite des sorties différentes. (shell python avec des fenêtre pop up, Jupyter notebooks, graphiques embarqués dans des GUI comme wxpython ou pygtk , sorties d'images postscript).\n",
    "\n",
    "Tous ces moyens sont des `backends`.\n",
    "\n",
    "Le **frontend** est le code pour tracer le graphe. Le **backend** fait tout le travail \"behind-the-scenes\" pour produire la figure.\n",
    "\n",
    "Il existe 2 types de backends: \n",
    "- **user interface backends** (pygtk, wxpython, tkinter, qt4, macosx) : ce sont les **interactive backends**.\n",
    "- **hardcopy backends** pour créer des fichiers images(PNG, SVG, PDF, PS) : ce sont les **non-interactive backends**.\n",
    "\n",
    "Pour savoir comment configurer son Backend (si nécessaire), consulter précisément la doc suivante : https://matplotlib.org/tutorials/introductory/usage.html#backends\n",
    "\n",
    "Certains backends peuvent être activés dans un Jupyter notebook avec les fonctions magiques %matplolib 'nom du backend' (il y a un backend spécial Jupyter mais cela nécessite l'installation d'un module iympl https://github.com/matplotlib/jupyter-matplotlib).\n",
    "\n",
    "Dans un environnement de notebook, il peut être intéressant de lister les backends existants pour trouver celui qui convient à notre besoin du moment (qui peut varier évidemment). Il faut redémarrer le kernel pour changer de backend. Voir la liste ci-dessous :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Available matplotlib backends: ['tk', 'gtk', 'gtk3', 'wx', 'qt4', 'qt5', 'qt', 'osx', 'nbagg', 'notebook', 'agg', 'svg', 'pdf', 'ps', 'inline', 'ipympl', 'widget']\n"
     ]
    }
   ],
   "source": [
    "%matplotlib -l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A priori, mes choix vont dans cet ordre :\n",
    "\n",
    "1- notebook\n",
    "\n",
    "2- inline\n",
    "\n",
    "3- qt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Avec le backend notebook, il est conseillé de numéroter les figures pour éviter des soucis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support.' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to  previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        event.shiftKey = false;\n",
       "        // Send a \"J\" for go to next cell\n",
       "        event.which = 74;\n",
       "        event.keyCode = 74;\n",
       "        manager.command_mode();\n",
       "        manager.handle_keydown(event);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"640\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib notebook\n",
    "\n",
    "x = np.linspace(0, 2, 100)\n",
    "\n",
    "plt.figure(42)\n",
    "\n",
    "plt.plot(x, x, label='linéaire')\n",
    "plt.plot(x, x**2, label='carré')\n",
    "plt.plot(x, x**3, label='cube')\n",
    "\n",
    "plt.xlabel('abscisses')\n",
    "plt.ylabel('ordonnées')\n",
    "\n",
    "plt.title(\"Graphique basique\")\n",
    "\n",
    "plt.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mode interactif"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il est possible (avec un backend interactif) de commuter le mode interactif ou non :\n",
    "- plt.ion() : active le mode interactif : on peut modifier la figure \"à chaud\". La commande plt.draw() peut être nécessaire pour forcer le rafraîchissment de la figure.\n",
    "- plt.ioff() : désactive le mode interactif : la figure n'apparaît que lorsque la commande plt.show() est exécutée. Cette commande bloque le script python en cours jusqu'à ce que la fenêtre graphique soit close.\n",
    "\n",
    "\n",
    "\n",
    "Pour connaître l'état courant : plt.isinteractive()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Des compléments (parfois utiles...)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Toolkits : des ajouts. https://matplotlib.org/api/toolkits/index.html\n",
    "\n",
    "Pour des graphes 3D :  https://matplotlib.org/api/toolkits/mplot3d/index.html\n",
    "\n",
    "Dautres outils complémentaires (cartographie par exple) : https://matplotlib.org/thirdpartypackages/index.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Anatomie d'une Figure\n",
    "\n",
    "<img src=\"matplotlib-anatomie.png\"/>"
   ]
  },
  {
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}