diff --git a/.ipynb_checkpoints/ejercicio1y2-checkpoint.ipynb b/.ipynb_checkpoints/ejercicio1y2-checkpoint.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..bd19a77d9251bc8b379bcf2a00146f37d0063704 --- /dev/null +++ b/.ipynb_checkpoints/ejercicio1y2-checkpoint.ipynb @@ -0,0 +1,4709 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Tatiana Acero Cuellar\n", + "### Universidad Nacional de Colombia\n", + "#### Ejercicios Semana 3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Ejercicio No. 1\n", + "\n", + "* Investigue sobre el diagrama de Hertzprung-Russell, una herramienta muy potente en astronomia, y describa un poco al respecto para darle contexto al resto de la tarea.\n", + "\n", + "\n", + "* El objetivo es generar un diagrama HR lo más parecido al de esta referencia. No lucirá idéntico por que no se usarán exactamente los mismos datos, y las unidades pueden ser ligeramente distinta. La idea sà es dejar su figura lo más parecida a la de referencia en el estilo: colores, escalas en los ejes, tamaño de los marcadores, leyendas, textos en el gráfico, etc.\n", + "\n", + "\n", + "* Los datos para crear la figura están en la carpeta Data. Cada tabla contiene las informaciones sobre un tipo de estrellas según indican los nombres de archivo. La información viene en 3 columnas: luminosidad en luminosidades solares, Temperatura en Kelvin y Radio de la estrella en unidades arbitrarias.\n", + "\n", + "\n", + "* La idea es que cada estrella en el gráfico tenga un color representativo de su temperatura (que estrellas frÃas son rojas y estrellas calientes son azules) y que el tamaño del sÃmbolo sea representativo del tamaño de cada estrella para diferenciar entre enanas, gigantes y estrellas de secuencia principal.\n", + "\n", + "\n", + "* Busque que su código sea semi automático; es indispensable leer los datos desde el propio programa, no copiarlos a mano, y hallar una forma de obtener los tamaños y colores sin declararlos uno a uno." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.colors\n", + "from matplotlib import cm\n", + "from matplotlib.animation import FuncAnimation\n", + "%matplotlib notebook" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Se que no hemos visto pandas, pero la verdad es que soy muy fan de la libreria jaja" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Enanas blancas" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6\n" + ] + }, + { + "data": { + "text/html": [ + "<div>\n", + "<style scoped>\n", + " .dataframe tbody tr th:only-of-type {\n", + " vertical-align: middle;\n", + " }\n", + "\n", + " .dataframe tbody tr th {\n", + " vertical-align: top;\n", + " }\n", + "\n", + " .dataframe thead th {\n", + " text-align: right;\n", + " }\n", + "</style>\n", + "<table border=\"1\" class=\"dataframe\">\n", + " <thead>\n", + " <tr style=\"text-align: right;\">\n", + " <th></th>\n", + " <th>lum</th>\n", + " <th>temp</th>\n", + " <th>radius</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>0</th>\n", + " <td>0.000109</td>\n", + " <td>5050.644696</td>\n", + " <td>7.096930</td>\n", + " </tr>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>0.000128</td>\n", + " <td>5967.543450</td>\n", + " <td>4.583996</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>0.000230</td>\n", + " <td>6674.161524</td>\n", + " <td>4.151078</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3</th>\n", + " <td>0.000269</td>\n", + " <td>7216.762974</td>\n", + " <td>3.491754</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>0.000472</td>\n", + " <td>7795.184395</td>\n", + " <td>3.472736</td>\n", + " </tr>\n", + " <tr>\n", + " <th>5</th>\n", + " <td>0.000613</td>\n", + " <td>8402.695283</td>\n", + " <td>3.077338</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "</div>" + ], + "text/plain": [ + " lum temp radius\n", + "0 0.000109 5050.644696 7.096930\n", + "1 0.000128 5967.543450 4.583996\n", + "2 0.000230 6674.161524 4.151078\n", + "3 0.000269 7216.762974 3.491754\n", + "4 0.000472 7795.184395 3.472736\n", + "5 0.000613 8402.695283 3.077338" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dwarfs = pd.read_csv('data/dwarfs.csv')\n", + "print(len(dwarfs))\n", + "dwarfs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Secuencia principal" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "90\n" + ] + }, + { + "data": { + "text/html": [ + "<div>\n", + "<style scoped>\n", + " .dataframe tbody tr th:only-of-type {\n", + " vertical-align: middle;\n", + " }\n", + "\n", + " .dataframe tbody tr th {\n", + " vertical-align: top;\n", + " }\n", + "\n", + " .dataframe thead th {\n", + " text-align: right;\n", + " }\n", + "</style>\n", + "<table border=\"1\" class=\"dataframe\">\n", + " <thead>\n", + " <tr style=\"text-align: right;\">\n", + " <th></th>\n", + " <th>lum</th>\n", + " <th>temp</th>\n", + " <th>radius</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>0</th>\n", + " <td>0.000776</td>\n", + " <td>3577.003926</td>\n", + " <td>0.814703</td>\n", + " </tr>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>0.002638</td>\n", + " <td>3691.168543</td>\n", + " <td>1.209778</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>0.006823</td>\n", + " <td>3793.506494</td>\n", + " <td>1.630027</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3</th>\n", + " <td>0.019733</td>\n", + " <td>3862.471423</td>\n", + " <td>2.361574</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>0.040402</td>\n", + " <td>3963.530109</td>\n", + " <td>2.910924</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "</div>" + ], + "text/plain": [ + " lum temp radius\n", + "0 0.000776 3577.003926 0.814703\n", + "1 0.002638 3691.168543 1.209778\n", + "2 0.006823 3793.506494 1.630027\n", + "3 0.019733 3862.471423 2.361574\n", + "4 0.040402 3963.530109 2.910924" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ms = pd.read_csv('data/ms.csv')\n", + "print(len(ms))\n", + "ms.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Gigantes (azul)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n" + ] + }, + { + "data": { + "text/html": [ + "<div>\n", + "<style scoped>\n", + " .dataframe tbody tr th:only-of-type {\n", + " vertical-align: middle;\n", + " }\n", + "\n", + " .dataframe tbody tr th {\n", + " vertical-align: top;\n", + " }\n", + "\n", + " .dataframe thead th {\n", + " text-align: right;\n", + " }\n", + "</style>\n", + "<table border=\"1\" class=\"dataframe\">\n", + " <thead>\n", + " <tr style=\"text-align: right;\">\n", + " <th></th>\n", + " <th>lum</th>\n", + " <th>temp</th>\n", + " <th>radius</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>0</th>\n", + " <td>304.228573</td>\n", + " <td>3654.601099</td>\n", + " <td>145.483474</td>\n", + " </tr>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>58.884366</td>\n", + " <td>3808.609875</td>\n", + " <td>66.642938</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>9.246982</td>\n", + " <td>3991.751692</td>\n", + " <td>27.603430</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3</th>\n", + " <td>58.505945</td>\n", + " <td>4164.818180</td>\n", + " <td>50.832968</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>32.033176</td>\n", + " <td>4425.773883</td>\n", + " <td>33.290931</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "</div>" + ], + "text/plain": [ + " lum temp radius\n", + "0 304.228573 3654.601099 145.483474\n", + "1 58.884366 3808.609875 66.642938\n", + "2 9.246982 3991.751692 27.603430\n", + "3 58.505945 4164.818180 50.832968\n", + "4 32.033176 4425.773883 33.290931" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "giants = pd.read_csv('data/giants.txt', sep=' ')\n", + "print(len(giants))\n", + "giants.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Supergigantes (rojo)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n" + ] + }, + { + "data": { + "text/html": [ + "<div>\n", + "<style scoped>\n", + " .dataframe tbody tr th:only-of-type {\n", + " vertical-align: middle;\n", + " }\n", + "\n", + " .dataframe tbody tr th {\n", + " vertical-align: top;\n", + " }\n", + "\n", + " .dataframe thead th {\n", + " text-align: right;\n", + " }\n", + "</style>\n", + "<table border=\"1\" class=\"dataframe\">\n", + " <thead>\n", + " <tr style=\"text-align: right;\">\n", + " <th></th>\n", + " <th>lum</th>\n", + " <th>temp</th>\n", + " <th>radius</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>0</th>\n", + " <td>359749.335156</td>\n", + " <td>3801.042587</td>\n", + " <td>278.055832</td>\n", + " </tr>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>416869.383470</td>\n", + " <td>4398.962354</td>\n", + " <td>190.278395</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>1000000.000000</td>\n", + " <td>5465.163392</td>\n", + " <td>140.809113</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3</th>\n", + " <td>920449.571753</td>\n", + " <td>7837.395137</td>\n", + " <td>46.187556</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>779830.110523</td>\n", + " <td>10200.701561</td>\n", + " <td>19.604244</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "</div>" + ], + "text/plain": [ + " lum temp radius\n", + "0 359749.335156 3801.042587 278.055832\n", + "1 416869.383470 4398.962354 190.278395\n", + "2 1000000.000000 5465.163392 140.809113\n", + "3 920449.571753 7837.395137 46.187556\n", + "4 779830.110523 10200.701561 19.604244" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "supergiants = pd.read_csv('data/supergiants.txt', sep=' ')\n", + "print(len(supergiants))\n", + "supergiants.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Valores máximos y mÃnimos" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def max_y_min(tabla):\n", + " lum_min, lum_max = min(tabla['lum']), max(tabla['lum'])\n", + " temp_min, temp_max = min(tabla['temp']), max(tabla['temp'])\n", + " \n", + " return lum_min, lum_max, temp_min, temp_max" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Enanas blancas" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "d_lum_min, d_lum_max, d_temp_min, d_temp_max = max_y_min(dwarfs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Secuencia principal" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "ms_lum_min, ms_lum_max, ms_temp_min, ms_temp_max = max_y_min(ms)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Gigantes" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "g_lum_min, g_lum_max, g_temp_min, g_temp_max = max_y_min(giants)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Supergigantes" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "sg_lum_min, sg_lum_max, sg_temp_min, sg_temp_max = max_y_min(supergiants)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A continuación hago el diagrama ploteando cada tabla de manera individual, al hacerlo asà no puedo acoplar de manera sencilla el color de las estrellas" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "/* global mpl */\n", + "window.mpl = {};\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(\n", + " '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", + "\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 = document.createElement('div');\n", + " this.root.setAttribute('style', 'display: inline-block');\n", + " this._root_extra_style(this.root);\n", + "\n", + " parent_element.appendChild(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 (fig.ratio !== 1) {\n", + " fig.send_message('set_dpi_ratio', { dpi_ratio: fig.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 = document.createElement('div');\n", + " titlebar.classList =\n", + " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", + " var titletext = document.createElement('div');\n", + " titletext.classList = 'ui-dialog-title';\n", + " titletext.setAttribute(\n", + " 'style',\n", + " 'width: 100%; text-align: center; padding: 3px;'\n", + " );\n", + " titlebar.appendChild(titletext);\n", + " this.root.appendChild(titlebar);\n", + " this.header = titletext;\n", + "};\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", + "\n", + "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", + "\n", + "mpl.figure.prototype._init_canvas = function () {\n", + " var fig = this;\n", + "\n", + " var canvas_div = (this.canvas_div = document.createElement('div'));\n", + " canvas_div.setAttribute(\n", + " 'style',\n", + " 'border: 1px solid #ddd;' +\n", + " 'box-sizing: content-box;' +\n", + " 'clear: both;' +\n", + " 'min-height: 1px;' +\n", + " 'min-width: 1px;' +\n", + " 'outline: 0;' +\n", + " 'overflow: hidden;' +\n", + " 'position: relative;' +\n", + " 'resize: both;'\n", + " );\n", + "\n", + " function on_keyboard_event_closure(name) {\n", + " return function (event) {\n", + " return fig.key_event(event, name);\n", + " };\n", + " }\n", + "\n", + " canvas_div.addEventListener(\n", + " 'keydown',\n", + " on_keyboard_event_closure('key_press')\n", + " );\n", + " canvas_div.addEventListener(\n", + " 'keyup',\n", + " on_keyboard_event_closure('key_release')\n", + " );\n", + "\n", + " this._canvas_extra_style(canvas_div);\n", + " this.root.appendChild(canvas_div);\n", + "\n", + " var canvas = (this.canvas = document.createElement('canvas'));\n", + " canvas.classList.add('mpl-canvas');\n", + " canvas.setAttribute('style', 'box-sizing: content-box;');\n", + "\n", + " this.context = canvas.getContext('2d');\n", + "\n", + " var backingStore =\n", + " this.context.backingStorePixelRatio ||\n", + " this.context.webkitBackingStorePixelRatio ||\n", + " this.context.mozBackingStorePixelRatio ||\n", + " this.context.msBackingStorePixelRatio ||\n", + " this.context.oBackingStorePixelRatio ||\n", + " this.context.backingStorePixelRatio ||\n", + " 1;\n", + "\n", + " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", + " 'canvas'\n", + " ));\n", + " rubberband_canvas.setAttribute(\n", + " 'style',\n", + " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n", + " );\n", + "\n", + " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", + " if (this.ResizeObserver === undefined) {\n", + " if (window.ResizeObserver !== undefined) {\n", + " this.ResizeObserver = window.ResizeObserver;\n", + " } else {\n", + " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", + " this.ResizeObserver = obs.ResizeObserver;\n", + " }\n", + " }\n", + "\n", + " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", + " var nentries = entries.length;\n", + " for (var i = 0; i < nentries; i++) {\n", + " var entry = entries[i];\n", + " var width, height;\n", + " if (entry.contentBoxSize) {\n", + " if (entry.contentBoxSize instanceof Array) {\n", + " // Chrome 84 implements new version of spec.\n", + " width = entry.contentBoxSize[0].inlineSize;\n", + " height = entry.contentBoxSize[0].blockSize;\n", + " } else {\n", + " // Firefox implements old version of spec.\n", + " width = entry.contentBoxSize.inlineSize;\n", + " height = entry.contentBoxSize.blockSize;\n", + " }\n", + " } else {\n", + " // Chrome <84 implements even older version of spec.\n", + " width = entry.contentRect.width;\n", + " height = entry.contentRect.height;\n", + " }\n", + "\n", + " // Keep the size of the canvas and rubber band canvas in sync with\n", + " // the canvas container.\n", + " if (entry.devicePixelContentBoxSize) {\n", + " // Chrome 84 implements new version of spec.\n", + " canvas.setAttribute(\n", + " 'width',\n", + " entry.devicePixelContentBoxSize[0].inlineSize\n", + " );\n", + " canvas.setAttribute(\n", + " 'height',\n", + " entry.devicePixelContentBoxSize[0].blockSize\n", + " );\n", + " } else {\n", + " canvas.setAttribute('width', width * fig.ratio);\n", + " canvas.setAttribute('height', height * fig.ratio);\n", + " }\n", + " canvas.setAttribute(\n", + " 'style',\n", + " 'width: ' + width + 'px; height: ' + height + 'px;'\n", + " );\n", + "\n", + " rubberband_canvas.setAttribute('width', width);\n", + " rubberband_canvas.setAttribute('height', height);\n", + "\n", + " // And update the size in Python. We ignore the initial 0/0 size\n", + " // that occurs as the element is placed into the DOM, which should\n", + " // otherwise not happen due to the minimum size styling.\n", + " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", + " fig.request_resize(width, height);\n", + " }\n", + " }\n", + " });\n", + " this.resizeObserverInstance.observe(canvas_div);\n", + "\n", + " function on_mouse_event_closure(name) {\n", + " return function (event) {\n", + " return fig.mouse_event(event, name);\n", + " };\n", + " }\n", + "\n", + " rubberband_canvas.addEventListener(\n", + " 'mousedown',\n", + " on_mouse_event_closure('button_press')\n", + " );\n", + " rubberband_canvas.addEventListener(\n", + " 'mouseup',\n", + " on_mouse_event_closure('button_release')\n", + " );\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband_canvas.addEventListener(\n", + " 'mousemove',\n", + " on_mouse_event_closure('motion_notify')\n", + " );\n", + "\n", + " rubberband_canvas.addEventListener(\n", + " 'mouseenter',\n", + " on_mouse_event_closure('figure_enter')\n", + " );\n", + " rubberband_canvas.addEventListener(\n", + " 'mouseleave',\n", + " on_mouse_event_closure('figure_leave')\n", + " );\n", + "\n", + " canvas_div.addEventListener('wheel', function (event) {\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " on_mouse_event_closure('scroll')(event);\n", + " });\n", + "\n", + " canvas_div.appendChild(canvas);\n", + " canvas_div.appendChild(rubberband_canvas);\n", + "\n", + " this.rubberband_context = rubberband_canvas.getContext('2d');\n", + " this.rubberband_context.strokeStyle = '#000000';\n", + "\n", + " this._resize_canvas = function (width, height, forward) {\n", + " if (forward) {\n", + " canvas_div.style.width = width + 'px';\n", + " canvas_div.style.height = height + 'px';\n", + " }\n", + " };\n", + "\n", + " // Disable right mouse context menu.\n", + " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n", + " event.preventDefault();\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 toolbar = document.createElement('div');\n", + " toolbar.classList = 'mpl-toolbar';\n", + " this.root.appendChild(toolbar);\n", + "\n", + " function on_click_closure(name) {\n", + " return function (_event) {\n", + " return fig.toolbar_button_onclick(name);\n", + " };\n", + " }\n", + "\n", + " function on_mouseover_closure(tooltip) {\n", + " return function (event) {\n", + " if (!event.currentTarget.disabled) {\n", + " return fig.toolbar_button_onmouseover(tooltip);\n", + " }\n", + " };\n", + " }\n", + "\n", + " fig.buttons = {};\n", + " var buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'mpl-button-group';\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", + " /* Instead of a spacer, we start a new button group. */\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + " buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'mpl-button-group';\n", + " continue;\n", + " }\n", + "\n", + " var button = (fig.buttons[name] = document.createElement('button'));\n", + " button.classList = 'mpl-widget';\n", + " button.setAttribute('role', 'button');\n", + " button.setAttribute('aria-disabled', 'false');\n", + " button.addEventListener('click', on_click_closure(method_name));\n", + " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", + "\n", + " var icon_img = document.createElement('img');\n", + " icon_img.src = '_images/' + image + '.png';\n", + " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", + " icon_img.alt = tooltip;\n", + " button.appendChild(icon_img);\n", + "\n", + " buttonGroup.appendChild(button);\n", + " }\n", + "\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + "\n", + " var fmt_picker = document.createElement('select');\n", + " fmt_picker.classList = 'mpl-widget';\n", + " toolbar.appendChild(fmt_picker);\n", + " this.format_dropdown = fmt_picker;\n", + "\n", + " for (var ind in mpl.extensions) {\n", + " var fmt = mpl.extensions[ind];\n", + " var option = document.createElement('option');\n", + " option.selected = fmt === mpl.default_extension;\n", + " option.innerHTML = fmt;\n", + " fmt_picker.appendChild(option);\n", + " }\n", + "\n", + " var status_bar = document.createElement('span');\n", + " status_bar.classList = 'mpl-message';\n", + " toolbar.appendChild(status_bar);\n", + " this.message = status_bar;\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", + "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", + "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], msg['forward']);\n", + " fig.send_message('refresh', {});\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", + " var x0 = msg['x0'] / fig.ratio;\n", + " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", + " var x1 = msg['x1'] / fig.ratio;\n", + " var y1 = (fig.canvas.height - msg['y1']) / fig.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,\n", + " 0,\n", + " fig.canvas.width / fig.ratio,\n", + " fig.canvas.height / fig.ratio\n", + " );\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", + " 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.handle_history_buttons = function (fig, msg) {\n", + " for (var key in msg) {\n", + " if (!(key in fig.buttons)) {\n", + " continue;\n", + " }\n", + " fig.buttons[key].disabled = !msg[key];\n", + " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", + " if (msg['mode'] === 'PAN') {\n", + " fig.buttons['Pan'].classList.add('active');\n", + " fig.buttons['Zoom'].classList.remove('active');\n", + " } else if (msg['mode'] === 'ZOOM') {\n", + " fig.buttons['Pan'].classList.remove('active');\n", + " fig.buttons['Zoom'].classList.add('active');\n", + " } else {\n", + " fig.buttons['Pan'].classList.remove('active');\n", + " fig.buttons['Zoom'].classList.remove('active');\n", + " }\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", + "\n", + " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", + " evt.data\n", + " );\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " } else if (\n", + " typeof evt.data === 'string' &&\n", + " evt.data.slice(0, 21) === 'data:image/png;base64'\n", + " ) {\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(\n", + " \"No handler for the '\" + msg_type + \"' message type: \",\n", + " msg\n", + " );\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(\n", + " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", + " e,\n", + " e.stack,\n", + " msg\n", + " );\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", + " }\n", + " if (e.target) {\n", + " targ = e.target;\n", + " } else if (e.srcElement) {\n", + " targ = e.srcElement;\n", + " }\n", + " if (targ.nodeType === 3) {\n", + " // defeat Safari bug\n", + " targ = targ.parentNode;\n", + " }\n", + "\n", + " // pageX,Y are the mouse positions relative to the document\n", + " var boundingRect = targ.getBoundingClientRect();\n", + " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n", + " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\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", + " }\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", + " this.canvas.focus();\n", + " this.canvas_div.focus();\n", + " }\n", + "\n", + " var x = canvas_pos.x * this.ratio;\n", + " var y = canvas_pos.y * this.ratio;\n", + "\n", + " this.send_message(name, {\n", + " x: x,\n", + " y: y,\n", + " button: event.button,\n", + " step: event.step,\n", + " guiEvent: simpleKeys(event),\n", + " });\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", + " // Prevent repeat events\n", + " if (name === 'key_press') {\n", + " if (event.which === this._key) {\n", + " return;\n", + " } else {\n", + " this._key = event.which;\n", + " }\n", + " }\n", + " if (name === 'key_release') {\n", + " this._key = null;\n", + " }\n", + "\n", + " var value = '';\n", + " if (event.ctrlKey && event.which !== 17) {\n", + " value += 'ctrl+';\n", + " }\n", + " if (event.altKey && event.which !== 18) {\n", + " value += 'alt+';\n", + " }\n", + " if (event.shiftKey && event.which !== 16) {\n", + " value += 'shift+';\n", + " }\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, 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", + "\n", + "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", + "// prettier-ignore\n", + "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\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\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"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\";/* global mpl */\n", + "\n", + "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 = document.getElementById(id);\n", + " var ws_proxy = comm_websocket_adapter(comm);\n", + "\n", + " function ondownload(figure, _format) {\n", + " window.open(figure.canvas.toDataURL());\n", + " }\n", + "\n", + " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\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;\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", + " fig.cell_info[0].output_area.element.on(\n", + " 'cleared',\n", + " { fig: fig },\n", + " fig._remove_fig_handler\n", + " );\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_close = function (fig, msg) {\n", + " var width = fig.canvas.width / fig.ratio;\n", + " fig.cell_info[0].output_area.element.off(\n", + " 'cleared',\n", + " fig._remove_fig_handler\n", + " );\n", + " fig.resizeObserverInstance.unobserve(fig.canvas_div);\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.innerHTML =\n", + " '<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 / this.ratio;\n", + " var dataURL = this.canvas.toDataURL();\n", + " this.cell_info[1]['text/html'] =\n", + " '<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 () {\n", + " fig.push_to_output();\n", + " }, 1000);\n", + "};\n", + "\n", + "mpl.figure.prototype._init_toolbar = function () {\n", + " var fig = this;\n", + "\n", + " var toolbar = document.createElement('div');\n", + " toolbar.classList = 'btn-toolbar';\n", + " this.root.appendChild(toolbar);\n", + "\n", + " function on_click_closure(name) {\n", + " return function (_event) {\n", + " return fig.toolbar_button_onclick(name);\n", + " };\n", + " }\n", + "\n", + " function on_mouseover_closure(tooltip) {\n", + " return function (event) {\n", + " if (!event.currentTarget.disabled) {\n", + " return fig.toolbar_button_onmouseover(tooltip);\n", + " }\n", + " };\n", + " }\n", + "\n", + " fig.buttons = {};\n", + " var buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'btn-group';\n", + " var button;\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", + " /* Instead of a spacer, we start a new button group. */\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + " buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'btn-group';\n", + " continue;\n", + " }\n", + "\n", + " button = fig.buttons[name] = document.createElement('button');\n", + " button.classList = 'btn btn-default';\n", + " button.href = '#';\n", + " button.title = name;\n", + " button.innerHTML = '<i class=\"fa ' + image + ' fa-lg\"></i>';\n", + " button.addEventListener('click', on_click_closure(method_name));\n", + " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", + " buttonGroup.appendChild(button);\n", + " }\n", + "\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = document.createElement('span');\n", + " status_bar.classList = 'mpl-message pull-right';\n", + " toolbar.appendChild(status_bar);\n", + " this.message = status_bar;\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = document.createElement('div');\n", + " buttongrp.classList = 'btn-group inline pull-right';\n", + " button = document.createElement('button');\n", + " button.classList = 'btn btn-mini btn-primary';\n", + " button.href = '#';\n", + " button.title = 'Stop Interaction';\n", + " button.innerHTML = '<i class=\"fa fa-power-off icon-remove icon-large\"></i>';\n", + " button.addEventListener('click', function (_evt) {\n", + " fig.handle_close(fig, {});\n", + " });\n", + " button.addEventListener(\n", + " 'mouseover',\n", + " on_mouseover_closure('Stop Interaction')\n", + " );\n", + " buttongrp.appendChild(button);\n", + " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", + " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", + "};\n", + "\n", + "mpl.figure.prototype._remove_fig_handler = function (event) {\n", + " var fig = event.data.fig;\n", + " if (event.target !== this) {\n", + " // Ignore bubbled events from children.\n", + " return;\n", + " }\n", + " fig.close_ws(fig, {});\n", + "};\n", + "\n", + "mpl.figure.prototype._root_extra_style = function (el) {\n", + " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", + "};\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function (el) {\n", + " // this is important to make the div 'focusable\n", + " el.setAttribute('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", + " } else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\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", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which === 13) {\n", + " this.canvas_div.blur();\n", + " // select the cell after this one\n", + " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", + " IPython.notebook.select(index + 1);\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", + " fig.ondownload(fig, null);\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(\n", + " 'matplotlib',\n", + " mpl.mpl_figure_comm\n", + " );\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=\"800\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "<matplotlib.colorbar.Colorbar at 0x7f727c218198>" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=[8,5])\n", + "\n", + "xmin = min( d_temp_min, ms_temp_min, g_temp_min, sg_temp_min )\n", + "xmax = max( d_temp_max, ms_temp_max, g_temp_max, sg_temp_max )\n", + "\n", + "\n", + "cmap = matplotlib.colors.LinearSegmentedColormap.from_list(\"\", [\"red\",\"violet\",\"blue\"])\n", + "\n", + "#cmap = cm.get_cmap('hsv', 7)\n", + "norm = plt.Normalize(xmin, xmax)\n", + "\n", + "sd = dwarfs['radius']\n", + "im = ax.scatter(dwarfs['temp'], dwarfs['lum'], c=dwarfs['temp'], s=sd, cmap=cmap, vmin=xmin, vmax=xmax)\n", + "\n", + "sms = ms['radius']\n", + "im = ax.scatter(ms['temp'], ms['lum'], c=ms['temp'], s=sms, cmap=cmap)\n", + "\n", + "sg = giants['radius']\n", + "im = ax.scatter(giants['temp'], giants['lum'], c=giants['temp'],s=sg, cmap=cmap)\n", + "\n", + "ssg = supergiants['radius']\n", + "im = ax.scatter(supergiants['temp'], supergiants['lum'], c=supergiants['temp'],s=ssg, cmap=cmap)\n", + "\n", + "ax.set_xlabel('Temperatura (K)')\n", + "ax.set_ylabel('Luminosidad (L$_{sol}$)')\n", + "ax.set_title('Diagrama Hertzsprung-Russell')\n", + "\n", + "\n", + "\n", + "ax.set_xlim(xmax, xmin-300)\n", + "#ax.set_xticks([12000, 10000, 8000, 6000, 3500])\n", + "ax.set_yscale(\"log\")\n", + "\n", + "\n", + "fig.colorbar(im, ax=ax)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Uno las cuatro tablas para poder integrar el color de las estrellas" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "all_stars = pd.concat([dwarfs, ms, giants, supergiants], ignore_index=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "/* global mpl */\n", + "window.mpl = {};\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(\n", + " '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", + "\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 = document.createElement('div');\n", + " this.root.setAttribute('style', 'display: inline-block');\n", + " this._root_extra_style(this.root);\n", + "\n", + " parent_element.appendChild(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 (fig.ratio !== 1) {\n", + " fig.send_message('set_dpi_ratio', { dpi_ratio: fig.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 = document.createElement('div');\n", + " titlebar.classList =\n", + " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", + " var titletext = document.createElement('div');\n", + " titletext.classList = 'ui-dialog-title';\n", + " titletext.setAttribute(\n", + " 'style',\n", + " 'width: 100%; text-align: center; padding: 3px;'\n", + " );\n", + " titlebar.appendChild(titletext);\n", + " this.root.appendChild(titlebar);\n", + " this.header = titletext;\n", + "};\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", + "\n", + "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", + "\n", + "mpl.figure.prototype._init_canvas = function () {\n", + " var fig = this;\n", + "\n", + " var canvas_div = (this.canvas_div = document.createElement('div'));\n", + " canvas_div.setAttribute(\n", + " 'style',\n", + " 'border: 1px solid #ddd;' +\n", + " 'box-sizing: content-box;' +\n", + " 'clear: both;' +\n", + " 'min-height: 1px;' +\n", + " 'min-width: 1px;' +\n", + " 'outline: 0;' +\n", + " 'overflow: hidden;' +\n", + " 'position: relative;' +\n", + " 'resize: both;'\n", + " );\n", + "\n", + " function on_keyboard_event_closure(name) {\n", + " return function (event) {\n", + " return fig.key_event(event, name);\n", + " };\n", + " }\n", + "\n", + " canvas_div.addEventListener(\n", + " 'keydown',\n", + " on_keyboard_event_closure('key_press')\n", + " );\n", + " canvas_div.addEventListener(\n", + " 'keyup',\n", + " on_keyboard_event_closure('key_release')\n", + " );\n", + "\n", + " this._canvas_extra_style(canvas_div);\n", + " this.root.appendChild(canvas_div);\n", + "\n", + " var canvas = (this.canvas = document.createElement('canvas'));\n", + " canvas.classList.add('mpl-canvas');\n", + " canvas.setAttribute('style', 'box-sizing: content-box;');\n", + "\n", + " this.context = canvas.getContext('2d');\n", + "\n", + " var backingStore =\n", + " this.context.backingStorePixelRatio ||\n", + " this.context.webkitBackingStorePixelRatio ||\n", + " this.context.mozBackingStorePixelRatio ||\n", + " this.context.msBackingStorePixelRatio ||\n", + " this.context.oBackingStorePixelRatio ||\n", + " this.context.backingStorePixelRatio ||\n", + " 1;\n", + "\n", + " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", + " 'canvas'\n", + " ));\n", + " rubberband_canvas.setAttribute(\n", + " 'style',\n", + " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n", + " );\n", + "\n", + " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", + " if (this.ResizeObserver === undefined) {\n", + " if (window.ResizeObserver !== undefined) {\n", + " this.ResizeObserver = window.ResizeObserver;\n", + " } else {\n", + " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", + " this.ResizeObserver = obs.ResizeObserver;\n", + " }\n", + " }\n", + "\n", + " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", + " var nentries = entries.length;\n", + " for (var i = 0; i < nentries; i++) {\n", + " var entry = entries[i];\n", + " var width, height;\n", + " if (entry.contentBoxSize) {\n", + " if (entry.contentBoxSize instanceof Array) {\n", + " // Chrome 84 implements new version of spec.\n", + " width = entry.contentBoxSize[0].inlineSize;\n", + " height = entry.contentBoxSize[0].blockSize;\n", + " } else {\n", + " // Firefox implements old version of spec.\n", + " width = entry.contentBoxSize.inlineSize;\n", + " height = entry.contentBoxSize.blockSize;\n", + " }\n", + " } else {\n", + " // Chrome <84 implements even older version of spec.\n", + " width = entry.contentRect.width;\n", + " height = entry.contentRect.height;\n", + " }\n", + "\n", + " // Keep the size of the canvas and rubber band canvas in sync with\n", + " // the canvas container.\n", + " if (entry.devicePixelContentBoxSize) {\n", + " // Chrome 84 implements new version of spec.\n", + " canvas.setAttribute(\n", + " 'width',\n", + " entry.devicePixelContentBoxSize[0].inlineSize\n", + " );\n", + " canvas.setAttribute(\n", + " 'height',\n", + " entry.devicePixelContentBoxSize[0].blockSize\n", + " );\n", + " } else {\n", + " canvas.setAttribute('width', width * fig.ratio);\n", + " canvas.setAttribute('height', height * fig.ratio);\n", + " }\n", + " canvas.setAttribute(\n", + " 'style',\n", + " 'width: ' + width + 'px; height: ' + height + 'px;'\n", + " );\n", + "\n", + " rubberband_canvas.setAttribute('width', width);\n", + " rubberband_canvas.setAttribute('height', height);\n", + "\n", + " // And update the size in Python. We ignore the initial 0/0 size\n", + " // that occurs as the element is placed into the DOM, which should\n", + " // otherwise not happen due to the minimum size styling.\n", + " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", + " fig.request_resize(width, height);\n", + " }\n", + " }\n", + " });\n", + " this.resizeObserverInstance.observe(canvas_div);\n", + "\n", + " function on_mouse_event_closure(name) {\n", + " return function (event) {\n", + " return fig.mouse_event(event, name);\n", + " };\n", + " }\n", + "\n", + " rubberband_canvas.addEventListener(\n", + " 'mousedown',\n", + " on_mouse_event_closure('button_press')\n", + " );\n", + " rubberband_canvas.addEventListener(\n", + " 'mouseup',\n", + " on_mouse_event_closure('button_release')\n", + " );\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband_canvas.addEventListener(\n", + " 'mousemove',\n", + " on_mouse_event_closure('motion_notify')\n", + " );\n", + "\n", + " rubberband_canvas.addEventListener(\n", + " 'mouseenter',\n", + " on_mouse_event_closure('figure_enter')\n", + " );\n", + " rubberband_canvas.addEventListener(\n", + " 'mouseleave',\n", + " on_mouse_event_closure('figure_leave')\n", + " );\n", + "\n", + " canvas_div.addEventListener('wheel', function (event) {\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " on_mouse_event_closure('scroll')(event);\n", + " });\n", + "\n", + " canvas_div.appendChild(canvas);\n", + " canvas_div.appendChild(rubberband_canvas);\n", + "\n", + " this.rubberband_context = rubberband_canvas.getContext('2d');\n", + " this.rubberband_context.strokeStyle = '#000000';\n", + "\n", + " this._resize_canvas = function (width, height, forward) {\n", + " if (forward) {\n", + " canvas_div.style.width = width + 'px';\n", + " canvas_div.style.height = height + 'px';\n", + " }\n", + " };\n", + "\n", + " // Disable right mouse context menu.\n", + " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n", + " event.preventDefault();\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 toolbar = document.createElement('div');\n", + " toolbar.classList = 'mpl-toolbar';\n", + " this.root.appendChild(toolbar);\n", + "\n", + " function on_click_closure(name) {\n", + " return function (_event) {\n", + " return fig.toolbar_button_onclick(name);\n", + " };\n", + " }\n", + "\n", + " function on_mouseover_closure(tooltip) {\n", + " return function (event) {\n", + " if (!event.currentTarget.disabled) {\n", + " return fig.toolbar_button_onmouseover(tooltip);\n", + " }\n", + " };\n", + " }\n", + "\n", + " fig.buttons = {};\n", + " var buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'mpl-button-group';\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", + " /* Instead of a spacer, we start a new button group. */\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + " buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'mpl-button-group';\n", + " continue;\n", + " }\n", + "\n", + " var button = (fig.buttons[name] = document.createElement('button'));\n", + " button.classList = 'mpl-widget';\n", + " button.setAttribute('role', 'button');\n", + " button.setAttribute('aria-disabled', 'false');\n", + " button.addEventListener('click', on_click_closure(method_name));\n", + " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", + "\n", + " var icon_img = document.createElement('img');\n", + " icon_img.src = '_images/' + image + '.png';\n", + " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", + " icon_img.alt = tooltip;\n", + " button.appendChild(icon_img);\n", + "\n", + " buttonGroup.appendChild(button);\n", + " }\n", + "\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + "\n", + " var fmt_picker = document.createElement('select');\n", + " fmt_picker.classList = 'mpl-widget';\n", + " toolbar.appendChild(fmt_picker);\n", + " this.format_dropdown = fmt_picker;\n", + "\n", + " for (var ind in mpl.extensions) {\n", + " var fmt = mpl.extensions[ind];\n", + " var option = document.createElement('option');\n", + " option.selected = fmt === mpl.default_extension;\n", + " option.innerHTML = fmt;\n", + " fmt_picker.appendChild(option);\n", + " }\n", + "\n", + " var status_bar = document.createElement('span');\n", + " status_bar.classList = 'mpl-message';\n", + " toolbar.appendChild(status_bar);\n", + " this.message = status_bar;\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", + "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", + "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], msg['forward']);\n", + " fig.send_message('refresh', {});\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", + " var x0 = msg['x0'] / fig.ratio;\n", + " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", + " var x1 = msg['x1'] / fig.ratio;\n", + " var y1 = (fig.canvas.height - msg['y1']) / fig.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,\n", + " 0,\n", + " fig.canvas.width / fig.ratio,\n", + " fig.canvas.height / fig.ratio\n", + " );\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", + " 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.handle_history_buttons = function (fig, msg) {\n", + " for (var key in msg) {\n", + " if (!(key in fig.buttons)) {\n", + " continue;\n", + " }\n", + " fig.buttons[key].disabled = !msg[key];\n", + " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", + " if (msg['mode'] === 'PAN') {\n", + " fig.buttons['Pan'].classList.add('active');\n", + " fig.buttons['Zoom'].classList.remove('active');\n", + " } else if (msg['mode'] === 'ZOOM') {\n", + " fig.buttons['Pan'].classList.remove('active');\n", + " fig.buttons['Zoom'].classList.add('active');\n", + " } else {\n", + " fig.buttons['Pan'].classList.remove('active');\n", + " fig.buttons['Zoom'].classList.remove('active');\n", + " }\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", + "\n", + " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", + " evt.data\n", + " );\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " } else if (\n", + " typeof evt.data === 'string' &&\n", + " evt.data.slice(0, 21) === 'data:image/png;base64'\n", + " ) {\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(\n", + " \"No handler for the '\" + msg_type + \"' message type: \",\n", + " msg\n", + " );\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(\n", + " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", + " e,\n", + " e.stack,\n", + " msg\n", + " );\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", + " }\n", + " if (e.target) {\n", + " targ = e.target;\n", + " } else if (e.srcElement) {\n", + " targ = e.srcElement;\n", + " }\n", + " if (targ.nodeType === 3) {\n", + " // defeat Safari bug\n", + " targ = targ.parentNode;\n", + " }\n", + "\n", + " // pageX,Y are the mouse positions relative to the document\n", + " var boundingRect = targ.getBoundingClientRect();\n", + " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n", + " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\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", + " }\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", + " this.canvas.focus();\n", + " this.canvas_div.focus();\n", + " }\n", + "\n", + " var x = canvas_pos.x * this.ratio;\n", + " var y = canvas_pos.y * this.ratio;\n", + "\n", + " this.send_message(name, {\n", + " x: x,\n", + " y: y,\n", + " button: event.button,\n", + " step: event.step,\n", + " guiEvent: simpleKeys(event),\n", + " });\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", + " // Prevent repeat events\n", + " if (name === 'key_press') {\n", + " if (event.which === this._key) {\n", + " return;\n", + " } else {\n", + " this._key = event.which;\n", + " }\n", + " }\n", + " if (name === 'key_release') {\n", + " this._key = null;\n", + " }\n", + "\n", + " var value = '';\n", + " if (event.ctrlKey && event.which !== 17) {\n", + " value += 'ctrl+';\n", + " }\n", + " if (event.altKey && event.which !== 18) {\n", + " value += 'alt+';\n", + " }\n", + " if (event.shiftKey && event.which !== 16) {\n", + " value += 'shift+';\n", + " }\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, 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", + "\n", + "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", + "// prettier-ignore\n", + "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\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\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"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\";/* global mpl */\n", + "\n", + "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 = document.getElementById(id);\n", + " var ws_proxy = comm_websocket_adapter(comm);\n", + "\n", + " function ondownload(figure, _format) {\n", + " window.open(figure.canvas.toDataURL());\n", + " }\n", + "\n", + " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\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;\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", + " fig.cell_info[0].output_area.element.on(\n", + " 'cleared',\n", + " { fig: fig },\n", + " fig._remove_fig_handler\n", + " );\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_close = function (fig, msg) {\n", + " var width = fig.canvas.width / fig.ratio;\n", + " fig.cell_info[0].output_area.element.off(\n", + " 'cleared',\n", + " fig._remove_fig_handler\n", + " );\n", + " fig.resizeObserverInstance.unobserve(fig.canvas_div);\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.innerHTML =\n", + " '<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 / this.ratio;\n", + " var dataURL = this.canvas.toDataURL();\n", + " this.cell_info[1]['text/html'] =\n", + " '<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 () {\n", + " fig.push_to_output();\n", + " }, 1000);\n", + "};\n", + "\n", + "mpl.figure.prototype._init_toolbar = function () {\n", + " var fig = this;\n", + "\n", + " var toolbar = document.createElement('div');\n", + " toolbar.classList = 'btn-toolbar';\n", + " this.root.appendChild(toolbar);\n", + "\n", + " function on_click_closure(name) {\n", + " return function (_event) {\n", + " return fig.toolbar_button_onclick(name);\n", + " };\n", + " }\n", + "\n", + " function on_mouseover_closure(tooltip) {\n", + " return function (event) {\n", + " if (!event.currentTarget.disabled) {\n", + " return fig.toolbar_button_onmouseover(tooltip);\n", + " }\n", + " };\n", + " }\n", + "\n", + " fig.buttons = {};\n", + " var buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'btn-group';\n", + " var button;\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", + " /* Instead of a spacer, we start a new button group. */\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + " buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'btn-group';\n", + " continue;\n", + " }\n", + "\n", + " button = fig.buttons[name] = document.createElement('button');\n", + " button.classList = 'btn btn-default';\n", + " button.href = '#';\n", + " button.title = name;\n", + " button.innerHTML = '<i class=\"fa ' + image + ' fa-lg\"></i>';\n", + " button.addEventListener('click', on_click_closure(method_name));\n", + " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", + " buttonGroup.appendChild(button);\n", + " }\n", + "\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = document.createElement('span');\n", + " status_bar.classList = 'mpl-message pull-right';\n", + " toolbar.appendChild(status_bar);\n", + " this.message = status_bar;\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = document.createElement('div');\n", + " buttongrp.classList = 'btn-group inline pull-right';\n", + " button = document.createElement('button');\n", + " button.classList = 'btn btn-mini btn-primary';\n", + " button.href = '#';\n", + " button.title = 'Stop Interaction';\n", + " button.innerHTML = '<i class=\"fa fa-power-off icon-remove icon-large\"></i>';\n", + " button.addEventListener('click', function (_evt) {\n", + " fig.handle_close(fig, {});\n", + " });\n", + " button.addEventListener(\n", + " 'mouseover',\n", + " on_mouseover_closure('Stop Interaction')\n", + " );\n", + " buttongrp.appendChild(button);\n", + " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", + " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", + "};\n", + "\n", + "mpl.figure.prototype._remove_fig_handler = function (event) {\n", + " var fig = event.data.fig;\n", + " if (event.target !== this) {\n", + " // Ignore bubbled events from children.\n", + " return;\n", + " }\n", + " fig.close_ws(fig, {});\n", + "};\n", + "\n", + "mpl.figure.prototype._root_extra_style = function (el) {\n", + " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", + "};\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function (el) {\n", + " // this is important to make the div 'focusable\n", + " el.setAttribute('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", + " } else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\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", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which === 13) {\n", + " this.canvas_div.blur();\n", + " // select the cell after this one\n", + " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", + " IPython.notebook.select(index + 1);\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", + " fig.ondownload(fig, null);\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(\n", + " 'matplotlib',\n", + " mpl.mpl_figure_comm\n", + " );\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=\"1000\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "<matplotlib.colorbar.Colorbar at 0x7f727c1afc88>" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=[10,6])\n", + "\n", + "# -- valor máximo y mÃnimo de temperatura para poder definir valores del eje x\n", + "xmin = min( d_temp_min, ms_temp_min, g_temp_min, sg_temp_min )\n", + "xmax = max( d_temp_max, ms_temp_max, g_temp_max, sg_temp_max )\n", + "\n", + "# -- crear colores para las estrellas, de rojo (fria) a azul (caliente)\n", + "cmap = matplotlib.colors.LinearSegmentedColormap.from_list(\"\", [\"red\",\"yellow\",\"blue\"])\n", + "\n", + "# -- definir el tamaño del punto de acuerdo al radio\n", + "sd = all_stars['radius']\n", + "# -- x: temperatura, y: luminosidad, color: temperatura\n", + "# -- estoy haciendo el punto el doble del tamaño y el borde negro, solo porque me parece se ve mejor\n", + "# -- cmap: colores que defini un par de lineas arruba\n", + "im = ax.scatter(all_stars['temp'], all_stars['lum'] , c=all_stars['temp'],\n", + " s=sd*2, edgecolors='black',cmap=cmap)\n", + "\n", + "\n", + "# -- definir nombre de ejes y tÃtulo del gráfico\n", + "ax.set_xlabel('Temperatura (K)')\n", + "ax.set_ylabel('Luminosidad (L$_{sol}$) en escala logarÃtmica')\n", + "ax.set_title('Diagrama Hertzsprung-Russell', fontsize = 15)\n", + "\n", + "# -- definir limites del eje x, para que incremente de derecha a izquierda\n", + "ax.set_xlim(xmax+300, xmin-300)\n", + "# -- poner eje y en escala logarÃtimica para que se entienda mejor el gráfico\n", + "ax.set_yscale(\"log\")\n", + "\n", + "\n", + "# -- definir el label de cada grupo de estrellas, usando cantidad máximas y mÃnimas y ajustando\n", + "ax.text((d_temp_min+d_temp_max)/2, 2*(d_lum_max+d_lum_min)/2, 'Enanas Blancas',fontweight='bold')\n", + "ax.text(1.3*(ms_temp_min+ms_temp_max)/2, 5*(ms_lum_max+ms_lum_min)/2, 'Secuencia principal',fontweight='bold')\n", + "ax.text(g_temp_max+700, (g_lum_max+g_lum_min)/2, 'Gigantes',fontweight='bold')\n", + "ax.text((sg_temp_min+sg_temp_max)/2, sg_lum_min*0.3, 'Supergigantes',fontweight='bold')\n", + "\n", + "fig.colorbar(im, ax=ax)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Ejercicio No. 2\n", + "\n", + "Después de tener un diseño de base para el ejercicio No. 1, en este ejercicio se pide generar una animación, en la cual se reproduzca el mismo gráfico de antes pero las estrellas vayan apareciendo progresivamente." + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "/* global mpl */\n", + "window.mpl = {};\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(\n", + " '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", + "\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 = document.createElement('div');\n", + " this.root.setAttribute('style', 'display: inline-block');\n", + " this._root_extra_style(this.root);\n", + "\n", + " parent_element.appendChild(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 (fig.ratio !== 1) {\n", + " fig.send_message('set_dpi_ratio', { dpi_ratio: fig.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 = document.createElement('div');\n", + " titlebar.classList =\n", + " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", + " var titletext = document.createElement('div');\n", + " titletext.classList = 'ui-dialog-title';\n", + " titletext.setAttribute(\n", + " 'style',\n", + " 'width: 100%; text-align: center; padding: 3px;'\n", + " );\n", + " titlebar.appendChild(titletext);\n", + " this.root.appendChild(titlebar);\n", + " this.header = titletext;\n", + "};\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", + "\n", + "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", + "\n", + "mpl.figure.prototype._init_canvas = function () {\n", + " var fig = this;\n", + "\n", + " var canvas_div = (this.canvas_div = document.createElement('div'));\n", + " canvas_div.setAttribute(\n", + " 'style',\n", + " 'border: 1px solid #ddd;' +\n", + " 'box-sizing: content-box;' +\n", + " 'clear: both;' +\n", + " 'min-height: 1px;' +\n", + " 'min-width: 1px;' +\n", + " 'outline: 0;' +\n", + " 'overflow: hidden;' +\n", + " 'position: relative;' +\n", + " 'resize: both;'\n", + " );\n", + "\n", + " function on_keyboard_event_closure(name) {\n", + " return function (event) {\n", + " return fig.key_event(event, name);\n", + " };\n", + " }\n", + "\n", + " canvas_div.addEventListener(\n", + " 'keydown',\n", + " on_keyboard_event_closure('key_press')\n", + " );\n", + " canvas_div.addEventListener(\n", + " 'keyup',\n", + " on_keyboard_event_closure('key_release')\n", + " );\n", + "\n", + " this._canvas_extra_style(canvas_div);\n", + " this.root.appendChild(canvas_div);\n", + "\n", + " var canvas = (this.canvas = document.createElement('canvas'));\n", + " canvas.classList.add('mpl-canvas');\n", + " canvas.setAttribute('style', 'box-sizing: content-box;');\n", + "\n", + " this.context = canvas.getContext('2d');\n", + "\n", + " var backingStore =\n", + " this.context.backingStorePixelRatio ||\n", + " this.context.webkitBackingStorePixelRatio ||\n", + " this.context.mozBackingStorePixelRatio ||\n", + " this.context.msBackingStorePixelRatio ||\n", + " this.context.oBackingStorePixelRatio ||\n", + " this.context.backingStorePixelRatio ||\n", + " 1;\n", + "\n", + " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", + " 'canvas'\n", + " ));\n", + " rubberband_canvas.setAttribute(\n", + " 'style',\n", + " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n", + " );\n", + "\n", + " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", + " if (this.ResizeObserver === undefined) {\n", + " if (window.ResizeObserver !== undefined) {\n", + " this.ResizeObserver = window.ResizeObserver;\n", + " } else {\n", + " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", + " this.ResizeObserver = obs.ResizeObserver;\n", + " }\n", + " }\n", + "\n", + " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", + " var nentries = entries.length;\n", + " for (var i = 0; i < nentries; i++) {\n", + " var entry = entries[i];\n", + " var width, height;\n", + " if (entry.contentBoxSize) {\n", + " if (entry.contentBoxSize instanceof Array) {\n", + " // Chrome 84 implements new version of spec.\n", + " width = entry.contentBoxSize[0].inlineSize;\n", + " height = entry.contentBoxSize[0].blockSize;\n", + " } else {\n", + " // Firefox implements old version of spec.\n", + " width = entry.contentBoxSize.inlineSize;\n", + " height = entry.contentBoxSize.blockSize;\n", + " }\n", + " } else {\n", + " // Chrome <84 implements even older version of spec.\n", + " width = entry.contentRect.width;\n", + " height = entry.contentRect.height;\n", + " }\n", + "\n", + " // Keep the size of the canvas and rubber band canvas in sync with\n", + " // the canvas container.\n", + " if (entry.devicePixelContentBoxSize) {\n", + " // Chrome 84 implements new version of spec.\n", + " canvas.setAttribute(\n", + " 'width',\n", + " entry.devicePixelContentBoxSize[0].inlineSize\n", + " );\n", + " canvas.setAttribute(\n", + " 'height',\n", + " entry.devicePixelContentBoxSize[0].blockSize\n", + " );\n", + " } else {\n", + " canvas.setAttribute('width', width * fig.ratio);\n", + " canvas.setAttribute('height', height * fig.ratio);\n", + " }\n", + " canvas.setAttribute(\n", + " 'style',\n", + " 'width: ' + width + 'px; height: ' + height + 'px;'\n", + " );\n", + "\n", + " rubberband_canvas.setAttribute('width', width);\n", + " rubberband_canvas.setAttribute('height', height);\n", + "\n", + " // And update the size in Python. We ignore the initial 0/0 size\n", + " // that occurs as the element is placed into the DOM, which should\n", + " // otherwise not happen due to the minimum size styling.\n", + " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", + " fig.request_resize(width, height);\n", + " }\n", + " }\n", + " });\n", + " this.resizeObserverInstance.observe(canvas_div);\n", + "\n", + " function on_mouse_event_closure(name) {\n", + " return function (event) {\n", + " return fig.mouse_event(event, name);\n", + " };\n", + " }\n", + "\n", + " rubberband_canvas.addEventListener(\n", + " 'mousedown',\n", + " on_mouse_event_closure('button_press')\n", + " );\n", + " rubberband_canvas.addEventListener(\n", + " 'mouseup',\n", + " on_mouse_event_closure('button_release')\n", + " );\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband_canvas.addEventListener(\n", + " 'mousemove',\n", + " on_mouse_event_closure('motion_notify')\n", + " );\n", + "\n", + " rubberband_canvas.addEventListener(\n", + " 'mouseenter',\n", + " on_mouse_event_closure('figure_enter')\n", + " );\n", + " rubberband_canvas.addEventListener(\n", + " 'mouseleave',\n", + " on_mouse_event_closure('figure_leave')\n", + " );\n", + "\n", + " canvas_div.addEventListener('wheel', function (event) {\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " on_mouse_event_closure('scroll')(event);\n", + " });\n", + "\n", + " canvas_div.appendChild(canvas);\n", + " canvas_div.appendChild(rubberband_canvas);\n", + "\n", + " this.rubberband_context = rubberband_canvas.getContext('2d');\n", + " this.rubberband_context.strokeStyle = '#000000';\n", + "\n", + " this._resize_canvas = function (width, height, forward) {\n", + " if (forward) {\n", + " canvas_div.style.width = width + 'px';\n", + " canvas_div.style.height = height + 'px';\n", + " }\n", + " };\n", + "\n", + " // Disable right mouse context menu.\n", + " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n", + " event.preventDefault();\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 toolbar = document.createElement('div');\n", + " toolbar.classList = 'mpl-toolbar';\n", + " this.root.appendChild(toolbar);\n", + "\n", + " function on_click_closure(name) {\n", + " return function (_event) {\n", + " return fig.toolbar_button_onclick(name);\n", + " };\n", + " }\n", + "\n", + " function on_mouseover_closure(tooltip) {\n", + " return function (event) {\n", + " if (!event.currentTarget.disabled) {\n", + " return fig.toolbar_button_onmouseover(tooltip);\n", + " }\n", + " };\n", + " }\n", + "\n", + " fig.buttons = {};\n", + " var buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'mpl-button-group';\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", + " /* Instead of a spacer, we start a new button group. */\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + " buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'mpl-button-group';\n", + " continue;\n", + " }\n", + "\n", + " var button = (fig.buttons[name] = document.createElement('button'));\n", + " button.classList = 'mpl-widget';\n", + " button.setAttribute('role', 'button');\n", + " button.setAttribute('aria-disabled', 'false');\n", + " button.addEventListener('click', on_click_closure(method_name));\n", + " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", + "\n", + " var icon_img = document.createElement('img');\n", + " icon_img.src = '_images/' + image + '.png';\n", + " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", + " icon_img.alt = tooltip;\n", + " button.appendChild(icon_img);\n", + "\n", + " buttonGroup.appendChild(button);\n", + " }\n", + "\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + "\n", + " var fmt_picker = document.createElement('select');\n", + " fmt_picker.classList = 'mpl-widget';\n", + " toolbar.appendChild(fmt_picker);\n", + " this.format_dropdown = fmt_picker;\n", + "\n", + " for (var ind in mpl.extensions) {\n", + " var fmt = mpl.extensions[ind];\n", + " var option = document.createElement('option');\n", + " option.selected = fmt === mpl.default_extension;\n", + " option.innerHTML = fmt;\n", + " fmt_picker.appendChild(option);\n", + " }\n", + "\n", + " var status_bar = document.createElement('span');\n", + " status_bar.classList = 'mpl-message';\n", + " toolbar.appendChild(status_bar);\n", + " this.message = status_bar;\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", + "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", + "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], msg['forward']);\n", + " fig.send_message('refresh', {});\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", + " var x0 = msg['x0'] / fig.ratio;\n", + " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", + " var x1 = msg['x1'] / fig.ratio;\n", + " var y1 = (fig.canvas.height - msg['y1']) / fig.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,\n", + " 0,\n", + " fig.canvas.width / fig.ratio,\n", + " fig.canvas.height / fig.ratio\n", + " );\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", + " 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.handle_history_buttons = function (fig, msg) {\n", + " for (var key in msg) {\n", + " if (!(key in fig.buttons)) {\n", + " continue;\n", + " }\n", + " fig.buttons[key].disabled = !msg[key];\n", + " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", + " if (msg['mode'] === 'PAN') {\n", + " fig.buttons['Pan'].classList.add('active');\n", + " fig.buttons['Zoom'].classList.remove('active');\n", + " } else if (msg['mode'] === 'ZOOM') {\n", + " fig.buttons['Pan'].classList.remove('active');\n", + " fig.buttons['Zoom'].classList.add('active');\n", + " } else {\n", + " fig.buttons['Pan'].classList.remove('active');\n", + " fig.buttons['Zoom'].classList.remove('active');\n", + " }\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", + "\n", + " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", + " evt.data\n", + " );\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " } else if (\n", + " typeof evt.data === 'string' &&\n", + " evt.data.slice(0, 21) === 'data:image/png;base64'\n", + " ) {\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(\n", + " \"No handler for the '\" + msg_type + \"' message type: \",\n", + " msg\n", + " );\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(\n", + " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", + " e,\n", + " e.stack,\n", + " msg\n", + " );\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", + " }\n", + " if (e.target) {\n", + " targ = e.target;\n", + " } else if (e.srcElement) {\n", + " targ = e.srcElement;\n", + " }\n", + " if (targ.nodeType === 3) {\n", + " // defeat Safari bug\n", + " targ = targ.parentNode;\n", + " }\n", + "\n", + " // pageX,Y are the mouse positions relative to the document\n", + " var boundingRect = targ.getBoundingClientRect();\n", + " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n", + " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\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", + " }\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", + " this.canvas.focus();\n", + " this.canvas_div.focus();\n", + " }\n", + "\n", + " var x = canvas_pos.x * this.ratio;\n", + " var y = canvas_pos.y * this.ratio;\n", + "\n", + " this.send_message(name, {\n", + " x: x,\n", + " y: y,\n", + " button: event.button,\n", + " step: event.step,\n", + " guiEvent: simpleKeys(event),\n", + " });\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", + " // Prevent repeat events\n", + " if (name === 'key_press') {\n", + " if (event.which === this._key) {\n", + " return;\n", + " } else {\n", + " this._key = event.which;\n", + " }\n", + " }\n", + " if (name === 'key_release') {\n", + " this._key = null;\n", + " }\n", + "\n", + " var value = '';\n", + " if (event.ctrlKey && event.which !== 17) {\n", + " value += 'ctrl+';\n", + " }\n", + " if (event.altKey && event.which !== 18) {\n", + " value += 'alt+';\n", + " }\n", + " if (event.shiftKey && event.which !== 16) {\n", + " value += 'shift+';\n", + " }\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, 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", + "\n", + "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", + "// prettier-ignore\n", + "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\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\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"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\";/* global mpl */\n", + "\n", + "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 = document.getElementById(id);\n", + " var ws_proxy = comm_websocket_adapter(comm);\n", + "\n", + " function ondownload(figure, _format) {\n", + " window.open(figure.canvas.toDataURL());\n", + " }\n", + "\n", + " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\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;\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", + " fig.cell_info[0].output_area.element.on(\n", + " 'cleared',\n", + " { fig: fig },\n", + " fig._remove_fig_handler\n", + " );\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_close = function (fig, msg) {\n", + " var width = fig.canvas.width / fig.ratio;\n", + " fig.cell_info[0].output_area.element.off(\n", + " 'cleared',\n", + " fig._remove_fig_handler\n", + " );\n", + " fig.resizeObserverInstance.unobserve(fig.canvas_div);\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.innerHTML =\n", + " '<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 / this.ratio;\n", + " var dataURL = this.canvas.toDataURL();\n", + " this.cell_info[1]['text/html'] =\n", + " '<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 () {\n", + " fig.push_to_output();\n", + " }, 1000);\n", + "};\n", + "\n", + "mpl.figure.prototype._init_toolbar = function () {\n", + " var fig = this;\n", + "\n", + " var toolbar = document.createElement('div');\n", + " toolbar.classList = 'btn-toolbar';\n", + " this.root.appendChild(toolbar);\n", + "\n", + " function on_click_closure(name) {\n", + " return function (_event) {\n", + " return fig.toolbar_button_onclick(name);\n", + " };\n", + " }\n", + "\n", + " function on_mouseover_closure(tooltip) {\n", + " return function (event) {\n", + " if (!event.currentTarget.disabled) {\n", + " return fig.toolbar_button_onmouseover(tooltip);\n", + " }\n", + " };\n", + " }\n", + "\n", + " fig.buttons = {};\n", + " var buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'btn-group';\n", + " var button;\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", + " /* Instead of a spacer, we start a new button group. */\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + " buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'btn-group';\n", + " continue;\n", + " }\n", + "\n", + " button = fig.buttons[name] = document.createElement('button');\n", + " button.classList = 'btn btn-default';\n", + " button.href = '#';\n", + " button.title = name;\n", + " button.innerHTML = '<i class=\"fa ' + image + ' fa-lg\"></i>';\n", + " button.addEventListener('click', on_click_closure(method_name));\n", + " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", + " buttonGroup.appendChild(button);\n", + " }\n", + "\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = document.createElement('span');\n", + " status_bar.classList = 'mpl-message pull-right';\n", + " toolbar.appendChild(status_bar);\n", + " this.message = status_bar;\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = document.createElement('div');\n", + " buttongrp.classList = 'btn-group inline pull-right';\n", + " button = document.createElement('button');\n", + " button.classList = 'btn btn-mini btn-primary';\n", + " button.href = '#';\n", + " button.title = 'Stop Interaction';\n", + " button.innerHTML = '<i class=\"fa fa-power-off icon-remove icon-large\"></i>';\n", + " button.addEventListener('click', function (_evt) {\n", + " fig.handle_close(fig, {});\n", + " });\n", + " button.addEventListener(\n", + " 'mouseover',\n", + " on_mouseover_closure('Stop Interaction')\n", + " );\n", + " buttongrp.appendChild(button);\n", + " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", + " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", + "};\n", + "\n", + "mpl.figure.prototype._remove_fig_handler = function (event) {\n", + " var fig = event.data.fig;\n", + " if (event.target !== this) {\n", + " // Ignore bubbled events from children.\n", + " return;\n", + " }\n", + " fig.close_ws(fig, {});\n", + "};\n", + "\n", + "mpl.figure.prototype._root_extra_style = function (el) {\n", + " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", + "};\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function (el) {\n", + " // this is important to make the div 'focusable\n", + " el.setAttribute('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", + " } else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\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", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which === 13) {\n", + " this.canvas_div.blur();\n", + " // select the cell after this one\n", + " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", + " IPython.notebook.select(index + 1);\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", + " fig.ondownload(fig, null);\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(\n", + " 'matplotlib',\n", + " mpl.mpl_figure_comm\n", + " );\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=\"1000\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=[10,6])\n", + "\n", + "# -- valor máximo y mÃnimo de temperatura para poder definir valores del eje x\n", + "xmin = min( d_temp_min, ms_temp_min, g_temp_min, sg_temp_min )\n", + "xmax = max( d_temp_max, ms_temp_max, g_temp_max, sg_temp_max )\n", + "\n", + "# -- crear colores para las estrellas, de rojo (fria) a azul (caliente)\n", + "cmap = matplotlib.colors.LinearSegmentedColormap.from_list(\"\", [\"red\",\"yellow\",\"blue\"])\n", + "\n", + "# -- definir el tamaño del punto de acuerdo al radio\n", + "sd = all_stars['radius']\n", + "# -- x: temperatura, y: luminosidad, color: temperatura\n", + "# -- estoy haciendo el punto el doble del tamaño y el borde negro, solo porque me parece se ve mejor\n", + "# -- cmap: colores que defini un par de lineas arruba\n", + "\n", + "im = ax.scatter(all_stars['temp'], all_stars['lum'], c=all_stars['temp'],edgecolors='black',cmap=cmap)\n", + "\n", + "\n", + "# -- definir nombre de ejes y tÃtulo del gráfico\n", + "ax.set_xlabel('Temperatura (K)')\n", + "ax.set_ylabel('Luminosidad (L$_{sol}$) en escala logarÃtmica')\n", + "ax.set_title('Diagrama Hertzsprung-Russell', fontsize = 15)\n", + "\n", + "# -- definir limites del eje x, para que incremente de derecha a izquierda\n", + "ax.set_xlim(xmax+300, xmin-300)\n", + "# -- poner eje y en escala logarÃtimica para que se entienda mejor el gráfico\n", + "ax.set_yscale(\"log\")\n", + "\n", + "\n", + "# -- definir el label de cada grupo de estrellas, usando cantidad máximas y mÃnimas y ajustando\n", + "ax.text((d_temp_min+d_temp_max)/2, 2*(d_lum_max+d_lum_min)/2, 'Enanas Blancas',fontweight='bold')\n", + "ax.text(1.3*(ms_temp_min+ms_temp_max)/2, 5*(ms_lum_max+ms_lum_min)/2, 'Secuencia principal',fontweight='bold')\n", + "ax.text(g_temp_max+700, (g_lum_max+g_lum_min)/2, 'Gigantes',fontweight='bold')\n", + "ax.text((sg_temp_min+sg_temp_max)/2, sg_lum_min*0.3, 'Supergigantes',fontweight='bold')\n", + "\n", + "# textos = ['Enanas Blancas','Secuencia principal']\n", + "# posicion = [((d_temp_min+d_temp_max)/2, 2*(d_lum_max+d_lum_min)/2),(1.3*(ms_temp_min+ms_temp_max)/2,5*(ms_lum_max+ms_lum_min)/2 )]\n", + "\n", + "# an1 = ax.annotate('Enanas Blancas', xy = ((d_temp_min+d_temp_max)/2, 2*(d_lum_max+d_lum_min)/2))\n", + "\n", + "\n", + "fig.colorbar(im, ax=ax)\n", + "\n", + "\n", + "datas = list(zip(all_stars['temp'], all_stars['lum']))\n", + "\n", + "x,y = [],[]\n", + "r = []\n", + "def animate(i):\n", + " x.append(all_stars['temp'][i])\n", + " y.append(all_stars['lum'][i])\n", + " im.set_offsets(np.c_[x,y])\n", + " im.set_array(np.array(x))\n", + " r.append(all_stars['radius'][i])\n", + " im.set_sizes(np.array(r))\n", + "# an1.set_text[textos[107]]\n", + "# an1.set_positon[posicion[107]]\n", + " return im\n", + "\n", + "ani = FuncAnimation (fig, animate, frames=108, interval=50)\n", + "#ani\n", + "#ani.save('sine_wave.gif')" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "/* global mpl */\n", + "window.mpl = {};\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(\n", + " '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", + "\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 = document.createElement('div');\n", + " this.root.setAttribute('style', 'display: inline-block');\n", + " this._root_extra_style(this.root);\n", + "\n", + " parent_element.appendChild(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 (fig.ratio !== 1) {\n", + " fig.send_message('set_dpi_ratio', { dpi_ratio: fig.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 = document.createElement('div');\n", + " titlebar.classList =\n", + " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", + " var titletext = document.createElement('div');\n", + " titletext.classList = 'ui-dialog-title';\n", + " titletext.setAttribute(\n", + " 'style',\n", + " 'width: 100%; text-align: center; padding: 3px;'\n", + " );\n", + " titlebar.appendChild(titletext);\n", + " this.root.appendChild(titlebar);\n", + " this.header = titletext;\n", + "};\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", + "\n", + "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", + "\n", + "mpl.figure.prototype._init_canvas = function () {\n", + " var fig = this;\n", + "\n", + " var canvas_div = (this.canvas_div = document.createElement('div'));\n", + " canvas_div.setAttribute(\n", + " 'style',\n", + " 'border: 1px solid #ddd;' +\n", + " 'box-sizing: content-box;' +\n", + " 'clear: both;' +\n", + " 'min-height: 1px;' +\n", + " 'min-width: 1px;' +\n", + " 'outline: 0;' +\n", + " 'overflow: hidden;' +\n", + " 'position: relative;' +\n", + " 'resize: both;'\n", + " );\n", + "\n", + " function on_keyboard_event_closure(name) {\n", + " return function (event) {\n", + " return fig.key_event(event, name);\n", + " };\n", + " }\n", + "\n", + " canvas_div.addEventListener(\n", + " 'keydown',\n", + " on_keyboard_event_closure('key_press')\n", + " );\n", + " canvas_div.addEventListener(\n", + " 'keyup',\n", + " on_keyboard_event_closure('key_release')\n", + " );\n", + "\n", + " this._canvas_extra_style(canvas_div);\n", + " this.root.appendChild(canvas_div);\n", + "\n", + " var canvas = (this.canvas = document.createElement('canvas'));\n", + " canvas.classList.add('mpl-canvas');\n", + " canvas.setAttribute('style', 'box-sizing: content-box;');\n", + "\n", + " this.context = canvas.getContext('2d');\n", + "\n", + " var backingStore =\n", + " this.context.backingStorePixelRatio ||\n", + " this.context.webkitBackingStorePixelRatio ||\n", + " this.context.mozBackingStorePixelRatio ||\n", + " this.context.msBackingStorePixelRatio ||\n", + " this.context.oBackingStorePixelRatio ||\n", + " this.context.backingStorePixelRatio ||\n", + " 1;\n", + "\n", + " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", + " 'canvas'\n", + " ));\n", + " rubberband_canvas.setAttribute(\n", + " 'style',\n", + " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n", + " );\n", + "\n", + " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", + " if (this.ResizeObserver === undefined) {\n", + " if (window.ResizeObserver !== undefined) {\n", + " this.ResizeObserver = window.ResizeObserver;\n", + " } else {\n", + " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", + " this.ResizeObserver = obs.ResizeObserver;\n", + " }\n", + " }\n", + "\n", + " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", + " var nentries = entries.length;\n", + " for (var i = 0; i < nentries; i++) {\n", + " var entry = entries[i];\n", + " var width, height;\n", + " if (entry.contentBoxSize) {\n", + " if (entry.contentBoxSize instanceof Array) {\n", + " // Chrome 84 implements new version of spec.\n", + " width = entry.contentBoxSize[0].inlineSize;\n", + " height = entry.contentBoxSize[0].blockSize;\n", + " } else {\n", + " // Firefox implements old version of spec.\n", + " width = entry.contentBoxSize.inlineSize;\n", + " height = entry.contentBoxSize.blockSize;\n", + " }\n", + " } else {\n", + " // Chrome <84 implements even older version of spec.\n", + " width = entry.contentRect.width;\n", + " height = entry.contentRect.height;\n", + " }\n", + "\n", + " // Keep the size of the canvas and rubber band canvas in sync with\n", + " // the canvas container.\n", + " if (entry.devicePixelContentBoxSize) {\n", + " // Chrome 84 implements new version of spec.\n", + " canvas.setAttribute(\n", + " 'width',\n", + " entry.devicePixelContentBoxSize[0].inlineSize\n", + " );\n", + " canvas.setAttribute(\n", + " 'height',\n", + " entry.devicePixelContentBoxSize[0].blockSize\n", + " );\n", + " } else {\n", + " canvas.setAttribute('width', width * fig.ratio);\n", + " canvas.setAttribute('height', height * fig.ratio);\n", + " }\n", + " canvas.setAttribute(\n", + " 'style',\n", + " 'width: ' + width + 'px; height: ' + height + 'px;'\n", + " );\n", + "\n", + " rubberband_canvas.setAttribute('width', width);\n", + " rubberband_canvas.setAttribute('height', height);\n", + "\n", + " // And update the size in Python. We ignore the initial 0/0 size\n", + " // that occurs as the element is placed into the DOM, which should\n", + " // otherwise not happen due to the minimum size styling.\n", + " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", + " fig.request_resize(width, height);\n", + " }\n", + " }\n", + " });\n", + " this.resizeObserverInstance.observe(canvas_div);\n", + "\n", + " function on_mouse_event_closure(name) {\n", + " return function (event) {\n", + " return fig.mouse_event(event, name);\n", + " };\n", + " }\n", + "\n", + " rubberband_canvas.addEventListener(\n", + " 'mousedown',\n", + " on_mouse_event_closure('button_press')\n", + " );\n", + " rubberband_canvas.addEventListener(\n", + " 'mouseup',\n", + " on_mouse_event_closure('button_release')\n", + " );\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband_canvas.addEventListener(\n", + " 'mousemove',\n", + " on_mouse_event_closure('motion_notify')\n", + " );\n", + "\n", + " rubberband_canvas.addEventListener(\n", + " 'mouseenter',\n", + " on_mouse_event_closure('figure_enter')\n", + " );\n", + " rubberband_canvas.addEventListener(\n", + " 'mouseleave',\n", + " on_mouse_event_closure('figure_leave')\n", + " );\n", + "\n", + " canvas_div.addEventListener('wheel', function (event) {\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " on_mouse_event_closure('scroll')(event);\n", + " });\n", + "\n", + " canvas_div.appendChild(canvas);\n", + " canvas_div.appendChild(rubberband_canvas);\n", + "\n", + " this.rubberband_context = rubberband_canvas.getContext('2d');\n", + " this.rubberband_context.strokeStyle = '#000000';\n", + "\n", + " this._resize_canvas = function (width, height, forward) {\n", + " if (forward) {\n", + " canvas_div.style.width = width + 'px';\n", + " canvas_div.style.height = height + 'px';\n", + " }\n", + " };\n", + "\n", + " // Disable right mouse context menu.\n", + " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n", + " event.preventDefault();\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 toolbar = document.createElement('div');\n", + " toolbar.classList = 'mpl-toolbar';\n", + " this.root.appendChild(toolbar);\n", + "\n", + " function on_click_closure(name) {\n", + " return function (_event) {\n", + " return fig.toolbar_button_onclick(name);\n", + " };\n", + " }\n", + "\n", + " function on_mouseover_closure(tooltip) {\n", + " return function (event) {\n", + " if (!event.currentTarget.disabled) {\n", + " return fig.toolbar_button_onmouseover(tooltip);\n", + " }\n", + " };\n", + " }\n", + "\n", + " fig.buttons = {};\n", + " var buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'mpl-button-group';\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", + " /* Instead of a spacer, we start a new button group. */\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + " buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'mpl-button-group';\n", + " continue;\n", + " }\n", + "\n", + " var button = (fig.buttons[name] = document.createElement('button'));\n", + " button.classList = 'mpl-widget';\n", + " button.setAttribute('role', 'button');\n", + " button.setAttribute('aria-disabled', 'false');\n", + " button.addEventListener('click', on_click_closure(method_name));\n", + " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", + "\n", + " var icon_img = document.createElement('img');\n", + " icon_img.src = '_images/' + image + '.png';\n", + " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", + " icon_img.alt = tooltip;\n", + " button.appendChild(icon_img);\n", + "\n", + " buttonGroup.appendChild(button);\n", + " }\n", + "\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + "\n", + " var fmt_picker = document.createElement('select');\n", + " fmt_picker.classList = 'mpl-widget';\n", + " toolbar.appendChild(fmt_picker);\n", + " this.format_dropdown = fmt_picker;\n", + "\n", + " for (var ind in mpl.extensions) {\n", + " var fmt = mpl.extensions[ind];\n", + " var option = document.createElement('option');\n", + " option.selected = fmt === mpl.default_extension;\n", + " option.innerHTML = fmt;\n", + " fmt_picker.appendChild(option);\n", + " }\n", + "\n", + " var status_bar = document.createElement('span');\n", + " status_bar.classList = 'mpl-message';\n", + " toolbar.appendChild(status_bar);\n", + " this.message = status_bar;\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", + "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", + "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], msg['forward']);\n", + " fig.send_message('refresh', {});\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", + " var x0 = msg['x0'] / fig.ratio;\n", + " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", + " var x1 = msg['x1'] / fig.ratio;\n", + " var y1 = (fig.canvas.height - msg['y1']) / fig.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,\n", + " 0,\n", + " fig.canvas.width / fig.ratio,\n", + " fig.canvas.height / fig.ratio\n", + " );\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", + " 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.handle_history_buttons = function (fig, msg) {\n", + " for (var key in msg) {\n", + " if (!(key in fig.buttons)) {\n", + " continue;\n", + " }\n", + " fig.buttons[key].disabled = !msg[key];\n", + " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", + " if (msg['mode'] === 'PAN') {\n", + " fig.buttons['Pan'].classList.add('active');\n", + " fig.buttons['Zoom'].classList.remove('active');\n", + " } else if (msg['mode'] === 'ZOOM') {\n", + " fig.buttons['Pan'].classList.remove('active');\n", + " fig.buttons['Zoom'].classList.add('active');\n", + " } else {\n", + " fig.buttons['Pan'].classList.remove('active');\n", + " fig.buttons['Zoom'].classList.remove('active');\n", + " }\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", + "\n", + " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", + " evt.data\n", + " );\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " } else if (\n", + " typeof evt.data === 'string' &&\n", + " evt.data.slice(0, 21) === 'data:image/png;base64'\n", + " ) {\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(\n", + " \"No handler for the '\" + msg_type + \"' message type: \",\n", + " msg\n", + " );\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(\n", + " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", + " e,\n", + " e.stack,\n", + " msg\n", + " );\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", + " }\n", + " if (e.target) {\n", + " targ = e.target;\n", + " } else if (e.srcElement) {\n", + " targ = e.srcElement;\n", + " }\n", + " if (targ.nodeType === 3) {\n", + " // defeat Safari bug\n", + " targ = targ.parentNode;\n", + " }\n", + "\n", + " // pageX,Y are the mouse positions relative to the document\n", + " var boundingRect = targ.getBoundingClientRect();\n", + " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n", + " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\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", + " }\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", + " this.canvas.focus();\n", + " this.canvas_div.focus();\n", + " }\n", + "\n", + " var x = canvas_pos.x * this.ratio;\n", + " var y = canvas_pos.y * this.ratio;\n", + "\n", + " this.send_message(name, {\n", + " x: x,\n", + " y: y,\n", + " button: event.button,\n", + " step: event.step,\n", + " guiEvent: simpleKeys(event),\n", + " });\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", + " // Prevent repeat events\n", + " if (name === 'key_press') {\n", + " if (event.which === this._key) {\n", + " return;\n", + " } else {\n", + " this._key = event.which;\n", + " }\n", + " }\n", + " if (name === 'key_release') {\n", + " this._key = null;\n", + " }\n", + "\n", + " var value = '';\n", + " if (event.ctrlKey && event.which !== 17) {\n", + " value += 'ctrl+';\n", + " }\n", + " if (event.altKey && event.which !== 18) {\n", + " value += 'alt+';\n", + " }\n", + " if (event.shiftKey && event.which !== 16) {\n", + " value += 'shift+';\n", + " }\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, 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", + "\n", + "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", + "// prettier-ignore\n", + "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\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\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"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\";/* global mpl */\n", + "\n", + "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 = document.getElementById(id);\n", + " var ws_proxy = comm_websocket_adapter(comm);\n", + "\n", + " function ondownload(figure, _format) {\n", + " window.open(figure.canvas.toDataURL());\n", + " }\n", + "\n", + " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\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;\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", + " fig.cell_info[0].output_area.element.on(\n", + " 'cleared',\n", + " { fig: fig },\n", + " fig._remove_fig_handler\n", + " );\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_close = function (fig, msg) {\n", + " var width = fig.canvas.width / fig.ratio;\n", + " fig.cell_info[0].output_area.element.off(\n", + " 'cleared',\n", + " fig._remove_fig_handler\n", + " );\n", + " fig.resizeObserverInstance.unobserve(fig.canvas_div);\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.innerHTML =\n", + " '<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 / this.ratio;\n", + " var dataURL = this.canvas.toDataURL();\n", + " this.cell_info[1]['text/html'] =\n", + " '<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 () {\n", + " fig.push_to_output();\n", + " }, 1000);\n", + "};\n", + "\n", + "mpl.figure.prototype._init_toolbar = function () {\n", + " var fig = this;\n", + "\n", + " var toolbar = document.createElement('div');\n", + " toolbar.classList = 'btn-toolbar';\n", + " this.root.appendChild(toolbar);\n", + "\n", + " function on_click_closure(name) {\n", + " return function (_event) {\n", + " return fig.toolbar_button_onclick(name);\n", + " };\n", + " }\n", + "\n", + " function on_mouseover_closure(tooltip) {\n", + " return function (event) {\n", + " if (!event.currentTarget.disabled) {\n", + " return fig.toolbar_button_onmouseover(tooltip);\n", + " }\n", + " };\n", + " }\n", + "\n", + " fig.buttons = {};\n", + " var buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'btn-group';\n", + " var button;\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", + " /* Instead of a spacer, we start a new button group. */\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + " buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'btn-group';\n", + " continue;\n", + " }\n", + "\n", + " button = fig.buttons[name] = document.createElement('button');\n", + " button.classList = 'btn btn-default';\n", + " button.href = '#';\n", + " button.title = name;\n", + " button.innerHTML = '<i class=\"fa ' + image + ' fa-lg\"></i>';\n", + " button.addEventListener('click', on_click_closure(method_name));\n", + " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", + " buttonGroup.appendChild(button);\n", + " }\n", + "\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = document.createElement('span');\n", + " status_bar.classList = 'mpl-message pull-right';\n", + " toolbar.appendChild(status_bar);\n", + " this.message = status_bar;\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = document.createElement('div');\n", + " buttongrp.classList = 'btn-group inline pull-right';\n", + " button = document.createElement('button');\n", + " button.classList = 'btn btn-mini btn-primary';\n", + " button.href = '#';\n", + " button.title = 'Stop Interaction';\n", + " button.innerHTML = '<i class=\"fa fa-power-off icon-remove icon-large\"></i>';\n", + " button.addEventListener('click', function (_evt) {\n", + " fig.handle_close(fig, {});\n", + " });\n", + " button.addEventListener(\n", + " 'mouseover',\n", + " on_mouseover_closure('Stop Interaction')\n", + " );\n", + " buttongrp.appendChild(button);\n", + " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", + " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", + "};\n", + "\n", + "mpl.figure.prototype._remove_fig_handler = function (event) {\n", + " var fig = event.data.fig;\n", + " if (event.target !== this) {\n", + " // Ignore bubbled events from children.\n", + " return;\n", + " }\n", + " fig.close_ws(fig, {});\n", + "};\n", + "\n", + "mpl.figure.prototype._root_extra_style = function (el) {\n", + " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", + "};\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function (el) {\n", + " // this is important to make the div 'focusable\n", + " el.setAttribute('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", + " } else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\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", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which === 13) {\n", + " this.canvas_div.blur();\n", + " // select the cell after this one\n", + " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", + " IPython.notebook.select(index + 1);\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", + " fig.ondownload(fig, null);\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(\n", + " 'matplotlib',\n", + " mpl.mpl_figure_comm\n", + " );\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=\"800\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x_data = np.random.randint(80, size=(400, 4))\n", + "y_data = np.random.randint(80, size=(400, 4))\n", + "\n", + "\n", + "fig, ax = plt.subplots(figsize = (8,6))\n", + "ax.set_xlim(0,80)\n", + "ax.set_ylim(0,80)\n", + "\n", + "text = ['Subject 1','Subject 2']\n", + "scatter = ax.scatter(x_data[0], y_data[0], zorder = 5) #Scatter plot\n", + "\n", + "annotation = ax.annotate(' Subject 1', xy=(x_data[0,2],y_data[0,2]))\n", + "\n", + "arrow = ax.annotate('', xy = (x_data[0,0], y_data[0,0]), \n", + " xytext = (x_data[0,1],y_data[0,1]), \n", + " arrowprops = {'arrowstyle': \"<->\"})\n", + "\n", + "def animate(i) : \n", + " scatter.set_offsets(np.c_[x_data[i,:], y_data[i,:]])\n", + "\n", + " annotation.set_position((x_data[i,2], y_data[i,2]))\n", + " \n", + " annotation.set_text((text[i]))\n", + "\n", + " start = (x_data[i,0], y_data[i,0]) \n", + " end = (x_data[i,1], y_data[i,1])\n", + " arrow.set_position(start)\n", + " arrow.xy = end\n", + "\n", + "ani = FuncAnimation(fig, animate, frames=len(x_data), \n", + " interval = 700, blit = False)\n" + ] + }, + { + "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.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/ejercicio1y2.ipynb b/ejercicio1y2.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..b39cb6347a22a2144a99e6c16db14d9799ca52b0 --- /dev/null +++ b/ejercicio1y2.ipynb @@ -0,0 +1,3732 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Tatiana Acero Cuellar\n", + "### Universidad Nacional de Colombia\n", + "#### Ejercicios Semana 3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Ejercicio No. 1\n", + "\n", + "* Investigue sobre el diagrama de Hertzprung-Russell, una herramienta muy potente en astronomia, y describa un poco al respecto para darle contexto al resto de la tarea.\n", + "\n", + "\n", + "* El objetivo es generar un diagrama HR lo más parecido al de esta referencia. No lucirá idéntico por que no se usarán exactamente los mismos datos, y las unidades pueden ser ligeramente distinta. La idea sà es dejar su figura lo más parecida a la de referencia en el estilo: colores, escalas en los ejes, tamaño de los marcadores, leyendas, textos en el gráfico, etc.\n", + "\n", + "\n", + "* Los datos para crear la figura están en la carpeta Data. Cada tabla contiene las informaciones sobre un tipo de estrellas según indican los nombres de archivo. La información viene en 3 columnas: luminosidad en luminosidades solares, Temperatura en Kelvin y Radio de la estrella en unidades arbitrarias.\n", + "\n", + "\n", + "* La idea es que cada estrella en el gráfico tenga un color representativo de su temperatura (que estrellas frÃas son rojas y estrellas calientes son azules) y que el tamaño del sÃmbolo sea representativo del tamaño de cada estrella para diferenciar entre enanas, gigantes y estrellas de secuencia principal.\n", + "\n", + "\n", + "* Busque que su código sea semi automático; es indispensable leer los datos desde el propio programa, no copiarlos a mano, y hallar una forma de obtener los tamaños y colores sin declararlos uno a uno." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.colors\n", + "from matplotlib import cm\n", + "from matplotlib.animation import FuncAnimation\n", + "%matplotlib notebook" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Se que no hemos visto pandas, pero la verdad es que soy muy fan de la libreria jaja" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Enanas blancas" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6\n" + ] + }, + { + "data": { + "text/html": [ + "<div>\n", + "<style scoped>\n", + " .dataframe tbody tr th:only-of-type {\n", + " vertical-align: middle;\n", + " }\n", + "\n", + " .dataframe tbody tr th {\n", + " vertical-align: top;\n", + " }\n", + "\n", + " .dataframe thead th {\n", + " text-align: right;\n", + " }\n", + "</style>\n", + "<table border=\"1\" class=\"dataframe\">\n", + " <thead>\n", + " <tr style=\"text-align: right;\">\n", + " <th></th>\n", + " <th>lum</th>\n", + " <th>temp</th>\n", + " <th>radius</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>0</th>\n", + " <td>0.000109</td>\n", + " <td>5050.644696</td>\n", + " <td>7.096930</td>\n", + " </tr>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>0.000128</td>\n", + " <td>5967.543450</td>\n", + " <td>4.583996</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>0.000230</td>\n", + " <td>6674.161524</td>\n", + " <td>4.151078</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3</th>\n", + " <td>0.000269</td>\n", + " <td>7216.762974</td>\n", + " <td>3.491754</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>0.000472</td>\n", + " <td>7795.184395</td>\n", + " <td>3.472736</td>\n", + " </tr>\n", + " <tr>\n", + " <th>5</th>\n", + " <td>0.000613</td>\n", + " <td>8402.695283</td>\n", + " <td>3.077338</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "</div>" + ], + "text/plain": [ + " lum temp radius\n", + "0 0.000109 5050.644696 7.096930\n", + "1 0.000128 5967.543450 4.583996\n", + "2 0.000230 6674.161524 4.151078\n", + "3 0.000269 7216.762974 3.491754\n", + "4 0.000472 7795.184395 3.472736\n", + "5 0.000613 8402.695283 3.077338" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dwarfs = pd.read_csv('data/dwarfs.csv')\n", + "print(len(dwarfs))\n", + "dwarfs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Secuencia principal" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "90\n" + ] + }, + { + "data": { + "text/html": [ + "<div>\n", + "<style scoped>\n", + " .dataframe tbody tr th:only-of-type {\n", + " vertical-align: middle;\n", + " }\n", + "\n", + " .dataframe tbody tr th {\n", + " vertical-align: top;\n", + " }\n", + "\n", + " .dataframe thead th {\n", + " text-align: right;\n", + " }\n", + "</style>\n", + "<table border=\"1\" class=\"dataframe\">\n", + " <thead>\n", + " <tr style=\"text-align: right;\">\n", + " <th></th>\n", + " <th>lum</th>\n", + " <th>temp</th>\n", + " <th>radius</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>0</th>\n", + " <td>0.000776</td>\n", + " <td>3577.003926</td>\n", + " <td>0.814703</td>\n", + " </tr>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>0.002638</td>\n", + " <td>3691.168543</td>\n", + " <td>1.209778</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>0.006823</td>\n", + " <td>3793.506494</td>\n", + " <td>1.630027</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3</th>\n", + " <td>0.019733</td>\n", + " <td>3862.471423</td>\n", + " <td>2.361574</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>0.040402</td>\n", + " <td>3963.530109</td>\n", + " <td>2.910924</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "</div>" + ], + "text/plain": [ + " lum temp radius\n", + "0 0.000776 3577.003926 0.814703\n", + "1 0.002638 3691.168543 1.209778\n", + "2 0.006823 3793.506494 1.630027\n", + "3 0.019733 3862.471423 2.361574\n", + "4 0.040402 3963.530109 2.910924" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ms = pd.read_csv('data/ms.csv')\n", + "print(len(ms))\n", + "ms.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Gigantes (azul)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n" + ] + }, + { + "data": { + "text/html": [ + "<div>\n", + "<style scoped>\n", + " .dataframe tbody tr th:only-of-type {\n", + " vertical-align: middle;\n", + " }\n", + "\n", + " .dataframe tbody tr th {\n", + " vertical-align: top;\n", + " }\n", + "\n", + " .dataframe thead th {\n", + " text-align: right;\n", + " }\n", + "</style>\n", + "<table border=\"1\" class=\"dataframe\">\n", + " <thead>\n", + " <tr style=\"text-align: right;\">\n", + " <th></th>\n", + " <th>lum</th>\n", + " <th>temp</th>\n", + " <th>radius</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>0</th>\n", + " <td>304.228573</td>\n", + " <td>3654.601099</td>\n", + " <td>145.483474</td>\n", + " </tr>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>58.884366</td>\n", + " <td>3808.609875</td>\n", + " <td>66.642938</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>9.246982</td>\n", + " <td>3991.751692</td>\n", + " <td>27.603430</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3</th>\n", + " <td>58.505945</td>\n", + " <td>4164.818180</td>\n", + " <td>50.832968</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>32.033176</td>\n", + " <td>4425.773883</td>\n", + " <td>33.290931</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "</div>" + ], + "text/plain": [ + " lum temp radius\n", + "0 304.228573 3654.601099 145.483474\n", + "1 58.884366 3808.609875 66.642938\n", + "2 9.246982 3991.751692 27.603430\n", + "3 58.505945 4164.818180 50.832968\n", + "4 32.033176 4425.773883 33.290931" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "giants = pd.read_csv('data/giants.txt', sep=' ')\n", + "print(len(giants))\n", + "giants.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Supergigantes (rojo)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n" + ] + }, + { + "data": { + "text/html": [ + "<div>\n", + "<style scoped>\n", + " .dataframe tbody tr th:only-of-type {\n", + " vertical-align: middle;\n", + " }\n", + "\n", + " .dataframe tbody tr th {\n", + " vertical-align: top;\n", + " }\n", + "\n", + " .dataframe thead th {\n", + " text-align: right;\n", + " }\n", + "</style>\n", + "<table border=\"1\" class=\"dataframe\">\n", + " <thead>\n", + " <tr style=\"text-align: right;\">\n", + " <th></th>\n", + " <th>lum</th>\n", + " <th>temp</th>\n", + " <th>radius</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>0</th>\n", + " <td>359749.335156</td>\n", + " <td>3801.042587</td>\n", + " <td>278.055832</td>\n", + " </tr>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>416869.383470</td>\n", + " <td>4398.962354</td>\n", + " <td>190.278395</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>1000000.000000</td>\n", + " <td>5465.163392</td>\n", + " <td>140.809113</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3</th>\n", + " <td>920449.571753</td>\n", + " <td>7837.395137</td>\n", + " <td>46.187556</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>779830.110523</td>\n", + " <td>10200.701561</td>\n", + " <td>19.604244</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "</div>" + ], + "text/plain": [ + " lum temp radius\n", + "0 359749.335156 3801.042587 278.055832\n", + "1 416869.383470 4398.962354 190.278395\n", + "2 1000000.000000 5465.163392 140.809113\n", + "3 920449.571753 7837.395137 46.187556\n", + "4 779830.110523 10200.701561 19.604244" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "supergiants = pd.read_csv('data/supergiants.txt', sep=' ')\n", + "print(len(supergiants))\n", + "supergiants.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Valores máximos y mÃnimos" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def max_y_min(tabla):\n", + " lum_min, lum_max = min(tabla['lum']), max(tabla['lum'])\n", + " temp_min, temp_max = min(tabla['temp']), max(tabla['temp'])\n", + " \n", + " return lum_min, lum_max, temp_min, temp_max" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Enanas blancas" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "d_lum_min, d_lum_max, d_temp_min, d_temp_max = max_y_min(dwarfs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Secuencia principal" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "ms_lum_min, ms_lum_max, ms_temp_min, ms_temp_max = max_y_min(ms)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Gigantes" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "g_lum_min, g_lum_max, g_temp_min, g_temp_max = max_y_min(giants)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Supergigantes" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "sg_lum_min, sg_lum_max, sg_temp_min, sg_temp_max = max_y_min(supergiants)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A continuación hago el diagrama ploteando cada tabla de manera individual, al hacerlo asà no puedo acoplar de manera sencilla el color de las estrellas" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "/* global mpl */\n", + "window.mpl = {};\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(\n", + " '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", + "\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 = document.createElement('div');\n", + " this.root.setAttribute('style', 'display: inline-block');\n", + " this._root_extra_style(this.root);\n", + "\n", + " parent_element.appendChild(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 (fig.ratio !== 1) {\n", + " fig.send_message('set_dpi_ratio', { dpi_ratio: fig.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 = document.createElement('div');\n", + " titlebar.classList =\n", + " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", + " var titletext = document.createElement('div');\n", + " titletext.classList = 'ui-dialog-title';\n", + " titletext.setAttribute(\n", + " 'style',\n", + " 'width: 100%; text-align: center; padding: 3px;'\n", + " );\n", + " titlebar.appendChild(titletext);\n", + " this.root.appendChild(titlebar);\n", + " this.header = titletext;\n", + "};\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", + "\n", + "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", + "\n", + "mpl.figure.prototype._init_canvas = function () {\n", + " var fig = this;\n", + "\n", + " var canvas_div = (this.canvas_div = document.createElement('div'));\n", + " canvas_div.setAttribute(\n", + " 'style',\n", + " 'border: 1px solid #ddd;' +\n", + " 'box-sizing: content-box;' +\n", + " 'clear: both;' +\n", + " 'min-height: 1px;' +\n", + " 'min-width: 1px;' +\n", + " 'outline: 0;' +\n", + " 'overflow: hidden;' +\n", + " 'position: relative;' +\n", + " 'resize: both;'\n", + " );\n", + "\n", + " function on_keyboard_event_closure(name) {\n", + " return function (event) {\n", + " return fig.key_event(event, name);\n", + " };\n", + " }\n", + "\n", + " canvas_div.addEventListener(\n", + " 'keydown',\n", + " on_keyboard_event_closure('key_press')\n", + " );\n", + " canvas_div.addEventListener(\n", + " 'keyup',\n", + " on_keyboard_event_closure('key_release')\n", + " );\n", + "\n", + " this._canvas_extra_style(canvas_div);\n", + " this.root.appendChild(canvas_div);\n", + "\n", + " var canvas = (this.canvas = document.createElement('canvas'));\n", + " canvas.classList.add('mpl-canvas');\n", + " canvas.setAttribute('style', 'box-sizing: content-box;');\n", + "\n", + " this.context = canvas.getContext('2d');\n", + "\n", + " var backingStore =\n", + " this.context.backingStorePixelRatio ||\n", + " this.context.webkitBackingStorePixelRatio ||\n", + " this.context.mozBackingStorePixelRatio ||\n", + " this.context.msBackingStorePixelRatio ||\n", + " this.context.oBackingStorePixelRatio ||\n", + " this.context.backingStorePixelRatio ||\n", + " 1;\n", + "\n", + " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", + " 'canvas'\n", + " ));\n", + " rubberband_canvas.setAttribute(\n", + " 'style',\n", + " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n", + " );\n", + "\n", + " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", + " if (this.ResizeObserver === undefined) {\n", + " if (window.ResizeObserver !== undefined) {\n", + " this.ResizeObserver = window.ResizeObserver;\n", + " } else {\n", + " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", + " this.ResizeObserver = obs.ResizeObserver;\n", + " }\n", + " }\n", + "\n", + " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", + " var nentries = entries.length;\n", + " for (var i = 0; i < nentries; i++) {\n", + " var entry = entries[i];\n", + " var width, height;\n", + " if (entry.contentBoxSize) {\n", + " if (entry.contentBoxSize instanceof Array) {\n", + " // Chrome 84 implements new version of spec.\n", + " width = entry.contentBoxSize[0].inlineSize;\n", + " height = entry.contentBoxSize[0].blockSize;\n", + " } else {\n", + " // Firefox implements old version of spec.\n", + " width = entry.contentBoxSize.inlineSize;\n", + " height = entry.contentBoxSize.blockSize;\n", + " }\n", + " } else {\n", + " // Chrome <84 implements even older version of spec.\n", + " width = entry.contentRect.width;\n", + " height = entry.contentRect.height;\n", + " }\n", + "\n", + " // Keep the size of the canvas and rubber band canvas in sync with\n", + " // the canvas container.\n", + " if (entry.devicePixelContentBoxSize) {\n", + " // Chrome 84 implements new version of spec.\n", + " canvas.setAttribute(\n", + " 'width',\n", + " entry.devicePixelContentBoxSize[0].inlineSize\n", + " );\n", + " canvas.setAttribute(\n", + " 'height',\n", + " entry.devicePixelContentBoxSize[0].blockSize\n", + " );\n", + " } else {\n", + " canvas.setAttribute('width', width * fig.ratio);\n", + " canvas.setAttribute('height', height * fig.ratio);\n", + " }\n", + " canvas.setAttribute(\n", + " 'style',\n", + " 'width: ' + width + 'px; height: ' + height + 'px;'\n", + " );\n", + "\n", + " rubberband_canvas.setAttribute('width', width);\n", + " rubberband_canvas.setAttribute('height', height);\n", + "\n", + " // And update the size in Python. We ignore the initial 0/0 size\n", + " // that occurs as the element is placed into the DOM, which should\n", + " // otherwise not happen due to the minimum size styling.\n", + " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", + " fig.request_resize(width, height);\n", + " }\n", + " }\n", + " });\n", + " this.resizeObserverInstance.observe(canvas_div);\n", + "\n", + " function on_mouse_event_closure(name) {\n", + " return function (event) {\n", + " return fig.mouse_event(event, name);\n", + " };\n", + " }\n", + "\n", + " rubberband_canvas.addEventListener(\n", + " 'mousedown',\n", + " on_mouse_event_closure('button_press')\n", + " );\n", + " rubberband_canvas.addEventListener(\n", + " 'mouseup',\n", + " on_mouse_event_closure('button_release')\n", + " );\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband_canvas.addEventListener(\n", + " 'mousemove',\n", + " on_mouse_event_closure('motion_notify')\n", + " );\n", + "\n", + " rubberband_canvas.addEventListener(\n", + " 'mouseenter',\n", + " on_mouse_event_closure('figure_enter')\n", + " );\n", + " rubberband_canvas.addEventListener(\n", + " 'mouseleave',\n", + " on_mouse_event_closure('figure_leave')\n", + " );\n", + "\n", + " canvas_div.addEventListener('wheel', function (event) {\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " on_mouse_event_closure('scroll')(event);\n", + " });\n", + "\n", + " canvas_div.appendChild(canvas);\n", + " canvas_div.appendChild(rubberband_canvas);\n", + "\n", + " this.rubberband_context = rubberband_canvas.getContext('2d');\n", + " this.rubberband_context.strokeStyle = '#000000';\n", + "\n", + " this._resize_canvas = function (width, height, forward) {\n", + " if (forward) {\n", + " canvas_div.style.width = width + 'px';\n", + " canvas_div.style.height = height + 'px';\n", + " }\n", + " };\n", + "\n", + " // Disable right mouse context menu.\n", + " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n", + " event.preventDefault();\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 toolbar = document.createElement('div');\n", + " toolbar.classList = 'mpl-toolbar';\n", + " this.root.appendChild(toolbar);\n", + "\n", + " function on_click_closure(name) {\n", + " return function (_event) {\n", + " return fig.toolbar_button_onclick(name);\n", + " };\n", + " }\n", + "\n", + " function on_mouseover_closure(tooltip) {\n", + " return function (event) {\n", + " if (!event.currentTarget.disabled) {\n", + " return fig.toolbar_button_onmouseover(tooltip);\n", + " }\n", + " };\n", + " }\n", + "\n", + " fig.buttons = {};\n", + " var buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'mpl-button-group';\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", + " /* Instead of a spacer, we start a new button group. */\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + " buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'mpl-button-group';\n", + " continue;\n", + " }\n", + "\n", + " var button = (fig.buttons[name] = document.createElement('button'));\n", + " button.classList = 'mpl-widget';\n", + " button.setAttribute('role', 'button');\n", + " button.setAttribute('aria-disabled', 'false');\n", + " button.addEventListener('click', on_click_closure(method_name));\n", + " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", + "\n", + " var icon_img = document.createElement('img');\n", + " icon_img.src = '_images/' + image + '.png';\n", + " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", + " icon_img.alt = tooltip;\n", + " button.appendChild(icon_img);\n", + "\n", + " buttonGroup.appendChild(button);\n", + " }\n", + "\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + "\n", + " var fmt_picker = document.createElement('select');\n", + " fmt_picker.classList = 'mpl-widget';\n", + " toolbar.appendChild(fmt_picker);\n", + " this.format_dropdown = fmt_picker;\n", + "\n", + " for (var ind in mpl.extensions) {\n", + " var fmt = mpl.extensions[ind];\n", + " var option = document.createElement('option');\n", + " option.selected = fmt === mpl.default_extension;\n", + " option.innerHTML = fmt;\n", + " fmt_picker.appendChild(option);\n", + " }\n", + "\n", + " var status_bar = document.createElement('span');\n", + " status_bar.classList = 'mpl-message';\n", + " toolbar.appendChild(status_bar);\n", + " this.message = status_bar;\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", + "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", + "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], msg['forward']);\n", + " fig.send_message('refresh', {});\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", + " var x0 = msg['x0'] / fig.ratio;\n", + " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", + " var x1 = msg['x1'] / fig.ratio;\n", + " var y1 = (fig.canvas.height - msg['y1']) / fig.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,\n", + " 0,\n", + " fig.canvas.width / fig.ratio,\n", + " fig.canvas.height / fig.ratio\n", + " );\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", + " 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.handle_history_buttons = function (fig, msg) {\n", + " for (var key in msg) {\n", + " if (!(key in fig.buttons)) {\n", + " continue;\n", + " }\n", + " fig.buttons[key].disabled = !msg[key];\n", + " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", + " if (msg['mode'] === 'PAN') {\n", + " fig.buttons['Pan'].classList.add('active');\n", + " fig.buttons['Zoom'].classList.remove('active');\n", + " } else if (msg['mode'] === 'ZOOM') {\n", + " fig.buttons['Pan'].classList.remove('active');\n", + " fig.buttons['Zoom'].classList.add('active');\n", + " } else {\n", + " fig.buttons['Pan'].classList.remove('active');\n", + " fig.buttons['Zoom'].classList.remove('active');\n", + " }\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", + "\n", + " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", + " evt.data\n", + " );\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " } else if (\n", + " typeof evt.data === 'string' &&\n", + " evt.data.slice(0, 21) === 'data:image/png;base64'\n", + " ) {\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(\n", + " \"No handler for the '\" + msg_type + \"' message type: \",\n", + " msg\n", + " );\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(\n", + " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", + " e,\n", + " e.stack,\n", + " msg\n", + " );\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", + " }\n", + " if (e.target) {\n", + " targ = e.target;\n", + " } else if (e.srcElement) {\n", + " targ = e.srcElement;\n", + " }\n", + " if (targ.nodeType === 3) {\n", + " // defeat Safari bug\n", + " targ = targ.parentNode;\n", + " }\n", + "\n", + " // pageX,Y are the mouse positions relative to the document\n", + " var boundingRect = targ.getBoundingClientRect();\n", + " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n", + " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\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", + " }\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", + " this.canvas.focus();\n", + " this.canvas_div.focus();\n", + " }\n", + "\n", + " var x = canvas_pos.x * this.ratio;\n", + " var y = canvas_pos.y * this.ratio;\n", + "\n", + " this.send_message(name, {\n", + " x: x,\n", + " y: y,\n", + " button: event.button,\n", + " step: event.step,\n", + " guiEvent: simpleKeys(event),\n", + " });\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", + " // Prevent repeat events\n", + " if (name === 'key_press') {\n", + " if (event.which === this._key) {\n", + " return;\n", + " } else {\n", + " this._key = event.which;\n", + " }\n", + " }\n", + " if (name === 'key_release') {\n", + " this._key = null;\n", + " }\n", + "\n", + " var value = '';\n", + " if (event.ctrlKey && event.which !== 17) {\n", + " value += 'ctrl+';\n", + " }\n", + " if (event.altKey && event.which !== 18) {\n", + " value += 'alt+';\n", + " }\n", + " if (event.shiftKey && event.which !== 16) {\n", + " value += 'shift+';\n", + " }\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, 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", + "\n", + "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", + "// prettier-ignore\n", + "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\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\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"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\";/* global mpl */\n", + "\n", + "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 = document.getElementById(id);\n", + " var ws_proxy = comm_websocket_adapter(comm);\n", + "\n", + " function ondownload(figure, _format) {\n", + " window.open(figure.canvas.toDataURL());\n", + " }\n", + "\n", + " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\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;\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", + " fig.cell_info[0].output_area.element.on(\n", + " 'cleared',\n", + " { fig: fig },\n", + " fig._remove_fig_handler\n", + " );\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_close = function (fig, msg) {\n", + " var width = fig.canvas.width / fig.ratio;\n", + " fig.cell_info[0].output_area.element.off(\n", + " 'cleared',\n", + " fig._remove_fig_handler\n", + " );\n", + " fig.resizeObserverInstance.unobserve(fig.canvas_div);\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.innerHTML =\n", + " '<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 / this.ratio;\n", + " var dataURL = this.canvas.toDataURL();\n", + " this.cell_info[1]['text/html'] =\n", + " '<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 () {\n", + " fig.push_to_output();\n", + " }, 1000);\n", + "};\n", + "\n", + "mpl.figure.prototype._init_toolbar = function () {\n", + " var fig = this;\n", + "\n", + " var toolbar = document.createElement('div');\n", + " toolbar.classList = 'btn-toolbar';\n", + " this.root.appendChild(toolbar);\n", + "\n", + " function on_click_closure(name) {\n", + " return function (_event) {\n", + " return fig.toolbar_button_onclick(name);\n", + " };\n", + " }\n", + "\n", + " function on_mouseover_closure(tooltip) {\n", + " return function (event) {\n", + " if (!event.currentTarget.disabled) {\n", + " return fig.toolbar_button_onmouseover(tooltip);\n", + " }\n", + " };\n", + " }\n", + "\n", + " fig.buttons = {};\n", + " var buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'btn-group';\n", + " var button;\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", + " /* Instead of a spacer, we start a new button group. */\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + " buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'btn-group';\n", + " continue;\n", + " }\n", + "\n", + " button = fig.buttons[name] = document.createElement('button');\n", + " button.classList = 'btn btn-default';\n", + " button.href = '#';\n", + " button.title = name;\n", + " button.innerHTML = '<i class=\"fa ' + image + ' fa-lg\"></i>';\n", + " button.addEventListener('click', on_click_closure(method_name));\n", + " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", + " buttonGroup.appendChild(button);\n", + " }\n", + "\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = document.createElement('span');\n", + " status_bar.classList = 'mpl-message pull-right';\n", + " toolbar.appendChild(status_bar);\n", + " this.message = status_bar;\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = document.createElement('div');\n", + " buttongrp.classList = 'btn-group inline pull-right';\n", + " button = document.createElement('button');\n", + " button.classList = 'btn btn-mini btn-primary';\n", + " button.href = '#';\n", + " button.title = 'Stop Interaction';\n", + " button.innerHTML = '<i class=\"fa fa-power-off icon-remove icon-large\"></i>';\n", + " button.addEventListener('click', function (_evt) {\n", + " fig.handle_close(fig, {});\n", + " });\n", + " button.addEventListener(\n", + " 'mouseover',\n", + " on_mouseover_closure('Stop Interaction')\n", + " );\n", + " buttongrp.appendChild(button);\n", + " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", + " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", + "};\n", + "\n", + "mpl.figure.prototype._remove_fig_handler = function (event) {\n", + " var fig = event.data.fig;\n", + " if (event.target !== this) {\n", + " // Ignore bubbled events from children.\n", + " return;\n", + " }\n", + " fig.close_ws(fig, {});\n", + "};\n", + "\n", + "mpl.figure.prototype._root_extra_style = function (el) {\n", + " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", + "};\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function (el) {\n", + " // this is important to make the div 'focusable\n", + " el.setAttribute('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", + " } else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\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", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which === 13) {\n", + " this.canvas_div.blur();\n", + " // select the cell after this one\n", + " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", + " IPython.notebook.select(index + 1);\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", + " fig.ondownload(fig, null);\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(\n", + " 'matplotlib',\n", + " mpl.mpl_figure_comm\n", + " );\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=\"800\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "<matplotlib.colorbar.Colorbar at 0x7f821e2ba198>" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=[8,5])\n", + "\n", + "xmin = min( d_temp_min, ms_temp_min, g_temp_min, sg_temp_min )\n", + "xmax = max( d_temp_max, ms_temp_max, g_temp_max, sg_temp_max )\n", + "\n", + "\n", + "cmap = matplotlib.colors.LinearSegmentedColormap.from_list(\"\", [\"red\",\"violet\",\"blue\"])\n", + "\n", + "#cmap = cm.get_cmap('hsv', 7)\n", + "norm = plt.Normalize(xmin, xmax)\n", + "\n", + "sd = dwarfs['radius']\n", + "im = ax.scatter(dwarfs['temp'], dwarfs['lum'], c=dwarfs['temp'], s=sd, cmap=cmap, vmin=xmin, vmax=xmax)\n", + "\n", + "sms = ms['radius']\n", + "im = ax.scatter(ms['temp'], ms['lum'], c=ms['temp'], s=sms, cmap=cmap)\n", + "\n", + "sg = giants['radius']\n", + "im = ax.scatter(giants['temp'], giants['lum'], c=giants['temp'],s=sg, cmap=cmap)\n", + "\n", + "ssg = supergiants['radius']\n", + "im = ax.scatter(supergiants['temp'], supergiants['lum'], c=supergiants['temp'],s=ssg, cmap=cmap)\n", + "\n", + "ax.set_xlabel('Temperatura (K)')\n", + "ax.set_ylabel('Luminosidad (L$_{sol}$)')\n", + "ax.set_title('Diagrama Hertzsprung-Russell')\n", + "\n", + "\n", + "\n", + "ax.set_xlim(xmax, xmin-300)\n", + "#ax.set_xticks([12000, 10000, 8000, 6000, 3500])\n", + "ax.set_yscale(\"log\")\n", + "\n", + "\n", + "fig.colorbar(im, ax=ax)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Uno las cuatro tablas para poder integrar el color de las estrellas" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "all_stars = pd.concat([dwarfs, ms, giants, supergiants], ignore_index=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "/* global mpl */\n", + "window.mpl = {};\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(\n", + " '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", + "\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 = document.createElement('div');\n", + " this.root.setAttribute('style', 'display: inline-block');\n", + " this._root_extra_style(this.root);\n", + "\n", + " parent_element.appendChild(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 (fig.ratio !== 1) {\n", + " fig.send_message('set_dpi_ratio', { dpi_ratio: fig.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 = document.createElement('div');\n", + " titlebar.classList =\n", + " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", + " var titletext = document.createElement('div');\n", + " titletext.classList = 'ui-dialog-title';\n", + " titletext.setAttribute(\n", + " 'style',\n", + " 'width: 100%; text-align: center; padding: 3px;'\n", + " );\n", + " titlebar.appendChild(titletext);\n", + " this.root.appendChild(titlebar);\n", + " this.header = titletext;\n", + "};\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", + "\n", + "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", + "\n", + "mpl.figure.prototype._init_canvas = function () {\n", + " var fig = this;\n", + "\n", + " var canvas_div = (this.canvas_div = document.createElement('div'));\n", + " canvas_div.setAttribute(\n", + " 'style',\n", + " 'border: 1px solid #ddd;' +\n", + " 'box-sizing: content-box;' +\n", + " 'clear: both;' +\n", + " 'min-height: 1px;' +\n", + " 'min-width: 1px;' +\n", + " 'outline: 0;' +\n", + " 'overflow: hidden;' +\n", + " 'position: relative;' +\n", + " 'resize: both;'\n", + " );\n", + "\n", + " function on_keyboard_event_closure(name) {\n", + " return function (event) {\n", + " return fig.key_event(event, name);\n", + " };\n", + " }\n", + "\n", + " canvas_div.addEventListener(\n", + " 'keydown',\n", + " on_keyboard_event_closure('key_press')\n", + " );\n", + " canvas_div.addEventListener(\n", + " 'keyup',\n", + " on_keyboard_event_closure('key_release')\n", + " );\n", + "\n", + " this._canvas_extra_style(canvas_div);\n", + " this.root.appendChild(canvas_div);\n", + "\n", + " var canvas = (this.canvas = document.createElement('canvas'));\n", + " canvas.classList.add('mpl-canvas');\n", + " canvas.setAttribute('style', 'box-sizing: content-box;');\n", + "\n", + " this.context = canvas.getContext('2d');\n", + "\n", + " var backingStore =\n", + " this.context.backingStorePixelRatio ||\n", + " this.context.webkitBackingStorePixelRatio ||\n", + " this.context.mozBackingStorePixelRatio ||\n", + " this.context.msBackingStorePixelRatio ||\n", + " this.context.oBackingStorePixelRatio ||\n", + " this.context.backingStorePixelRatio ||\n", + " 1;\n", + "\n", + " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", + " 'canvas'\n", + " ));\n", + " rubberband_canvas.setAttribute(\n", + " 'style',\n", + " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n", + " );\n", + "\n", + " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", + " if (this.ResizeObserver === undefined) {\n", + " if (window.ResizeObserver !== undefined) {\n", + " this.ResizeObserver = window.ResizeObserver;\n", + " } else {\n", + " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", + " this.ResizeObserver = obs.ResizeObserver;\n", + " }\n", + " }\n", + "\n", + " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", + " var nentries = entries.length;\n", + " for (var i = 0; i < nentries; i++) {\n", + " var entry = entries[i];\n", + " var width, height;\n", + " if (entry.contentBoxSize) {\n", + " if (entry.contentBoxSize instanceof Array) {\n", + " // Chrome 84 implements new version of spec.\n", + " width = entry.contentBoxSize[0].inlineSize;\n", + " height = entry.contentBoxSize[0].blockSize;\n", + " } else {\n", + " // Firefox implements old version of spec.\n", + " width = entry.contentBoxSize.inlineSize;\n", + " height = entry.contentBoxSize.blockSize;\n", + " }\n", + " } else {\n", + " // Chrome <84 implements even older version of spec.\n", + " width = entry.contentRect.width;\n", + " height = entry.contentRect.height;\n", + " }\n", + "\n", + " // Keep the size of the canvas and rubber band canvas in sync with\n", + " // the canvas container.\n", + " if (entry.devicePixelContentBoxSize) {\n", + " // Chrome 84 implements new version of spec.\n", + " canvas.setAttribute(\n", + " 'width',\n", + " entry.devicePixelContentBoxSize[0].inlineSize\n", + " );\n", + " canvas.setAttribute(\n", + " 'height',\n", + " entry.devicePixelContentBoxSize[0].blockSize\n", + " );\n", + " } else {\n", + " canvas.setAttribute('width', width * fig.ratio);\n", + " canvas.setAttribute('height', height * fig.ratio);\n", + " }\n", + " canvas.setAttribute(\n", + " 'style',\n", + " 'width: ' + width + 'px; height: ' + height + 'px;'\n", + " );\n", + "\n", + " rubberband_canvas.setAttribute('width', width);\n", + " rubberband_canvas.setAttribute('height', height);\n", + "\n", + " // And update the size in Python. We ignore the initial 0/0 size\n", + " // that occurs as the element is placed into the DOM, which should\n", + " // otherwise not happen due to the minimum size styling.\n", + " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", + " fig.request_resize(width, height);\n", + " }\n", + " }\n", + " });\n", + " this.resizeObserverInstance.observe(canvas_div);\n", + "\n", + " function on_mouse_event_closure(name) {\n", + " return function (event) {\n", + " return fig.mouse_event(event, name);\n", + " };\n", + " }\n", + "\n", + " rubberband_canvas.addEventListener(\n", + " 'mousedown',\n", + " on_mouse_event_closure('button_press')\n", + " );\n", + " rubberband_canvas.addEventListener(\n", + " 'mouseup',\n", + " on_mouse_event_closure('button_release')\n", + " );\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband_canvas.addEventListener(\n", + " 'mousemove',\n", + " on_mouse_event_closure('motion_notify')\n", + " );\n", + "\n", + " rubberband_canvas.addEventListener(\n", + " 'mouseenter',\n", + " on_mouse_event_closure('figure_enter')\n", + " );\n", + " rubberband_canvas.addEventListener(\n", + " 'mouseleave',\n", + " on_mouse_event_closure('figure_leave')\n", + " );\n", + "\n", + " canvas_div.addEventListener('wheel', function (event) {\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " on_mouse_event_closure('scroll')(event);\n", + " });\n", + "\n", + " canvas_div.appendChild(canvas);\n", + " canvas_div.appendChild(rubberband_canvas);\n", + "\n", + " this.rubberband_context = rubberband_canvas.getContext('2d');\n", + " this.rubberband_context.strokeStyle = '#000000';\n", + "\n", + " this._resize_canvas = function (width, height, forward) {\n", + " if (forward) {\n", + " canvas_div.style.width = width + 'px';\n", + " canvas_div.style.height = height + 'px';\n", + " }\n", + " };\n", + "\n", + " // Disable right mouse context menu.\n", + " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n", + " event.preventDefault();\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 toolbar = document.createElement('div');\n", + " toolbar.classList = 'mpl-toolbar';\n", + " this.root.appendChild(toolbar);\n", + "\n", + " function on_click_closure(name) {\n", + " return function (_event) {\n", + " return fig.toolbar_button_onclick(name);\n", + " };\n", + " }\n", + "\n", + " function on_mouseover_closure(tooltip) {\n", + " return function (event) {\n", + " if (!event.currentTarget.disabled) {\n", + " return fig.toolbar_button_onmouseover(tooltip);\n", + " }\n", + " };\n", + " }\n", + "\n", + " fig.buttons = {};\n", + " var buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'mpl-button-group';\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", + " /* Instead of a spacer, we start a new button group. */\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + " buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'mpl-button-group';\n", + " continue;\n", + " }\n", + "\n", + " var button = (fig.buttons[name] = document.createElement('button'));\n", + " button.classList = 'mpl-widget';\n", + " button.setAttribute('role', 'button');\n", + " button.setAttribute('aria-disabled', 'false');\n", + " button.addEventListener('click', on_click_closure(method_name));\n", + " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", + "\n", + " var icon_img = document.createElement('img');\n", + " icon_img.src = '_images/' + image + '.png';\n", + " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", + " icon_img.alt = tooltip;\n", + " button.appendChild(icon_img);\n", + "\n", + " buttonGroup.appendChild(button);\n", + " }\n", + "\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + "\n", + " var fmt_picker = document.createElement('select');\n", + " fmt_picker.classList = 'mpl-widget';\n", + " toolbar.appendChild(fmt_picker);\n", + " this.format_dropdown = fmt_picker;\n", + "\n", + " for (var ind in mpl.extensions) {\n", + " var fmt = mpl.extensions[ind];\n", + " var option = document.createElement('option');\n", + " option.selected = fmt === mpl.default_extension;\n", + " option.innerHTML = fmt;\n", + " fmt_picker.appendChild(option);\n", + " }\n", + "\n", + " var status_bar = document.createElement('span');\n", + " status_bar.classList = 'mpl-message';\n", + " toolbar.appendChild(status_bar);\n", + " this.message = status_bar;\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", + "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", + "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], msg['forward']);\n", + " fig.send_message('refresh', {});\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", + " var x0 = msg['x0'] / fig.ratio;\n", + " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", + " var x1 = msg['x1'] / fig.ratio;\n", + " var y1 = (fig.canvas.height - msg['y1']) / fig.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,\n", + " 0,\n", + " fig.canvas.width / fig.ratio,\n", + " fig.canvas.height / fig.ratio\n", + " );\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", + " 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.handle_history_buttons = function (fig, msg) {\n", + " for (var key in msg) {\n", + " if (!(key in fig.buttons)) {\n", + " continue;\n", + " }\n", + " fig.buttons[key].disabled = !msg[key];\n", + " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", + " if (msg['mode'] === 'PAN') {\n", + " fig.buttons['Pan'].classList.add('active');\n", + " fig.buttons['Zoom'].classList.remove('active');\n", + " } else if (msg['mode'] === 'ZOOM') {\n", + " fig.buttons['Pan'].classList.remove('active');\n", + " fig.buttons['Zoom'].classList.add('active');\n", + " } else {\n", + " fig.buttons['Pan'].classList.remove('active');\n", + " fig.buttons['Zoom'].classList.remove('active');\n", + " }\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", + "\n", + " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", + " evt.data\n", + " );\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " } else if (\n", + " typeof evt.data === 'string' &&\n", + " evt.data.slice(0, 21) === 'data:image/png;base64'\n", + " ) {\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(\n", + " \"No handler for the '\" + msg_type + \"' message type: \",\n", + " msg\n", + " );\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(\n", + " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", + " e,\n", + " e.stack,\n", + " msg\n", + " );\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", + " }\n", + " if (e.target) {\n", + " targ = e.target;\n", + " } else if (e.srcElement) {\n", + " targ = e.srcElement;\n", + " }\n", + " if (targ.nodeType === 3) {\n", + " // defeat Safari bug\n", + " targ = targ.parentNode;\n", + " }\n", + "\n", + " // pageX,Y are the mouse positions relative to the document\n", + " var boundingRect = targ.getBoundingClientRect();\n", + " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n", + " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\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", + " }\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", + " this.canvas.focus();\n", + " this.canvas_div.focus();\n", + " }\n", + "\n", + " var x = canvas_pos.x * this.ratio;\n", + " var y = canvas_pos.y * this.ratio;\n", + "\n", + " this.send_message(name, {\n", + " x: x,\n", + " y: y,\n", + " button: event.button,\n", + " step: event.step,\n", + " guiEvent: simpleKeys(event),\n", + " });\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", + " // Prevent repeat events\n", + " if (name === 'key_press') {\n", + " if (event.which === this._key) {\n", + " return;\n", + " } else {\n", + " this._key = event.which;\n", + " }\n", + " }\n", + " if (name === 'key_release') {\n", + " this._key = null;\n", + " }\n", + "\n", + " var value = '';\n", + " if (event.ctrlKey && event.which !== 17) {\n", + " value += 'ctrl+';\n", + " }\n", + " if (event.altKey && event.which !== 18) {\n", + " value += 'alt+';\n", + " }\n", + " if (event.shiftKey && event.which !== 16) {\n", + " value += 'shift+';\n", + " }\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, 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", + "\n", + "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", + "// prettier-ignore\n", + "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\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\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"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\";/* global mpl */\n", + "\n", + "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 = document.getElementById(id);\n", + " var ws_proxy = comm_websocket_adapter(comm);\n", + "\n", + " function ondownload(figure, _format) {\n", + " window.open(figure.canvas.toDataURL());\n", + " }\n", + "\n", + " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\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;\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", + " fig.cell_info[0].output_area.element.on(\n", + " 'cleared',\n", + " { fig: fig },\n", + " fig._remove_fig_handler\n", + " );\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_close = function (fig, msg) {\n", + " var width = fig.canvas.width / fig.ratio;\n", + " fig.cell_info[0].output_area.element.off(\n", + " 'cleared',\n", + " fig._remove_fig_handler\n", + " );\n", + " fig.resizeObserverInstance.unobserve(fig.canvas_div);\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.innerHTML =\n", + " '<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 / this.ratio;\n", + " var dataURL = this.canvas.toDataURL();\n", + " this.cell_info[1]['text/html'] =\n", + " '<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 () {\n", + " fig.push_to_output();\n", + " }, 1000);\n", + "};\n", + "\n", + "mpl.figure.prototype._init_toolbar = function () {\n", + " var fig = this;\n", + "\n", + " var toolbar = document.createElement('div');\n", + " toolbar.classList = 'btn-toolbar';\n", + " this.root.appendChild(toolbar);\n", + "\n", + " function on_click_closure(name) {\n", + " return function (_event) {\n", + " return fig.toolbar_button_onclick(name);\n", + " };\n", + " }\n", + "\n", + " function on_mouseover_closure(tooltip) {\n", + " return function (event) {\n", + " if (!event.currentTarget.disabled) {\n", + " return fig.toolbar_button_onmouseover(tooltip);\n", + " }\n", + " };\n", + " }\n", + "\n", + " fig.buttons = {};\n", + " var buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'btn-group';\n", + " var button;\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", + " /* Instead of a spacer, we start a new button group. */\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + " buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'btn-group';\n", + " continue;\n", + " }\n", + "\n", + " button = fig.buttons[name] = document.createElement('button');\n", + " button.classList = 'btn btn-default';\n", + " button.href = '#';\n", + " button.title = name;\n", + " button.innerHTML = '<i class=\"fa ' + image + ' fa-lg\"></i>';\n", + " button.addEventListener('click', on_click_closure(method_name));\n", + " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", + " buttonGroup.appendChild(button);\n", + " }\n", + "\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = document.createElement('span');\n", + " status_bar.classList = 'mpl-message pull-right';\n", + " toolbar.appendChild(status_bar);\n", + " this.message = status_bar;\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = document.createElement('div');\n", + " buttongrp.classList = 'btn-group inline pull-right';\n", + " button = document.createElement('button');\n", + " button.classList = 'btn btn-mini btn-primary';\n", + " button.href = '#';\n", + " button.title = 'Stop Interaction';\n", + " button.innerHTML = '<i class=\"fa fa-power-off icon-remove icon-large\"></i>';\n", + " button.addEventListener('click', function (_evt) {\n", + " fig.handle_close(fig, {});\n", + " });\n", + " button.addEventListener(\n", + " 'mouseover',\n", + " on_mouseover_closure('Stop Interaction')\n", + " );\n", + " buttongrp.appendChild(button);\n", + " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", + " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", + "};\n", + "\n", + "mpl.figure.prototype._remove_fig_handler = function (event) {\n", + " var fig = event.data.fig;\n", + " if (event.target !== this) {\n", + " // Ignore bubbled events from children.\n", + " return;\n", + " }\n", + " fig.close_ws(fig, {});\n", + "};\n", + "\n", + "mpl.figure.prototype._root_extra_style = function (el) {\n", + " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", + "};\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function (el) {\n", + " // this is important to make the div 'focusable\n", + " el.setAttribute('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", + " } else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\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", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which === 13) {\n", + " this.canvas_div.blur();\n", + " // select the cell after this one\n", + " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", + " IPython.notebook.select(index + 1);\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", + " fig.ondownload(fig, null);\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(\n", + " 'matplotlib',\n", + " mpl.mpl_figure_comm\n", + " );\n", + "}\n" + ], + "text/plain": [ + "<IPython.core.display.Javascript object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<img src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAA+gAAAJYCAYAAADxHswlAAAgAElEQVR4nOzdd3gUVdsG8LObbDa9kIQEAmmUEBISiiaAdKkSmkDohKI0ESkKKAjKSxcElN7soiLt9VWwAJ8CUgQp0qQr0gmEZgok9/dHnDGb3fQth+z9u65zaXZnd58zSQ7nzsycESAiIiIiIiIimxO2LoCIiIiIiIiIGNCJiIiIiIiIpMCATkRERERERCQBBnQiIiIiIiIiCTCgExEREREREUmAAZ2IiIiIiIhIAgzoRERERERERBJgQCciIiIiIiKSAAM6ERERERERkQQY0ImIiIiIiIgkwIBOREREREREJAEGdCIiIiIiIiIJMKATERERERERSYABnYiIiIiIiEgCDOhEREREREREEmBAJyIiIiIiIpIAAzoRERERERGRBBjQiYiIiIiIiCTAgE5EREREREQkAQZ0IiIiIiIiIgkwoBMRERERERFJgAGdiIiIiIiISAIM6EREREREREQSYEAnIiIiIiIikgADOhEREREREZEEGNCJiIiIiIiIJMCATkRERERERCQBBnQiIiIiIiIiCTCgExEREREREUmAAZ2IiIiIiIhIAgzoRERERERERBJgQCciIiIiIiKSAAM6ERERERERkQQY0ImIiIiIiIgkwIBOREREREREJAEGdCIiIiIiIiIJMKATERERERERSYABnYiIiIiIiEgCDOhEREREREREEmBAJyIiIiIiIpIAAzoRERERERGRBBjQiYiIiIiIiCTAgE5EREREREQkAQZ0IiIiIiIiIgkwoBMRERERERFJgAGdiIiIiIiISAIM6EREREREREQSYEAnIrMTQhg0R0dH+Pr6Ijo6GklJSfjyyy/x8OHDfF8fEhJivYLt3Pnz5wu1zydPngwhBCZPnmyVukgO27dvN/qddnBwgL+/P1q1aoWNGzfaukSLMPU7ofyuNG7c2CY1ERFR6ceATkRmp0zik5KSkJSUhD59+qB9+/aoVq0aNBoNhBCoXLky9u7dm+frGdCtR8aAziAkDyWgBwQEqL/T3bp1Q3R0tPq7Xhr/aMOATkREtsCATkRmp0zaTTlz5gwSExMhhICrqysOHjxotM2JEydw5swZS5dJ/2BAp/woAd3U92L+/PnqEfXz589bvTZLYkAnIiJbYEAnIrPLL6ArBg4cCCEEatWqZaWqKC8M6JSf/AI6AFSrVg1CCKxcudK6hVkYAzoREdkCAzoRmV1hAnpKSgrc3NwghMCOHTuMXp97YpyVlYVPP/0U3bp1Q5UqVeDq6gp3d3c8+eSTWLRoETIzM01+zv379zFu3DiEhIRAr9ejUqVKmDJlCjIyMhASEmJUpxJGkpKScOXKFQwcOBBBQUFwcHDAvHnzAACXL1/GrFmz0KhRI5QvXx46nQ4BAQHo1KkT9u3bZ7KOnJ+1cOFCREVFwdnZGaGhoZg1axaysrIAAAcOHEBCQgJ8fHzg5uaG9u3b48KFC0bvV5wa8mKOgK58f5o2bQpvb2/o9XpUq1YNkydPxoMHD4y2b9y4MYQQOH/+PD755BPEx8fD3d0dXl5e6ueYaklJSQavz6/lPKL722+/oVevXggLC4Ner4efnx9iY2Px0ksv4fLly+p2Ob//ly9fRlJSEsqWLQtnZ2fUqlULH3zwgcl9o+y/9PR0vPnmm4iIiICTkxM6dOhgsO/ee+89k68v6GcxOTkZQ4YMQWBgIJycnBAVFYVVq1bl+b1at24d4uPj4eLiAl9fX3Tp0gWnT58usA5TCgronTt3hhAC06dPN7lPTHnvvfdM/izdu3cP06dPR0xMDDw9PeHm5obw8HB06dIFW7ZsMdj2+vXrGDduHCIjI+Hm5gZPT09UqVIFffr0MXn5THJyMsaPH4/IyEg4OzvD09MTTZs2xVdffWWyRgZ0IiKyBQZ0IjK7wgR0AOjSpQuEEJgyZYrR63NPjFNTUyGEgK+vLxo2bIhu3bqhefPmcHV1NQhuOaWlpaFu3boQQqBMmTLo3LkzEhIS4Orqio4dO+Ybip555hlUqFABgYGB6NKlCxISErBs2TIAwJIlSyCEQEREBFq3bo3ExETUqlULQgjodDp8++23RrUonzVy5Ei4uLjgmWeeQUJCAjw8PCCEwKRJk7Bz5064urqidu3aSExMROXKlSGEQKVKlfD3338bvF9xashLSQN6ZmYmevToASEE3N3d0aRJE3Tq1AkVK1aEEAJxcXFG9SsBe9CgQdBqtWjYsCG6d++Op556Chs2bFBDX87rnpOSkrBixQoAwIwZMwweV5ryOiEE/vzzTwDA/v374ezsDCEEYmJikJiYiISEBFSvXh1CCGzfvl2tS/n+t2vXDsHBwQgICEBiYiJatGgBR0fHPP9AIYRAxYoV0aZNG7i5ueGZZ55B165dMWTIEIN9V5yA3qFDB1StWhXly5dH165d0bRpUzg4OEAIoe6PnJTTzrVaLZo0aYLu3bsjLCwMPj4+6Nu3r9kDesuWLU0eQS9qQH/06BHi4+MhhICfnx/at2+PxMRE1K9fH66urga/43fv3kVYWJi63zt27IguXbogLi4OOp3O6Hv0+++/qz+PoaGh6NChA5o1a6aOH2+99ZZRjQzoRERkCwzoRGR2hQ3oU6dOhRACPXr0MHp97onxw4cPsWHDBmRkZBg8fv36dTzxxBMQQuDHH380eO4///mPGhBv376tPn7+/Hl1sp5XKBJCoFOnTkhNTTWq+8iRIzh69KjR41u2bIGTkxMqVaqkHhFXKAGsfPnyBtfXnzhxAnq9Hq6urggNDcWSJUvU59LT09GsWTMIIbB69eoS15CXkgb02bNnQwiBJk2a4MqVKwb1K5cyjBs3zuA1SkB3dnbG//3f/+VZU1GCUFZWFjp27AghBIYNG6Y+roTSOXPmGL3mxIkTJo+gCyHQokUL3L9/X31u3759cHd3h1arxYEDBwzeR3lN5cqV8ddffxl9TkkCuhAC3bt3R1pamvrchg0bIIRAcHCwwWvOnj0LJycnODk5Ydu2berjDx8+RP/+/dX3M1dAT05Ohre3NxwcHIzO9ChqQN+2bRuEEHjyySeNfu/u3LmD/fv3q1+vXr0aQgi0b9/e6OyZ69ev47ffflO/fvToEWrUqAEhBGbPnm2w/enTpxEWFgYHBweD1+RVPwM6ERFZGgM6EZldYQP60qVLIYRA69atjV5flFXcv//+ewghMHr0aIPHg4KCTJ5CDwArVqzIN6Dr9XqTQasgvXr1ghACR44cMXhcCWCmrtPt1KkThBBo0KCB0XObNm3K8wyBotaQFyV0FLblDFUPHz6En58f3NzccPXqVaP3/vvvvxEYGAgfHx+DYKQE9BdeeCHfmooShCZMmAAhBJo2bWpwG782bdpACIFDhw4V+B7K91+r1eLkyZNGz48bNw5CCAwcONDgcWXfrF271uT7liSge3p64ubNm0avUVZRz3kqv7IPctcHALdv34a7u7tZAnpqaip++eUXNGrUSA2+uRU1oH/++efqWSYFmTVrFoQQmD9/foHbKn/M6Ny5s8nn169fDyEERowYUWD9DOhERGRpDOhEZHaFDejKadpt2rQxen1eE/uDBw9i1qxZGDZsGPr164ekpCQ8++yz6mnJigsXLkAIgcDAQJPvc/fu3XwDer169fKtPS0tDRs3bsRrr72G559/Xj3FOiYmBkIIrFu3zmB7JYApp13nNGbMGAhhfKo/kH3ttBACLVu2LHENeVFCh5ubm8nTxpUWGxtrFKr27t2rHm3OS9u2bSGEMAi8SkDP61T8ogahNWvWQIjsywGSk5MNnps4cSKEEHjqqaewfft2g/Cem/L9r127tsnnDx06BCEEqlatavC4EAIajcbgKHdOJQnoTZs2Nfka5ef+559/Vh9r0qQJhBBG12vnfk1xArqpptFo8OGHH5p8XVED+u+//w6tVgsvLy8sX77c5B8lFD/88AOEEAgKCsKaNWtw9+7dPLcdOnQohBD45JNPTD5/48YNCCFQt27dAutnQCciIktjQCcisytsQFdOQe/Vq5fR63NPjNPT09XrnPNqTZo0UbffvXu3erpsXry9vfMMRd26dcvzdUeOHEFoaGi+tbz//vsGr1ECmKnF7JTwZmrRr7wCQXFqyEtJTnFXjnoWpu3cuVN9nRLQT5w4kW9NhQlC+/fvh4uLCzw8PHDs2DGj5+/cuaMGVyGyr5Nv0aIF5s+fj5SUFINtle9/p06dTH5WSkqK+h45CZF9vXxeShLQ+/TpY/I1SUlJEMLwGvqIiAgIIUzuBwAYOXKkUR2mruefMWOGUR051wPo2LEjAgIC1CP8hw8fNvqsogZ0AJgzZw50Op16FkNMTAxGjRpl8v1HjRoFjUYDIQQcHR0RFxeHCRMm4OzZswbbKWdQFNQqV65cYP0M6EREZGkM6ERkdoUN6MrRvGnTphm9PvfEeMaMGRBCoEaNGti8eTOuXbumXo/++++/G02aSxrQ8zqlPCsrS72t1JAhQ3Do0CHcvXtXvd771VdfNRnETAUwRX7hzVQgKG4NeSlJQFeOXFeuXDnfo+9JSUkGYTznKu751VRQELpy5QqCgoKg1WrzXI0byN5nO3bswNixYxEXF6cushYQEIBTp06p25UkoOe3/woK6MqaCDkV9LNoroBuakX8nPs9r2vQ09LS1MszYmJijP74lN8+WbVqlcmADgB//vkn3nnnHbRr1079HdVoNCZPZz958iRmzZqFFi1aqAu+6XQ6fPnll+o2rVq1ghDZl9Lk9/M5ZsyYAutnQCciIktjQCcisytMQM95m7Wcp+gqr889MY6Li4MQwuTCaJs3bzaaNJf0FPe8QtHx48chhMATTzxh8vlu3bpZPKAXt4a8lCSg79ixA0IIJCQkFOqzFOYI6Glpaeqq37NmzSrS51+7dk09I6Nr167q4wWd4n748GEIYfoU9/z237Rp0yCEwLvvvmv03KNHj9SjxjkVJ6AXdIq7ssq9uRaJS0lJQdmyZSGEMLoFnU6ng6+vr8n3fOONN/IM6Dk9fPgQH330ERwdHeHk5IRbt27luW1qaireeustCCHg7++vPq4sVJgztBcGAzoREdkCAzoRmV1hAroyaTZ1hNvUxLhKlSoQQhidkgxAXZ0696RZWSRu165dRq9RjuAVNRTt2rULQgh07NjR6Llbt26hTJkyFg/oxa0hLyUJ6GlpafDy8oKHh4fRtd/5KSigX7p0CUJkXzeelz59+kAIgd69exf6c3NSzryIjIxUH8u5SFzOI+sK5eyEAQMGGDxe0P5TVh1/8cUXjZ5TFjk0R0BXFol7/vnnjbZPSUlRb+tnztuszZs3D0IIVKtWzeAoenBwMIQQJq8lb9CgQaECuqJevXoQQpi8v3lu5cqVgxAC165dAwB89tlnEML4UpqCMKATEZEtMKATkdnlF9DPnj2LxMRECJG9KJmplcZNTYyVhcZmzpxp8PjatWvV05VzT5qVa9zr1q1rEOwvXLigBuaihqJr165Bq9XC09PTIMClpqaq/bJ0QC9uDXkp6W3WlKPDjRs3Nrr+FwD++usvo4XECgro6enp0Ol0CAwMxKNHj4yeV1bxjo+PN3krvJyWLFmCc+fOGT2uBMucC/DlXBCtVatWePDggfrc/v374eHhAY1Gg19++cXgvQraf2fOnIEQAj4+PgZ9PnfuHCIjI80W0M+cOQMnJyfo9XqD2w4+evRI/aOYuQP633//rYbiL774Qn1c+QNK7lXZle9d7p+lbdu24fvvvzc6Vf7cuXPw9vaGRqPBpUuXAGSvzL57926jWvbv3w+tVgt3d3ekp6cDyD4Kr9zzfsqUKUYL+WVlZWHnzp0GayQADOhERGQbDOhEZHbK5Fu5trNPnz7o0KEDIiMj1UWdqlSpYhRycr4+98T4xx9/VIN4nTp10KNHD/X+5y+//LLJSXNaWhrq1q0LIQR8fX3RpUsXtGvXDm5ubmjfvj2Cg4Oh0+kMXlNQKAKA559/HkIIuLi4oG3btujSpQsCAgLg5+eHfv36WTygF7eGvJQ0oGdmZqphzMnJCfHx8ejevTueffZZREVFQaPRIDY21uA1BQV0AGjXrh2EEIiKikKfPn0wcOBA9X7wWq0WQuR/XfGNGzcAQF19vnr16ujcuTO6deumPubs7GwQzJTvf0JCAipWrIjAwEAkJiaiVatW6mnoEydONKq1MPtPuR+7l5cX2rVrh6effhpubm7o2rVrvovEFSWgA8D8+fPVswCaNm2K7t27Izw8HN7e3ujduzeEyHtFc1MKCugAsGDBAgghUKtWLfWxo0ePwsXFBUII1KxZE507d0bVqlXh4uKCYcOGGf0sKX8w8ff3R+vWrdGrVy+0bNkSer3e6OyDl156CUJkr+KekJCAnj17okmTJuoYMXfuXIP6Tp06hbCwMAghULZsWTRv3hw9e/ZEy5Yt1VP0582bZ/AaBnQiIrIFBnQiMjsloCvN0dERZcqUQXR0NJKSkrB+/XqTR0Vzvt5U2Nm9ezeaNWsGHx8feHh4oH79+li3bl2+k+Z79+5h7NixCA4OhpOTE8LDwzFp0iSkpqZCr9cbXaNemID+6NEjzJ07F9WrV4ezszMCAgLQq1cvXLhwIc+wbe6AXpwa8lLSgK7YtGkT2rZti7Jly0Kn06Fs2bKoU6cOxo4diwMHDhhsW5iAfu3aNfTp0weBgYFq8FK+L7l/xkw15b3/+9//YsCAAYiKioK3tzdcXV1RtWpVPPfcc0b3Os/5/b906RJ69+4Nf39/6PV6xMbG5rlPC7P/0tPTMX78eFSsWBFOTk6oVKkSpk6dikePHpk1oAPAl19+ibi4OLi4uMDHxwfPPvssfv/9dzz33HMQIu9r1E0pTEBPTU1VLyn5+uuv1cd3796NJk2awNXVFZ6enmjTpg0OHTpkchX306dPY+LEiXjqqadQrlw5ODk5ISgoCE8//TTWrVunLoIIZN9uccyYMXjyySdRtmxZ6PV6hISEoF27dvjhhx9M1piSkoKpU6eidu3acHd3h7OzM0JDQ9GqVSssWrRI/YOOggGdiIhsgQGdiOySssp769atbV0KSaQwf6B5XD169AjVq1eHRqPBlStXbF0OERERmcCATkSl2q+//mp0TevZs2cRExMDIQQ+/vhjG1VGMioNAf3MmTO4ffu2wWNpaWkYPXo0hBBo3ry5jSojIiKigjCgE1GpFhERgcDAQLRo0QLdu3dH/fr11Wta27dvb3DaLFFpCOgzZsyAk5MT6tWrh8TERLRu3VpdxM3Pz8/otH4iIiKSBwM6EZVqCxcuRKNGjRAQEACdTgcPDw/Ex8fj3XffxcOHD21dHkmmNAT0ffv2oXv37ggNDYWbmxv0ej3Cw8MxdOhQ/Pnnn7Yuj4iIiPLBgE5EREREREQkAQZ0IiIiIiIiIgkwoBMRERERERFJgAHdzmRmZuLixYtISUnBnTt32NjY2NjY2NjYJGspKSm4ePGi0V1IZJGammqxvqemptq6e0Q2xYBuZy5evAghBBsbGxsbGxsbm+Tt4sWLtp46GklNTYUQgRbrc2BgIEM62TUGdDuTkpKiDvi2/uswGxsbGxsbGxubcVMOqKSkpNh66mjkzp07/4TpixDijplbdr/v3Llj624S2QwDup1RBlUOfERERERyknm+ptSm0dyGVptp1qbR3Ja230TWwoBuZ2Qe8ImIiIhI7vkaAzqRZTGg2xmZB3wiIiIiknu+ptTm4JAMR8eHZm0ODsnS9pvIWhjQ7YzMAz4RERERyT1fY0AnsiwGdDsj84BPRERERHLP15TadLobcHJKN2vT6W5I228ia2FAtzMyD/hEREREJPd8jQGdyLIY0O2MzAM+ERGRXbh9CfhtM7DvM2D/WuDcHiD9b1tXRRKReb6m1KbXX4Ozc6pZm15/Tdp+E1kLA7qdkXnAJyIiKrWungK+GA2MKQsMEsZtsBaY/iSw6z2GdZJ6vsaATmRZDOh2RuYBn4iIqNT5OwX4YGB2CB/iYDqc5wzpgwQwqgxw4EtbV042JPN8TanNxeUKXF0fmLW5uFyRtt9E1sKAbmdkHvCJiIhKlfO/AK+UAwYXEMyNgrom+78regAZabbuBdmAzPM1pTY3t0twd79n1ubmdknafhNZCwO6nZF5wCciIio1zu0BhrsWPZznPqI+vyXwMN3WvSErk3m+xoBOZFkM6HZG5gGfiIioVLhzFRjpU7JwnjOkfzLU1j0iK5N5vqbU5uFxEZ6ed8zaPDwuSttvImthQLczMg/4REREj72sLGBxx4KvNy9qO7HV1j0jK5J5vsaATmRZDOh2RuYBn4hIWllZQNp24FZ34HoUcK0KcKMBcH8hkMnxlHI4uc28wVw5iv561eyfQ7ILMs/XlNq8vP6At/dtszYvrz+k7TeRtTCg2xmZB3wiIill/ApciwAuC+Cy4z//FcBlzT/NGbg3jeGJsi3pBAxxNH9IHySAk9tt3TuyEpnnawzoRJbFgG5nZB7wiYikk74HuOwCXHbIEczzaCkvMKTbu/u3/r1VmrnbEEdgdV9b95CsROb5mlKbj895lCmTbNbm43Ne2n4TWQsDup2RecAnIpJK5m3gSpnChXOlPVhp66rJlo59Z5lwrrTXwm3dQ7ISmedrDOhElsWAbmdkHvCJiKRyf8E/p7AXMpxf1gDXKvMouj3bPNM8K7fn2TRA6l1b95KsQOb5mlJbmTLn4Od3w6ytTJlz0vabyFoY0O2MzAM+kSXdunUFhw9/j19/3Yw//jiCzMxMW5dEMsvKAq5VKmJA/6elbbN19WQra18GhuosexT9xnlb95KsQOb5mlKbn98ZlC17zazNz++MtP0mshYGdDsj84BPZAmpqffwv/8twNKlg7Fs2RAsWzYUS5cOxkcfjcNff520dXkkq0eXix7ML4vsReTuvm7r6slWGNDJTGSerzGgE1kWA7qdkXnAJzK3hw8z8MUXU9RQnrMtWzYEy5cPw7Vr52xdJsno4e/FDOg6IOUlW1dPtsJT3IvmwX3g5GHg8B7g6H7gxhXb1vP338C+PcDGdcAXnwIb1gL/txW4dcvqpcg8X1NqK1v2FAIDr5i1lS17Stp+E1kLA7qdkXnAJzK3kyd3GQVzw5A+FF99Nc/WZZKMHl0qwRH0ibaunmyFi8TlLysLOLIXeGMQ0LYqUEMLRAvD1tAPGNYW+N8nQHqa5Ws6egR4+UWgTiTgqQXchekWURHo3xPY+h1ghUukZJ6vMaATWRYDup2RecAnMreNG2dj6dIh+Yb0pUsH4/7927YulWSTlQlcCy3mNejf2bp6shXeZi1vP38PdI7NDuGxjsbBPGeL+Se41/cBlk8DMjLMX8//NgFP188O316OeQfznE3ZLioMWLzAMnX9Q+b5mlJbYOBJlC9/yawtMPCktP0mshYGdDsj84BPZG4ff/xqgeF86dLBuH79gq1LJRndm1uMVdzDs8M92a8lnbLDtCVC+snttu5d0d27A7zxvGHwLkqroQE6RQMnD5mnnuvXgT5ds4N2fkfM82semuxWNyb7CLwFyDxfY0AnsiwGdDsj84BPZG7r1k0vVEC/e/emrUslGWUmA1e8gMvawof0+0tsXTXZ2slt5g/mg7XA61Ufv1v4Xb8MtKsGxDgUPZjnbLEOQE0dsP2/Jatn63dARR/Ay6F4wdzoiLpD9lH1d+aaZ3/lIPN8TamtfPnjqFDhollb+fLHpe03kbUwoNsZmQd8InP77bdtBYTzIVi/fqatyySZpf8EXNYDlx0KDue3Bzx+AYrMLysLWNwRGGLmxeJObLV1z4om+TrwTOWCT2cvypH0WEfgp2+KV8/Gddlh2kNjnnCeu70+zqy//zLP1xjQiSyLAd3OyDzgE5lbenoqPv74VZOruCsB/eLFY7Yuk2SXvhe4FvLvInAGwVwLXHbKvrUaT20nxZ1rwEgf86zoPlgLfDLU1j0qmqwsYFBL84VzNaRrgSdcgct/FK2e77dYNpwrbcabZtuFMs/XlNoqVDiK4OA/zNoqVDgqbb+JrIUB3c7IPOATWcLduzfx+edvqqu2L18+DEuXDsbKlS/izJlfbF0ePS6yMoHUzUBy++zrzK9WAG7UAe7NATJ5iQSZcG4vMNy1ZCF9sBaY3wp4mG7r3hTN+lXmDeYGp7s7As81L/zR6iuXgXKexb/evKht2/dm2YUyz9eU2oKDjyA09LxZW3DwEWn7TWQtDOh2RuYBn8hSsrKy8NdfJ/Dzz2uxY8caHD/+EzIyUm1dFhGVdud/AV4pV/SQPliT/d+VPYEMK9xqzJzu3QHi3C0X0JX27dqCa8nKAjq3Lfwq7SVtnlqgSnnADHMsmedrDOhElsWAbmdkHvCJiIhKnb9TgA8G/nOrtAKCunKLtlG+wIEvbV158axZlH29uCXDeYwW6PNUwbWsXWOdYJ47pI8s+SUJMs/XlNpCQw8hPPysWVto6CFp+01kLQzodkbmAZ+IiKjUunYaWDsGGFM2j/ucOwDTnwR+fh9I/9vW1RZPVlb2qu2WDuhKO/Vb/rU8Ud3y152bat6OwI0bJdqVMs/XGNCJLIsB3c7IPOATERHZhZTLwG+bgX2fZR8pP7cHKA2X3Vy5aJ1grhxFf39O3rXs3mX9YJ7zKPrbs0q0K2Werym1hYf/isqVT5u1hYf/Km2/iayFAd3OyDzgExER0WNs60YrBnQH4JUeedcysFf2kWxbhfSqFUp02zWZ52sM6ESWxYBuZ2Qe8ImIiOgxtvhN899aLb/WpnLetYT62y6cK+38uWLvSpnna0ptlSodQNWqv5u1Vap0QNp+E1kLA7qdkXnAJyIiosfYrFFATZ31AnpDf9N1XLls+3DuLoANhVhpPg8yz9cY0IksiwHdzsg84BMREdFjbOZIKwd0P9N1fPOV7cO5tw54fVyxd6XM8zWltipVfkG1aifM2qpU+UXafhNZCwO6nSsP5iYAACAASURBVJF5wCciIqLH2OI3rHyKeyXTdSxfZJvV23M2LwegX/di70qZ52tKbRERe1G9+jGztoiIvdL2m8haGNDtjMwDPhERET3GflhvvXAe4wC83M10He/MzQ7Itj6K3r1jsXelzPM1BnQiy2JAtzMyD/hERET0GLv8hxUDuhZYPdt0HYsXZN/qzJbh3FML9Ola7F0p83xNqS0ycjeio38za4uM3C1tv4mshQHdzsg84BMREdFjLCsLeKYKUENjnZB+8pDpOj75wPZHz70dgReeK/aulHm+xoBOZFkM6HZG5gGfiIiIHnMfL7B8QI/RAj3i867hyCHbB3QPDbBsYbF3o8zzNaW2qKhdiIk5bNYWFbVL2n4TWQsDup2RecAnIiKix9yd28ATrpY/ev71p3nXkJEBlHGyfUjft6f4u1Hi+RoDOpFlMaDbGZkHfCIiIioFPl9iuWAe6wgkNQIyM/OvoXGcbVdy99YBf/9d7F0o83xNqa1GjR2oWfOgWVuNGjuk7TeRtTCg2xmZB3wiIiIqBTIzgX6NzX/LtRoaoI4LcPFcwTWsXAK42yigezsCA3qWaBfKPF+TKaD/+OOPSEhIQLly5SCEwIYNG9TnMjIyMHbsWERHR8PV1RXlypVDnz59cOnSJYP3SE5ORs+ePeHh4QEvLy8MGDAA9+7dM9jm8OHDaNCgAfR6PSpUqIBZs2YZ1fLFF18gIiICer0e0dHR+Prrr4uxd4kY0O2OzAM+ERERlRI3rgAtQ8wX0mtosq8937qxcJ9/9y7g72q7I+i7d5Vo98k8X1Nqi439EbVrHzBri439sUj9/uabbzBhwgSsX7/eKKCnpKSgefPm+Pzzz3Hy5Ens3r0bcXFxqFOnjsF7tG7dGrGxsdizZw927NiBypUro0ePHgb9DQgIQK9evXD06FGsWbMGLi4uWLZsmbrNrl274ODggNmzZ+P48eOYOHEidDodfvvttxLubbJHDOh2RuYBn4iIiEqRy38ArcOz71leknAe45Ad9L9dW7TPHzPc+vdD93IA4qKzV7QvAZnna0pttWptxxNP/GLWVqvW9mL3O3dAN2Xfvn0QQuCPP/4AABw/fhxCCPzyyy/qNps3b4ZGo1GPtC9evBg+Pj5IT09Xtxk3bhwiIiLUrxMTE9G2bVuDz4qPj8fgwYOL3A8iBnQ7I/OAT0RERKVMSjIwrte/R8GLfORcC7StAhzZW/TPvnkTqFjGuteie2iAn3eWeLfJPF+zRkC/ePEi7ty5o7a0tLQC6ypMQP/++++h0WjU/bpq1Sp4e3sbbPPw4UM4ODhg/fr1AIA+ffqgQ4cOBtts27YNQgjcunULAFCxYkXMmzfPYJtJkyYhJiamwLqJcmNAtzMyD/hERERUSm3bBLSt+u9CbwWdzh4tgDh34J2JQFpq8T9303rrhXNPLTB+tFl2l8zzNaW2OnW2Ii5ur1lbnTpbIYQwapMnTy6wroICempqKmrXro2ePf9dH2DatGmoWrWq0bb+/v5YvHgxAKBFixYYNGiQwfPHjh2DEALHjx8HAOh0Onz6qeGdBRYtWoSyZcsWWDdRbgzodkbmAZ+IiIhKsaws4JcfgfG9geYVTYfzOA9gQDNg3UrgwX3zfO6gJMsfRfdyBOpElmjl9pxknq9ZI6Cb+wh6RkYG2rVrh1q1ahnsUwZ0khEDup2RecAnIiKylJCQkEIfiSMrSUkGDu0G9m4DDuwA/jxb4mu3TcrIADq1yT7CbalwHhkMXLlstpJlnq8ptT3xxA+oW3e3WdsTT/xg9mvQMzIy0LFjR8TExODmzZsGz/EUd5IRA7qdkXnAJyIi20lPT8e0adMQGRkJV1dXeHh4oFKlSujYsSMOHTpk6/JKrGPHjoiPj8eKFStsWkfjxo0hhEBSUpJN67A7aWlAj06WOa29VlXg8qWCaygCmedrj1NAV8J5VFQUrl+/bvQaZZG4/fv3q499++23JheJy8jIULd59dVXjRaJS0hIMHjvevXqcZE4KhYGdDsj84BPRES2M2LECPV6zypVqqBGjRrw8PCAEAJr1xZx9WwryLmi8uOEAd2GMjOBJe8Avs7Z9yovaTB3F8DIoUCue2abg8zzNaW2uLjvUL/+LrO2uLjvitTve/fu4eDBgzh48CCEEHj77bdx8OBB/PHHH8jIyED79u1RoUIFHDp0CFeuXFFbzvGjdevWqFWrFvbu3YudO3eiSpUqBrdZS0lJQUBAAPr06YOjR4/is88+g6urq9Ft1hwdHTFnzhycOHECkydP5m3WqNgY0O2MzAM+ERHZTkBAAIQQmDRpkvpYVlYWdu7ciVOnTqmPmTpVPCkpCUIING7cWH1MCftz585Fz5494e7uDj8/P7z++uvIynEac0pKCkaMGIHg4GDodDoEBQVh1KhRePDggcn3nzVrFoKCgqDRaAAAaWlpGDx4MDw8PODv74833ngDffv2hRACISEh+da9fft2REdHQ6/X46mnnsL//vc/te733nsPAHDx4kW0adMGFSpUgLOzM5ydnREVFYV58+YZ9EN5/7Fjx+KFF15AmTJl4O/vjxEjRuDhw4cG+yR3O3/+PADgxIkT6NKlC/z8/KDT6VCtWjX1OljF119/jbp168LLywsuLi6oVKkSEhMT1VNtqRDOngHaNPn39PQinc7+z23bosKA/9tqsRJlnq/JFNC3b99u8ncqKSkJ58+fz/N3bvv27ep7JCcno0ePHnB3d4enpyf69++Pe7n+6HL48GE0aNAAer0eQUFBmDlzplEtX3zxBapWrQonJydERUXh66+/LtF+JvvFgG5nZB7wiYjIdvz9/SGEQN26dfHVV1/h6tWrJrcrakDX6/UoX748goKC1McWLFgAIPsoeM2aNSGEgLOzM2JiYuDs7AwhBJo1a6YGYOX9nZycoNVqERkZCV9fXwDA6NGj1fcNDw+Ht7c33NzcCgzoV65cUbdzcXFBtWrV1K9zBnTlyFyFChVQq1YtlC1bVt1m4cKFRu+v0+lQpkwZg/4uX74cQPZ9kZWzEvz8/BAfH4/4+HhcvnwZp06dgpeXF4QQKFOmDKKjo6HRaCCEwJtvvgkAuH79OpycnCCEQHBwMGJiYuDt7W0Q8qkIDv0KDH8u+4i6clQ8933TPbX/Hm330ADPPgN8+0320XgLknm+ptRWt+4WNGiww6ytbt0t0vabyFoY0O2MzAM+ERHZzuTJk42OMkVERGDKlClITf33NldFDegNGzZERkYGMjIy0LBhQwghEBAQAAB4//331eCtHKU/dOiQ+toffvjB4P2FEPjmm28AAI8ePcL9+/eh1+shhEDXrl0BZIdYHx+fAgP6xIkTIYSAVqvF4cOHDR7LGdBTUlIMwm9mZiYaNWoEIQQaNGhg9P5hYWFISUlBamoqypcvDyEEunXrpm6X1ynu/fr1gxAC0dHR6tkD8+fPV/+AcPfuXezfvx9CCHh4eODvf1YLz8rKwr59+3D/vplWPLdH9+4BO/4PeGcu0K8H0KIB0KAO0KwekNgemP4GsPl/wDXTf7SyBJnna0pt9et/g0aNfjRrq1//G2n7TWQtDOiPoZCQENSoUQOxsbFo0qRJkV4r84BPRES2tX79erRr1w6enp5Gp4sqihrQlaPlALBgwQL18evXr2PYsGF5noIqhMDUqVMN3j/nokxA9mmnyrZffPGF+vizzz5bYEDv1KkThBCoXr26us2RI0eMAvr9+/cxdOhQBAcHw9HR0aC+8PBwo/d/6aWX1MeeeuopCCEM/q3OK6BXr149332xc+dOpKamIjw8HEIIuLu7o1atWujbty82bdpk+htKjy2Z52sM6ESWxYD+GAoJCTG6NqawZB7wiYhIDpmZmdi3bx9q1KgBIQS8vLzU50JDQyGEwMSJE9XHOnbsWKKA7uTkpJ7unbMtWrQIwL8BvVGjRgZ1WiOgP/fcc+pjVapUQXx8PPz8/Ap8f+DfMJ5zvxQU0HOe+p6z7d69GwBw+/ZtvPPOO+jVqxdq1aqlngafs//0+JN5vqbU1qDB/9CkyXaztgYN/idtv4mshQH9McSATkRE5jZhwgQcPHjQ4LHOnTur1zsr4uLiIIRAYmIiAODGjRvqddCmAnrjxo3x8OFDPHz4UA2nyinu7733HoQQcHBwwIEDB9TXpqam4ssvv8Tt27cBmD5CDwAPHjxQr1nv2bMngMKf4v7666+rn338+HEApk9xj46OhhACLVu2VGuLjY0tdkBv06YNhBDo0qWLQV+UPlaqVAnJycnq4zdu3MBnn30GIPvf8J9//tlgcbpWrVpBCIHhw4eDSg+Z52sM6ESWxYBuZT/++CMSEhJQrlw5CGF8v0YAWLhwIUJCQqDX6xEXF4e9e/caPB8aGoratWvjiSeewMcff1ykz5d5wCciIttRVnH38/ND7dq1UaFCBTWsjh8/Xt3u1VdfVR9v0KABAgMDodVq8wzobm5uCAoKMlg0bd68eQCyV2CPiYlRrwWPiopC1apV1evKlWu/8wrogOEicZUqVYK3tzdcXV0LDNA5F4lzc3NDtWrV1NflDOg9e/ZUH6tatSr8/PxQpkyZYgf0UaNGqf2tVasWWrVqBQA4efKkemmBq6sratasieDgYDg4OKifc/r0aQgh4OPjgxo1aiAiIkKtTVmIjkoHmedrSm2NGv0XzZptNWtr1Oi/0vabyFoY0K3sm2++wYQJE7B+/XqTAf2zzz6Dk5MTVq9ejWPHjuH555+Ht7c3rl27pm7z119/AQAuX76M6tWrq4vbFIbMAz4REdnOihUr0KFDB4SFhcHV1RVOTk6IiIjA5MmT1duEAcDdu3fRu3dveHt7o2zZshg7dqwaYvM6xb1v375wd3eHr68vJkyYgMwcK2Dfvn0bI0aMQEhICHQ6Hfz9/fHUU09h2rRp6kJo+QX0nLdZ8/Pzw4QJE9Qj/9WqVVO3y+s2a1FRUXByckLdunXx6aefqnUrR62vXr2KDh06wN3dHeXKlcOsWbPUeooT0C9duoTmzZvD3d0dQgh1NXoAOHbsGLp27areZq1ChQpo27YtPvzwQwDArVu30K9fP1SrVg3u7u5wdXVFtWrVMH36dIOj6vT4k3m+xoBOZFkM6DZkKqDHxcXhhRdeUL/OzMxE+fLlMWPGDJPv8fLLL6t/5TclLS0Nd+7cUdvFixc58BERkcXlPhJtKVevXjX4Ny05OVk9G6B79+75vjbn/d0BYOrUqWrdJ06csEi9RIXxOAT0Jk02onnz783amjTZKG2/iayFAd2Gcgf09PR0ODg4GIX2vn37on379gCyV5O9e/cuAODevXuoXbs29u3bl+dnmLptDgc+IiKyNGsF9A0bNsDd3R1NmzZF27Zt1dPP3dzcCjzDLDY2FpGRkWjfvj2eeOIJtebevXtbtGaigjCgy9dvImthQLeh3AH90qVLEELg559/NtjulVdeQVxcHADg7NmziImJQUxMDKKiojB//vx8P4NH0ImIyBasFdAPHTqEhg0bwsfHB46OjggICEDXrl1x5MiRAl87fvx4hIeHw9nZGS4uLoiNjcXcuXMNTuknsoXHIaA3a7YeLVt+a9bWrNl6aftNZC0M6DZUnIBeUjIP+EREREQk93xNqa158y/RuvVms7bmzb+Utt9E1sKAbkPFOcW9pGQe8ImIiIhI7vkaAzqRZTGg21Bei8TlvJdpZmYmgoKC8lwkrqhkHvCJiIiISO75mlJbixZr8cwzX5u1tWixVtp+E1kLA7qV3bt3DwcPHsTBgwchhMDbb7+NgwcP4o8//gCQfZs1vV6P999/H8ePH8egQYPg7e2Nq1evmuXzZR7wiYiIiEju+RoDOpFlMaBb2fbt202uqp6UlKRu8+677yI4OBhOTk6Ii4vDnj17zPb5Mg/4RERERCT3fE2prVWrz5GQ8JVZW6tWn0vbbyJrYUC3MzIP+EREREQk93yNAZ3IshjQ7YzMAz4RERERyT1fU2pr02YN2rffZNbWps0aaftNZC0M6HZG5gGfiIiIiOSerzGgE1kWA7qdkXnAJyIiIiK552tKbW3bfoKOHTeYtbVt+4m0/SayFgZ0OyPzgE9EREREcs/XlNratfsIzz67zqytXbuPpO03kbUwoNsZmQd8IiIiIpJ7vsaATmRZDOh2RuYBn4iIiIjknq8ptXXo8AG6dFlr1tahwwfS9pvIWhjQ7YzMAz4RERERyT1fY0AnsiwGdDsj84BPRERERHLP15TaOnV6D4mJn5u1der0nrT9JrIWBnQ7I/OAT0RERERyz9cY0IksiwHdzsg84BMRERGR3PM1pbbOnVehe/c1Zm2dO6+Stt9E1sKAbmdkHvCJiIiISO75GgM6kWUxoNsZmQd8IiIiIpJ7vqbU1rXrCvTs+YlZW9euK6TtN5G1MKDbGZkHfCIiIiKSe77GgE5kWQzodkbmAZ+IiIiI5J6vKbUlJi5H794fmbUlJi6Xtt9E1sKAbmdkHvCJiIiISO75mlJb9+5L0bfvB2Zt3bsvlbbfRNbCgG5nZB7wiYiIiEju+RoDOpFlMaDbGZkHfCIiIiKSe76m1Naz52L06/eeWVvPnoul7TeRtTCg2xmZB3wiIiIiknu+xoBOZFkM6HZG5gGfiIiIiOSerym19e69EAMGrDJr6917obT9JrIWBnQ7I/OAT0RERERyz9cY0IksiwHdzsg84BMRERGR3PM1pba+fd/Bc8+tMGvr2/cdaftNZC0M6HZG5gGfiIiIiOSerzGgE1mW3Qf0Y8eOYfPmzdi0aZNBK61kHvCJiIiISO75mlJbv37zMWjQMrO2fv3mS9tvImux24B+9uxZxMTEQKPRQKvVQqPRqP+v1WptXZ7FyDzgExEREZHc8zWltgED3saQIUvM2gYMeFvafhNZi90G9ISEBHTo0AE3btyAu7s7jh8/jh07diAuLg4//fSTrcuzGJkHfCIiIiKSe77GgE5kWXYb0H19fXH48GEAgKenJ06ePAkA2Lp1K2rWrGnL0ixK5gGfiIiIiOSerym1PffcHAwbtsis7bnn5kjbbyJrsduA7u3tjXPnzgEAwsPDsW3bNgDAmTNn4OLiYsvSLErmAZ+IiIiI5J6vMaATWZbdBvQGDRpgw4YNAIAePXqgdevW2LlzJ/r27YuoqCgbV2c5Mg/4RERERCT3fE2pbdCg2Rg+/F2ztkGDZkvbbyJrsduAvmXLFqxbtw4AcPr0aURERECj0cDPzw9bt261cXWWI/OAT0RERERyz9cY0Iksy24DuinJycnIysqydRkWJfOAT0RERERyz9eU2gYPnoURIxaYtQ0ePEvafhNZCwO6nZF5wCciIiIiuedrDOhElmW3AX369OlYtWqV0eOrVq3CzJkzbVCRdcg84BMRERGR3PM1pbahQ2dg5Mh5Zm1Dh86Qtt9E1mK3AT0kJAS7du0yenzPnj0IDQ21QUXWIfOAT0RERERyz9eU2l54YRpGj55r1vbCC9Ok7TeRtdhtQNfr9ept1nI6e/Ys9Hq9DSqyDpkHfCIiIiKSe77GgE5kWXYb0CtXroyPPvrI6PEPP/wQYWFhNqjIOmQe8ImIiIhI7vmaUtuLL/4HL7/8llnbiy/+R9p+E1mL3Qb0WbNmwdfXF6tXr8aFCxdw4cIFrFq1Cr6+vpg+fbqty7MYmQd8IiIiIpJ7vsaATmRZdhvQs7KyMHbsWDg7O0Or1UKr1cLV1RVvvvmmrUuzKJkHfCIiIiKSe76m1PbSS29i7NhZZm0vvfSmtP0msha7DeiKe/fuYd++ffjtt9+QlpZm63IsTuYBn4iIiIjknq8xoBNZlt0HdHsj84BPRERERHLP15TaRo2ajPHjZ5i1jRo1Wdp+E1mLXQX0UaNG4f79++r/59dKK5kHfCIiIiKSe77GgE5kWXYV0Js0aYLbt2+r/59Xa9q0qY0rtRyZB3wiIiIiknu+ptQ2ZszreO21aWZtY8a8Lm2/iazFrgI6yT3gExEREZHc8zWltldemYCJE/9j1vbKKxOk7TeRtdh1QE9NTcXevXvx1VdfYdOmTWr773//a+vSLEbmAZ+IiIiI5J6vMaATWZbdBvTNmzfDz88PGo3GqGm1WluXZzEyD/hEREREJPd8Talt3LhXMWnSm2Zt48a9Km2/iazFbgN65cqVMWzYMFy9etXWpViVzAM+EREREck9X2NAJ7Isuw3oHh4eOHPmjK3LsDqZB3wiIiIiknu+ptQ2fvx4vPHGZLO28ePHS9tvImux24Dev39/rFy50tZlWJ3MAz4RERERyT1fY0Ansiy7DegPHjzAM888g6SkJMyZMwcLFiwwaKWVzAM+EREREck9X1Nqe+21sZgy5XWzttdeGyttv4msxW4D+sqVK+Ho6Ah3d3eEhIQgNDRUbWFhYbYuz2JkHvCJiIiISO75GgM6kWXZbUAPCAjAtGnTkJmZaetSrErmAZ+IiIiI5J6vKbVNnPgypk6dYNY2ceLL0vabyFrsNqD7+PhwkTgiIiIiko7M8zWltkmTRmP69FfN2iZNGi1tv4msxW4D+siRIzFt2jRbl2F1Mg/4RERERCT3fI0Bnciy7Dagv/jii/Dy8kKjRo0wfPhwjBo1yqCVVjIP+EREREQk93xNqe2NN0Zi5sxxZm1vvDFS2n4TWYvdBvQmTZrk2Zo2bWrr8ixG5gGfiIiIiOSerzGgE1mW3QZ0eyXzgE9EREREcs/XlNqmTBmB2bNfMWubMmWEtP0msha7Deh//PEHsrKy8nyutJJ5wCciIiIiuedrDOhElmW3AV2r1eLatWtGj9+8eRNardYGFVmHzAM+EREREck9X1Nqmzp1OObMGWPWNnXqcGn7TWQtdhvQNRoNrl+/bvT4hQsX4OrqaoOKrEPmAZ+IiIiI5J6vMaATWZbdBXRllXatVovBgwcbrNw+YsQIxMfHo379+rYu02JkHvCJiIiISO75mlLb9OnD8Pbbo8zapk8fJm2/iazF7gK6slK7RqNB/fr1DVZvb9myJQYNGoRTp07ZukyLkXnAJyIiIiK552tKbTNnDsH8+S+Ztc2cOUTafhNZi90E9IyMDIOv+/XrZ5e//DIP+EREREQk93yNAZ3IsuwmoM+YMQOff/65rcuwOZkHfCIiIiKSe76m1DZr1mC8886LZm2zZg2Wtt9E1mI3Af33339H9erVMX/+fAAwuPbcVCutZB7wiYiIiEju+RoDOpFl2U1AB4C7d+/i2WefBQCDa89zt6ZNm9q4UsuRecAnIiIiIrnna0ptb731PBYufMGs7a23npe230TWYlcBXZGRkYFmzZqV6sXg8iLzgE9EREREcs/XGNCJLMsuAzoA+Pn5MaATERERkXRknq8ptc2dOxCLFw81a5s7d6C0/SayFrsN6CNHjsS4ceNsXYbVyTzgExEREZHc8zUGdCLLstuAPnz4cHh6eqJOnToYNGgQF4kjIiIiIinIPF9Taps3rz+WLh1s1jZvXn9p+01kLXYb0LlIHAc+IiIiIhnJPF9TaluwIAnLlz9v1rZgQZK0/SayFrsN6PZK5gGfiIiIiOSerzGgE1kWA/pj5vbt26hTpw5iY2MRFRWF5cuXF+n1Mg/4RKVZUlL2pKNx48a2LgUAEBISAiEEJk+ebNb3PX/+PIQQEEJg+/btZn1va7w/EZEMZJ6vKbW9+24frFw50Kzt3Xf7SNtvImux+4B+7NgxbN68GZs2bTJosnr06BEePHgAALh//z5CQ0Nx8+bNQr9e5gGfSq/09HRMmzYNkZGRcHV1hYeHBypVqoSOHTvi0KFDti7PKqZMmYL4+HgMHTrU1qUAADp27Ij4+HisWLHCrO97+fJlxMfHIz4+HgcOHDDrewMM6ERkH2SerzGgE1mW3Qb0s2fPIiYmBhqNBlqtFhqNRv1/rVZr6/IKJTk5GSEhIbhx40ahXyPzgE+l14gRI9RQVaVKFdSoUQMeHh4QQmDt2rW2Ls+upKen27qEEmFAJyJ7IPN8Talt0aJeWL26v1nbokW9itTvH3/8EQkJCShXrhyEENiwYYPB81lZWXj99dcRGBgIZ2dnPP3000a3WU5OTkbPnj3h4eEBLy8vDBgwAPfu3TPY5vDhw2jQoAH0ej0qVKiAWbNmGdXyxRdfICIiAnq9HtHR0fj666+LuGeJstltQE9ISECHDh1w48YNuLu74/jx49ixYwfi4uLw008/WexzCxpIAGDhwoUICQmBXq9HXFwc9u7da/D87du3ERMTAxcXFyxcuLBIny/zgE+lV0BAAIQQmDRpkvpYVlYWdu7cafAPZWZmJubPn4+oqCjo9Xp4e3ujS5cuOHfunMH7nTp1Cj169EBAQAB0Oh2CgoIwZswYAHkHOFOndF+6dAn9+/dHuXLloNPpEBYWhilTpuDhw4fqNo0bN4YQAn369MGkSZMQGBgIb29v9OrVC3fv3jXoz6JFi1CzZk04OzvD3d0dTz75JA4ePAjA9Cnu48aNQ/Xq1eHl5QVHR0eUK1cOffv2xeXLl/Pdnznfa+HChQgODoZer0fr1q3x559/GtXeu3dvvPzyy/D390doaKjJ/bF9+3Z1v23cuBENGzaEs7MzIiIi8NVXX5Vo/0+ePBlCCISEhGDt2rWoWrUq9Ho96tWrhyNHjqjv+91336FBgwbw9/eHTqeDh4cHGjRogG+++UbdhgGdiOyBzPM1mQL6N998gwkTJmD9+vUm59UzZ86El5cXNm7ciMOHD6N9+/YICwtDamqquk3r1q0RGxuLPXv2YMeOHahcuTJ69Ohh0N+AgAD06tULR48exZo1a+Di4oJly5ap2+zatQsODg6YPXs2jh8/jokTJ0Kn0+G3334r4d4me2S3Ad3X1xeHDx8GAHh6euLkyZMAgK1bt6JmzZoW+9yCBpLPPvsMTk5OWL16NY4dO4bnn38e3t7euHbtmtF7Xb16FfXrjVri/QAAIABJREFU18fVq1cL/fkyD/hUevn7+0MIgbp16+Krr77K82d26NChaviKioqCr68vhBAIDAxUfwdOnz4Nb29vCCHg4OCAyMhIBAYGIjY2FkDhA/rNmzdRsWJFCCHg4eGBmJgYODo6QgiB/v37q69TQq4SGMPCwtT3f+2119Tthg8frj7u6+uLqKgoODk5qb/jpgJ6bGwsvLy8EB0djWrVqkGj0UAIgSeffDLf/am8l16vh4uLCyIjI6HVaiGEQO3atZGVlWVQu5OTE3Q6HaKjoxETE2Nyf+QM6DqdDlWqVIGLi4u6f5KTk4u9/5WArtPpoNfrUb16deh0OgghEBQUpF62M2/ePOh0OoSHh6NWrVpwd3eHEAKOjo7qpRAM6ERkD2Serym1LVnSA++/n2TWtmRJj2L3O/e8OisrC4GBgXjrrbfUx1JSUqDX67FmzRoAwPHjxyGEwC+//KJus3nzZmg0Gly6dAkAsHjxYvj4+BicgTZu3DhERESoXycmJqJt27YG9cTHx2Pw4MFF7geR3QZ0b29v9ahceHg4tm3bBgA4c+YMXFxcrFKDqYAeFxeHF154Qf06MzMT5cuXx4wZM0y+x9ChQ/M9RTgtLQ137txR28WLF6Ud8Kn0UgJazhYREYEpU6aof8U+d+6cGlA/+OADAMC9e/dQoUIFCCEwceJEAED//v3VsLdr1y71M3799VcAhQ/ob7zxBoQQCAgIwPXr1wEAGzduhBACGo0Gp0+fBvBvyPXw8MBff/2FzMxM1KlTB0IIxMfHq5+p1N6pUyf1H/Hr16/j4sWLAEwH9CNHjiAzM1P9esWKFWrtZ86cyXN/Ku/l6OiIo0ePAgCWLl2qvnbz5s0GtTs5OakB99GjRyb3R86APnr0aADApk2bjN6zOPs/5/d/y5YtAIAtW7aojy1ZsgQAcOHCBdy+fVt9z1u3bqmXQijffwZ0IrIH9h7QL168aDB/TUtLK7Cu3PPqs2fPQgihnsmmaNSoEUaMGAEAWLVqFby9vQ2ef/jwIRwcHLB+/XoAQJ8+fdChQweDbbZt2wYhBG7dugUAqFixIubNm2ewzaRJk9Q/ihMVhd0G9AYNGqi/xD169EDr1q2xc+dO9O3bF1FRUVapIfdAkp6eDgcHB6PQ3rdvX7Rv3x5A9lFz5bTalJQUREVFGZwimpupYCTrgE+l2/r169GuXTt4enoa/CwmJSUByL52y9TPqtKaN28OAKhevbrB17kVNqA/88wz+X7exx9/DODfkJvzH+devbJPwVNOF89Z+86dO03WZSqgf/jhh6hduzbc3NyMPj+/S22U96pVq5b6mDJhEkJg9uzZBrW3atXK6D3yC+jKZOb06dPqY++//z6A4u1/ZRzy8fEx2NbHxwdCCAwbNgwA8Pvvv6NDhw7w9/dXzwhQ2oABA/J8fyKi0uZxCOjLlnXDhx/2MWtbtqybyX+TC3PHkdzz6l27dkEIYXTZWNeuXZGYmAgAmDZtGqpWrWr0Xv7+/li8eDEAoEWLFhg0aJDB88eOHYMQAsePHwcA6HQ6fPrppwbbLFq0CGXLli14hxLlYrcBfcuWLVi3bh2A7EloREQENBoN/Pz8sHXrVqvUkHsguXTpEoQQ+Pnnnw22e+WVVxAXFwcA2Lt3L2JjYxETE4MaNWpg6dKl+X4Gj6CTbDIzM7Fv3z7UqFEDQgh4eXkBMAy5NWvWVFcCV9rAgQMBFBwQL1y4oL7PDz/8oD6unJadO6B7eHgYfVZ8fLz6l3Ml5Cp/SAD+DcghISFGtRc2oO/YsUM96u7r64snn3wSkZGRhQqfRQ3offv2NXqP/AL6+fPnARiG4ffeew+AZQN65cqV1TMDYmNjER8fDycnJ4P9z4BORPbgcQjoy5cn4uOPe5m1LV+eaLYj6Azo9Liy24BuSnJysnrtpjUUJ6CXlMwDPpVeEyZMMDrFrHPnzhBCIDg4GED2qWhKYJ0/f766XVZWFn766Sd1zYicp1jv2bNH3U45hfvvv/9WA5zyj+v3339v9Ff4nKFRCaQAcPfuXfUUe6BwAT3nKe5dunRRT3G/efNmnqe4z5kzR61JmTzMmDGjSAHd0dFRnRwsX75cfW3uU9xz1q4obkAvaP8XdIr7d999ByB7QTjlsSVLluDmzZvq19OnT1ffS6/XM6ATkd2Reb5mjYBujmvQeYo7Pa4Y0G0o90BSmFPcS0rmAZ9KL2UVdz8/P9SuXVu9rlwIgfHjx6vbDRo0SH08LCwMNWrUUE+JVwJi7kXKqlevjvLly6uLlAFAvXr1IISAi4sLmjZtCldXV/WUaSWQXr9+HUFBQRAi+xrt2NhYhIeHq4uXKQoT0AHDReL8/PwQHR0NvV6f5yJxOQOqr68vqlWrhjJlyhQpoLu5ucHFxQXVq1dX+1ezZk2jReLMGdAL2v/5BXRlUTtlAT0hBMqVK4cHDx4gKytL/blQFrTz8fFRT/9nQCcieyLzfE2pbeXKLvj00x5mbStXdjFbQFcWiZszZ45B7aYWidu/f7+6zbfffmtykbiMjAx1m1dffdVokbiEhASDeurVq8dF4qhY7Dagjxo1ymQbPXo0XnvtNaxevVpdtdhScg8kQPYiccOHD1e/zszMRFBQUJ6LxBWVzAM+lV4rVqxAhw4dEBYWBldXVzg5OSEiIgKTJ082uKVZZmYm5s2bhxo1akCv18PT0xMxMTEYPXq0wVFu5TZfZcuWhU6nQ/ny5dWFzYDsa5kbNmwIl/9n777DoyrTPo6fmYQUiCGCSJW2KlJEQMGyqKAroqKoKy7IUlT01V1FUewoCIqggAqKIksVBelVeuhIDwkkAUIgJBAgkJDeZ77vH5OZZEiAlDlznmTuz3XdV2DKc+6T993H58dp/v7ccsstzJw5s8THrMXFxTkes2Z/zNlDDz3k9K/gpQ3olz9mrUaNGtd8zNrYsWNp0KAB1atX5+mnn+aPP/4oU0B/8MEHmTp1quOxjN26dSMmJuaqvduVN6Bf6/d/rcesLVu2jNtuuw0fHx/uuecex5F3sF3C07FjR/z8/GjZsiV//vmno08J6EIIT6Lyek2lgJ6WlkZISAghISFomsaECRMICQnh1KlTgO0xa0FBQSxbtoywsDDHWuTyx6y1b9+e3bt3s337dm655Ranx6wlJydTt25d+vXrx+HDh5k3bx7Vq1cv9pg1b29vxo0bR2RkJMOHD5fHrIly89iA3qVLFwIDA6lRowYdOnSgQ4cOBAQEULNmTe6++26CgoK4/vrrCQ8Pd+l2rzWRzJs3D19fX2bOnElERASvvvoqQUFBZXqU2tWoPOELIUqnpLCvsqIBXQghxLWpvF6z9zZ9+rPMm/cvl9b06c+Wab+L/uNy0bL/o67VauXTTz+lbt26+Pr68vDDD3P06FGnMRITE+nTpw8BAQEEBgby4osvkpaW5vSZ0NBQOnfujK+vLw0bNmTMmDHFepk/fz633norPj4+tG7dmlWrVpXvFyw8nscG9G+//ZZnn33WaQJITk7mueee47vvviMjI4OePXvSrVs3l273WhMJwKRJk2jcuDE+Pj506tTJ6TrPilJ5whdClI4EdCGEqNpUXq+pFNCFqIo8NqA3aNCgxKPjhw8fpkGDBgDs37+f2rVru7s1Xak84QshSkcCuhBCVG0qr9fsvc2c+TTz5/dyac2c+bSy+y2Eu3hsQK9Ro0aJ1y9u2rSJgIAAwHb3x+uuu87NnelL5QlfCCGEEEKovV6TgC6Evjw2oL/wwgs0a9aMxYsXExcXR1xcHIsXL6Z58+b8+9//BmDu3LnceeedBnfqWipP+EIIIYQQyktMhG1bYc1q2LAejh8HFz+mV+X1mr232bOfYuHCf7q0Zs9+Stn9FsJdPDagp6WlMWjQIHx8fDCbzZhMJnx8fHjllVdIT08HcNzMrSpRecIXQgghhFDS0aPwztvQtBF4a8Xr+uvgmadsod1iqfDmVF6vSUAXQl8eG9Dt0tLSCA0NJTQ0tNgdG6silSd8IYQQQgilJCRA7162EO7rXXI4t5dfwfstbobt2yu0WZXXa/be5szpweLFz7i05szpoex+C+EuHh3QL126xLhx43j55Zd5+eWXmTBhAsnJyUa3pSuVJ3whhBBCCGWsWQ03XA++XlcP5peXrxdUM8GH75f7aLrK6zV7b7///jhLl/Z0af3+++PK7rcQ7uKxAX3v3r3UqlWLhg0b8swzz/DMM8/QqFEjateuzf79+41uTzcqT/hCCCGEEEpYtLAwaJclnBetaiYY0K9cIV3l9ZoEdCH05bEBvXPnzgwcOJC8vDzHa3l5eQwYMID777/fwM70pfKEL4QQQghhuD17bKerVyScF61PPylzCyqv1+y9zZvXneXLn3RpzZvXXdn9FsJdPDag+/n5ERkZWez18PBw/P39DejIPVSe8IUQQgghDJWVBa1uLftp7dc6kr5nT5naUHm9JgFdCH15bEC/8cYbWbt2bbHX16xZw4033mhAR+6h8oQvhBBCCGGoMaNdd+S86DXp7W4v06PYVF6v2XubP78bK1c+4dKaP7+bsvsthLt4bEB/8803adSoEfPmzSM2NpbY2Fjmzp1Lo0aNeOutt4xuTzcqT/hCCCGEEIbJy4OG9VwbzotWGe7srvJ6TQK6EPry2ICek5PD4MGDHc9BN5vN+Pr68vbbb5OdnW10e7pRecIXQiVWq5XMzBTy83OMbkUIIYQ7rFyhXzj384aB/UrdisrrNXtvCxf+gz//fMyltXDhP5TdbyHcxWMDul1GRgZhYWGEhYWRkZFhdDu6c9WEb7VCWlqZztYSotI4ezaCJUveZfbsfvz228uEhCzAai3fo3KEEEJUEh++X/gscz2qSaNStyIBXb39FsJdPD6gexpXTPgxMdCqFWgaNGsGJdxrT4hKKzPzEr/99hKzZ/dn9ux+joqMXGd0a0IIIfT0cBf9wrm9EhNL1UplCOiLFj3MmjWPurQWLXpY2f0Wwl08KqAPGTKk1FVVuWLCf/JJ8PKyBXQvL7j3Xhc2KITBIiPXFgvns2f3Y/nyj4xuTQghhJ5ubqp/QD94sFStVIaAvmRJV9ate8SltWRJV2X3Wwh38aiA3qVLl1JV165djW5VN66Y8Nu0sYVze9Wv78IGhTDY4cMrSwzoS5YMNbo1IYQQemraSP+Avn9/qVqRgK7efgvhLh4V0IVrJvzPPy88em4ywZtvurBBIQyWknK2hIDen5CQBUa3JoQQuhg+fDiaptGkSROjWzHW7a30D+hHj5aqlcoQ0Jcte5ANGx52aS1b9qCy+y2Eu0hA9zCumPAtFpg0Cfr0ga+/tj2VRIiqJCpqS8F16LaAHhz8LXl5cjd3IUTlk5WVxYQJE7j33nupWbMmPj4+3HTTTTz88MOMHz8egKlTp3L33Xfz9NNPG9rrjBkz0DQNTTNoedr/37ZnlusVzgP8ID+/VK1IQFdvv4VwFwnoHkblCV8IleTkZHL2bAQpKWeNbkWIsrHkQvxPsP8O2BEE+1rB6W/BkmV0Z8LNLl68yB133OEIvdWrV6dNmzY0adIEb29v44LwFRge0L//DnzM+gX0++4udSsqr9fsva1YcT/BwV1dWitW3K/sfgvhLmrNzEJ3Kk/4QgghKsiSA2HdYKupoLTCP4fcC/lV/3GiolDv3r0dgfett94iK6vwH2mSk5OZMWMGUPIp7klJSTz//PP4+/tz0003MXnyZB580HZ088EHH3R87oMPPqBVq1bUrFkTb29v6tevT//+/YmPj3d8puj48+fPp0WLFlSvXp3777+fI0eOADBgwABHr0Vr+PDhAGRnZ/PZZ59x8803U61aNerUqcOLL77IhQsXHNs5e/YsL7zwAvXq1cPHx4e6devStWtXVq1aVbpfWEwMVDPpE86rmeC7b0v9fzuV12sS0IXQlwR0D6PyhC+EEKKCTk8sEswvLzPEfK7v9q1WSD8FaSfAItc/GenSpUt4eXmhaRp33HEHFovlip8tKaA/++yzjpDcokULatSoQY0aNYoF9DvuuIOaNWvSpk0bbrvtNkwmE5qm0bFjx2Lje3t7U61aNafP3XfffQCMHDmS5s2bO7Z59913c/fddzN16lQAHn/8cTRNw8vLi7Zt2xIYGIimabRq1YrMzEwAnnnmGTRNIyAggA4dOnDTTTdhMpkcIb9UevbQ5zT3Gr6QlFTqNlRer9l7W7Xq72ze/KBLa9Wqvyu730K4iwR0D6PyhC+EEKKC9ra8SkDX4K96+mzXaoXo6bDyFpin2WpJXQj/UoK6QXbv3u0Iu2+88Ybj9Z49ezodoZ4xY0axgH78+HHH+0OH2p5gERkZ6TgtvmhADwsLcwr/U6dOdXz3+PHjQGFA1zSN5cuXA7ZH39pfswfsK53ivnnzZsfrW7ZsASA+Ph5/f380TeN///sfAG3atEHTNObMmeP4bnx8PJGRkaX/xe3Z4/qj6NVM8EnZHtWp8npNAroQ+vL4gB4eHs7q1atZtmyZU1VVKk/4ovJJTU1n7dqdLF++hZiYM0a3I4TY7nflcG4vS67rtxs2rCCYmwoDuv3v254B65WP3gp9FA3ogwcPdrz+/vvvO12XXlJAX7ZsmeP9PXv2OL7boUOHYgF99uzZdOjQwXF0vWht3boVKAzoNWvWdHyvaJCPiYkBrhzQv/766xJPf7fXoEGDAPjoo48cR9n/9re/8cQTT/D111+Xfc3z0QeuC+m+XtDqVsjOLlMLKq/X7L2tXn0vW7fe79JavfpeZfdbCHfx2IAeHR1N27ZtMZlMmM1mTCaT489ms9no9nSj8oQvKpe0tExGjPiZd9+dwNCh3/LuuxOIjDxhdFtCeLbdja8ezncE2Y52u1JK5GWhvISKW+TabYprSk5Odpziftdddzm9FxkZ6ZKAvm3bNsep6rVr16Zjx460bNnS8d1NmzYBJZ9CXzSMnzx5sthrRRUN6PZT34vWsGHDALBaraxcuZI333yTrl27ct1116FpGo8//njZfnnZ2fBg54qf6u7rBddfB2FhZds+aq/X7L2tXXs327f/3aW1du3dyu63EO7isQG9R48e9OzZkwsXLhAQEEBERATbtm2jU6dOjn/xrYpUnvBF5bJ1637efXc877xTWD/88IfRbQnh2U6Nsl1rXmJA94Lod1y/zZB34Q/vK4fzP7xgUzfXb1dcU58+fRzB9rPPPiO/4BFf1wro0dHRjvc/+ugjx3cuP8V93Lhxjs/Zbwr31VdflTug//HHH47X0tPTHZ/dtGmT4/WlS5c6Xs/Ly2P16tWO72/bto20tDTH+3PnznVck15mqanQ9YHyH0n384baQbB3b9m3jdrrNQnoQujLYwN67dq1CQ0NBSAwMNBxF9GNGzfSrl07I1vTlcoTvqhcgoP38u67E5wC+nff/WZ0W0J4trxU2NfGFsYvD+d7mkPuhWuPUVbbninh1PbLakVT129XXNPFixdp27atI9wGBgbSrl076tate9WADs43ibvtttuoUaMG1atXdwro69atc3ymdu3a3HbbbdSqVavcAT00NNTxWuPGjbn77rvZvn07AI8++qjjvRYtWtCqVSvHafX27fz973/Hx8eHv/3tb3To0MFxjbr9RnRllpMDnw+3HQn38y5dMLc/pu3Rf0BsbPm2i9rrNXtv69d3ZOfOe11a69d3VHa/hXAXjw3oQUFBnDhhOx23efPmBAcHA7Ybo/j7+xvZmq5UnvBF5XLx4iU++OB7p5D+119lP41PCOFieckQPRR21LSF8+01IOoNyEnQZ3t7Bl39CPo8E6zreO1xhC4yMzMZO3Ysd955JwEBAfj5+dG0aVMeffRRfv75Zy5dunTFx6z16tULf39/GjZsyKRJk7jrrrvQNI3u3bs7Pjd27FgaNGhA9erVefrpp52Ogpc1oAN8+umnTv+AsGLFCgCysrL47LPPuOWWW6hWrRq1atXirrvuYtiwYY5HrU2cOJH77ruPOnXqUK1aNerXr0/v3r05depUxX6JoaHQt09hSPevVvxouT2Y330nzP29wpeSqLxek4AuhL48NqB37tyZJUuWALZTwLp378727dvp378/rVu3Nrg7/ag84XuSpUtP8dxzwTz//CbWrau8N1c7cyaB2bNXMnXqYvbuDTe6HSFEUVYL5KWANV/f7ZwLvsY16CY49oO+PQiXi42NdXpu+vHjx/Hz80PTND788EMDOzPQ+fMwexa8PRgeehA6doC/3wMD+sH330FIiMs2pfJ6zd7bxo13smvX3S6tjRvvVHa/hXAXjw3oa9asYdEi201roqKiaNGiBSaTiRtuuIGNGzca3J1+VJ7wPUV4+CW6dVvrqEcfXUtMTNq1vyiEECqyWm3XmM8zl3D9ubft0Wu5MsdVNt9++y21a9emW7duPProo47TyevWrcuZM5X3H5YrC5XXaxLQhdCXxwb0kiQmJmJ19d1tFaPyhO8pVq+Ocwro3bqtZfv2c0a3JYQQ5ZeXAbv6224IVzSgb3oEMs8a3Z0ohw0bNtCpUycCAwPx9vamUaNGvPjii45Hogl9qbxes/cWHNyBPXs6urSCgzsou99CuIsEdA+j8oTvKWJi0njssXU8+qjt6HmPHus5fz7r2l8UQgjVZcbDyTlwYiakHDG6GyEqLZXXaxLQhdCXRwX0IUOGlLqqKpUnfE+yb98Fhg7dw4cf7uXQoSS3bDM7O4+5c/fw5ZermDdvDzk5eW7ZrhBCCCHKRuX1mr23zZvbsW/fnS6tzZvbKbvfQriLRwX0Ll26lKq6du1qdKu6UXnCF/qaOnUrL744k4EDZ/DiizOYMWO70S0JIYQQogQqr9fsvW3d2pYDB9q7tLZubavsfgvhLh4V0IXaE77Q1+DBcxk4cIajhgz5w+iWPI7Vmk9W1gXy8+WSBiGEEFem8npNAroQ+vL4gB4eHs7q1atZtmyZo5YvX250W7pRecIX+ho9+k9eesl2BP2ll2Yyduwao1vyKKmpMWzc+CIrVz7BqlVPEROzyuiWhBBCKErl9Zq9t+3b23Dw4B0ure3b2yi730K4i8cG9OjoaNq2bYvJZMJsNmMymRx/NpvNRrenG5UnfKGv8+dT+fjjJQwcOINhw5Zy4UKq0S15DKvVSnDwy6xa9SQrVz7hqEuXjhrdmhBCCAWpvF6TgC6Evjw2oPfo0YOePXty4cIFAgICiIiIYNu2bXTq1ImtW7ca3Z5uVJ7whXvk51uMbsHj5OamOQVze508udLo1oQQQtjl5sKmDTD3V/h1BqxYComJhrSi8nrN3tvOna0IC7vdpbVzZytl91sId/HYgF67dm1CQ0MBCAwM5MgR2+NgNm7cSLt27YxsTVcqT/hCVEaxsTtYv/5D1q17n5MnN5f4Gas1n9Wr/1ksoJ87t6vYZxMSdrB9e182bXqSsLDPyctL03sXhBCi8jl3BvbugF1bICoSrNbyj3U2HkaPgGY3QoDmXLV84LWBsH+v63ovBZXXaxLQhdCXxwb0oKAgTpw4AUDz5s0JDg4G4Pjx4/j7+xvZmq5UnvCFqGzOnQtl/vxeTnX69O4SP3vmzFZWriw8xX3fvtFYrc5nM6SmRrFhwyNs2PAPNmx4mA0bHiE09DN37IoQQqjPYoENK6Ffd2higsZaYXW9DWZPhvQy/qPmiqVQ2xcCvYqHc3sFedt+fjDE1oMbqLxes/e2a9dtHD7c2qW1a9dtyu63EO7isQG9c+fOLFmyBIA+ffrQvXt3tm/fTv/+/WndurXB3elH5QlfiMpm//6pLFjQ2xHOFyz4F7t3/3DFz6elxRIXt4GEhP3FwjlATMy8goD+sKM2bnxUz10olfz8ZM6fH8ypU52Ii+tORkaw0S1dnTUDLHMh/0ewRhndjRDCFdLTYMDjtjDezMs5nDfWCgK7Ce5uZDuiXhpLF8F1JltdKZwXretM8PpLFTtaX0oqr9ckoAuhL48N6GvWrGHRokUAREVF0aJFC0wmEzfccAMbN240uDv9qDzhC1HZhIX9zoIF/3IK6AcOTC/3eKdPrypy9NxWW7Y868KOy85qtXLmTC9OnLiZEyeaceJEc06c+BtZWfsN7euKrFGQWx9yNcg12Sr/e6O7EkJURE4O9O4KTUsI5pdXMy+4ozbEnrz6mJERttPXSxvOi9ZPE3XfZZXXa/be9uy5lYiIli6tPXtuVXa/hXAXjw3oJUlMTMTqhn8VNZLKE74QlU1W1iVWrHjNEdCXLRtERsaFco+Xn5/JX3+9zIYN/2Djxm5s2PAw8fFrXdhx2eXmni4I5kXrZi5eHGFoX1eU1wNyvQoCur3MYI0zujMhRHn99DU0MV87nDtCujf0evDqY771GtT0Lns4D9DglgaQn6/rLqu8XrP3tm/fzRw50sKltW/fzcrutxDuIgHdw6g84QtRGeXkpHHixEaiozeQnV3x/13l5WUSG7uE6OiZXLoU5oIOK9pPJQvouX6XhfOCsswxujMhRHnk59tOWy9tOC9axyJKHjMlBW7wK184t9eq5brutsrrNQnoQujLYwP66NGjmTZtWrHXp02bxpgxYwzoyD1UnvCFEOqxneL+rxJOcQ8xurWS5Ta+QkCvupcuCVGlbVxVvnDezBs+e7PkMWf+DwLKcWq7vWp6Qa8ndd1tlddr9t4OHGjOsWO3uLQOHGiu7H4L4S4eG9CbNGnCjh07ir2+a9cumjZtakBH7qHyhC+EUFN+fgrnzw/h1Kl7OX36CTIytui2Las1g9zcYWRndycn52UsluNlGyD/x8vCuRfk3g4l3JRPCFEJfDsCmnuXL6Q/cVfJY44cBtdXq9gR9Lta6brbKq/XJKALoS+PDei+vr6Ox6wVFR0dja+vrwEduYfKE74Qejp58iAzZ77LL7/8h61bfy/xLurCWFZrPtnZ3cjMrEFmpj+ZmQFkZtbDYinD9eNWK1imQm4ryK1MUnxXAAAgAElEQVQLea+ANUG/poUQ+vpiKPytWvkCepcWJY/50bsVD+itm+m62yqv1+y9hYQ04/jxv7m0QkKaKbvfQriLxwb0m2++mV9//bXY67Nnz6ZZM30nXSOpPOELoZfMzDR++eU//Pzz/zkqMnK70W2Jy1gsuwuCedEKIDd3lNGtCSGM8v2okh+rVprqeXfJY44dVfhs8/LWfe103W2V12sS0IXQl8cG9LFjx1K7dm2mT59OTEwMMTExTJs2jdq1azN69Gij29ONyhO+8EypqSls2bKFHTt2kJ2dpcs2EhJinML5lCmvs3PnQl22JcovP39jCQE9kNzcD4xuTQhhlN1byxfOm3rB2I9LHjN4fcXCeU1veP8tXXdb5fWavbfQ0CYl3ES0YhUa2kTZ/RbCXTw2oFutVt5//338/Pwwm82YzWaqV6/O559/bnRrulJ5wheeJysrk3HjvuHzz0fw+ecj+Pnnn7BYXH/qeW5uNrNmDWXKlNccIf3UqUMu346oGKs1kczMukVOcbdVfr6xj5oTQhjIaoWut0ETU9kCehMTnD5V8pgWC7RpXr5noNvr6BFdd1vl9ZoEdCH05bEB3S4tLY09e/Zw6NAhsrOzjW5HdypP+MLzHD16lBEjhjvVhQvlf4741SQlnWXNmsksXfoNR4/+pcs2RMXl5/9FZmbjgnB+HXl5k4xuSVRU1gU4txlSjhrdiaisfp9axju4e8Erz1x9zB++LV9Ar+kFj3XRfZdVXq/Zezt06CZiYpq4tA4duknZ/RbCXTw2oGdmZpKRkeH4e0xMDN9++y1r11btIzUqT/jC85w7d84pnI8aNZLMzEyj2xIGs1rzsVpPY7XK/y9UapY82DsYfvOGOZqt1t4PGaeN7kwYKT8fNi2D17vDPxra6v8egQ2LIS+v5O9YrfB2v9IdRW/mDff/DS4lXr2PtDTo2Np2unppw/l1JqjlC/v3uv73chmV12v23sLDGxIbe5NLKzy8obL7LYS7eGxAf+SRR/jpp58AuHTpEnXr1qVRo0b4+fkxefJkg7vTj8oTvvBMu3fvYsyYrxg37hsiIiKMbkcI4SoHP4U5psJwPkezhfWVbW2BS3ieMzHQ8zZoq0F7L9vPthq0K/jzEzdD7BUerZifD5/+tzCElxTMG2vQoyNcOF/Kfk7b7sZe0+va4TzQDLV8YPVK1/0+rkLl9ZoEdCH05bEBvXbt2hw+fBiAqVOn0rZtWywWC/Pnz+e2224zuDv9qDzhCyGEqCIsufBHoHM4L1rnNhvdoXC3i+fhkUbQ3rswmF9e7b3hoXpw/syVxzkaDp++AbfVKHK9uRleehK2rLVdX14WFy5Arx62o+MlBXX73d7b3Qp/7ajY76AMVF6v2XuLjKzP6dMNXVqRkfWV3W8h3MVjA7q/vz+nTtluHtKrVy9GjBgBQGxsLP7+/ka2piuVJ3whRNVmtVrIzp5Oevr/kZk5EqtV5qEqK/PslcP5HA2iphrdoXC3MYOdj5pfLaR//uq1x8vNhYRzcPY0ZLngcpgT0fDJe9C8ru1oeYAGdQPg38/Bts1uP+tD5fWaBHQh9OWxAf3222/n+++/JzY2lsDAQHbu3AnAvn37qFu3rsHd6UflCV8IUbVlZHxCUtL1JCXdQFLSDSQn/x2rterfnNMjWXLhj5pXOYK+xegOhTtlpMPdNa4dzu3V0Q9Sk43r12q1nVJvIJXXa/bejh6tS3x8fZfW0aN1ld1vIdzFYwP6ggULqFatGmazmUceecTx+ujRo+nevbuBnelL5QlfCFF1Wa35JCXVKQjohZWbK6c6V1mhw0u+Bn3VHXINuqfZvqb04dxewUuN7tpQKq/XJKALoS+PDegAZ8+e5cCBA07PXd69ezeRkZEGdqUvlSd8IUTVZbXmFRw5vzygBxvdmtCLJR/2DYHfqhUG9HVdIDPe6M6Eu62dX/aAvny20V0bSuX1mr23qKg6nDtX16UVFVVH2f0Wwl08OqB7IpUnfCFE1Zae/g5JSbUK6gaSkzvKo9RUlnoYzq+CrLMVGyc7Ec5vg9Qr3J1bVH1/rS97QN+8wuiuDaXyek0CuhD68uiAvnXrVvr27cs999zD6dO257LOnj2bbdu2GdyZflSe8IUQVZvVmk9W1kTS0v5NRsYHWCwXDWgiG7LfgIwGkNES8ha6cOw8SP0ZEodA6o9gzXHd2O6Ulwa7usFKraC84OhwOS1dlF92Fvy9ZunD+T0BtuvWPZjK6zV7b9HRtUlIqOPSio6urex+C+EuHhvQFy5ciL+/P4MGDcLX15fo6GgAJk2axGOPPWZwd/pRecIXQgjdZf8fpJshXYN0k63yt1Z8XGs+nHscYkwQU8328+xDttBeWeSmwJm5sLsbrDQXCegFdX6V0R2KymzC+4XPO7/qXdy9YOxbRndrOJXXa/beTp68nosXa7u0Tp68Xtn9FsJdPDagt2vXjlmzZgEQEBDgCOgHDhyQu7gLITyKxZJNQsJEYmP/w4ULv2CtTKGyrNKvLwjn9vKG7HcqPm7mGojRildGJbnR1cXNsDYA/tRsteqycL7KCw70NbpLUZmlXIKnWlz7OeiPN4dLBpxdoxiV12sS0IXQl8cGdH9/f06ePAk4B/To6Gh8fX0N7ExfKk/4QpRFfn4+ISE72LlzLSkpSUa343ZWaz6JiZtJSPiT3NyK/e/5zJmPiIhoRURESyIiWnHu3Ncu6lJBGQ0vC+hekDOs4uOmzSo5oKf+XPGx9WbJgw314E+zc0BfdXlA72N0p6Kyu3ge+t1bGMaLBvO2GvS5CxLkJoKg9nrN3ltMTFCxG39WtGJigpTdbyHcxWMDerNmzVi/fj3gHNBnzZpFy5YtjWxNVypP+EKUxZo1fzBu3LuMHz+UyZOHk52dZXRLbmO1Wjly5BN27ryXnTvvZd++nuTmXir3eEeOdCwI57aKivpHucaxWC6SmbmIrKx1WK3GPkP4inJ/KTxynu5tO6JuOVXxcXMOFZzeXjSgmyB7X8XH1lvyvsJgfnkVPYoev8joTkVVYLVCyA74uB/0age97oCP+sL+rXKfgyJUXq9JQBdCXx4b0EePHk2rVq3YtWsX1113Hdu2bWPOnDnUqVOHiRMnGt2eblSe8IUoi8mThzNu3LuOOn36pNEtuU129jlHOLfX2bOLyz3e8eNPEhHRuiCgtyYmpn+Zx8jPP825c7c7nmWbmNgPq9Vy7S8aIW8FZL8KOUPBEuO6cVOnQIxXQTg3Q0ol+W9J+rFrB/TDgyU8CeFGKq/X7L3FxgaSnFzTpRUbG6jsfgvhLh4b0K1WK1988QU1atTAZDJhMpnw8/Nj2DAXnOqoMJUnfCHKYvnyWYwfP5Tx499j4sRPyMzMMLolt8nNTWLnzvucAnpCwp/lHi8z8zBHj3YmIqIlx449RHb2iTKPkZIyivj4Ro6AHh9fn5ycveXuyTC5WyH1AUhuA5kjbTd/K4v8s5C1A/LKeJqu1WpsAN7ZGVZ7FQbz1d6w+WaI+w3S5fFoQribyus1CehC6MtjA7pdTk4O4eHh7N69m7S0NKPb0Z3KE74QZZGbm82OHWvZsGERFy543jWLp0/PcoTzw4f/i8VSsUd6Wa155OUllPvU9JSU4cUCenb2zgr15Hb5kZDkA0lmSNIgyQSZn+m7TWs+nH0PwqtDuB+ceRUs2fpusyTZ52HvE/CnyRbQd/8DMuPc34cQAlB7vWbv7fTpAFJTr3NpnT4doOx+C+EuHh/QPY3KE74Qomyys8+RkXFCiVPJc3OPEB/fnPj4hsTHNyAhoRvWyvYc8Kyvi4Tzgkq+Wd9tJnwFh01wWCsoM8QP0XebV5ObDBW4n4EQwjVUXq9JQBdCXxLQPYzKE74QonLLy4smLW0i6enTsVgq4SUH2ZNtR80dAd0EKe313WZ0xyLhvKCONtF3m2VhtUDsLDg8BI59BTny+Csh3EHl9Zq9t/j46qSn13BpxcdXV3a/hXAXCegeRuUJXwghDGVNhuRbCo6ie9t+5qzQd5snH77sCLoGUa313WZpWa2wrzcs12BFNVjuBesaQtZZY/vKz4YTK+DoPMi8UPHxctIg7azcBE8oReX1mr23c+f8yMz0d2mdO+en7H4L4S4S0D2MyhO+EEIYznIJsr6FzBGQ54ab3KWttZ3Wftir4KcGyXP1325pJKyzhfOitcIbQv/PuJ7O7YWpdWCiZqsfqkH4tPKNlZkEC1+Az71ghAbf/w2O6vwPMkKUksrrNQnoQuhLArqHUXnCF0IIj5S+FeL6QdwLkFr+u/G73Mmfigf05RrseMiYfiz5MP0mmORVGNAnajDRDMllvNO81QrT7y8M5yM0GGGCz80QW8lubiiqJJXXa/beEhJ8yM72dWklJPgou99CuItHB/QNGzbw0Ucf8fLLL/Piiy86VVWl8oQvhBBCIefXlHwE/eCrxvRz9q/LgnlBTfKCvV+Vbawze4sE8yL1uTf88Zw+/QtRBiqv1ySgC6Evjw3oI0aMwGw206lTJ3r27MnTTz/tVCp7+umnCQoK4p///GeZv6vyhC+EEOIaLv0JYS3hQB2I7gf5qaX/bu5FSFwHKbttN3+7FqsV9vZyvgZ9bX3IMuixhvE7rhzQ93xZtrHCfis5oI/Q4MdW+vQvRBmovF6z93bxoje5udVcWhcveiu730K4i8cG9Hr16jF79myj2yiXTZs2sXz5cgnoQgjhSTIOwh5v2GOCPRrs8YJjz5buu8k7YUtNCNZsFfoEWErxGDyrBU5Ng7A34OgoyE6o2D5UhCUP/lcPJpmLh/TEyLKNFX+g5HA+0hsW9Nanf2GMM3EwfhS8OQDeeQX+mAVZWUZ3dU0qr9ckoAuhL48N6LVq1eL48TJes6aQTZs2SUAXQoiqymqF899CRGuIvBMuLYQzX9pC+R6tSHlf+2i41QrbG0KwuTCgB5vh1Hj37IsrndkGPwcWOXpuhoPfl2+sWf8ofg36SG/b6e+i8svJgSGDoJ4Z6nlBfW9o4A03anBzECz8zegOr0rl9Zq9t6QkM/n5Xi6tpCSzsvsthLt4bEB///33GTlypNu3u2XLFnr06EH9+vXRNI0lS5YU+8wPP/xAkyZN8PX1pVOnTuzevbvYZySgCyFEFXbhJzigFZTJVqfegD1m54C+77prPx4sL61IMC+oTd4QUUnvt5KTartz+8IH4Ifq8GMAbHzN9npZZKfC8kEwyscW0Ce3gePr9OlZuJfFAgOehrpmWyC/Ui341ehOr0jl9ZoEdCH05bEBffDgwQQFBfHAAw/wxhtvMGTIEKfSy59//sknn3zC4sWLSwzo8+bNw8fHh+nTpxMeHs4rr7xCUFAQ58+fd/qcBHQhhKhkrHmQudNW1ryrf/ZY1yIBXYMD3nDqVTjYuOAourctoJ+dAJYsOD0Wol6C+InFx7ZaYWttCDY5H0E/+YV++6q3pY/B917wnWar771g6ePlGys/B7Llv4lVyqolVw/m9moWAOnpRndbIpXXa/bekpM1rFaTSys5WVN2v4VwF48N6F26dLlide3a1S09lBTQO3XqxH//+1/H3y0WCw0aNOCrr5zvUFvagJ6dnU1KSoqj4uLiZOITQgh3s2RA7H1wTLNV7H1gybzy56N7wgFzkYDuBWeGQW4CnB4OMf+FpKW209vDH4GdZvjLG3aa4Fjf4uNdXAWbfAoD+t6OkK9mMLmm5OjCYH55JZ8wujuhgmcfgvpepQvpv041utsSVYaAnpKsgdW1lSIBXQjPDegquDyg5+Tk4OXlVSy09+/fn6eeesrptdIG9OHDh6NpWrGSiU8Iz5Gfn0ZWVgzW0ty5W+gj6Vs4Zi4M6MfMtteuJGMvhPjbgvkBM4TVg9wS7p6eHgo7teKVU8JnM49D/ExIWAqWbNftm7ud3XXlgH52l9HdCaNZrbbrzUsTzut7wWsvGN1xiSSgq7ffQriLBHQDXR7Qz5w5g6Zp7Ny50+lz7733Hp06dXL8/eGHH+aGG27A39+fhg0bFvt8UXIEXQjPlpa2n4MH7+XAgfYcPfoilsoczCqzCx/AMe8iAd3b9trVZB2Fs6Ph/HjIPV/yZ9L2lhzQs2Ncvw+qyMuCn4KKh/OfgmzvCc9msZQunN+oQV0TvKzmc+8rRUBP0iDftZWSJAFdCI8O6Fu3bqVv377cc889nD59GoDZs2ezbds2t2y/vAG9IlSe8IUQrnfs2GscONCBAwfac+BAey5dCja6Jc+UsRmOmZwrY3PFx7XkQkgb2OlVEM694NAD175xXGUXtQi+94bvzLaaWA2iFhvdlVDFHY1KeQTdGz5/z+huS6Tyek0CuhD68tiAvnDhQvz9/Rk0aBC+vr5ER0cDMGnSJB577DG39FCRU9zLS+UJXwjhetHR73LgwJ2OgJ6aKqcAGyZ1Ppy6y1ap8103bm4CHB8EYffCiTcgr4rO7wkHYN0AWPk0HBgPySfhwHe2So2FrEtwaAbs/x7O7TO2V2Gs8aNsj1crTUiPOmJ0tyVSeb3m6O2iBrmurZSLEtCF8NiA3q5dO2bNmgVAQECAI6AfOHCAunXruqWHK90k7o033nD83WKx0LBhw2I3iSsvlSd8IYTrZWefJjKyNwcP3kdc3ASsVf3Iqqiazu2BH3xgkhdMNNlq7b8LzxRIOQU/N4JxGowz2SpksrE9C+MknIdbr7c9//xKwbyeFwx4xuhOr0jl9ZoEdCH05bEB3d/fn5MnTwLOAT06OhpfX1/dtpuWlkZISAghISFomsaECRMICQnh1KlTgO0xa76+vsycOZOIiAheffVVgoKCOHfunEu2r/KEL4QQooqzWuHIT7DhSdjaFy4eKN33lj8Jk8wwUXOuxEjb+4t7wHjvgoBeUOPNkBKj374ItYXshVtKCOn2I+s9H4D0NKO7vCKV12uO3hI0yHZtpSRIQBfCYwN6s2bNWL9+PeAc0GfNmkXLli112+6mTZtKvKv6gAEDHJ+ZNGkSjRs3xsfHh06dOrFrl+tOSVV5whdCCFHF7f8YZmow0wSzvGC2LyQevPb35t1VPJxP1OD0Vtv7jqPnl9WJ1ZCTBgemwPZRcGyF667Pz8+F9V/CF03hsxth4euQftE1YwvXOBcPYz6FlnUKA/o/OsC8mZCTY3R3V6Xyek0CuhD68tiAPnr0aFq1asWuXbu47rrr2LZtG3PmzKFOnTpMnDjR6PZ0o/KEL4QQogqz5MPsagUBvaBmecPOV6/93c1vFJzeXiSc/+gHmRds7//aEcaZiwf02C3wcwsYbYIx3jBagzX/dc3+zH8V3jHBO5qthnrBN21t+ynUYrVCerryobwolddrjt7OaZDp2ko5JwFdCI8N6FarlS+++IIaNWpgMpkwmUz4+fkxbNgwo1vTlcoTvhBCCDe6uA4O9oKwPpC8W//t5efYjpw7BXQv2Prva383JwX+6FQYzn/wgaiFhe/HbLCd0j6+SEif0QbmdYOvzLZgXrRit1ZsX1LPw7vmwnBetCL+rNjYQqD2ek0CuhD68tiAbpeTk0N4eDi7d+8mLU3da5FcReUJXwghhJskboZ1JlhnhnVesN4X0sL13+66R22hvGhIP1nKO9rn50LsRtsj1lJPFX//9HZY8S+YXA++1uAbs+3nWA2+uiygh/xSsf2I3VtyOH/HBNsmVWxsIVB7veboLV6DdNdWSnzZAnp+fj7Dhg2jadOm+Pn50bx5c0aOHOl0Q1Sr1cqnn35KvXr18PPz4+GHH+bYsWNO4yQmJvLCCy9w3XXXUbNmTV566aViuSA0NJTOnTvj6+tLo0aNGDt2bMV/mUKUwOMDuqdRecIXQgjhJuGvwnpvWKfZar0XHB+h/3azE2FDD9up7r8HQcT3xT9zdiesfRZWPgLhP5XtmvGoZbZQXrTGajDmspB+vIJHubNS4X3/kkN6jDzKUFScyus1R2+nNUh1baWcLltA//LLL6lduzYrV67k5MmTLFiwgICAAL7/vnBuGTNmDDVr1mTp0qWEhoby1FNP0axZM7Kyshyf6d69O3fccQe7du1i27Zt3HzzzfTp08dpn+vWrUvfvn05fPgwc+fOxd/fnylTprjuFytEAQnoHkblCV8IIYSbHBniHNDXmeHkuPKNZcmBE9Mg4ku4+FfpvnOl0J2wF36pBlPM8LNmq/1flr6XvRMKj5wXDej2o+hfafDH42C1lG68s6Gw8XPYMALOhDi/t2mcLZC/6wXvFlyLPvOfrrsJnfBoKq/XVAroTzzxBC+99JLTa88++yx9+/YFbEfP69WrxzfffON4Pzk5GV9fX+bOnQtAREQEmqaxd+9ex2dWr16NyWTizJkzAEyePJnrr7+enCL3Mfjggw9o0aJF+X6JQlyFBHQPo/KEL4QQwk0yY2DTDQWnuZtgWzPITbz296wWyE4AS57t75Y82NQF5ptggZft56m55e9r8yswxbswnP+swcwbSv/9qOVXPoI+xgRz/2E7Vd5qgYRwOBdWuC+Xi1wJw7xhmFfBT28IXwJ52RC5GkLmwa5pMPtf8L8e8NdUyL/CWEKUkcrrNUdvsRoku7ZSYm0BPS4ujpSUFEdlZ2eX2MuXX35JkyZNOHr0KAAHDx7kxhtvZM6cOYDt8cmaphES4vwPbA888ACDBw8GYNq0aQQFBTm9n5eXh5eXF4sXLwagX79+9OzZ0+kzwcHBaJpGUlJSxX+pQhQhAd3DqDzhCyGEcKPscxD7E8RNhdxL1/58SgSsaQqLNVhxPSRshHPrYL7mXCublrGPRAgbD/tHwOoeMMXLOaBPr1n6saxWWN675IA+1hvO7oeMi/C/TjBSs9WPt0FybPFxRtWGj03wsVZQJvg8EL5pA0M1W73vDftml21/hSgFlddr7gjol9fw4cNL7MVisfDBBx9gMpnw9vbGZDIxevRox/s7duxA0zTi4+OdvterVy+ef/55wBbyb7311mJj16lTh8mTJwPwyCOP8Oqrzk+cCA8PR9M0IiIiKvLrFKIYjw7oubm5xMbGcuTIERITS3HkoApQecIXQgihsA23wxIvW0BfbILl10HsvOIBfVmd4t/Ny4Rdr8GChrCiPZwruIt6diLMawr/M8M0b9vPKRr8bCoI6CbY/mbZ+rRa4ehiWP8G/NgIxnrB5MZwfJXt/QW9YJRXYUD/whtmdHYeI/NSkWB+Wb1vLgzo9pCeeLLMv04hrkbl9ZqjtxgNklxbKTFlO4I+d+5cGjVqxNy5cwkLC2P27NnUqlWLmTNnAhLQReXkcQE9NTWVyZMn88ADD+Dn54fZbMZkMmE2m2ncuDGDBg1iz549RrepG5UnfCGEEApbUq0gnBeppH2w7MaC09s12ynuB98p/t2//g9mm2G2Zvv5mz+knYSwb2CaGf6nFZQJ5jaBBXfArPowuxHM7wBhE113bfe4OoXh3F6jvJzHt1hgREAJAd3kHM7tFbbYNb0JUUDl9Zo7Anpp97tRo0b88MMPTq+NGjXKcW24nOIuKiOPCujjx4+nVq1adOzYkZEjR7JmzRrCwsKIiopi9+7dTJs2jYEDBxIUFMSjjz5a7BEMVYHKE74QQpSG1ZqNxfIp+fm9sFqXG92O5wi+s8gRdDOsqAX5WZB6DHY+Bxvvg/CRJV/TPb9eQTgvUtGzYd+nBUfOtcKa1xTit8NkM0w2wWTNVqEl3PG9PH5sASNNzgH96+uLfy7kV1sgt19//rEGo2+CoSWE9OObXNObEAVUXq85ejupwUXXVsrJsgX0WrVqOY5y240ePZpbbrkFKLxJ3LhxhTfBTElJKfEmcfv27XN8Zu3atSXeJC43N9fxmY8++khuEid04VEBvXfv3hw+fPian8vOzuann35i2rRpbujKvVSe8IUQojQslo/Jz/d2lNV6yOiWPEN6tO0098Ua/NkALu4o/XeX317kCHpBnV4FCbsLjqCbCo+g734Ptr0JP3kXhvPJmu1IuiuELyg4am621UgN9v5Y8mejg2HZf2Dp6xC1HkIXFITygpD+nhdMvMd24zkhXEjl9ZpKAX3AgAE0bNjQ8Zi1xYsXc8MNN/D+++87PjNmzBiCgoJYtmwZYWFh9OzZs8THrLVv357du3ezfft2brnlFqfHrCUnJ1O3bl369evH4cOHmTdvHtWrV5fHrAldeFRAF2pP+EIIURr5+T3Jz/dylNW6wOiWPEt+VtlPN4/fCHN8C8P5xh5gybe9F7MMFraB3xvC8s6wayis73tZQDfB4r+7bh+Or4VFvW3Xo0csLNt3QxfC951gzK0wfxBkJruuLyEKqLxec/QWrUGCayslumwBPTU1lbfeeovGjRvj5+dH8+bN+eSTT5weh2a1Wvn000+pW7cuvr6+PPzww467vtslJibSp08fAgICCAwM5MUXXyQtLc3pM6GhoXTu3BlfX18aNmzImDFjKv7LFKIEHh/Q33rrLaZPn86+ffuueAOKqkTlCV8IIUrDYplfJKA3xGq9YHRLoiRp0XBxty3QA6Qeh6hpELeiMJzbZV+C35vCVC+Y6g2/mOEXf1tI/8nbFtBPyuUMDhnJsP032DwTUhKM7kboQOX1mqO3KA3OubZSosoW0IWoijw+oC9btoxRo0bRq1cvWrVqRevWrXn++ef54osvWL686i0GVJ7whRCitKzWfVgsv2G1SjgxhNUKp+ZA2Adweknx98M+g981Wy1rBhmnrz5e5P/gFxP8ohWUCZbeAzvehS3/gTNb9NkP1WWnQ+QWOBNZ+Fr4ZhgYAL01W/3bB3aV8SwAoTyV12sS0IXQl8cH9MtlZWWxd+9epk2bxttvv210Oy6n8oQvhBCikgj7ABZqsMjb9vPo+ML3kiMKw/nvGsz1gl0vXX28iJ8vC+gaLOt89e9UdXsWwCsB0F+z1dfdIC0JXqsHfcyFAb23Bv2rQ4b8d70qUXm95ujtqAbxrq2UoxLQhZCAXiA3N5cZM2bw9a9tsW4AACAASURBVNdfs3LlSiwWi9Et6ULlCV8IIZSXdxLSvoSMX8FaNf87USpLqtuCub1WNS5871ywc0D/XYNN3a8+XsZZmFXbdnr7VLMtoEf9ru8+XE1CJBxdBYnRxmw/6Qy8WK0wnPfXYKAXTPqXczAvWnuXGtOr0IXK6zUJ6ELoSwJ6gWeffZb//ve/TJo0iddee4077rij2A0kqgKVJ3whhFCa5QKcrQXxZttiMuUjozsyzvLaRQK6Cda2LHwvNwUW3Wg7cm4P6FE/X3vMlGjY9hpsfAFOGhg2t3wFwzRbfWqGvVPd30PwFOdwbq//q3XlgB623v19Ct2ovF5z9BapwWnXVkqkBHQhJKAXaNeundPfQ0JCuP/++w3qRj8qT/hCCKG0rNXOR3sSWl77O1XVqV9hobngNPdqEL/S+f2Uo7D1n7D+fjg6qex3fTfKuUOF4dwR0r0g5Yx7+9g2s+SA/lZD+PgueMG7MJi/4AX/vQnyS3j+vKi0VF6vSUAXQl8S0Avcf//9REVFOb3Wpk0bg7rRj8oTvhBCKC0/DuL9Id7LdhT90itGd2SslEg4vch2t/aq4vCi4gF9mAYnt7q3j/RL8H+BMMBcJKCbYOkouBgHI+4vDOjv3wGnI9zbn9Cdyus1R2/hGsS6tlLCJaALIQG9QGhoKK1atWLo0KFMnz6d9957jyeeeMLotlxO5QlfCCGUl7PbFsxTR4E1y+huhKtYrXBgBky9Dz69LJx/5g2p8e7v6fgu+LClLZy/5Au/ve18lDzxNCScrDxnJ4gyUXm9JgFdCH1JQC8iOzubefPmMXz4cKZMmUJGRobRLbmcyhO+EEIID5ObDvk5RncBe6fAZ1pBmQpD+qdesH+6cX1ZrZByHnIyjetBGELl9Zqjt0MaxLi2Ug5JQBdCAnqB3r17OyaDpUuXMn/+fIM70ofKE74QQggPYcmDzS/AdA1m+sCRKeUfK2oJTL8VfmkEu74o3xHlye2LBHQNhnvB/D5w6VT5+xKiAlRerzl6C9XghGsrJVQCuhAS0AvcfvvtAISHh9O6dWv+85//8MYbbxjcleupPOELIYTwEEem2MK5o0yQeqLs41w4BN96wQQTTNBsdfgqR7wvnYDIxXA+zPn1KR1tR86LBvTg4WXvRwgXUXm9JgFdCH1JQC/QoUMHrFYrQ4cO5ddff3W8VtWoPOELIYTwEHs/hBneziH97OayjxM2tTCYT9DgW29YM7Dkzx5dDqOrwRearXZNKHzv8AJbMB/hbasvAyHpZLl2TQhXUHm95ugtRIPjrq2UEAnoQkhALzB16lTatWtH06ZNSU9PB6BFixYGd+V6Kk/4QgghPMTZLbaj5tNNMMMLfq8DOcllHyc2+LKAbrad5l6S7xrAF6bCgP6lGbIuFb4ftRaWDoI/34KLUSWPYZSLsTD9NRj/JCz8DHLkBoVVncrrNQnoQuhLAnoRly5dIi0tDYCoqCgGDBhgbEM6UHnCF0II4UFOLYN1T8DmPpB8tPzjbPuoMKAv6gZ5V7ih2ld+heHcXpdOln+77nLpLPznRujvDf/WoJ8ZvuwKlnyjOxM6Unm95ujtgAbHXFspBySgCyEB/TJxcXG88krVfbatyhO+EEIIUS5ZiZB25uo3iFvc23bU/AsNvvSCKW1cG3Lz82D3DFjzORxZX/h6blbFHoW2bDT097KF86J1dEeFWxbqUnm9JgFdCH1JQL/MwYMHMZvNRrehG5UnfCGEEEI3uRmwdjBM7QBL+kLaOdeNbbHAlCfgbQ3e8bb9XPERfNEK3tDggxvg8J/lG3vu+zCgWvGAHrLKdf0L5ai8XnP0tk+DI66tlH0S0IWQgH4ZCehCCCGEKJMTO2yh3KlMMNhsC+hvmuBtX0iKK/vYB/90Dub9TPBSdUh24T8wCOWovF6TgC6EviSgX0YCuhBCCCHKJHJN8YD+lmYL50UrbHn5xl/5je3a839r8EpNOLT+2t8RlZrK6zVHb3s0iHBtpeyRgC6EBPTLSEAXQgghFGLJh9j1EPMn5OcY3U3JMpPh07rwjpctnA/xgre9igf02APl30ZGMpw9Jndw9xAqr9ccve3S4LBrK2WXBHQhPC6gP/PMM1etrl27SkAXQgghVGC1wMoe8INmq4X3qRvSzx+Fnx+D0bfBH6/CXzNgsHdhOF/8jtEdikpE5fWaBHQh9OVxAX3gwIGlqqpK5QlfCCGEcJKwvzCc2yumnDdbM8L5Y7D/Dzi5y+hORCWj8nrN0dtODcJcWyk7JaAL4XEB3dOpPOELIYQQTi6EFg/oseuM7koI3am8XpOALoS+JKB7GJUnfCGEEMKJ1QobBhaG8xU9XPvsciEUpfJ6zdHbdg0OurZStktAF8KjAvqpU6fK9PnTp0/r1IlxVJ7whRBCiGKsVrhwEM7vtV2TLoQHUHm9JgFdCH15VEC/8cYbefXVV9mzZ88VP5OcnMwvv/xC69at+f77793YnXuoPOELIYQQQgi112uO3rZqcMC1lbJVAroQHhXQL168yJAhQ6hZsyZ169bl8ccfZ9CgQbzxxhv07duX9u3b4+Pjwz333MOqVauMblcXKk/4QgghhJJS4uGnv8Mn1WDSXZB00uiORBWn8npNAroQ+vKogG6XmZnJggULeOutt3j66ad59NFH6du3L+PGjePQoUNGt6crlSd8IYQQQkkzn4CPveBDDT7ygp/vd+34+XmwbQYsHQ6Rwa4dW1RKKq/XHL1t1mCfaytlswR0ITwyoHsylSd8IYQQQkljmtjCub0+r+W6sa1W+PE5eEmDQd62n9umu258USmpvF5z9BaswR7XVkqwBHQhJKB7GJUnfCGEEEJJC16Cj8yFR9B//afrxj5/3BbKi9b7TV03vqiUVF6vSUAXQl8S0D2MyhO+EEIIoaScdFjyOnx3uy2sZyW7buyzR4sH9KE3uW58USmpvF5z9LZRg12urZSNEtCFkIDuYVSe8IUQQgiPY7XCuEfgZTO8Us0W0Nd9V7YxIrbCjLdh3meQfF6fPoVbqbxek4AuhL4koHsYlSd8IYQQwiPlZsPaCfDbm7B/cdm+u28l9DLBv7zheS94rTGkX9KnT+E2Kq/XHL2t12CnaytlvQR0ISSgexiVJ3whhBBClNGIh+A5EzynFdammUZ3JSpI5fWaBHQh9OVRAX3IkCGlrqpK5QlfCCGEEGU0vEvxgL7uF9j/J+xbBdmZRncoykHl9Zqjt7UabHdtpayVgC6ERwX0Ll26OFVgYCDVq1enffv2tG/fnho1ahAYGEjXrl2NblU3Kk/4QgghhMdLPguRm2w/S2P3Elsof77gFPdXGsDglvCsZqvBreSU90pI5fWaBHQh9OVRAb2o8ePH8+STT5KUlOR4LSkpiZ49ezJu3DgDO9OXyhO+EEII4dEOr4NX/GCgZvt5eH3pvhe6Hqa8Br9+AL9/Av80Fwb057xgwaji3wmeA/9pC6+1gtW/uHY/RIWpvF5z9LZag62urZTVEtCF8NiA3qBBAw4fPlzs9UOHDlG/fn0DOnIPlSd8IYQQokqzWmHHdJjRH9aPg/w85/c/bAEDTbaA/qIJPmpZ9m3Meg96eRcG9F7eMO0t58/sXwuPa861bUH590u4nMrrNUdvqzTY7NpKWSUBXQiPDegBAQFs2rSp2OvBwcEEBAS4vyE3UXnCF0IIIaq0TZPgNQ3+4wWvmeCPwc7vv1XfFs7t9XaDsm8jfCs8a4J/mmw/n9UgbKPzZ356E570LgznPbxgXL/y75dwOZXXaxLQhdCXxwb0fv360bRpUxYtWkRcXBxxcXEsXLiQZs2a0b9/f6Pb043KE74QQghRpU3oagvo9vqwofP7y7+wBfOXvG0/V3xZvu3sWgIf3Qcf3gs7SzgyPme4LZQ7Aro3THm7fNsSulB5vebobYUGwa6tlBUS0IXw2ICekZHB66+/jq+vL2azGZPJhI+PD6+//jrp6elGt6cblSd8IYQQokr7dVDB0fOCo+jj7nd+32qFXfPgj/dg9x+2v+shNRFevrkwoPdvBInx+mxLlIvK6zUJ6ELoy2MDul16ejqhoaGEhoZW6WBup/KEL4QQQlRpaRdh/IPwuhlG3g4Jx43rJSMVtsyDTb9DmtzlXTUqr9ccvS3TYINrK2WZBHQhPD6gh4eHs3r1apYtW+ZUVZXKE74QQgjhEfQ6Mi6qDJXXaxLQhdCXxwb06Oho2rZti8lkcpzibv+z2Ww2uj3dqDzhCyGEEEIItddrjt6WaLDOtZWyRAK6EB4b0Hv06EHPnj25cOECAQEBhIeHs23bNjp16sTWrVuNbk83Kk/4QgghhBBC7fWaBHQh9OWxAb127dqEhoYCEBgYyJEjRwDYuHEj7dq1M7I1Xak84QshhBBCCLXXa47eFmmwxrWVskgCuhAeG9CDgoI4ceIEAM2bNyc4OBiA48eP4+/vb2RrulJ5whdCCCGEEGqv1xy9LdTgT9dWykIJ6EJ4bEDv3LkzS5YsAaBPnz50796d7du3079/f1q3bm1wd/pRecIXQgghhBBqr9ckoAuhL48N6GvWrGHRokUAREVF0aJFC0wmEzfccAMbN240uDv9qDzhCyGEEEIHGSkw+2P4biDsX1227544DN8MgjED4cheffoTxai8XnP0Nl+Dla6tlPkS0IXw2IBeksTERKxV/NEnKk/4QgghhHAxqxU+6AxPe9nqKQ1C1pXuu2dj4LEAeMjLVo/42AK70J3K6zUJ6ELoSwK6h1F5whdCCCGEi6VctIVyez3jDT+9XrrvLp0MXbTCesgLZo/St18BqL1ec/Q2T4Plrq2UeRLQhfCogD5kyJBSV1Wl8oQvhBBCCBfLzYHnA6CnyRbQe5pgwVel++7Guc4BvYsJlvyob78CUHu9JgFdCH15VEDv0qWLUwUGBlK9enXat29P+/btqVGjBoGBgXTt2tXoVnWj8oQvhBBCCB3sXw29A20BfWQPyM4s3ffycmHoI4UB/T/3QFaGvr0KQO31mqO33zVY6tpK+V0CuhAeFdCLGj9+PE8++SRJSUmO15KSkujZsyfjxo0zsDN9qTzhCyGEEEInFkvpg3lR+flweCeEbrUFduEWKq/XJKALoS+PDegNGjTg8OHiNzo5dOgQ9evXN6Aj91B5whdCCCGEEGqv1xy9zdFgsWsrZY4EdCE8NqAHBASwadOmYq8HBwcTEBDg/obcROUJXwghhBBCqL1ec/Q2W4OFrq2U2RLQhfDYgN6vXz+aNm3KokWLiIuLIy4ujoULF9KsWTP69+9vdHu6UXnCF0IIIYSBTh6GaR/DwgnlOx1e/H97dx4fVXX/f/wkIZlshBASwp6IbDYpIQXDUlyooLiBWLVfQBal4K64AEVA3ECsFKUi7sDPqqBYcKkILkTrClLDDiqibAUXIEOAQELy/v2R5sJkwQAzmZPc1/Px+Dw0d87c+czcPA7nnblzx29sXq8R0IHAcm1AP3DggG644QZ5PB6FhoYqNDRUERERuuGGG7R///5gtxcwNk/4AAAgSLZ9LV0UJZ0fJvUKkUb3KvkOdX9a+rp0QXPp93HSIyNLPt+OCtm8XnN6m2OkV/1b3jkEdMC1Ab3U/v37tWrVKq1atapWB/NSNk/4AAAgSF59ROoVKvU0R8u7+/j3KSys+v63b5Y61pEyQ6QOpqRe/vup9VyL2bxeI6ADgeX6gO42Nk/4AAAgSLLnHQ3mvUKkS2Mrv2r7NznSFSlSdyPddp6Ul1uF/b9xNJh3MFLHMGncIL8+hdrE5vWa09ssI83zb3lnEdABVwX022+/3XmX/Pbbbz9u2eyyyy5TfHy8/vjHP57wfW2e8AEAQJAUFUmPXV9yinu/BtLyxZWPHXiGdHZYSUA/O0x6/I5f3/8P30i/Cz0a0DNDpP/3SPlxh/KlAr7Ozeb1GgEdCCxXBfRzzz1Xe/fudf6/surRo0eQOz2+7OxsvfnmmwR0AADgX0eO/Ppnz3vGlITz7kY6K0Qaf0XV9r3oJems+JJT3Sde6xvEjxyRJgyXzgiR0upIzzx08s+hFrB5veb09pyRXvZveZ8joAOuCui1SXZ2NgEdAABUv8nXlATzc+qUhPT3Xq76fYuLS96tL2v+c1I741srPvZfzzWMzes1AjoQWK4N6AcPHtSBAwecn3/44Qc9+uijWrJkySnt96OPPtIll1yixo0byxijhQsXlhszY8YMpaSkyOPxKCsrS8uWLTvhxyGgAwCAoCg4LL38iPTwcOnDf1Z8+66tJ3YRuYfvLHnn/NiA/uqz/uu5hrF5veb09oyRXvRveZ8hoAOuDei9evXSk08+KUnau3evGjZsqGbNmikyMlIzZ8486f0uWrRI48aN04IFCyoM6PPmzVNERIRmzZqldevWafjw4YqPj9ePP/7ojMnIyFBaWlq52rFjhzOGgA4AAKyz8Svp/EQpy0iXnSbt+L5q93t3wdFgfkaI9JtQaeOqgLZqM5vXawR0ILBcG9AbNGigtWvXSpKeffZZtW/fXkVFRXr11VfVrl07vzxGRQE9KytLN910k/NzUVGRmjRpooceOrHPWlU1oB86dEher9epbdu2MfEBAIDAGNZV6hJWEtC7hEkTBlb9vrOnSec2l85vJS2eH7gea4AaEdCfNtIL/i3v0wR0wLUBPSoqSlu2bJEkXXnllbr33nslSVu3blVUVJRfHqNsQD98+LDCwsLKhfbBgwerT58+J7Tvqgb0iRMnyhhTrpj4AACA313RpiScZxkpK0S67cJgd1Qj1YiA/qSR5vi3vE+yTgVcG9B/+9vfavr06dq6davi4uL02WefSZJWrFih5ORkvzxG2YC+Y8cOGWOcxyo1atQoZWVlVXm/5513nhITExUVFaWmTZuW29+xeAcdAABUm/lPlITzziEl9eHrwe6oRiKg2/e8geri2oA+f/58hYeHKzQ0VL169XK2T548Wb179/bLYwQqoJ8Kmyd8AABQCyx7T3pxqrTmi2B3UmPZvF5zenvCSLP8W94nCOiAawO6JO3cuVNfffWVio75uo9ly5Zpw4YNftl/IE9xP1k2T/gAAACwe71GQAcCy9UBPdAqu0jczTff7PxcVFSkpk2bnvBF4k6WzRM+AAAA7F6vOb09bqTn/FvexwnogKsD+t69ezV16lQNGzZMw4YN07Rp05Sbm3tK+8zLy1NOTo5ycnJkjNG0adOUk5PjXJBu3rx58ng8mjNnjtavX68RI0YoPj5eu3bt8sdT+lU2T/gAAACwe71GQAcCy7UB/csvv1RCQoKaNm2qfv36qV+/fmrWrJkaNGig//znPye93+zs7Aqvmj5kyBBnzOOPP64WLVooIiJCWVlZ+uKL6vuMls0TPgAAAOxerzm9TTfSM/4t73QCOuDagN69e3cNHTpUhYWFzrbCwkINGTJEZ511VhA7CyybJ3wAAADYvV4joAOB5dqAHhkZWeHF4NatW+e370G3kc0TPgAAAOxerzm9PWqkp/xb3kcJ6IBrA3rDhg21ZMmSctsXL16shg0bBqGj6mHzhA8AAAC712tOb38z0kz/lvdvBHTAtQH9lltuUbNmzTRv3jxt3bpVW7du1dy5c9WsWTPddtttwW4vYGye8AEAAGD3eo2ADgSWawP64cOHdeuttyoiIkKhoaEKDQ2Vx+PRyJEjdejQoWC3FzA2T/gAAACwe73m9PaIkWb4t7yPENAB1wb0UgcOHNDq1au1evVqHThwINjtBJzNEz4AAMAp2fVf6bnp0tznpfz8YHdz0mxerxHQgcByfUB3G5snfAAAgJP2407pt0lS0xCpiZH+eI5UVBTsrk6Kzes1p7eHjfR3/5b3YQI64OqA/v7772vs2LEaNmyYrrnmGp+qrWye8AEAAE7a7CeOhvPS+npdyW3FxdJzM6RrrpAeuU+y/OOMNq/XCOhAYLk2oN97770KDQ1VVlaW+vbtq8suu8ynaiubJ3wAAICT9to/fMN5EyNt31py298flhKN1DC0pG4eGtxef4XN6zWntylGesy/5Z1CQAdcG9AbNWqkF154IdhtVDubJ3wAAICTVlAgDbjgaDh/7MGjt/XuWhLQS+v0+OD1WQU2r9cI6EBguTagJyQkaNOmTcFuo9rZPOEDAACckuJi6btvpJ07fLffcLWUHFYSzpPDpB6Zwemvimxerzm9TTbSNP+WdzIBHXBtQB89erTuv//+YLdR7Wye8AEAAALix13S+VklAb1jS2nD2mB3dFw2r9ec3h400lT/lvdBAjrg2oB+6623Kj4+XmeffbZuvvlm3X777T5VW9k84QMAAATU4cPB7qBKbF6vEdCBwHJtQD/33HOPW7WVzRM+AAAA7F6vOb3db6S/+re89xPQAdcGdLeyecIHAACA3es1AjoQWK4K6Lfffrv279/v/H9ldccddwS508CxecIHAACA3es1p7d7jTTFv+W9l4AOuCqgn3vuudq7d6/z/5VVjx49gtxp4Ng84QMAAMDu9ZptAX379u0aOHCgEhISFBkZqfT0dH355ZfO7cXFxZowYYIaNWqkyMhInXfeefrmm2989rF7924NGDBAdevWVb169XTttdcqLy/PZ8yqVavUvXt3eTweNWvWTA8//PCpvZBAJVwV0GH3hA8AAAC712tOb/cYabJ/y3vPiQX0PXv2KCUlRUOHDtWyZcu0efNmLVmyxOerlKdMmaJ69erp9ddf16pVq9SnTx+ddtppys/Pd8b07t1bGRkZ+uKLL/Txxx+rVatW6t+/v89zTk5O1sCBA7V27VrNnTtXUVFRevrpp/33wgL/Q0B3GZsnfAAAANi9XrMpoI8ZM0bdu3ev9Pbi4mI1atRIjzzyiLMtNzdXHo9Hc+fOlSStX79exhifd93feecdhYSEaMeOHZKkmTNnqn79+jp8zLcAjBkzRm3btj2h1w6oClcH9Pz8fC1btkxvvfWW3njjDZ+qrWye8AEAAGD3es3pbbyRHvRveceXBPRt27bJ6/U6dejQoQp7OeOMMzRy5EhdccUVSkpKUocOHfTMM884t3/33XcyxignJ8fnfmeffbZuvfVWSdLzzz+v+Ph4n9sLCwsVFhamBQsWSJIGDRqkvn37+oxZunSpjDHas2fPKb+mwLFcG9DfeecdJSUlKSQkpFyFhoYGu72AsXnCBwAAqHZ79khzX5DeXSQVFwe7G0l2r9ec3u420v3+Le/dJQG9bE2cOLHCXjwejzwej8aOHauvvvpKTz/9tCIjIzVnzhxJ0qeffipjjP773//63O/KK6/UVVddJUmaNGmS2rRpU27fSUlJmjlzpiSpV69eGjFihM/t69atkzFG69evP9WXFPDh2oDeqlUr3Xjjjdq1a1ewW6lWNk/4AAAA1WrvXiktRYozJTXqlmB3JMnu9Vp1BPSqvoMeHh6url27+my75ZZb1KVLF0kEdNRMrg3odevW9bmAhFvYPOEDAABUq9fmHQ3ncUaqHyYVFQW7K6vXa05vfzHSvf4t719O7DPoLVq00LBhw3y2zZw5U02aNJHEKe6omVwb0K+55ho999xzwW6j2tk84QMAAFSrf2cfDef1QqTTG1pxmrvN6zWbAnr//v3LXSRu5MiRzrvqpReJmzp1qk//FV0kbsWKFc6YJUuWVHiRuIKCAmfM2LFjuUgcAsK1Af3AgQO66KKLNGTIEE2dOlXTp0/3qdrK5gkfAACgWhUXS/fdLSVFSm2aSB9/GOyOJNm9XnN6G2Oke/xb3jEnFtCXL1+uOnXqaNKkSfr222/10ksvKTo6Wi+++KIzZsqUKYqPj9cbb7yh1atXq2/fvhV+zVpmZqaWLVumTz75RK1bt/b5mrXc3FwlJydr0KBBWrt2rebNm6fo6Gi+Zg0B4dqA/txzz6lOnTqKjY1VSkqKUlNTnTrttNOC3V7A2DzhAwAAwO71mk0BXZLeeustpaeny+PxqF27dj5XcZdK3kWfMGGCkpOT5fF4dN555+nrr7/2GbN79271799fsbGxiouL0zXXXKO8vDyfMatWrVL37t3l8XjUtGlTTZky5eRfROA4XBvQk5OTNWnSJBVZ8Dmj6mTzhA8AAAC712tOb6OMNN6/5R114gEdqG1cG9Dr16/PReIAAABgHZvXawR0ILBcG9BHjhypSZMmBbuNamfzhA8AAAC712tOb3ca6W7/lvdOAjrg2oB+yy23qF69ejr77LN188036/bbb/ep2srmCR8AAAB2r9ec3m430l/8W97bCeiAawP6ueeeW2n16NEj2O0FjM0TPgAAAOxerxHQgcBybUB3K5snfAAAANi9XnN6u81Io/1b3tsI6AAB3WVsnvABAABg93qNgA4ElmsD+n333Xfcqq1snvABAABg93rN6e0WI93l3/LeQkAHXBvQO3To4FNpaWmKjo5WXFycMjMzg91ewNg84QMAAMDu9RoBHQgs1wb0ini9XvXr108vvPBCsFsJGJsnfAAAANi9XnN6u8lId/i3vDcR0AECehmrV69WSkpKsNsIGJsnfAAAANi9XiOgA4FFQC/j448/Vnx8fLDbCBibJ3wAAADYvV5zervBSCP9W94bCOiAawP69OnTfeqxxx7TmDFj1KRJE/Xv3z/Y7QWMzRM+AAAA7F6vOb1dZ6Rb/Vve6wjogGsDempqqk+1bNlSnTt31tixY5WXlxfs9gLG5gkfAAAAdq/XCOhAYLk2oFdm27ZtGj58eLDbCBibJ3wAAICg+/FH6eYR0tAB0sYNQWnB5vWa09sII93s3/KOIKADBPQyVq5cqdDQ0GC3ETA2T/gAAABB1+8iqW6YFBsmtW0hFRdXews2r9cI6EBgEdDLIKADAAC4WIe2UrQpqdhQ6ciRam/B5vWa09ufjXSjf8v7ZwI6QEAvg4AOAADgYi+9UBLMo41077igtGDzeo2ADgQWAb0MAjoAAIDL7dolbfkhaA9v83rNxvOoKQAAIABJREFU6e1aI13v3/JeS0AHXBfQ+/Xrd9zq0aMHAR0AAABBY/N6jYAOBJbrAvrQoUOrVLWVzRM+AAAA7F6vOb0NNdII/5Z3KAEdcF1AdzubJ3wAAADYvV5zehtspD/7t7yDCegAAd1lbJ7wAQAAYPd6jYAOBBYB3WVsnvABAABg93rN6e1qI13r3/JeTUAHCOguY/OEDwAAALvXawR0ILAI6C5j84QPAAAAu9drTm8DjDTUv+UdQEAHCOguY/OEDwAAALvXawR0ILAI6C5j84QPAAAAu9drTm//Z6TB/i3v/xHQAQK6y9g84QMAAMDu9RoBHQgsArrL2DzhAwAAwO71mtPbVUa62r/lvYqADhDQXcbmCR8AAAB2r9ec3q400gD/lvdKAjpAQHcZmyd8AAAAqxUWStu3S8XFAX0Ym9drBHQgsAjoLmPzhA8AAGCtvXultDZShJEu7S0VFQXsoWxerzm9/dFI/+ff8v6RgA4Q0F3G5gkfAADAWvNfKQnnpbVxY8Aeyub1GgEdCCwCusvYPOEDAABY6+uvpdiIknDeopF04EDAHsrm9ZrTWz8jXeXf8vYjoAMEdJexecIHAACw2vp10qznpB07AvowNq/XCOhAYBHQXcbmCR8AAAB2r9ec3voa6Qr/lrcvAR0goLuMzRM+AAAA7F6vEdCBwCKgu4zNEz4AAADsXq85vV1qpMv9W95LCegAAd1lbJ7wAQAAYPd6jYAOBBYB3WVsnvABAABg93rN6e1iI13m3/JeTEAHCOguY/OEDwAAALvXa05vFxqpj3/LeyEBHSCgu4zNEz4AAADsXq8R0IHAIqC7jM0TPgAAAOxerzm9XWCkS/xb3gsI6AAB3WVsnvABAABg93qNgA4EFgG9htm7d686duyojIwMpaWl6Zlnnjmh+9s84QMAAMDu9ZrTWy8jXeTf8vYioAME9BrmyJEjOnDggCRp//79Sk1N1S+//FLl+9s84QMAUJulpKTIGKOJEycGuxVYzub1GgEdCCwCeg22e/dupaSk6Oeff67yfWye8AEANds555wjY0yFtXDhwmC3FxCzZ8/2eZ4hISGKi4tTly5d9Morr/iMJaCjqmxerzm99TRSb/+WtycBHSCg+9lHH32kSy65RI0bN650QTJjxgylpKTI4/EoKytLy5YtO6HH2Lt3r9q3b6+oqCjNmDHjhO5r84QPAKjZSgN6RESEOnfu7FMfffRRsNsLiGMD+hlnnKEzzzxTsbGxMsYoNDTU5994Ajqqyub1GgEdCCwCup8tWrRI48aN04IFCyoM6PPmzVNERIRmzZqldevWafjw4YqPj9ePP/7ojCn9fHnZ2rFjh8++du3apW7dumnXrl1V7s/mCR8AULOVBvSUlJRKxxwbaJcuXarMzExFRkYqMzNTn3/+uTMuJydHf/jDH9SoUSNFREQoOjpanTp10j/+8Q+f/ZXua+rUqRo4cKBiY2PVpEkTPfDAAz7jBg8erFatWik2Nlbh4eFq0aKFbrnlFp9/Dzdu3KhLL71USUlJioiIUNOmTdW7d+/j/iH92OeTnZ0tSfr44499+ipVNqAfPHhQffv2VWpqqqKjoxUREaFWrVppwoQJOnz4cLnXddCgQbrnnnvUqFEjxcfHa+DAgdq3b58zrri4WE888YQ6dOigyMhIxcbG6swzz1ROTo4k6d1331X37t2VlJSk8PBw1a1bV927d9eiRYt8ntPUqVPVtm1bRUVFKS4uTu3bt9ddd91V6WsA/7N5veb09gcjne/f8v6BgA4Q0AOoooCelZWlm266yfm5qKhITZo00UMPPXRSj3HDDTdo/vz5ld5+6NAheb1ep7Zt28bEBwAIiBMN6B6PR23btlWdOnWc+xUWFkqSFi5cqNDQUKWkpCgzM1P169d37vevf/3L2V/ptvDwcDVu3FiJiYnOtnfffdcZV69ePTVo0EAZGRlq2bKlM+aKK65wxmRmZsoYo/r16yszM9M5G2727NlVej7Z2dkqLi722XbsOqBsQN+7d6+MMUpOTlaHDh3UrFkz537HBuLS17U0VJ922mnOuLvvvtsZd/PNNzvbGzRooLS0NEVERDg9PProowoPD1fLli2VmZnpvNNfp04drVy5UpL0xhtvOPv4zW9+o3bt2ikqKuq4xxT+VyMC+rlG6unf8p5LQAcI6AFU9h/mw4cPKywsrFxoHzx4sPr06VOlfe7atcv5a3lubq7S0tK0evXqSsdPnDixws8CMvEBAPzteJ9BL3VseP373/8uSZo+fbqzbcOGDZKknTt3+pwhlp+fr1atWskYo6uvvtrZXnq/rl276vDhw/r5558VHh4uY4zGjBnjjCsNoKXGjRvnhNP8/HxJcgLrJ5984ozbvHmzvv/++0qfc9nPoB9bQ4YM8RlbNqAXFBRo3bp1PmOuvvpqGWPUrFmzcq9r3bp1tX37dhUVFaljx44yxqhz586SpO+//14hISEyxqhfv37OO/A//fSTtm3bJkn64YcftHfvXme/e/bsUd26dWWM0fjx4yWVvHtujFHPnj2dcYcOHdKnn35a6WsA/yOg2/e8gepCQA+gsgF9x44dMsbos88+8xk3atQoZWVlVWmfy5YtU0ZGhtq3b6/f/va3euqpp447nnfQAQDV5XifQS91bKAtDYvvvfees+3DDz+UVPIH6YEDB6px48YKCwvzCb5/+MMfnP2Vbnv00UedbU2bNpUxRkOHDnW2TZ06VWlpaYqMjCwXpLdu3SpJ6t+/v/NOdbt27XT55Zdr5syZOnToUKXPuexn0Dt37uy8826M0fPPP++MLRvQjxw5orFjx6p169aKiIjw6Sk0NLTc69q3b19n28CBA2WMUWpqqiTp1Vdfde577B8YjvX111+rb9++SkpKUmhoqM/jXXvttZKkNWvWOL0kJibq97//vW699VbnNHlUjxoR0M820h/8W96zCegAAT2AAhHQT5XNEz4AoGY70VPcS2VnZ5f7HHfPnj1lTMlV0dPS0tS5c2fn3d5zzjnHuW/p/Y49Db00CJe+g/3iiy864xo3bqysrCyf09xL3yEvLCzU3Llzdd111+mss85ywvyNN95YpedT2vuRI0fUpUsXGWPUtGnTcn2VBvQHH3zQuW9KSoo6d+7s/HHh2Nen9HU99h35IUOG+LzWVQnopWcg1KlTRxkZGercubMTxo/d97fffqv77rtPl112mXM6fXR0tLZs2VLp6wD/snm9RkAHAouAHkCBOMX9VNk84QMAajZ/BvTS081HjBghqeSrRUvfmT7RgF762ey6des674Zff/315QL60qVLfd4tf+ihh2SMUXp6epWeT2nvRUVFTkBv0KBBub5KA/oll1wiY4zatGkjqSTYX3TRRScV0I89xf2KK65wTnH/5ZdftG3bNv3yyy/OfidPnuzcx+Px+Oz7m2++0aZNm5zHOXz4sOLi4mSM0WuvvVbp6wBJK1ZIEydKZT62cDJsXq85vXU30rn+LW93AjpAQA+gsgFdKrlI3M033+z8XFRUpKZNm570ReJOlM0TPgCgZjveKe7z5s2TVPWA3q1bN+dU79/85jeKj493LhR3ogH9mWeeccY1adJEp512mhISEsoF9KZNmyoqKkpt2rRRhw4dnM+yDxgwoNLnXNEp7k2aNHG2DRs2rFxfpQH97rvvdsalpqaqadOmPn2VfV2PF9Al34vEJSYmKj09XR6PRwsXLlRxcbFzEbrw8HClp6erfv36iomJ8dn3s88+65xpkJmZ6TyXsLAwrV+//ld+A1xs/34pJkYyRkpMlIqKTml3Nq/XCOhAYBHQ/SwvL085OTnKycmRMUbTpk1TTk6Oc1rYvHnz5PF4NGfOHK1fv14jRoxQfHz8CX1V2qmwecIHANRsx7tIXOlnxKsa0L/55hv16NFD0dHRSk1N1Zw5c5z9n2hALyoq0h133KHExETVrVtX11xzjWbMmFEuoI8fP16dOnVSQkKCIiIi1Lx5c40YMUJ79uyp9DlXdJG48PBwnX766brzzjt18ODBcn2VBvT9+/dryJAhio+PV0JCgu68806NHz/+pAN62a9Zi4mJ8fmatWXLlunMM89UZGSkzjjjDC1atKjca7VixQr169dPKSkp8ng8qlevnrp06aIFCxYc79DD65XCw0sCemysdOTIKe7O3vWa01s3I53t3/J2I6ADBHQ/O3aRcWwd+4/q448/rhYtWigiIkJZWVn64osvqq0/myd8AKhMcXGRiosP/vpAAAiWJUuk4cOljz8+5V3ZvF4joAOBRUB3GZsnfACoSFHROyooSFRBQbgKCy9UcXFesFsCgICyeb3m9NbFSN39W94uBHSAgO4yNk/4AFBWcfFBFRTUU0FBhAoKwlVQ4NGRI3cHuy0ACCib12tOb1lG6ubf8mYR0AECusvYPOEDQFnFxVv/F8zDnYBeWPh/wW4LAALK5vUaAR0ILAK6y9g84QNAWcXFR1RQkK6CgkgnpBcVzQp2WwAQUDav15zeOhmpi3/L24mADhDQXcbmCR8AKlJcvEOFhdeosLCXjhx5UsXFxcFuqcSRndKBF6SDb0rFp3bFZgA4ls3rNQI6EFgEdJexecIHgBqjYIO0I17abkrq54sJ6QD8xub1mtNbRyNl+be8HQnoAAHdZWye8AGgxtgzVNoedjSgbzfSoexgdwWglrB5vUZABwKLgO4yNk/4AFBj7L5S2h7qG9Dz/xXsrgDUEjav15zeMo3Uyb/lzSSgAwR0l7F5wgeAGiN/kbQ9RNpep+Sd9J2pUtG+YHcFoJaweb1GQAcCi4DuMjZP+ABQo+S/J+35s5Q7SjqyK9jdAKhFbF6vOb1lGOl3/i1vBgEdIKC7jM0TPgAAAOxerzm9/dZIHfxb3t8S0AECusvYPOEDAADA7vUaAR0ILAK6y9g84QMAAMDu9ZrTW5qR2vu3vGkEdICA7jI2T/gAAACwe71GQAcCi4DuMjZP+ACAU1BcLB3JK/kvgBrN5vWa09sZRkr3b3nPIKADBHSXsXnCBwCcpIPfSCvaSJ8YaXkTad/yYHcE4BTYvF4joAOBRUB3GZsnfADAScrpJH0SVhLQPwmVljXinXSgBrN5veb01tZIv/FvedsS0AECusvYPOEDAE7SZ1H/C+fHVGFu9fdRkCdtmSttniPl893wwMmyeb1GQAcCi4DuMjZP+ACAk7T6LOmTOv8L52HSl6dV/zvoh/dIb7eR5pmSWpAgeTdWbw9ALWHzes3prbWR2vm3vK0J6AAB3WVsnvABACfp0HZp1e+lTz3SVxnSgfXV38Pa+6RXwo4G9FfCpE+vrP4+gFrA5vWa09vpRmrj3/KeTkAHCOguY/OEDwCowVbcJL1S52hAn2ekD84KdldAjWTzeo2ADgQWAd1lbJ7wAQA12PbXfcP5vBBp3eRgdwXUSDav15zeWhqplX/L25KADhDQXcbmCR8AUMN987i0sKH0z3pSzp1S0ZFgdwTUSDav1wjoQGAR0F3G5gkfAAAAdq/XnN5SjdTSv+VNJaADBHSXsXnCBwAAgN3rNQI6EFgEdJexecIHAACA3es1p7cWRkr1b3lbENABArrL2DzhAwAAwO71GgEdCCwCusvYPOEDAADA7vWa01szI7Xwb3mbEdABArrL2DzhAwBQbYqLpS+fkl69UnrremnP5mB3BDhsXq85vTUxUjP/lrcJAR0goLuMzRM+AADV5v27pXuNdG+odF8d6eEEybs92F0BkuxerxHQgcAioLuMzRM+AADVorhIeiDifwH9f3VfmPTxlGB35n9b10vL35J+3hbsTnACbF6vOb01MlIT/5a30ckH9IceekjGGN12223Otvz8fN14441KSEhQTEyMLr/8cu3atcvnflu2bNFFF12kqKgoJSUl6a677lJhYaHPmOzsbGVmZioiIkKnn366Zs+efVKvHVAVBHSXsXnCBwCgWhQVSveF+gb0++tI2fcGuzP/OXRQeuBSqY8pqb6h0pzRJaf2w3o2r9dsDOjLly9Xamqq2rdv7xPQr7/+ejVv3lwffPCBVqxYoS5duqhbt27O7UeOHFF6erp69uypnJwcLVq0SImJiRo7dqwzZvPmzYqOjtYdd9yh9evX6/HHH1dYWJgWL1586i8mUAECusvYPOEDAFBtXr2i5F3z0tPc768j7VwZ7K785x/jSkJ5aUAvrU9fC3ZnqAKb12tObw2N1Mi/5W144gE9Ly9PrVu31nvvvadzzjnHCei5ubkKDw/X/PnznbEbNmyQMUaff/65JGnRokUKDQ31eVf9ySefVFxcnA4fPixJGj16tNLS0nwe809/+pMuuOCCk34NgeMhoLuMzRM+AADV5vB+6c3h0rQW0lOZ0nfvBbsj/xqWUj6cXxYqPXxlsDtDFdi8XquOgL5t2zZ5vV6nDh06VGk/gwcP1siRIyXJJ6B/8MEHMsZo7969PuNbtGihadOmSZImTJigjIwMn9s3b94sY4y++uorSdJZZ53l8668JM2aNUtxcXGn9kIClSCgu4zNEz4AAPATAnqNZvN6zekt0UgN/VvexJKAXrYmTpxYYS9z585Venq68vPzJfkG9JdeekkRERHl7nPmmWdq9OjRkqThw4fr/PPP97n9wIEDMsZo0aJFkqTWrVtr8uTJPmPefvttGWN08ODBU3otgYoQ0F3G5gkfAAD4Cae412g2r9eqI6BX5R30rVu3qmHDhlq1apWzjYCO2oCA7jI2T/gAAMBPDh2UHuzDReJqKJvXa05vCUZK9G95E6r+GfSFCxfKGKOwsDCnjDEKCQlRWFiY3n//fU5xR41EQHcZmyd8AADgZ6Vfs/YL3/Fek9i8XnN6q2+kBP+Wt37VA/q+ffu0Zs0an+rUqZOuvvpqrVmzxrlI3GuvHT1rZOPGjRVeJO7HH390xjz99NOKi4tz3rUfPXq00tPTfR67f//+XCQOAUNAdxmbJ3wAAADYvV6zJaBX5NhT3KWSr1lr0aKFli5dqhUrVqhr167q2rWrc3vp16ydf/75WrlypRYvXqykpKQKv2Zt1KhR2rBhg5544gm+Zg0BRUB3GZsnfAAAANi9XnN6q2ekeP+Wt55/A3p+fr5uvPFG1a9fX9HR0erXr5927tzpc58ffvhBF154oaKiopSYmKg777xThYWFPmOys7PVoUMHRUREqGXLlpo9e/ZJ9QdUBQHdZWye8AEAAGD3es3mgA7UBgR0l7F5wgcAAIDd6zWnt7pGivNveesS0AECusvYPOEDAADA7vUaAR0ILAK6y9g84QMAAMDu9ZrTW4yRYv1b3hgCOkBAdxmbJ3wAAADYvV4joAOBRUB3GZsnfAAAANi9XnN6izJStH/LG0VABwjoLmPzhA8AAAC712tObx4jRfq3vB4COkBAdxmbJ3wAAADYvV4joAOBRUB3GZsnfAAAANi9XnN6CzdShH/LG05ABwjoLmPzhA8AAAC712sEdCCwCOguY/OEDwAAALvXa05vYUaq49/yhhHQAQK6y9g84QMAAMDu9RoBHQgsArrL2DzhAwAAwO71mtNbiJFC/VveEAI6QEB3GZsnfAAAANi9XiOgA4FFQHeZ3NxcGWO0bds2eb1eiqIoiqIoyrLatm2bjDHKzc0N9tKxHK+3JKBvM0ZeP9c2Q0AHCOguUzrhUxRFURRFUXbXtm3bgr10LCc/P1+NGjUK2HNu1KiR8vPzg/00gaAhoLtMUVGRtm3bptzc3KD/dbimVukfOTgLwR3F8XZPcazdVRxv91RNPNa5ubnatm2bioqKgr10rFB+fn7AnjvhHG5HQAdOkNdr7+fC4H8cb/fgWLsLx9s9ONYAahICOnCC+IfeXTje7sGxdheOt3twrAHUJAR04ATxD727cLzdg2PtLhxv9+BYA6hJCOjACTp06JAmTpyoQ4cOBbsVVAOOt3twrN2F4+0eHGsANQkBHQAAAAAACxDQAQAAAACwAAEdAAAAAAALENABAAAAALAAAR0AAAAAAAsQ0OEKH330kS655BI1btxYxhgtXLjQua2goECjR49Wenq6oqOj1bhxYw0aNEg7duzw2cfu3bs1YMAA1a1bV/Xq1dO1116rvLw8nzGrVq1S9+7d5fF41KxZMz388MPlenn11VfVtm1beTwepaen6+233w7Mk3ap4x1rSSouLtaECRPUqFEjRUZG6rzzztM333zjM4ZjXXMdOXJE48ePV2pqqiIjI9WyZUvdf//9Ki4udsZU5+8AAmv79u0aOHCgEhISFBkZqfT0dH355ZfO7Rzr2uuhhx6SMUa33Xabsy0/P1833nijEhISFBMTo8svv1y7du3yud+WLVt00UUXKSoqSklJSbrrrrtUWFjoMyY7O1uZmZmKiIjQ6aefrtmzZ1fHUwIASQR0uMSiRYs0btw4LViwoFxoy83NVc+ePfXKK69o48aN+vzzz5WVlaWOHTv67KN3797KyMjQF198oY8//litWrVS//79ndu9Xq+Sk5M1cOBArV27VnPnzlVUVJSefvppZ8ynn36qsLAw/fWvf9X69es1fvx4hYeHa82aNYF/EVzieMdakqZMmaJ69erp9ddf16pVq9SnTx+ddtppys/Pd8ZwrGuuSZMmqUGDBvrXv/6l77//XvPnz1dsbKymT5/ujKmu3wEE1p49e5SSkqKhQ4dq2bJl2rx5s5YsWaJNmzY5YzjWtdPy5cuVmpqq9u3b+wT066+/Xs2bN9cHH3ygFStWqEuXLurWrZtz+5EjR5Senq6ePXsqJydHixYtUmJiosaOHeuM2bx5s6Kjo3XHHXdo/fr1evzxxxUWFqbFixdX63ME4F4EdLhORaGtrOXLl8sYoy1btkiS1q9fL2OMzzsz77zzjkJCQpx32mfOnKn69evr8OHDzpgxY8aobdu2zs9XXXWVLr74Yp/H6ty5s6677rpTfl4or+yxLi4uVqNGjfTII48423Jzc+XxeDR37lxJHOua7uKLL9a1117rs+3yyy/XwIEDJVXv7wACa8yYMerevXult3Osa6e8vDy1bt1a7733ns455xwnoOfm5io8PFzz5893xm7YsEHGGH3++eeSSv6AGxoa6vOu+pNPPqm4uDjn+I4ePVppaWk+j/mnP/1JF1xwQaCfGgBIIqDDhaoS0N977z2FhITI6/VKkp5//nnFx8f7jCksLFRYWJgWLFggSRo0aJD69u3rM2bp0qUyxmjPnj2SpObNm+vRRx/1GXPPPfeoffv2p/ScULGyx/q7776TMUY5OTk+484++2zdeuutkjjWNd2kSZOUkpKir7/+WpK0cuVKNWzYUC+++KKk6v0dQGCdccYZGjlypK644golJSWpQ4cOeuaZZ5zbOda10+DBgzVy5EhJ8gnoH3zwgYwx2rt3r8/4Fi1aaNq0aZKkCRMmKCMjw+f2zZs3yxijr776SpJ01lln+bwrL0mzZs1SXFxcQJ4PAJRFQIfr/FpAz8/P1+9+9zsNGDDA2TZp0iS1adOm3NikpCTNnDlTktSrVy+NGDHC5/Z169bJGKP169dLksLDw/Xyyy/7jHniiSfUsGHDk34+qFzZY/3pp5/KGKP//ve/PuOuvPJKXXXVVZI41jVdUVGRxowZo5CQENWpU0chISGaPHmyc3t1/g4gsDwejzwej8aOHauvvvpKTz/9tCIjIzVnzhxJHOvaaO7cuUpPT3c+onBsQH/ppZcUERFR7j5nnnmmRo8eLUkaPny4zj//fJ/bDxw4IGOMFi1aJElq3bq1z5whSW+//baMMTp48KDfnxMAlEVAh+scL6AXFBTo0ksvVWZmpvPuuURoq6kI6O4zd+5cNWvWTHPnztXq1av1wgsvKCEhgdBWC4WHh6tr164+22655RZ16dJFEse6ttm6dasaNmyoVatWOdsI6ABqIwI6XKeygF5QUKDLLrtM7du31y+//OJzG6c910yc4u4+zZo104wZM3y2PfDAA87nhTntufZo0aKFhg0b5rNt5syZatKkiSSOdW2zcOFCGWMUFhbmlDFGISEhCgsL0/vvv88p7gBqBQI6XKeigF4aztPS0vTTTz+Vu0/phYRWrFjhbFuyZEmFFxIqKChwxowdO7bchcMuueQSn3137dqVC4cFSGUXiZs6daqzzev1VnjRKI51zZSQkOC881lq8uTJat26taTq/R1AYPXv37/cReJGjhzpvKvOsa5d9u3bpzVr1vhUp06ddPXVV2vNmjXOReJee+015z4bN26s8CJxP/74ozPm6aefVlxcnA4dOiRJzteuHqt///5cJA5AtSGgwxXy8vKUk5OjnJwcGWM0bdo05eTkaMuWLSooKFCfPn3UrFkzrVy5Ujt37nTq2Kv29u7dW5mZmVq2bJk++eQTtW7d2uereHJzc5WcnKxBgwZp7dq1mjdvnqKjo8t99VadOnU0depUbdiwQRMnTuSrt/zseMdaKvnapfj4eL3xxhtavXq1+vbtW+HXLnGsa6YhQ4aoadOmztesLViwQImJic4prlL1/Q4gsJYvX646depo0qRJ+vbbb/XSSy8pOjrauSCgxLGu7Y49xV0q+Zq1Fi1aaOnSpVqxYoW6du3q8zGI0q9ZO//887Vy5UotXrxYSUlJFX7N2qhRo7RhwwY98cQTfM0agGpFQIcrZGdnyxhTroYMGaLvv/++wtuMMcrOznb2sXv3bvXv31+xsbGKi4vTNddco7y8PJ/HWbVqlbp37y6Px6OmTZtqypQp5Xp59dVX1aZNG0VERCgtLU1vv/12oJ++qxzvWEsl76pNmDBBycnJ8ng8Ou+885wrfpfiWNdc+/bt02233aYWLVooMjJSLVu21Lhx43z+2FadvwMIrLfeekvp6enyeDxq166dz1XcJY51bVc2oOfn5+vGG29U/fr1FR0drX79+mnnzp0+9/nhhx904YUXKioqSomJibrzzjtVWFilsPy3AAAI9ElEQVToMyY7O1sdOnRQRESEWrZsqdmzZ1fH0wEASQR0AAAAAACsQEAHAAAAAMACBHQAAAAAACxAQAcAAAAAwAIEdAAAAAAALEBABwAAAADAAgR0AAAAAAAsQEAHAAAAAMACBHQAAAJo48aNSk5O1r59+6p8n3feeUcZGRkqKioKYGcAAMA2BHQAcAFjzHFr4sSJwW7R71JSUvToo48Guw3169dPDz74oPNzdna2jDHau3evs23Hjh1KT0/XWWedpdzcXElSp06d9MILL1R7vwAAIHgI6ADgAjt37nTqscceU1xcnM+2vLy8YLdYJcXFxSosLKzSWH8F9MOHD5/0fbds2aLw8HBt377d2VY2oG/atEmnnXaaLr74Yh08eNAZN2PGDHXq1OnkGwcAADUOAR0AXGb27NmqV6+ez7Znn31W7dq1k8fjUdu2bfXEE084t33//fcyxuiVV15R9+7dFRkZqU6dOunrr7/W8uXL1bFjR8XExKh379766aefnPsNGTJEffv21b333qvExETVrVtX1113nU/gLSoq0uTJk5WamqrIyEi1b99e8+fPd24vDbOLFi3S7373O4WHhys7O1ubNm1Snz591LBhQ8XExKhTp0567733nPudc8455c4SkKSJEycqIyPD57k/+uijSklJKdf3gw8+qMaNGys1NVWS9MILL6hjx46KjY1VcnKy+vfvrx9//PG4r/UjjzxSLmQfG9BXrVqlRo0aacCAAeX+8LBlyxYZY7Rp06bjPgYAAKg9COgA4DJlA/qLL76oxo0b65///Kc2b96sf/7zn0pISNCcOXMkHQ3o7dq10+LFi7V+/Xp16dJFHTt21LnnnqtPPvlEX331lVq1aqXrr7/e2e+QIUMUGxurP/3pT1q7dq3+9a9/KSkpSXfffbcz5sEHH3T2+91332n27NnyeDz68MMPJR0Ns+3bt9e7776rTZs2affu3Vq5cqWeeuoprVmzRt98843Gjx+vyMhIbdmyRZK0e/duNWvWTPfff79zloBU9YAeGxurQYMGae3atVq7dq0k6fnnn9eiRYv03Xff6fPPP1fXrl114YUXHve17tOnj89rcuxzevvttxUfH6+bbrpJxcXFFd4/OTlZs2fPPu5jAACA2oOADgAuUzagn3766Xr55Zd9xjzwwAPq2rWrpKMB/bnnnnNunzt3rowx+uCDD5xtDz30kNq2bev8PGTIECUkJOjAgQPOtieffFKxsbEqKirSoUOHFB0drc8++8znsYcNG6b+/ftLOhpmX3/99V99XmlpaXr88cednys6xb2qAT05OflXT23/8ssvZYw57scDMjIydP/99/tsK31OERERGjRo0HEfIzMzU/fee+9xxwAAgNqDgA4ALnNsQN+/f7+MMYqKilJMTIxTHo9HDRs2lHQ0oC9fvtzZx9KlS2WM8TmlfdasWapfv77z85AhQ9SjRw+fx165cqWMMfrhhx+0du1aGWN8HjcmJkbh4eHKysqSdDTMHvsZbknKy8vTnXfeqXbt2qlevXqKiYlRaGioRo0a5Yw5lYDes2fPcq/bihUrdMkll6h58+aKjY1VdHS0jDFat25dpa91mzZt9Ne//tVnW+lzuvLKKxUbG6t///vfld6/W7duGj16dKW3AwCA2oWADgAuc2xA37Vrl4wxevHFF/Xtt9/61ObNmyUdDeg5OTnOPiq6EnnZd+Z/LaB/8cUXMsboww8/LPfYW7durfRxJOm6665Ty5YttWDBAq1evVrffvutMjIydNtttzljKgro9913n9q3b++z7a9//WuFn0E/1v79+9WgQQMNGDBA//73v7VhwwYtWbKk3OtSVrdu3TR27FifbaXPac+ePfrzn/+smJgYffTRRxXev127dnrkkUcq3T8AAKhdCOgA4DJlg3STJk3KnYZ9rFMJ6AkJCT5XJn/qqaecU9z37dsnj8dz3K8Sqyygp6en+/Scl5enevXq+QT01q1ba+rUqT73mzlzpho2bOjzme8BAwb8akBfsWKFjDHOHw4k6R//+MevBvSbbrqp3L6OfU7FxcUaMWKEYmJinM/dl8rPz1d4eLjef//9SvcPAABqFwI6ALhM2SD97LPPKioqStOnT9fXX3+t1atXa9asWfrb3/4m6dQCemxsrPr3769169bp7bffVnJysv7yl784Y8aNG6cGDRpozpw52rRpk/7zn//o73//u3OBusoCer9+/dShQwfl5ORo5cqVuvTSS1W3bl2fgN6rVy/16dNH27dv188//yxJWr9+vUJCQjRlyhRt2rRJM2bMUP369X81oP/000+KiIjQqFGj9N133+mNN95QmzZtfjWgv/nmm2rYsKGOHDlS6WtXXFysG264QdHR0crOzvYZFxsb6/MZfgAAULsR0AHAZSr6mrWXXnpJHTp0UEREhOrXr6+zzz5bCxYskHRqAb1v376655571KBBA8XGxmr48OE6dOiQM6a4uFiPPfaY2rZtq/DwcCUlJemCCy5wTvmuLKB///336tGjh6KiotS8eXPNmDFD55xzjk9A//zzz9W+fXt5PB7na9akkgvVNW/eXDExMRo8eLAmTZr0qwFdkl5++WWlpqbK4/Goa9euevPNN381oBcWFqpJkyZavHjxcV+74uJi3XTTTYqOjtbSpUslSSNGjNB1111X6b4BAEDtQ0AHAAREZUHXbWbMmKHzzz//hO7z888/KyEhwbkOAAAAcAcCOgAgIAjoJQoLC/Xggw9q3759Vb7Pl19+qXnz5gWwKwAAYCMCOgAgIAjoAAAAJ4aADgAAAACABQjoAAAAAABYgIAOAAAAAIAFCOgAAAAAAFiAgA4AAAAAgAUI6AAAAAAAWICADgAAAACABQjoAAAAAABYgIAOAAAAAIAFCOgAAAAAAFiAgA4AAAAAgAUI6AAAAAAAWICADgAAAACABQjoAAAAAABYgIAOAAAAAIAFCOgAAAAAAFiAgA4AAAAAgAUI6AAAAAAAWICADgAAAACABQjoAAAAAABYgIAOAAAAAIAFCOgAAAAAAFiAgA4AAAAAgAX+P0eqXRIwzSeLAAAAAElFTkSuQmCC\" width=\"1000\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "<matplotlib.colorbar.Colorbar at 0x7f821e254b38>" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=[10,6])\n", + "\n", + "# -- valor máximo y mÃnimo de temperatura para poder definir valores del eje x\n", + "xmin = min( d_temp_min, ms_temp_min, g_temp_min, sg_temp_min )\n", + "xmax = max( d_temp_max, ms_temp_max, g_temp_max, sg_temp_max )\n", + "\n", + "# -- crear colores para las estrellas, de rojo (fria) a azul (caliente)\n", + "cmap = matplotlib.colors.LinearSegmentedColormap.from_list(\"\", [\"red\",\"yellow\",\"blue\"])\n", + "\n", + "# -- definir el tamaño del punto de acuerdo al radio\n", + "sd = all_stars['radius']\n", + "# -- x: temperatura, y: luminosidad, color: temperatura\n", + "# -- estoy haciendo el punto el doble del tamaño, solo porque me parece se ve mejor\n", + "# -- cmap: colores que defini un par de lineas arruba\n", + "im = ax.scatter(all_stars['temp'], all_stars['lum'] , c=all_stars['temp'],\n", + " s=sd*2,cmap=cmap)\n", + "\n", + "\n", + "# -- definir nombre de ejes y tÃtulo del gráfico\n", + "ax.set_xlabel('Temperatura (K)')\n", + "ax.set_ylabel('Luminosidad (L$_{sol}$) en escala logarÃtmica')\n", + "ax.set_title('Diagrama Hertzsprung-Russell', fontsize = 15)\n", + "\n", + "# -- definir limites del eje x, para que incremente de derecha a izquierda\n", + "ax.set_xlim(xmax+300, xmin-300)\n", + "# -- poner eje y en escala logarÃtimica para que se entienda mejor el gráfico\n", + "ax.set_yscale(\"log\")\n", + "\n", + "\n", + "# -- definir el label de cada grupo de estrellas, usando cantidad máximas y mÃnimas y ajustando\n", + "ax.text((d_temp_min+d_temp_max)/2, 2*(d_lum_max+d_lum_min)/2, 'Enanas Blancas',fontweight='bold')\n", + "ax.text(1.3*(ms_temp_min+ms_temp_max)/2, 5*(ms_lum_max+ms_lum_min)/2, 'Secuencia principal',fontweight='bold')\n", + "ax.text(g_temp_max+700, (g_lum_max+g_lum_min)/2, 'Gigantes',fontweight='bold')\n", + "ax.text((sg_temp_min+sg_temp_max)/2, sg_lum_min*0.3, 'Supergigantes',fontweight='bold')\n", + "\n", + "fig.colorbar(im, ax=ax)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Ejercicio No. 2\n", + "\n", + "Después de tener un diseño de base para el ejercicio No. 1, en este ejercicio se pide generar una animación, en la cual se reproduzca el mismo gráfico de antes pero las estrellas vayan apareciendo progresivamente." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "text_d = np.concatenate(([None]*5,['Enanas Blancas']*101))\n", + "text_ms = np.concatenate(([None]*95,['Secuencia Principal']*11))\n", + "text_g = np.concatenate(([None]*100,['Gigantes']*6))\n", + "text_sg = np.concatenate(([None]*105,['Supergigantes']*1))" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "106" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(text_ms)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "/* global mpl */\n", + "window.mpl = {};\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(\n", + " '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", + "\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 = document.createElement('div');\n", + " this.root.setAttribute('style', 'display: inline-block');\n", + " this._root_extra_style(this.root);\n", + "\n", + " parent_element.appendChild(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 (fig.ratio !== 1) {\n", + " fig.send_message('set_dpi_ratio', { dpi_ratio: fig.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 = document.createElement('div');\n", + " titlebar.classList =\n", + " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", + " var titletext = document.createElement('div');\n", + " titletext.classList = 'ui-dialog-title';\n", + " titletext.setAttribute(\n", + " 'style',\n", + " 'width: 100%; text-align: center; padding: 3px;'\n", + " );\n", + " titlebar.appendChild(titletext);\n", + " this.root.appendChild(titlebar);\n", + " this.header = titletext;\n", + "};\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", + "\n", + "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", + "\n", + "mpl.figure.prototype._init_canvas = function () {\n", + " var fig = this;\n", + "\n", + " var canvas_div = (this.canvas_div = document.createElement('div'));\n", + " canvas_div.setAttribute(\n", + " 'style',\n", + " 'border: 1px solid #ddd;' +\n", + " 'box-sizing: content-box;' +\n", + " 'clear: both;' +\n", + " 'min-height: 1px;' +\n", + " 'min-width: 1px;' +\n", + " 'outline: 0;' +\n", + " 'overflow: hidden;' +\n", + " 'position: relative;' +\n", + " 'resize: both;'\n", + " );\n", + "\n", + " function on_keyboard_event_closure(name) {\n", + " return function (event) {\n", + " return fig.key_event(event, name);\n", + " };\n", + " }\n", + "\n", + " canvas_div.addEventListener(\n", + " 'keydown',\n", + " on_keyboard_event_closure('key_press')\n", + " );\n", + " canvas_div.addEventListener(\n", + " 'keyup',\n", + " on_keyboard_event_closure('key_release')\n", + " );\n", + "\n", + " this._canvas_extra_style(canvas_div);\n", + " this.root.appendChild(canvas_div);\n", + "\n", + " var canvas = (this.canvas = document.createElement('canvas'));\n", + " canvas.classList.add('mpl-canvas');\n", + " canvas.setAttribute('style', 'box-sizing: content-box;');\n", + "\n", + " this.context = canvas.getContext('2d');\n", + "\n", + " var backingStore =\n", + " this.context.backingStorePixelRatio ||\n", + " this.context.webkitBackingStorePixelRatio ||\n", + " this.context.mozBackingStorePixelRatio ||\n", + " this.context.msBackingStorePixelRatio ||\n", + " this.context.oBackingStorePixelRatio ||\n", + " this.context.backingStorePixelRatio ||\n", + " 1;\n", + "\n", + " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", + " 'canvas'\n", + " ));\n", + " rubberband_canvas.setAttribute(\n", + " 'style',\n", + " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n", + " );\n", + "\n", + " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", + " if (this.ResizeObserver === undefined) {\n", + " if (window.ResizeObserver !== undefined) {\n", + " this.ResizeObserver = window.ResizeObserver;\n", + " } else {\n", + " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", + " this.ResizeObserver = obs.ResizeObserver;\n", + " }\n", + " }\n", + "\n", + " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", + " var nentries = entries.length;\n", + " for (var i = 0; i < nentries; i++) {\n", + " var entry = entries[i];\n", + " var width, height;\n", + " if (entry.contentBoxSize) {\n", + " if (entry.contentBoxSize instanceof Array) {\n", + " // Chrome 84 implements new version of spec.\n", + " width = entry.contentBoxSize[0].inlineSize;\n", + " height = entry.contentBoxSize[0].blockSize;\n", + " } else {\n", + " // Firefox implements old version of spec.\n", + " width = entry.contentBoxSize.inlineSize;\n", + " height = entry.contentBoxSize.blockSize;\n", + " }\n", + " } else {\n", + " // Chrome <84 implements even older version of spec.\n", + " width = entry.contentRect.width;\n", + " height = entry.contentRect.height;\n", + " }\n", + "\n", + " // Keep the size of the canvas and rubber band canvas in sync with\n", + " // the canvas container.\n", + " if (entry.devicePixelContentBoxSize) {\n", + " // Chrome 84 implements new version of spec.\n", + " canvas.setAttribute(\n", + " 'width',\n", + " entry.devicePixelContentBoxSize[0].inlineSize\n", + " );\n", + " canvas.setAttribute(\n", + " 'height',\n", + " entry.devicePixelContentBoxSize[0].blockSize\n", + " );\n", + " } else {\n", + " canvas.setAttribute('width', width * fig.ratio);\n", + " canvas.setAttribute('height', height * fig.ratio);\n", + " }\n", + " canvas.setAttribute(\n", + " 'style',\n", + " 'width: ' + width + 'px; height: ' + height + 'px;'\n", + " );\n", + "\n", + " rubberband_canvas.setAttribute('width', width);\n", + " rubberband_canvas.setAttribute('height', height);\n", + "\n", + " // And update the size in Python. We ignore the initial 0/0 size\n", + " // that occurs as the element is placed into the DOM, which should\n", + " // otherwise not happen due to the minimum size styling.\n", + " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", + " fig.request_resize(width, height);\n", + " }\n", + " }\n", + " });\n", + " this.resizeObserverInstance.observe(canvas_div);\n", + "\n", + " function on_mouse_event_closure(name) {\n", + " return function (event) {\n", + " return fig.mouse_event(event, name);\n", + " };\n", + " }\n", + "\n", + " rubberband_canvas.addEventListener(\n", + " 'mousedown',\n", + " on_mouse_event_closure('button_press')\n", + " );\n", + " rubberband_canvas.addEventListener(\n", + " 'mouseup',\n", + " on_mouse_event_closure('button_release')\n", + " );\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband_canvas.addEventListener(\n", + " 'mousemove',\n", + " on_mouse_event_closure('motion_notify')\n", + " );\n", + "\n", + " rubberband_canvas.addEventListener(\n", + " 'mouseenter',\n", + " on_mouse_event_closure('figure_enter')\n", + " );\n", + " rubberband_canvas.addEventListener(\n", + " 'mouseleave',\n", + " on_mouse_event_closure('figure_leave')\n", + " );\n", + "\n", + " canvas_div.addEventListener('wheel', function (event) {\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " on_mouse_event_closure('scroll')(event);\n", + " });\n", + "\n", + " canvas_div.appendChild(canvas);\n", + " canvas_div.appendChild(rubberband_canvas);\n", + "\n", + " this.rubberband_context = rubberband_canvas.getContext('2d');\n", + " this.rubberband_context.strokeStyle = '#000000';\n", + "\n", + " this._resize_canvas = function (width, height, forward) {\n", + " if (forward) {\n", + " canvas_div.style.width = width + 'px';\n", + " canvas_div.style.height = height + 'px';\n", + " }\n", + " };\n", + "\n", + " // Disable right mouse context menu.\n", + " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n", + " event.preventDefault();\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 toolbar = document.createElement('div');\n", + " toolbar.classList = 'mpl-toolbar';\n", + " this.root.appendChild(toolbar);\n", + "\n", + " function on_click_closure(name) {\n", + " return function (_event) {\n", + " return fig.toolbar_button_onclick(name);\n", + " };\n", + " }\n", + "\n", + " function on_mouseover_closure(tooltip) {\n", + " return function (event) {\n", + " if (!event.currentTarget.disabled) {\n", + " return fig.toolbar_button_onmouseover(tooltip);\n", + " }\n", + " };\n", + " }\n", + "\n", + " fig.buttons = {};\n", + " var buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'mpl-button-group';\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", + " /* Instead of a spacer, we start a new button group. */\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + " buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'mpl-button-group';\n", + " continue;\n", + " }\n", + "\n", + " var button = (fig.buttons[name] = document.createElement('button'));\n", + " button.classList = 'mpl-widget';\n", + " button.setAttribute('role', 'button');\n", + " button.setAttribute('aria-disabled', 'false');\n", + " button.addEventListener('click', on_click_closure(method_name));\n", + " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", + "\n", + " var icon_img = document.createElement('img');\n", + " icon_img.src = '_images/' + image + '.png';\n", + " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", + " icon_img.alt = tooltip;\n", + " button.appendChild(icon_img);\n", + "\n", + " buttonGroup.appendChild(button);\n", + " }\n", + "\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + "\n", + " var fmt_picker = document.createElement('select');\n", + " fmt_picker.classList = 'mpl-widget';\n", + " toolbar.appendChild(fmt_picker);\n", + " this.format_dropdown = fmt_picker;\n", + "\n", + " for (var ind in mpl.extensions) {\n", + " var fmt = mpl.extensions[ind];\n", + " var option = document.createElement('option');\n", + " option.selected = fmt === mpl.default_extension;\n", + " option.innerHTML = fmt;\n", + " fmt_picker.appendChild(option);\n", + " }\n", + "\n", + " var status_bar = document.createElement('span');\n", + " status_bar.classList = 'mpl-message';\n", + " toolbar.appendChild(status_bar);\n", + " this.message = status_bar;\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", + "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", + "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], msg['forward']);\n", + " fig.send_message('refresh', {});\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", + " var x0 = msg['x0'] / fig.ratio;\n", + " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", + " var x1 = msg['x1'] / fig.ratio;\n", + " var y1 = (fig.canvas.height - msg['y1']) / fig.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,\n", + " 0,\n", + " fig.canvas.width / fig.ratio,\n", + " fig.canvas.height / fig.ratio\n", + " );\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", + " 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.handle_history_buttons = function (fig, msg) {\n", + " for (var key in msg) {\n", + " if (!(key in fig.buttons)) {\n", + " continue;\n", + " }\n", + " fig.buttons[key].disabled = !msg[key];\n", + " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", + " if (msg['mode'] === 'PAN') {\n", + " fig.buttons['Pan'].classList.add('active');\n", + " fig.buttons['Zoom'].classList.remove('active');\n", + " } else if (msg['mode'] === 'ZOOM') {\n", + " fig.buttons['Pan'].classList.remove('active');\n", + " fig.buttons['Zoom'].classList.add('active');\n", + " } else {\n", + " fig.buttons['Pan'].classList.remove('active');\n", + " fig.buttons['Zoom'].classList.remove('active');\n", + " }\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", + "\n", + " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", + " evt.data\n", + " );\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " } else if (\n", + " typeof evt.data === 'string' &&\n", + " evt.data.slice(0, 21) === 'data:image/png;base64'\n", + " ) {\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(\n", + " \"No handler for the '\" + msg_type + \"' message type: \",\n", + " msg\n", + " );\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(\n", + " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", + " e,\n", + " e.stack,\n", + " msg\n", + " );\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", + " }\n", + " if (e.target) {\n", + " targ = e.target;\n", + " } else if (e.srcElement) {\n", + " targ = e.srcElement;\n", + " }\n", + " if (targ.nodeType === 3) {\n", + " // defeat Safari bug\n", + " targ = targ.parentNode;\n", + " }\n", + "\n", + " // pageX,Y are the mouse positions relative to the document\n", + " var boundingRect = targ.getBoundingClientRect();\n", + " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n", + " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\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", + " }\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", + " this.canvas.focus();\n", + " this.canvas_div.focus();\n", + " }\n", + "\n", + " var x = canvas_pos.x * this.ratio;\n", + " var y = canvas_pos.y * this.ratio;\n", + "\n", + " this.send_message(name, {\n", + " x: x,\n", + " y: y,\n", + " button: event.button,\n", + " step: event.step,\n", + " guiEvent: simpleKeys(event),\n", + " });\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", + " // Prevent repeat events\n", + " if (name === 'key_press') {\n", + " if (event.which === this._key) {\n", + " return;\n", + " } else {\n", + " this._key = event.which;\n", + " }\n", + " }\n", + " if (name === 'key_release') {\n", + " this._key = null;\n", + " }\n", + "\n", + " var value = '';\n", + " if (event.ctrlKey && event.which !== 17) {\n", + " value += 'ctrl+';\n", + " }\n", + " if (event.altKey && event.which !== 18) {\n", + " value += 'alt+';\n", + " }\n", + " if (event.shiftKey && event.which !== 16) {\n", + " value += 'shift+';\n", + " }\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, 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", + "\n", + "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", + "// prettier-ignore\n", + "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\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\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"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\";/* global mpl */\n", + "\n", + "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 = document.getElementById(id);\n", + " var ws_proxy = comm_websocket_adapter(comm);\n", + "\n", + " function ondownload(figure, _format) {\n", + " window.open(figure.canvas.toDataURL());\n", + " }\n", + "\n", + " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\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;\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", + " fig.cell_info[0].output_area.element.on(\n", + " 'cleared',\n", + " { fig: fig },\n", + " fig._remove_fig_handler\n", + " );\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_close = function (fig, msg) {\n", + " var width = fig.canvas.width / fig.ratio;\n", + " fig.cell_info[0].output_area.element.off(\n", + " 'cleared',\n", + " fig._remove_fig_handler\n", + " );\n", + " fig.resizeObserverInstance.unobserve(fig.canvas_div);\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.innerHTML =\n", + " '<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 / this.ratio;\n", + " var dataURL = this.canvas.toDataURL();\n", + " this.cell_info[1]['text/html'] =\n", + " '<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 () {\n", + " fig.push_to_output();\n", + " }, 1000);\n", + "};\n", + "\n", + "mpl.figure.prototype._init_toolbar = function () {\n", + " var fig = this;\n", + "\n", + " var toolbar = document.createElement('div');\n", + " toolbar.classList = 'btn-toolbar';\n", + " this.root.appendChild(toolbar);\n", + "\n", + " function on_click_closure(name) {\n", + " return function (_event) {\n", + " return fig.toolbar_button_onclick(name);\n", + " };\n", + " }\n", + "\n", + " function on_mouseover_closure(tooltip) {\n", + " return function (event) {\n", + " if (!event.currentTarget.disabled) {\n", + " return fig.toolbar_button_onmouseover(tooltip);\n", + " }\n", + " };\n", + " }\n", + "\n", + " fig.buttons = {};\n", + " var buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'btn-group';\n", + " var button;\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", + " /* Instead of a spacer, we start a new button group. */\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + " buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'btn-group';\n", + " continue;\n", + " }\n", + "\n", + " button = fig.buttons[name] = document.createElement('button');\n", + " button.classList = 'btn btn-default';\n", + " button.href = '#';\n", + " button.title = name;\n", + " button.innerHTML = '<i class=\"fa ' + image + ' fa-lg\"></i>';\n", + " button.addEventListener('click', on_click_closure(method_name));\n", + " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", + " buttonGroup.appendChild(button);\n", + " }\n", + "\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = document.createElement('span');\n", + " status_bar.classList = 'mpl-message pull-right';\n", + " toolbar.appendChild(status_bar);\n", + " this.message = status_bar;\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = document.createElement('div');\n", + " buttongrp.classList = 'btn-group inline pull-right';\n", + " button = document.createElement('button');\n", + " button.classList = 'btn btn-mini btn-primary';\n", + " button.href = '#';\n", + " button.title = 'Stop Interaction';\n", + " button.innerHTML = '<i class=\"fa fa-power-off icon-remove icon-large\"></i>';\n", + " button.addEventListener('click', function (_evt) {\n", + " fig.handle_close(fig, {});\n", + " });\n", + " button.addEventListener(\n", + " 'mouseover',\n", + " on_mouseover_closure('Stop Interaction')\n", + " );\n", + " buttongrp.appendChild(button);\n", + " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", + " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", + "};\n", + "\n", + "mpl.figure.prototype._remove_fig_handler = function (event) {\n", + " var fig = event.data.fig;\n", + " if (event.target !== this) {\n", + " // Ignore bubbled events from children.\n", + " return;\n", + " }\n", + " fig.close_ws(fig, {});\n", + "};\n", + "\n", + "mpl.figure.prototype._root_extra_style = function (el) {\n", + " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", + "};\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function (el) {\n", + " // this is important to make the div 'focusable\n", + " el.setAttribute('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", + " } else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\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", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which === 13) {\n", + " this.canvas_div.blur();\n", + " // select the cell after this one\n", + " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", + " IPython.notebook.select(index + 1);\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", + " fig.ondownload(fig, null);\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(\n", + " 'matplotlib',\n", + " mpl.mpl_figure_comm\n", + " );\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=\"1000\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=[10,6])\n", + "\n", + "# -- valor máximo y mÃnimo de temperatura para poder definir valores del eje x\n", + "xmin = min( d_temp_min, ms_temp_min, g_temp_min, sg_temp_min )\n", + "xmax = max( d_temp_max, ms_temp_max, g_temp_max, sg_temp_max )\n", + "\n", + "# -- crear colores para las estrellas, de rojo (fria) a azul (caliente)\n", + "cmap = matplotlib.colors.LinearSegmentedColormap.from_list(\"\", [\"red\",\"yellow\",\"blue\"])\n", + "\n", + "# -- definir el tamaño del punto de acuerdo al radio\n", + "sd = all_stars['radius']\n", + "# -- x: temperatura, y: luminosidad, color: temperatura\n", + "# -- estoy haciendo el punto el doble del tamaño y el borde negro, solo porque me parece se ve mejor\n", + "# -- cmap: colores que defini un par de lineas arruba\n", + "\n", + "im = ax.scatter(all_stars['temp'], all_stars['lum'], c=all_stars['temp'],cmap=cmap)\n", + "\n", + "\n", + "# -- definir nombre de ejes y tÃtulo del gráfico\n", + "ax.set_xlabel('Temperatura (K)')\n", + "ax.set_ylabel('Luminosidad (L$_{sol}$) en escala logarÃtmica')\n", + "ax.set_title('Diagrama Hertzsprung-Russell', fontsize = 15)\n", + "\n", + "# -- definir limites del eje x, para que incremente de derecha a izquierda\n", + "ax.set_xlim(xmax+300, xmin-300)\n", + "# -- poner eje y en escala logarÃtimica para que se entienda mejor el gráfico\n", + "ax.set_yscale(\"log\")\n", + "\n", + "\n", + "# -- definir el label de cada grupo de estrellas, usando cantidad máximas y mÃnimas y ajustando\n", + "\n", + "\n", + "an1 = ax.annotate(' ', fontweight='bold', xy = ((d_temp_min+d_temp_max)/2, 2*(d_lum_max+d_lum_min)/2))\n", + "an2 = ax.annotate(' ', fontweight='bold', xy = (1.3*(ms_temp_min+ms_temp_max)/2, 5*(ms_lum_max+ms_lum_min)/2))\n", + "an3 = ax.annotate(' ', fontweight='bold', xy = (g_temp_max+700, (g_lum_max+g_lum_min)/2))\n", + "an4 = ax.annotate(' ', fontweight='bold', xy = ((sg_temp_min+sg_temp_max)/2, sg_lum_min*0.3))\n", + "\n", + "\n", + "fig.colorbar(im, ax=ax)\n", + "\n", + "\n", + "datas = list(zip(all_stars['temp'], all_stars['lum']))\n", + "\n", + "x,y = [],[]\n", + "r = []\n", + "def animate(i):\n", + " x.append(all_stars['temp'][i])\n", + " y.append(all_stars['lum'][i])\n", + " im.set_offsets(np.c_[x,y])\n", + " im.set_array(np.array(x))\n", + " r.append(all_stars['radius'][i])\n", + " im.set_sizes(np.array(r))\n", + " an1.set_text((text_d[i]))\n", + " an2.set_text((text_ms[i]))\n", + " an3.set_text((text_g[i]))\n", + " an4.set_text((text_sg[i]))\n", + "# an1.set_positon[posicion[107]]\n", + " return im\n", + "\n", + "# -- ES MEJOR VER EL GIF QUE SE GUARDA\n", + "ani = FuncAnimation (fig, animate, frames=106, interval=300)\n", + "#ani\n", + "#ani.save('sine_wave.gif')" + ] + }, + { + "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.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/sine_wave.gif b/sine_wave.gif new file mode 100644 index 0000000000000000000000000000000000000000..39eeb828158764e90e79a03bdfa4017680b391ac Binary files /dev/null and b/sine_wave.gif differ