DP03_07_Interactive_Catalog_Visualization.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "749b0ddf",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Interactive Solar System Catalog Visualization with Holoviews, Bokeh, and Datashader\n",
    "<img align=\"left\" src = https://project.lsst.org/sites/default/files/Rubin-O-Logo_0.png width=250 style=\"padding: 10px\" alt=\"Rubin Observatory logo, a graphical representation of turning stars into data.\">\n",
    "Contact author(s): Sarah Greenstreet <br>\n",
    "Last verified to run: 2024-12-18 <br>\n",
    "LSST Science Pipelines version: Weekly 2024_50 <br>\n",
    "Container Size: large <br>\n",
    "Targeted learning level: intermediate <br>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9da1a210-d858-42fe-8591-570965b8be1a",
   "metadata": {},
   "source": [
    "**Description:** Interactive Solar System catalog data visualizations with three open-source python libraries."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80a0baf5-51ad-40ec-8991-060a7b27c289",
   "metadata": {},
   "source": [
    "**Skills:** Create linked interactive plots for large datasets, and output interactive plots to interactive HTML files. Use Bokeh, HoloViews, and Datashader."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "393da88f-7978-4920-aa4a-a9830df6eed9",
   "metadata": {},
   "source": [
    "**LSST Data Products:** Solar System Object catalogs."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb8c7003-292c-4deb-b4a3-d5b2c6b73bd7",
   "metadata": {},
   "source": [
    "**Packages:** bokeh, holoviews, datashader"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f72b27f",
   "metadata": {},
   "source": [
    "**Credit:** This tutorial is based on the DP02 NB06b tutorial notebook developed by Leanne Guy. It has been adapted and extended to visualizing data in the DP0.3 simulated Solar System catalogs by Sarah Greenstreet."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28e91cbf-ab7f-4e26-9276-b00299d6065e",
   "metadata": {},
   "source": [
    "**Get Support:**\n",
    "Find DP0-related documentation and resources at <a href=\"https://dp0-3.lsst.io\">dp0-3.lsst.io</a>.\n",
    "Questions are welcome as new topics in the \n",
    "<a href=\"https://community.lsst.org/c/support/dp0\">Support - Data Preview 0 Category</a> \n",
    "of the Rubin Community Forum. \n",
    "Rubin staff will respond to all questions posted there."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfc73be0",
   "metadata": {},
   "source": [
    "## 1. Introduction\n",
    "\n",
    "The Rubin Science Platform was designed to enable scientific analysis of the LSST data sets, which will be unprecedentedly large and complex. \n",
    "The software and techniques that are best suited for visualizing large data sets might be new to many astronomers.\n",
    "This notebook introduces learners with some knowledge of python to three open-source Python libraries that enable powerful interactive visualization of catalogs.\n",
    " 1. [**HoloViews**](http://holoviews.org): Produce high-quality interactive visualizations easily by annotating plots and images rather than using direct calls to a plotting library.\n",
    " 2. [**Bokeh**](https://bokeh.org): A powerful data visualization library that provides interactive tools including brushing and linking between multiple plots.\n",
    " 3. [**Datashader**](https://datashader.org): Accurately render very large datasets quickly and flexibly.\n",
    "\n",
    "These packages are part of the [Holoviz](http://holoviz.org/) ecosystem of tools intended for visualization in a web browser and can be used to create quite sophisticated dashboard-like interactive displays and widgets. The goal of this tutorial is to provide an introduction and starting point from which to create more advanced, custom interactive visualizations of the DP0.3 simulated Solar System catalogs. Holoviz has a [vibrant and active community](https://discourse.holoviz.org/) where you can ask questions and discuss visualizations with a global community. \n",
    "\n",
    "> **Notice:** If the notebook or any interactive features seem to stall, first try going a few cells back and rerunning them in order (the order in which cells are run is imporant for this notebook's functionality). If that does not work, try restarting the kernel. If issues persist, try logging out and restarting the Notebook aspect using a \"large\" instance of the JupyterLab environment.\n",
    "\n",
    "> **Warning: It is not recommended to \"Restart Kernel and Run All Cells\" in this notebook, or to execute multiple cells very quickly.** Some of the examples require interaction (e.g., for the user to select points on a graph) in order to run correctly, and going too fast can cause some plots to not display properly."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc36f107",
   "metadata": {},
   "source": [
    "### 1.1. Import packages\n",
    "\n",
    "Import general scientific python packages (`os`, `numpy`, `pandas`),\n",
    "functions from the astronomy python package `astropy`,\n",
    "the Rubin function for accessing the TAP service (`lsst.rsp.get_tap_service`),\n",
    "and various functions from the `bokeh` and `holoviews` packages\n",
    "that are used in this tutorial."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7443ecf7-70d4-42ab-affc-b680b4548287",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "from lsst.rsp import get_tap_service\n",
    "\n",
    "from math import pi\n",
    "\n",
    "import bokeh\n",
    "from bokeh.io import output_notebook, show, output_file, reset_output\n",
    "from bokeh.models import ColumnDataSource, Range1d, HoverTool, CDSView\n",
    "from bokeh.plotting import figure, gridplot\n",
    "from bokeh.transform import factor_cmap, cumsum\n",
    "from bokeh.palettes import Colorblind\n",
    "\n",
    "import holoviews as hv\n",
    "from holoviews import streams, dim, opts\n",
    "from holoviews.operation.datashader import datashade, dynspread\n",
    "from holoviews.plotting.util import process_cmap\n",
    "\n",
    "import datashader as dsh"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53e556e6-6d9f-439f-8a00-4c44a64d12f2",
   "metadata": {},
   "source": [
    "Show which versions of Bokeh, HoloViews, and Datashader we are working with.\n",
    "This is important when referring to online documentation as APIs can change between versions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0f640fe-0065-4d31-aabd-181c824f46c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Bokeh version: \" + bokeh.__version__)\n",
    "print(\"HoloViews version: \" + hv.__version__)\n",
    "print(\"Datashader version: \" + dsh.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86fb1886-62d5-47db-bde0-f5fb02aa2b45",
   "metadata": {},
   "source": [
    "### 1.2. Define functions and parameters\n",
    "\n",
    "Update the maximum number of display rows for Pandas tables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a79aa99-518b-46de-a0cc-d97c4f1ea301",
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.set_option('display.max_rows', 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71b70386-3f45-4216-ae44-cbefd4529785",
   "metadata": {},
   "source": [
    "> **Notice:** The ordering of the next two cells is important for ensuring the plots in this notebook render properly."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9821622-91a6-447d-a33a-27298f388a39",
   "metadata": {},
   "source": [
    "Set the display of the output Bokeh plots to be inline, in the notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15368dd8-20f8-41c5-b878-e9ccb8bfbe71",
   "metadata": {},
   "outputs": [],
   "source": [
    "output_notebook()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c76d78ec-98d0-4f7b-a6cf-14c30a323ce1",
   "metadata": {},
   "source": [
    "Set the HoloViews plotting library to be bokeh. \n",
    "The HoloViews and Bokeh icons are displayed when the library is loaded successfully."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "141e7645-6ee4-449f-a000-46e8502f9414",
   "metadata": {},
   "outputs": [],
   "source": [
    "hv.extension('bokeh')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "513255e6-f3f6-4199-aa2c-3903ec6332e6",
   "metadata": {},
   "source": [
    "> **Notice:** Sometimes the `bokeh.io.show` function can be finicky when output modes are switched (e.g., from inline to an HTML file and back again).\n",
    "\n",
    "To avert a \"Models must be owned by only a single document\" error (see, e.g., <a href=\"https://github.com/bokeh/bokeh/issues/8579\">https://github.com/bokeh/bokeh/issues/8579</a>), define the following two functions and use them in Section 4."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "50f5ccbe-829e-4d12-a05b-1dbfcec762b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_bokeh_inline(p):\n",
    "    try:\n",
    "        reset_output()\n",
    "        output_notebook()\n",
    "        show(p)\n",
    "    except Exception:\n",
    "        output_notebook()\n",
    "        show(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "28d3a2bb-46e2-444f-8afe-2bf5efeda43a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_bokeh_to_file(p, outputFile):\n",
    "    try:\n",
    "        reset_output()\n",
    "        output_file(outputFile)\n",
    "        show(p)\n",
    "    except Exception:\n",
    "        output_file(outputFile)\n",
    "        show(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0aed4254-e651-4fcd-9a10-228e81ad8b14",
   "metadata": {},
   "source": [
    "Define a function to convert a given perihelion distance ($q$) and eccentricity ($e$) to an orbital semimajor axis ($a$). Their relationship is defined by $q = a * (1 - e)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d02e77b-875a-4638-b345-33e2f31cf772",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calc_semimajor_axis(q, e):\n",
    "    \"\"\"\n",
    "    Given a perihelion distance and orbital eccentricity,\n",
    "    calculate the semi-major axis of the orbit.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    q: ndarray\n",
    "        Distance at perihelion, in au.\n",
    "    e: ndarray\n",
    "        Orbital eccentricity.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    a: ndarray\n",
    "        Semi-major axis of the orbit, in au.\n",
    "        q = a(1-e), so a = q/(1-e)\n",
    "    \"\"\"\n",
    "\n",
    "    return q / (1.0 - e)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a5e03f9-3dbb-463c-bd90-2fdc91c55cf0",
   "metadata": {},
   "source": [
    "Define a function to convert a given perihelion distance ($q$) and eccentricity ($e$) to an aphelion distance ($Q$). Their relationship is defined by $Q = q * (1 + e) / (1 - e)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3f1d94c7-a794-4d35-b0a2-fbdff533e242",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calc_aphelion(q, e):\n",
    "    \"\"\"\n",
    "    Given a perihelion distance and orbital eccentricity,\n",
    "    calculate the semi-major axis of the orbit.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    q: ndarray\n",
    "        Distance at perihelion, in au.\n",
    "    e: ndarray\n",
    "        Orbital eccentricity.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    Q: ndarray\n",
    "        Distance at aphelion, in au.\n",
    "        Q = q*(1+e)/(1-e)\n",
    "    \"\"\"\n",
    "\n",
    "    return q * (1.0 + e) / (1.0 - e)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0ea4b66-0be5-492f-8818-04d190480570",
   "metadata": {
    "tags": []
   },
   "source": [
    "## 2. Use the TAP service to obtain table data\n",
    "\n",
    "The basis for any data visualization is the underlying data. This tutorial works with tabular data that is retrieved from the DP0.3 simulated Solar System catalogs using the Rubin TAP service."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aadb2a7a-ab69-425b-bac2-2c1c3a5fc81e",
   "metadata": {},
   "source": [
    "Get a Rubin TAP service instance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a751e381-022e-45e1-b307-43ea2d3d8aef",
   "metadata": {},
   "outputs": [],
   "source": [
    "service = get_tap_service(\"ssotap\")\n",
    "assert service is not None"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d34680d-7713-4527-90e1-deb4bb660555",
   "metadata": {},
   "source": [
    "Define the orbital parameter boundaries for querying the DP0.3 catalogs for all main-belt asteroids, as an additional example subset of Solar System objects to explore with these data visualization tools. Create a query for the DP0.3 MPCORB and SSObject catalogs for the orbital parameters above to obtain a sample of main-belt asteroids with semimajor axis 1.8 < $a$ < 3.7 au, eccentricity $e$ < 1.0, and perihelion $q$ > 1.3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "61616064-dca5-486f-a556-819c3c88b7c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "a_MBA_min = 1.8\n",
    "a_MBA_max = 3.7\n",
    "q_MBA_min = 1.3\n",
    "e_MBA_max = 1.0\n",
    "\n",
    "query = \"\"\"\n",
    "SELECT\n",
    "    mpc.ssObjectId, mpc.mpcDesignation, mpc.mpcNumber,\n",
    "    mpc.mpcH, mpc.e, mpc.q, mpc.incl, mpc.n,\n",
    "    sso.arc, sso.numObs, sso.g_H, sso.r_H, sso.i_H, sso.z_H\n",
    "FROM\n",
    "    dp03_catalogs_10yr.MPCORB as mpc\n",
    "INNER JOIN dp03_catalogs_10yr.SSObject as sso\n",
    "ON mpc.ssObjectId = sso.ssObjectId\n",
    "WHERE mpc.q/(1.0-mpc.e) > {}\n",
    "        AND mpc.q/(1.0-mpc.e) < {}\n",
    "        AND mpc.e < {}\n",
    "        AND mpc.q > {}\n",
    "        ORDER by sso.ssObjectId\n",
    "\"\"\".format(a_MBA_min, a_MBA_max, e_MBA_max, q_MBA_min)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "003844a5-e62b-48d9-948b-2b08467ca693",
   "metadata": {},
   "source": [
    "Run the query."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d80d72d0-a945-486e-a2e8-6a3d84cb0267",
   "metadata": {},
   "outputs": [],
   "source": [
    "job = service.submit_job(query)\n",
    "job.run()\n",
    "job.wait(phases=['COMPLETED', 'ERROR'])\n",
    "print('Job phase is', job.phase)\n",
    "assert job.phase == 'COMPLETED'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee3d3aa6-2624-46c2-b7f0-0e448de4c9c2",
   "metadata": {},
   "source": [
    "Retrieve the query results as a pandas table."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7cab1427-196c-42b5-887b-543f7209c6b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "uniqueMBAs = job.fetch_result().to_table().to_pandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34666bb2-3b0b-474b-bd95-d3c69338f1c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "uniqueMBAs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4af81f33-fb96-4a3e-8eff-0774eb1f4c8b",
   "metadata": {},
   "source": [
    "Calculate the semimajor axis $a$ for all objects in `uniqueMBAs` and add as a new column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8e9553e-a41d-42cf-9d8e-babad8569add",
   "metadata": {},
   "outputs": [],
   "source": [
    "a_MBAs = calc_semimajor_axis(uniqueMBAs['q'], uniqueMBAs['e'])\n",
    "uniqueMBAs['a'] = a_MBAs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34d32517-5ae2-4014-a2c4-68b79f77737e",
   "metadata": {},
   "source": [
    "Calculate the aphelion distance $Q$ for all objects in `uniqueMBAs` and add as a new column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "86b9a029-5a58-4e3b-a94f-33ec3117775d",
   "metadata": {},
   "outputs": [],
   "source": [
    "Q_MBAs = calc_aphelion(uniqueMBAs['q'], uniqueMBAs['e'])\n",
    "uniqueMBAs['Q'] = Q_MBAs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3bba56a8-4792-4a87-b1b4-60a168327a37",
   "metadata": {},
   "source": [
    "Define the conditions for assigning MBAs to their dynamical classifications (Note: the conditions used here are simplified to only include limits in semimajor axis and not eccentricity or inclination for the purposes of this tutorial)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "938f7e8a-6e4f-4a17-b9a9-ee03260a8d7c",
   "metadata": {},
   "outputs": [],
   "source": [
    "MBApop_conditions = [\n",
    "    (uniqueMBAs['a'] >= 1.8) & (uniqueMBAs['a'] < 2.0),\n",
    "    (uniqueMBAs['a'] >= 2.0) & (uniqueMBAs['a'] < 2.5),\n",
    "    (uniqueMBAs['a'] >= 2.5) & (uniqueMBAs['a'] < 2.82),\n",
    "    (uniqueMBAs['a'] >= 2.82) & (uniqueMBAs['a'] < 3.25),\n",
    "    (uniqueMBAs['a'] >= 3.25) & (uniqueMBAs['a'] <= 3.7)\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02077101-f431-46ba-aaa3-34da10d91954",
   "metadata": {},
   "source": [
    "Define the names of the MBA dynamical classes as they correspond to the `MBApop_conditions` above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "00c035ab-c756-4bf0-927c-b2635b4d5dbb",
   "metadata": {},
   "outputs": [],
   "source": [
    "MBApop_types = ['Hungaria', 'Inner Belt',\n",
    "                'Middle Belt', 'Outer Belt',\n",
    "                'Cybele']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0028a068-9f00-496a-b969-603efce2728b",
   "metadata": {},
   "source": [
    "Determine the MBA population for each object in `uniqueMBAs` and add as a new column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49d188d2-2cb2-424d-acae-7c8e82d6e05c",
   "metadata": {},
   "outputs": [],
   "source": [
    "uniqueMBAs['MBApop'] = np.select(MBApop_conditions, MBApop_types)\n",
    "uniqueMBAs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da19cae9-c285-4fcb-8a1b-c98f55dd1dfd",
   "metadata": {},
   "outputs": [],
   "source": [
    "uniqueMBAs['MBApop'].value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31e9cf1b-2b02-4c92-b34d-b9215950bd3f",
   "metadata": {},
   "source": [
    "To visualize the fraction of MBAs in each population, a pie chart can be created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c2b89ed0-6de8-4c71-9d40-d24d27725be5",
   "metadata": {},
   "outputs": [],
   "source": [
    "MBApop_counts = uniqueMBAs['MBApop'].value_counts().to_dict()\n",
    "data = pd.Series(MBApop_counts).reset_index(name='value').rename(\n",
    "    columns={'index': 'subpop'})\n",
    "data['angle'] = data['value']/data['value'].sum() * 2*pi\n",
    "data['color'] = Colorblind[len(MBApop_counts)]\n",
    "\n",
    "MBApop = figure(height=350, title=\"MBA Populations\",\n",
    "                toolbar_location=None, tools=\"hover\",\n",
    "                tooltips=\"@subpop: @value\", x_range=(-0.5, 1.0))\n",
    "\n",
    "MBApop.wedge(x=0, y=1, radius=0.4,\n",
    "             start_angle=cumsum('angle', include_zero=True),\n",
    "             end_angle=cumsum('angle'),\n",
    "             line_color=\"white\", fill_color='color',\n",
    "             legend_field='subpop', source=data)\n",
    "\n",
    "MBApop.axis.axis_label = None\n",
    "MBApop.axis.visible = False\n",
    "MBApop.grid.grid_line_color = None\n",
    "\n",
    "show_bokeh_inline(MBApop)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82df3b07-05f1-4f6f-882f-6d2fa8aa2edb",
   "metadata": {},
   "source": [
    "> Figure 1: Pie chart showing the fraction of objects in each MBA population."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b6d0635-0e4e-4584-ba08-5c17a0fc01c8",
   "metadata": {},
   "source": [
    "Compute three colors from the apparent magnitudes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f649a247-25b8-4ceb-ac77-3892596455c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "uniqueMBAs['gmi'] = uniqueMBAs['g_H'] - uniqueMBAs['i_H']\n",
    "uniqueMBAs['rmi'] = uniqueMBAs['r_H'] - uniqueMBAs['i_H']\n",
    "uniqueMBAs['gmr'] = uniqueMBAs['g_H'] - uniqueMBAs['r_H']\n",
    "uniqueMBAs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9400f485-c38c-4046-93a0-be30a7606ade",
   "metadata": {},
   "source": [
    "## 3. Holoviews\n",
    "\n",
    "[Holoviews](https://holoviews.org/) supports easy analysis and visualization by annotating data rather than utilizing direct calls to plotting packages. This tutorial uses Bokeh as the plotting library backend for HoloViews. **HoloViews supports several plotting libraries, and exercise 1 in Section 5 is to explore using HoloViews with other plotting packages.**\n",
    "\n",
    "Create a random subsample of 20,000 MBAs from `uniqueMBAs` to use to demonstrate some basic HoloViews functionality. Print the length of this subset and confirm that it contains roughly 20K objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "225d8042-829c-4a5b-82fd-de40009ac002",
   "metadata": {},
   "outputs": [],
   "source": [
    "frac = 0.005\n",
    "data20K_MBAs = uniqueMBAs.sample(frac=frac, axis='index')\n",
    "print(len(data20K_MBAs))\n",
    "assert len(data20K_MBAs) == round(frac * len(uniqueMBAs))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "daf507cd-afa5-4448-8506-0ef82d3ef4e9",
   "metadata": {},
   "source": [
    "### 3.1. Single plots\n",
    "\n",
    "The basic core primitives of HoloViews are [Elements](http://holoviews.org/Reference_Manual/holoviews.element.html) (`hv.Element`). Elements are simple wrappers for data which provide a semantically meaningful visual representation. An Element may be a set of Points, an Image, a Curve, a Histogram, etc. See the HoloViews [Reference Gallery](http://holoviews.org/reference/index.html) for all the various types of Elements that can be created with HoloViews.\n",
    "\n",
    "The example in this section uses the HoloViews [Scatter Element](http://holoviews.org/reference/elements/bokeh/Scatter.html) to quickly visualize the catalog data as a scatter plot.\n",
    "\n",
    "Instead of subsetting a dataset to choose which columns to plot, HoloViews allows the user to specify the dimensionality directly. `kdims` are the key dimensions or the independent variable(s) and `vdims` are the value dimensions or the dependenent variable(s). The dimensions have to be specified as strings as below, but they are in fact rich objects. Dimension objects support a long descriptive label, which complements the short programmer-friendly name.\n",
    "\n",
    "HoloViews maintains a strict separation between content and presentation. This separation is achieved by maintaining sets of keyword values as `options` that specify how `Elements` are to appear.\n",
    "\n",
    "This example plots the semimajor axes and eccentricities with chosen x-axis limits, fontscale, plot height and width, and removes the toolbar.\n",
    "\n",
    "Make a simple scatter plot of the data using the Scatter element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f2125ff3-20bf-4ac1-9d3e-ce8326243f76",
   "metadata": {},
   "outputs": [],
   "source": [
    "aeplot = hv.Scatter(data20K_MBAs, kdims=['a'],\n",
    "                    vdims=['e']).options(xlim=(1.8, 3.7), toolbar=None,\n",
    "                                         fontscale=1.2, height=350, width=350)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a1548998-10f9-40f2-a12f-8a218fde24df",
   "metadata": {},
   "outputs": [],
   "source": [
    "aeplot"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6f11253-f10b-4d5a-8b3b-a08050e383d8",
   "metadata": {},
   "source": [
    "> Figure 2: A non-interactive plot of semimajor axis $a$ vs. eccentricity $e$ appears as a blue circle composed of individual, but mostly blended, blue dots."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ee1cfa8-a98d-426b-b796-30f3b303cca6",
   "metadata": {},
   "source": [
    "The `data20K` set contains several columns. If no columns are specified explicitly, the first 2 columns are taken for x and y respectively by the Scatter Element.\n",
    "\n",
    "Now bin the data in semimajor axis $a$ using the robust Freedman Diaconis Estimator, plot the resulting distribution using the HoloViews Histogram Element, and add in some basic plot options. Read more about about customizing plots via `options`. Note that `options` can be shortened to `opts`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b144e1c-36d4-4d9b-8192-da86c758a463",
   "metadata": {},
   "outputs": [],
   "source": [
    "(H_bin, count) = np.histogram(data20K_MBAs['mpcH'], bins='fd')\n",
    "H_distribution = hv.Histogram((H_bin, count)).opts(\n",
    "    title=\"H Magnitude Distribution\", color='darkmagenta',\n",
    "    xlabel='H mag', fontscale=1.2,\n",
    "    height=400, width=400)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb87012a-84ce-4ba4-abd8-ba8fa75ffca4",
   "metadata": {},
   "outputs": [],
   "source": [
    "H_distribution"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac7e71bf-8cf3-418c-a443-ea165654468a",
   "metadata": {},
   "source": [
    "> Figure 3: A histogram (bar chart in purple) of the number of objects in a given $H$ magnitude bin in the subset of twenty thousand objects. This plot is interactive and displays a tool bar at right for the user to, e.g., zoom in on the plot."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcc4e56e-0e85-4c2a-aa7c-bb81c719f5d0",
   "metadata": {},
   "source": [
    "### 3.2. Layouts of unlinked plots\n",
    "\n",
    "Create a layout of several plots. A `Layout` is a type of `Container` that can contain any HoloViews object. Other types of `Containers` that exist include `Overlay`, `Gridspace`, `Dynamicmap`, etc. See the HoloViews [Reference Gallery](http://holoviews.org/reference/index.html) for the full list of `Layouts` that can be created with HoloViews. See [Building Composite Objects](http://holoviews.org/user_guide/Building_Composite_Objects.html) for the full details about the ways `Containers` can be composed.\n",
    "\n",
    "Slice the data and set some more options, and then construct a layout using the `+` operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e41f621-1e0b-4634-a2c5-827d28f90d8c",
   "metadata": {},
   "outputs": [],
   "source": [
    "aeplot = hv.Scatter(data20K_MBAs, kdims=['a'],\n",
    "                    vdims=['e']).opts(\n",
    "    title=\"Semimajor Axis vs Eccentricity\",\n",
    "    toolbar='above', tools=['hover'],\n",
    "    height=350, width=350, alpha=0.2,\n",
    "    size=2)\n",
    "\n",
    "OrbHPlots = aeplot + H_distribution.options(height=350, width=350)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0ee38d2e-5f6d-4610-88ef-38d50a608308",
   "metadata": {},
   "outputs": [],
   "source": [
    "OrbHPlots"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13e512a0-be9e-4172-839b-0a293694cc5b",
   "metadata": {},
   "source": [
    "> Figure 4: Two side-by-side plots, Fig 2 from above on the left with the `hover` tool, and Fig 3 from above on the right, with the interactive toolbar at upper right."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d9f6611-1bc0-4dd8-9eef-11149949830a",
   "metadata": {},
   "source": [
    "Note that these two plots above are not linked, they are two independent plots laid out next to each other.\n",
    "\n",
    "Zoom in on the Semimajor Axis vs Eccentricity plot and notice that the data are not rebinned in the semimajor axis distribution plot. Linking plots is demonstrated below.\n",
    "\n",
    "The tools, however, do apply to both plots. Try modifying both plots and then use the \"reset\" tool (the circular arrow symbol). Notice that both plots are reset to their original states."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6333d008-bb5b-464d-b47a-a62d622ab8bd",
   "metadata": {},
   "source": [
    "### 3.3. Layouts of linked plots\n",
    "\n",
    "Set up some default plot options to avoid duplicating long lists for every new plot.\n",
    "\n",
    "Different plotting packages typically provide different customization capabilities. Below, one set of options is defined for a Bokeh backend, and one for a matplotlib backend.\n",
    "\n",
    "Set Bokeh customizations as a python dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ab617564-6f3d-480b-afba-743daca8ae05",
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_style_bkh = dict(alpha=0.5, color='darkmagenta',\n",
    "                      marker='triangle', size=3,\n",
    "                      xticks=5, yticks=5,\n",
    "                      height=400, width=400,\n",
    "                      toolbar='above')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2115039-83ad-4316-8820-b8f0ed428d87",
   "metadata": {},
   "source": [
    "Set matplotlib customizations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3964c246-8535-47c5-929d-0c1a8ae9033b",
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_style_mpl = dict(alpha=0.2, color='c', marker='s',\n",
    "                      fig_size=200, s=2,\n",
    "                      fontsize=14, xticks=8, yticks=8)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a79d3a9-7475-4ff6-a883-b77371cce234",
   "metadata": {},
   "source": [
    "Choose to use the Bokeh plot style."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64822b3d-1ab8-475d-93b9-a5af7ef9ed23",
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_style = plot_style_bkh"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1c033f2-b108-499c-a9b9-dd734e61765f",
   "metadata": {},
   "source": [
    "Below, create a color-color diagram of the MBAs in the dataset, and also display the distribution of samples along both value dimensions using the `hist()` method of the [Scatter Element](http://holoviews.org/reference/elements/bokeh/Scatter.html).\n",
    "\n",
    "Set the axes as rich objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "504758b1-eced-4544-9ec5-96f095e2d39f",
   "metadata": {},
   "outputs": [],
   "source": [
    "rmi = hv.Dimension('rmi', label='(r-i)', range=(-1.0, 1.0))\n",
    "gmr = hv.Dimension('gmr', label='(g-r)', range=(-0.5, 1.5))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "752e24c6-61d3-4c34-8fe8-8354cc6aab0e",
   "metadata": {},
   "source": [
    "Create the scatter plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19755d1b-dfb4-4b09-9bfc-9543e53380e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "col_col = hv.Scatter(data20K_MBAs, kdims=gmr,\n",
    "                     vdims=rmi).opts(**plot_style)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afa448e9-c569-44e4-a6ba-aef163e195b6",
   "metadata": {},
   "source": [
    "Use the hist method to show the distribution of samples along both value dimensions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "93f2105d-472d-48ee-9b35-055de8f6169f",
   "metadata": {},
   "outputs": [],
   "source": [
    "col_col = col_col.hist(dimension=[gmr, rmi],\n",
    "                       num_bins=100, adjoin=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15fa1a3c-fc8f-45a6-9324-e416a4607da4",
   "metadata": {},
   "outputs": [],
   "source": [
    "col_col"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c83f108-09b0-4483-9b6b-4e95c5e0f92d",
   "metadata": {},
   "source": [
    "> Figure 5: The r-i color versus the g-r color (purple triangles), with histograms (blue bar charts) of the color distributions above and to the right. The interactive tool bar is at upper right."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7138ba5f-78f7-41fe-89cb-9eda6831f2a6",
   "metadata": {},
   "source": [
    "## 4. Bokeh\n",
    "\n",
    "A very useful feature of Bokeh is the ability to add connected interactivity between plots that show different attributes of the same data. **This is called linking.**\n",
    "\n",
    "With linked plots it is possible to carry out data **brushing**, whereby data can be selected and manipulated synchronously across multiple linked plots.\n",
    "\n",
    "For example, if an orbital element plot is linked with a colour-magnitude diagram of the same dataset, it becomes possible to interactively explore the relationship between the positions of objects in each plot.\n",
    "\n",
    "This section uses the Bokeh plotting library to demonstrate how to set up brushing and linking between two panels showing different representations of the same dataset. A selection applied to either panel will highlight the selected points in the other panel.\n",
    "\n",
    "This section is based on [Bokeh linked brushing](http://bokeh.pydata.org/en/latest/docs/user_guide/interaction/linking.html#linked-brushing)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6b8c18a-acb2-4dc3-b10d-364354ef6f1d",
   "metadata": {},
   "source": [
    "### 4.1. Data preparation\n",
    "Getting the data preparation phase right is key to creating powerful visualizations. Bokeh works with a ColumnDataSource (CDS). A CDS is essentially a collection of sequences of data that have their own unique column name.\n",
    "\n",
    "The CDS is the core of bokeh plots. Bokeh automatically creates a CDS from data passed as python lists or numpy arrays. CDS are useful as they allow data to be shared between multiple plots and renderers, enabling brushing and linking.\n",
    "\n",
    "Below, a CDS is created from the data returned by the query above and passed directly to Bokeh.\n",
    "\n",
    "Create a CDS for the plots to share. The data defined as `x0`, `y0`, `x1`, `y1` will be used to plot the left and right plots, respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e64a858-1a74-4fb3-b8e0-02567fc7342b",
   "metadata": {},
   "outputs": [],
   "source": [
    "col_data = dict(x0=data20K_MBAs['a'],\n",
    "                y0=data20K_MBAs['incl'],\n",
    "                x1=data20K_MBAs['gmr'],\n",
    "                y1=data20K_MBAs['rmi'],\n",
    "                a=data20K_MBAs['a'],\n",
    "                ecc=data20K_MBAs['e'],\n",
    "                incl=data20K_MBAs['incl'],\n",
    "                Hmag=data20K_MBAs['mpcH'],\n",
    "                gmi=data20K_MBAs['gmi'],\n",
    "                rmi=data20K_MBAs['rmi'],\n",
    "                gmr=data20K_MBAs['gmr'],\n",
    "                MBApop=data20K_MBAs['MBApop'],\n",
    "                g_H=data20K_MBAs['g_H'],\n",
    "                r_H=data20K_MBAs['r_H'],\n",
    "                i_H=data20K_MBAs['i_H'],\n",
    "                z_H=data20K_MBAs['z_H'])\n",
    "source_MBAs = ColumnDataSource(data=col_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a835430-bed8-4396-96e2-6157e6392737",
   "metadata": {},
   "source": [
    "Additional data can be added to the CDS after creation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "16fbe6e1-1301-446b-984e-5d5fe915f1d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "source_MBAs.data['mpcDesignation'] = data20K_MBAs['mpcDesignation']\n",
    "source_MBAs.data['q'] = data20K_MBAs['q']\n",
    "source_MBAs.data['arc'] = data20K_MBAs['arc']/365.25\n",
    "source_MBAs.data['numObs'] = data20K_MBAs['numObs']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "deb6ca6a-b7b4-4582-9700-511cec7a5127",
   "metadata": {},
   "source": [
    "The pointsize used for plotting can be defined based on a given parameter. Define the conditions for assigning a point size for each MBA to be plotted based on its $H$ magnitude."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c14cd3c-4164-4032-a3ea-b321e4896c5f",
   "metadata": {},
   "outputs": [],
   "source": [
    "pointconditions_fromH = [\n",
    "    (data20K_MBAs['mpcH'] <= 5.),\n",
    "    (data20K_MBAs['mpcH'] <= 10.) & (data20K_MBAs['mpcH'] > 5.),\n",
    "    (data20K_MBAs['mpcH'] <= 15.) & (data20K_MBAs['mpcH'] > 10.),\n",
    "    (data20K_MBAs['mpcH'] <= 20.) & (data20K_MBAs['mpcH'] > 15.),\n",
    "    (data20K_MBAs['mpcH'] <= 25.) & (data20K_MBAs['mpcH'] > 20.),\n",
    "    (data20K_MBAs['mpcH'] <= 30.) & (data20K_MBAs['mpcH'] > 25.)\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8648c2a8-a98b-4ff3-b11c-7146e5e0f5e8",
   "metadata": {},
   "source": [
    "Define the point sizes for the given $H$ magnitude ranges in `pointconditions_fromH` above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b6f4bd9f-cc65-4de7-8967-4015650fc395",
   "metadata": {},
   "outputs": [],
   "source": [
    "pointsize_fromH = [12, 10, 8, 6, 4, 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da2f9602-966a-4e66-ac07-c7b8355cf34f",
   "metadata": {},
   "source": [
    "Determine the point size bin for each object and add it to the source."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a55af791-7d2a-4107-9267-ec6e01830b43",
   "metadata": {},
   "outputs": [],
   "source": [
    "pointsize_bin = np.select(pointconditions_fromH, pointsize_fromH)\n",
    "source_MBAs.data['pointsize_bin'] = pointsize_bin"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25e9dfe7-4540-43bd-8d40-b21b251f8cf2",
   "metadata": {},
   "source": [
    "Create a \"points\" view."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0909c71a-7f63-48e0-8680-f6088fff698c",
   "metadata": {},
   "outputs": [],
   "source": [
    "points = CDSView()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5819679e-c80d-4269-9b2b-c78e29591a39",
   "metadata": {},
   "source": [
    "### 4.2. Linked plots with data brushing\n",
    "Use Bokeh to plot semimajor axis vs eccentricity and semimajor axis vs inclination, and then link them.\n",
    "\n",
    "Create a custom hover tool for each panel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dccb5b33-e872-4285-9b59-7d943ee30362",
   "metadata": {},
   "outputs": [],
   "source": [
    "hover_left = HoverTool(tooltips=[(\"mpcDesignation\", \"@mpcDesignation\"),\n",
    "                                 (\"MBApop\", \"@MBApop\"),\n",
    "                                 (\"(a,e,inc, H)\", \"(@a, @ecc, @incl, @Hmag)\"),\n",
    "                                 (\"(g,r,i,z)\", \"(@g_H, @r_H, @i_H, @z_H)\"),\n",
    "                                 (\"(g-i), (r-i), (g-r)\",\n",
    "                                  \"(@gmi), (@rmi), (@gmr)\")\n",
    "                                 ])\n",
    "hover_right = HoverTool(tooltips=[(\"mpcDesignation\", \"@mpcDesignation\"),\n",
    "                                  (\"MBApop\", \"@MBApop\"),\n",
    "                                  (\"(a,e,inc, H)\", \"(@a, @ecc, @incl, @Hmag)\"),\n",
    "                                  (\"(g,r,i,z)\", \"(@g_H, @r_H, @i_H, @z_H)\"),\n",
    "                                  (\"(g-i), (r-i), (g-r)\",\n",
    "                                   \"(@gmi), (@rmi), (@gmr)\")\n",
    "                                  ])\n",
    "tools = \"box_zoom,box_select,lasso_select,reset,help\"\n",
    "tools_left = [hover_left, tools]\n",
    "tools_right = [hover_right, tools]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "864b8eac-ca00-4122-81ff-9a534cef3e81",
   "metadata": {},
   "source": [
    "Create a new two-panel plot and add a renderer. Use the \"points\" view defined above.\n",
    "\n",
    "Create the left-side plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "085f56c5-31bc-4173-b5b4-d69aadef7894",
   "metadata": {},
   "outputs": [],
   "source": [
    "left = figure(tools=tools_left, width=400, height=400,\n",
    "              title='Semimajor Axis vs Inclination')\n",
    "left.scatter('x0', 'y0', hover_color='firebrick',\n",
    "             size='pointsize_bin', alpha=0.7, source=source_MBAs, view=points)\n",
    "\n",
    "left.x_range = Range1d(1.7, 3.7)\n",
    "left.y_range = Range1d(0., 55.)\n",
    "left.xaxis.axis_label = 'Semimajor Axis (au)'\n",
    "left.yaxis.axis_label = 'Inclination (deg)'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41ef53dc-1c91-4ac9-a858-967c706f7619",
   "metadata": {},
   "source": [
    "Create the right-side plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59952236-cfe2-4d54-a37b-e1b5a8ee2ec8",
   "metadata": {},
   "outputs": [],
   "source": [
    "right = figure(tools=tools_right, width=400, height=400,\n",
    "               title='Color-Color')\n",
    "right.scatter('x1', 'y1', hover_color='firebrick',\n",
    "              size='pointsize_bin', alpha=0.8, source=source_MBAs, view=points)\n",
    "\n",
    "right.x_range = Range1d(-0.5, 1.5)\n",
    "right.y_range = Range1d(-1., 1.)\n",
    "right.xaxis.axis_label = '(g - r)'\n",
    "right.yaxis.axis_label = '(r - i)'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "025670ce-05f1-4fe1-90dc-98972b99ee3a",
   "metadata": {},
   "source": [
    "Display the grid of plots. This can take a moment to render."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "533a1b5a-1b62-47bf-b2fd-7174309cd703",
   "metadata": {},
   "outputs": [],
   "source": [
    "p = gridplot([[left, right]])\n",
    "show_bokeh_inline(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8634921e-448f-4a00-9f7c-37c01581af97",
   "metadata": {},
   "source": [
    ">Figure 6: At left, MBA semimajor axis vs eccentricity, and at right, MBA semimajor axis vs inclination. All points are blue circles and the interactive toolbar is at upper right."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "376648d9-ca9a-401f-b138-7be37569c31f",
   "metadata": {},
   "source": [
    "Use the hover tool to see information about individual data points (e.g., the \"mpcDesignation\"). This information should appear automatically when the mouse is hovered over the data points. Notice the data points highlighted in red on one panel with the hover tool are also highlighted on the other panel.\n",
    "\n",
    "Next, click on the selection box icon or the selection lasso icon found in the upper right corner of the figure. Use the selection box and selection lasso to make various selections in either panel by clicking and dragging on either panel. The selected data points will be displayed in the other panel."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa3672d5-1692-4beb-8301-e5e9007ad54b",
   "metadata": {},
   "source": [
    "### 4.3. Output to interactive HTML file\n",
    "Output this interactive plot to an interactive HTML file.\n",
    "\n",
    "Define the output file name to store it in the home directory `~/.`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4a4dbb77-dd5b-437c-93fc-1e2b0d527e6a",
   "metadata": {},
   "outputs": [],
   "source": [
    "outputDir = os.path.expanduser('~')\n",
    "outputFileName = 'draft_DP03_advanced_plots_plot1.html'\n",
    "outputFile = os.path.join(outputDir, outputFileName)\n",
    "\n",
    "print('The full pathname of the interactive HTML file will be '+outputFile)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c1d8618-107e-4e57-90c2-9607b7cc49fe",
   "metadata": {},
   "source": [
    "Use the `bokeh.io.show` method, embedded in the `show_bokeh_to_file` function defined in Section 1.2 above, to output the interactive HTML file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75dbf93e-93e7-4ef0-a68f-153719be6a66",
   "metadata": {},
   "outputs": [],
   "source": [
    "show_bokeh_to_file(p, outputFile)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75203c15-c6a1-472e-a378-c3afa2d9056d",
   "metadata": {},
   "source": [
    "To view the interactive HTML file navigate to it via the directory listing in the left-hand side panel of this Jupyter notebook graphical interface, and click on its name. This will open another tab containing the HTML file.\n",
    "\n",
    "Since the file is relatively small (about 3.6 MB) it should load quickly (within a few seconds). Once loading is complete, click on the \"Trust HTML\" button at the top-left of the tab's window. Then, a near-duplicate of the two linked plots above should be displayed.\n",
    "\n",
    "It is also possible to download the HTML file, interact with it in a browser as a a local file."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df84b759-47a7-4f2a-8f91-e69c284c3d1d",
   "metadata": {},
   "source": [
    "### 4.4. Linked streams\n",
    "To do subsequent calculations with the set of selected points, it is possible to use HoloViews linked streams for custom interactivity. The following visualization is a modification of this example.\n",
    "\n",
    "As for the example above, the plots generated below use the selection box and selection lasso to choose data points on the left panel, and then the selected points appear in the right panel.\n",
    "\n",
    "Notice that as the selection is changed in the left panel, the mean x- and y-values for selected data points are shown in the title of the right panel.\n",
    "\n",
    "This section is based on [HoloViews Selection1D points](https://holoviews.org/reference/streams/bokeh/Selection1D_points.html).\n",
    "\n",
    "Declare some points, and define a selection for the stream."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "11472038-0312-4315-8757-ab0ca32ecda6",
   "metadata": {},
   "outputs": [],
   "source": [
    "points = hv.Points((data20K_MBAs['gmr'],\n",
    "                    data20K_MBAs['rmi'])).options(\n",
    "    tools=['box_select', 'lasso_select'])\n",
    "\n",
    "selection = streams.Selection1D(source=points)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97a3e9a4-276c-4e02-8e3a-600a25887da6",
   "metadata": {},
   "source": [
    "Define a function that uses the selection indices to slice points and compute statistics. This function is defined here (and not in Section 1.2) because it is only used in the subsequent (i.e., it is not a globally defined and used function)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "874020a2-1719-419b-89e2-0212be20f1fe",
   "metadata": {},
   "outputs": [],
   "source": [
    "def selected_info(index) -> str:\n",
    "    selected = points.iloc[index]\n",
    "    if index:\n",
    "        label = 'Mean (g-r), (r-i): %.3f, %.3f' % tuple(\n",
    "            selected.array().mean(axis=0))\n",
    "    else:\n",
    "        label = 'No selection'\n",
    "    return selected.relabel(label).options(color='red')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c09a09d4-d1a0-49af-9c95-377bca5cddfe",
   "metadata": {},
   "source": [
    "Combine \"points\" and DynamicMap. Notice the syntax used here, how the \"+\" sign makes side-by-side panels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca41ab78-ecd8-491c-a232-4f1bef8f9847",
   "metadata": {},
   "outputs": [],
   "source": [
    "points.opts(xlabel='(g-r)', ylabel='(r-i)') + hv.DynamicMap(\n",
    "    selected_info, streams=[selection]).opts(xlabel='(g-r)',\n",
    "                                             ylabel='(r-i)')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53f38359-bda9-477d-b311-235489660c18",
   "metadata": {},
   "source": [
    ">Figure 7: At left, the MBA semimajor axis vs eccentricity. The plot at right has the same axes, but will be empty until the action below is taken to select points in the left plot. The interactive toolbar is at upper right."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0b3f0ec-804c-44a5-b432-1b576d41d7b7",
   "metadata": {},
   "source": [
    "Use the lasso- or box-select to select a region in the left-hand plot.\n",
    "\n",
    "Print the number of objects selected."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60d25b30-2c65-4805-a80b-e972fa0a0176",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(len(selection.index))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f4174de-1861-400e-a980-377108fd1a0b",
   "metadata": {},
   "source": [
    "## 5.0 Datashader\n",
    "The interactive features of Bokeh work well with datasets up to a few tens of thousands of data points. To efficiently explore larger datasets it is recommended to use another visualization model that offers better scalability: Datashader.\n",
    "\n",
    "The examples below will show how, when zooming in on the datashaded two-dimensional histograms, the bin sizes are dynamically adjusted to show finer or coarser granularity in the distribution. This allows for the interactive exploration of large datasets without having to manually adjust the bin sizes while panning and zooming.\n",
    "\n",
    "Zoom in all the way to see individual points (i.e., bins contain either zero or one count). Soom in far enough and find that the individual points are represented by extremely small pixels in datashader that are difficult to see. A solution is to [dynspread](https://datashader.org/api.html#datashader.transfer_functions.dynspread) instead of datashade, which will preserve a finite size of the plotted points."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22b77795-0805-4814-858a-e966cce0f094",
   "metadata": {},
   "source": [
    "### 5.1. Plotting thousands of data points\n",
    "\n",
    "Plot a color-colour diagram using Bokeh with a customized hover tool."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3dc05a39-60d6-4d84-9163-e8ee26f9a688",
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_options = {'height': 400, 'width': 800,\n",
    "                'tools': ['pan', 'box_zoom', 'box_select',\n",
    "                          'wheel_zoom', 'reset', 'help']}\n",
    "\n",
    "p = figure(title=\"Color-Color Diagram\",\n",
    "           x_axis_label=\"(g-r)\", y_axis_label=\"(r-i)\",\n",
    "           x_range=(0., 1.5), y_range=(-0.5, 1.0),\n",
    "           **plot_options)\n",
    "p.scatter(x='gmr', y='rmi', source=source_MBAs,\n",
    "          size='pointsize_bin', alpha=0.2,\n",
    "          hover_color='firebrick',\n",
    "          legend_field=\"MBApop\",\n",
    "          color=factor_cmap('MBApop', 'Category10_5',\n",
    "                            ['Hungaria', 'Inner Belt', 'Middle Belt', 'Outer Belt', 'Cybele']))\n",
    "\n",
    "hover = HoverTool(tooltips=[(\"mpcDesignation\", \"@mpcDesignation\"),\n",
    "                            (\"Class\", \"@MBApop\"),\n",
    "                            (\"(a, ecc, inc, H)\", \"(@a, @ecc, @incl, @Hmag)\"),\n",
    "                            (\"(g_H, r_H, i_H, z_H)\",\n",
    "                             \"(@g_H, @r_H, @i_H, @z_H)\"),\n",
    "                            (\"(g-r, r-i)\", \"(@gmr, @rmi)\"),\n",
    "                            (\"(numObs, arc (yr))\", \"(@numObs, @arc)\")])\n",
    "p.add_tools(hover)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "855c08c4-7899-4d5c-8820-f5908d0547c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "show_bokeh_inline(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34fbf1eb-d97b-4baa-831e-fc24e3d8996f",
   "metadata": {},
   "source": [
    ">Figure 8: The r-i color vs. the g-r color for the MBAs, with Hungarias in blue, Inner Belt objects in orange, Middle Belt objects in green, Outer Belt objects in red, and Cybeles in purple. The interactive tool bar is at right."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d59b16f-2645-41c3-8233-87633b44976c",
   "metadata": {},
   "source": [
    "Create another plot using Bokeh with a customized hover tool for the semimajor axis vs eccentricity distribution of the MBAs, divided into their respective populations. First create a CDS from the TNO data returned by the query above to be passed directly to Bokeh."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "69225069-e459-4ea8-8dda-db3c083388d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_options = {'height': 400, 'width': 800,\n",
    "                'tools': ['pan', 'box_zoom', 'box_select',\n",
    "                          'wheel_zoom', 'reset', 'help']}\n",
    "\n",
    "p = figure(title=\"Semimajor Axis vs Eccentricity\",\n",
    "           x_axis_label=\"a (au)\", y_axis_label=\"e\",\n",
    "           x_range=(1.7, 3.7), y_range=(0., 0.6),\n",
    "           **plot_options)\n",
    "p.scatter(x='a', y='ecc', source=source_MBAs,\n",
    "          size='pointsize_bin', alpha=0.2,\n",
    "          hover_color='firebrick',\n",
    "          legend_field=\"MBApop\",\n",
    "          color=factor_cmap('MBApop', 'Category10_5',\n",
    "                            ['Hungaria', 'Inner Belt', 'Middle Belt', 'Outer Belt', 'Cybele']))\n",
    "\n",
    "hover = HoverTool(tooltips=[(\"mpcDesignation\", \"@mpcDesignation\"),\n",
    "                            (\"Class\", \"@MBApop\"),\n",
    "                            (\"(a, ecc, inc, H)\", \"(@a, @ecc, @incl, @Hmag)\"),\n",
    "                            (\"(g_H, r_H, i_H, z_H)\",\n",
    "                             \"(@g_H, @r_H, @i_H, @z_H)\"),\n",
    "                            (\"(g-r, r-i)\", \"(@gmr, @rmi)\"),\n",
    "                            (\"(numObs, arc (yr))\", \"(@numObs, @arc)\")])\n",
    "p.add_tools(hover)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6b913c19-d0c0-4ce1-8649-3425eb6a5e21",
   "metadata": {},
   "outputs": [],
   "source": [
    "show_bokeh_inline(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8374c27e-be02-422b-9e97-bd03282d7941",
   "metadata": {},
   "source": [
    ">Figure 9: Semimajor axis (au) vs. eccentricity for the MBAs, with the Hungarias in blue, Inner Belt objects in orange, Middle Belt objects in green, Outer Belt objects in red, and Cybeles in purple. The interactive tool bar is at right."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89bf17c3-e509-4854-ae0d-3d1cdaf6e8a3",
   "metadata": {},
   "source": [
    "The plot above suffers from overplotting (confusion), even though the dataset only contains ~20K points. A classic strategy to visualize the dense areas is to specify the transparency (alpha) of the glyphs; in the plot above, alpha=0.2 was used. This has helped, but washes out the detail in the sparser regions.\n",
    "\n",
    "HoloViews + Datashader allow millions to billions of points to be plotted, and this produces much more informative plots. Datashader rasterizes or aggregates datasets into regular grids that can then be further analysed or viewed as plots or images.\n",
    "\n",
    "Create a Holoviews object \"points\" to hold and plot data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c577d811-3a71-4902-a63c-f40da7c690c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "points = hv.Points((source_MBAs.to_df()['gmr'], source_MBAs.to_df()['rmi']))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d966d9b4-8f8d-4f35-b71e-ab6aa54da158",
   "metadata": {},
   "source": [
    "Create the linked streams instance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e336962-a34f-4289-89f0-fa8cb21a8ea4",
   "metadata": {},
   "outputs": [],
   "source": [
    "boundsxy = (0, 0, 0, 0)\n",
    "box = streams.BoundsXY(source=points, bounds=boundsxy)\n",
    "bounds = hv.DynamicMap(lambda bounds: hv.Bounds(bounds), streams=[box])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1e45e86-14c6-4010-a8e0-dcdfef91c3bb",
   "metadata": {},
   "source": [
    "Apply the datashader."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f0b11205-539b-4d26-9cf1-075a60960d7e",
   "metadata": {},
   "outputs": [],
   "source": [
    "p = dynspread(datashade(points, cmap=\"Viridis\"))\n",
    "p = p.opts(width=800, height=300, padding=0.05, show_grid=True,\n",
    "           xlim=(0., 1.5), ylim=(-0.5, 1.0), xlabel=\"(g-r)\", ylabel=\"(r-i)\",\n",
    "           tools=['box_select'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8edc9c55-b4cf-42af-88f1-79284bcee36d",
   "metadata": {},
   "source": [
    "Render the datashaded plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d82f3a98-0d3e-4d08-bf3a-11afeec92d1c",
   "metadata": {},
   "outputs": [],
   "source": [
    "p * bounds"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "379f02c2-5872-4c09-bd50-28acabe83b91",
   "metadata": {},
   "source": [
    ">Figure 10: The MBA r-i vs. the g-r colors as in Fig 8, but displayed as a 2-dimensional density map (with a purple-green-yellow colormap) in regions of high density, and as individual points in regions of low density. Interactive toolbar at right."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2ed169b-3b54-48d8-8c0d-e97a723d6261",
   "metadata": {},
   "source": [
    "This datashaded plot of the same color-color diagram as above does not require any magic-number parameters such as size and alpha and automatically ensures that there is no saturation or overplotting.\n",
    "\n",
    "Above, select the wheel zoom and adjust the image to interact with the plot. Note how the shades of color of the data points change according to the local density."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d16a0c39-c689-469d-a8eb-f5b6a994075f",
   "metadata": {},
   "source": [
    "### 5.2. Plotting millions of data points\n",
    "The datasest of ~20K points used above is actually too small to demonstrate the power of datashader.\n",
    "\n",
    "Below, visualize the full >1 million main-belt object dataset returned by the query.\n",
    "\n",
    "Create a Points Element for the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c5a4d93-0088-43c8-ade2-a3d4a23acf2c",
   "metadata": {},
   "outputs": [],
   "source": [
    "points = hv.Points((uniqueMBAs['gmr'], uniqueMBAs['rmi']))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6b71bc3-81ef-460e-b26d-59a6f5964058",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-07-17T19:43:14.189876Z",
     "iopub.status.busy": "2024-07-17T19:43:14.189152Z",
     "iopub.status.idle": "2024-07-17T19:43:14.564607Z",
     "shell.execute_reply": "2024-07-17T19:43:14.563763Z",
     "shell.execute_reply.started": "2024-07-17T19:43:14.189854Z"
    }
   },
   "source": [
    "Create the linked streams instance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e3700dd0-a1aa-426d-b66f-7c0a33ac3b17",
   "metadata": {},
   "outputs": [],
   "source": [
    "boundsxy = (0, 0, 0, 0)\n",
    "box = streams.BoundsXY(source=points, bounds=boundsxy)\n",
    "bounds = hv.DynamicMap(lambda bounds: hv.Bounds(bounds), streams=[box])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61df1473-515a-48a1-ba28-5106f97a69b8",
   "metadata": {},
   "source": [
    "Apply the datashader."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d6c9aea3-957c-4326-b303-bf4dab6ea33d",
   "metadata": {},
   "outputs": [],
   "source": [
    "p = dynspread(datashade(points, cmap=\"Viridis\"))\n",
    "p = p.opts(width=800, height=300, padding=0.05, show_grid=True,\n",
    "           xlim=(-2.0, 7.0), ylim=(-5.0, 3.0), xlabel=\"(g-r)\", ylabel=\"(r-i)\",\n",
    "           tools=['box_select'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0314389-2aeb-4f18-9981-6f959aaebc8c",
   "metadata": {},
   "source": [
    "Render the datashaded plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7295a747-166d-45e0-8e2c-a3ab2d7f0767",
   "metadata": {},
   "outputs": [],
   "source": [
    "p * bounds"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02735c64-fe54-4a3a-9cde-3c458c6be1f7",
   "metadata": {},
   "source": [
    ">Figure 11: Similar to Fig 10, but for MBAs and with many more objects included."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2625b56a-7624-4962-9f55-36e3a5cbb50a",
   "metadata": {},
   "source": [
    "Above, use the box zoom or wheel zoom functionality to zoom in on the plot, and watch how datashader adapts the view to optimally display the data."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcbd26a3-8342-4207-84aa-a8570604cca3",
   "metadata": {},
   "source": [
    "### 5.3. Adding a callback function\n",
    "Add callback functionality to the color-color diagam above to retrieve the indices of selected points.\n",
    "\n",
    "Above, use the box selection tool to select data.\n",
    "\n",
    "> STOP - Select some data points from the plot above using the box select tool before proceeding.\n",
    "\n",
    "Print the number of objects selected."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0f3fa34e-3a2e-445b-af50-89b271f85ac2",
   "metadata": {},
   "outputs": [],
   "source": [
    "selection = (points.data.x > box.bounds[0]) \\\n",
    "    & (points.data.y > box.bounds[1]) \\\n",
    "    & (points.data.x < box.bounds[2]) \\\n",
    "    & (points.data.y < box.bounds[3])\n",
    "print('The selection box contains %i data points'%(np.sum(selection)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab711617-1f49-4d67-99b9-20d0b0bc8eac",
   "metadata": {},
   "source": [
    "### 5.4. Interactive selection\n",
    "Below, create two side-by-side plots.\n",
    "\n",
    "The left-hand plot will show the datashaded spatial distribution on the sky, and the right-hand plot will be a linked and brushed plot showing the r-band magnitude distribution for objects selected in the left-hand plot. It will be possible to use the box selection in the spatial distribution plot to change which data are included in the histogram.\n",
    "\n",
    "First, create a holoviews dataset instance, and label some of the columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e2c55d01-bc23-49db-a4d8-a2d2ad079b9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "kdims = [('a', 'semimajor axis (au)'), ('e', 'eccentricity')]\n",
    "vdims = [('incl', 'inclination (deg)')]\n",
    "ds = hv.Dataset(uniqueMBAs, kdims, vdims)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9bcf45fb-3c1d-474b-b09f-5aa956b62502",
   "metadata": {},
   "outputs": [],
   "source": [
    "points = hv.Points(ds)\n",
    "boundsxy = (np.min(ds.data['a']), np.min(ds.data['e']),\n",
    "            np.max(ds.data['a']), np.max(ds.data['e']))\n",
    "box = streams.BoundsXY(source=points, bounds=boundsxy)\n",
    "box_plot = hv.DynamicMap(lambda bounds: hv.Bounds(bounds), streams=[box])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b430aa3b-9368-4c69-8c3c-8e994393f1e9",
   "metadata": {},
   "source": [
    "Create custom callback functionality to update the linked histogram.\n",
    "\n",
    "These functions are defined here (and not in Section 1.2) because they are only used in the following cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "95c8847a-6e11-4e39-8199-7c647de86d05",
   "metadata": {},
   "outputs": [],
   "source": [
    "def log_inf(x) -> float:\n",
    "    return np.log(x) if x > 0 else 0\n",
    "\n",
    "\n",
    "def update_histogram(bounds=bounds) -> hv.Histogram:\n",
    "    selection = (ds.data['a'] > bounds[0]) & \\\n",
    "                (ds.data['e'] > bounds[1]) & \\\n",
    "                (ds.data['a'] < bounds[2]) & \\\n",
    "                (ds.data['e'] < bounds[3])\n",
    "    selected_mag = ds.data.loc[selection]['incl']\n",
    "    frequencies, edges = np.histogram(selected_mag)\n",
    "    hist = hv.Histogram(\n",
    "        (list(map(log_inf, frequencies)), edges)).opts(\n",
    "        xlabel='inclination (deg)')\n",
    "    return hist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07503225-45d1-45bb-8a8a-fa7c75d4c695",
   "metadata": {},
   "outputs": [],
   "source": [
    "dmap = hv.DynamicMap(\n",
    "    update_histogram, streams=[box]).options(height=400, width=400)\n",
    "datashade(points, cmap=process_cmap(\"Viridis\", provider=\"bokeh\")) * \\\n",
    "    box_plot.options(height=400, width=400, tools=['box_select']) + \\\n",
    "    dmap"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0f7bed5-5272-4281-ab2f-f057f727c297",
   "metadata": {},
   "source": [
    "> Figure 12: At right, semimajor axis vs eccentricity as a 2-dimensional density map with a purple-green-yellow colormap. At left, a histogram (blue bar chart) of the fraction of objects in bins of number of observations.\n",
    "\n",
    "Try changing the box selection across the inner, middle, and outer main belt, and watch as the histogram is recomputed and displayed."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73ee157e-769b-444b-a5b3-291cafb69448",
   "metadata": {},
   "source": [
    "## 6. Exercises for the learner\n",
    "HoloViews works with a wide range of plotting libraries; Bokeh, matplotlib, plotly, mpld3, pygal to name a few. As an exercise, try changing the HoloViews plotting library to be matplotlib instead of bokeh at the beginning of the notebook with hv.extension('matplotlib'). Notice the holoviews + matplotlib icons displayed when the library is loaded successfully. Recreate a few plots and compare the outputs. Try again with some other plotting library. Don't forget to set the plotting library back to Bokeh, which is used for this tutorial. Note that some warnings might be raised.\n",
    "\n",
    "As in Section 4.3, try writing other interactive plots from this notebook to an interactive HTML file. Which ones can easily be output to an interactive HTML file? Which HTML files show full interactive functionality? Which ones don't?\n",
    "\n",
    "Try making the above interactive plots with a different small body population, such as the transneptunian objects (TNOs) or near-Earth objects (NEOs)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3f2c89a-0b71-4bc4-a0a6-054b336c5079",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "LSST",
   "language": "python",
   "name": "lsst"
  },
  "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.11.9"
  },
  "toc-autonumbering": false
 },
 "nbformat": 4,
 "nbformat_minor": 5
}