DP02_06a_Interactive_Image_Visualization.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Interactive Image Visualization\n",
    "\n",
    "<img align=\"left\" src = https://project.lsst.org/sites/default/files/Rubin-O-Logo_0.png width=250 style=\"padding: 10px\"> \n",
    "<br>\n",
    "Contact author(s): Leanne Guy <br>\n",
    "Last verified to run: 2024-12-17 <br>\n",
    "LSST Science Pipelines version: Weekly 2024_50 <br>\n",
    "Container Size: large <br>\n",
    "Targeted learning level: intermediate <br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Description:** Interactive image visualizations with three open-source python libraries."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Skills:** Visualize exposure images with HoloViews, interact with images with HoloViews Streams and Dynamic Map, and output interactive images to interactive HTML files."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**LSST Data Products:** The calexp and deepCoadd images, Source and Object tables."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Packages:** bokeh, holoviews"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Credit:**\n",
    "This tutorial was inspired by a notebook originally developed by Keith Bechtol in the context of the LSST Stack Club. \n",
    "It has been updated and extended for DP0.1 and DP0.2 by Leanne Guy. Material on how to output an interactive HTML file \n",
    "in Section 3.2 was added by Douglas Tucker."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Get Support:**\n",
    "Find DP0-related documentation and resources at <a href=\"https://dp0.lsst.io\">dp0.lsst.io</a>. \n",
    "Questions are welcome as new topics in the <a href=\"https://community.lsst.org/c/support/dp0\">Support - Data Preview 0 Category</a> of the \n",
    "Rubin Community Forum. Rubin staff will respond to all questions posted there."
   ]
  },
  {
   "cell_type": "markdown",
   "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 two packages that are exceptionally useful for data visualization, holoviews and bokeh, and demonstrates how to use them with the DP0.2 data sets. \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. Some of the examples require interaction (e.g., for the user to select points on a graph) in order to run correctly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1. Package imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# General\n",
    "import os\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Astropy\n",
    "from astropy.visualization import ZScaleInterval, AsinhStretch\n",
    "\n",
    "# LSST packages\n",
    "from lsst.daf.butler import Butler\n",
    "\n",
    "# Bokeh\n",
    "import bokeh\n",
    "from bokeh.io import output_notebook\n",
    "from bokeh.models import HoverTool\n",
    "\n",
    "# HoloViews\n",
    "import holoviews as hv\n",
    "from holoviews import streams, opts\n",
    "from holoviews.operation.datashader import rasterize"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check which versions of bokeh and holoviews and datashader are we working with.\n",
    "This is important when referring to online documentation as APIs can change between versions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(\"Bokeh version: \" + bokeh.__version__)\n",
    "print(\"HoloViews version: \" + hv.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2. Define functions and parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set the display output for bokeh plots to be inline, in the notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "output_notebook()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set the holoviews plotting library to be bokeh. \n",
    "You will see the holoviews + bokeh icons displayed when the library is loaded successfully.\n",
    "**Always set the extension after executing `output_notebook()` to avoid issues with plot display.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hv.extension('bokeh')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a function that converts a butler dataId into a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def dataIdToString(dataId: dict) -> str:\n",
    "    \"\"\"\n",
    "    Convert a dataId dictionary to a string.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    dataId: dict\n",
    "        dataId as a dictionary\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    str\n",
    "    \"\"\"\n",
    "    output = ''\n",
    "    nkeys = len(dataId.items())\n",
    "    for i, (key, value) in enumerate(dataId.items()):\n",
    "        if i < nkeys - 1:\n",
    "            output += str(key) + \": \" + str(value) + \", \"\n",
    "        elif i == nkeys - 1:\n",
    "            output += str(key) + \": \" + str(value)\n",
    "    return output.strip()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Data preparation\n",
    "\n",
    "The basis for any data visualization is the underlying data.\n",
    "In this tutorial we will work with images."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this notebook we will access data via <a href=\"https://pipelines.lsst.io/modules/lsst.daf.butler/index.html\">the butler</a>: an LSST Science Pipelines software package that allows you to fetch the LSST data you want without having to know its location or format.\n",
    "\n",
    "Create a DP0.2 data butler to use in this notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "config = 'dp02'\n",
    "collection = '2.2i/runs/DP0.2'\n",
    "butler = Butler(config, collections=collection)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1. Retrieve a calexp and the sources in it\n",
    "\n",
    "Retrieve a calexp from the butler by specifying its visit, detector, and band as the dataId."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "calexpId = {'visit': 192350, 'detector': 175, 'band': 'i'}\n",
    "calexp = butler.get('calexp', dataId=calexpId)\n",
    "\n",
    "assert calexp is not None\n",
    "\n",
    "print('The dataId as a string: \"'+dataIdToString(calexpId)+'\"')\n",
    "\n",
    "print('calexp visit: ', calexp.visitInfo.id)\n",
    "print('calexp band: ', calexp.filter.bandLabel)\n",
    "print('calexp detector: ', calexp.detector.getId())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get entries in the sourceTable using the same dataId."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "calexp_sources = butler.get('sourceTable', dataId=calexpId)\n",
    "print(len(calexp_sources))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2. Retrieve a deepCoadd and the objects in it\n",
    "\n",
    "Retrieve a deepCoadd from the butler by specifying a tract, patch, and band as the dataId."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "coaddId = {'tract': 4226, 'patch': 17, 'band': 'r'}\n",
    "coadd = butler.get('deepCoadd', dataId=coaddId)\n",
    "\n",
    "assert coadd is not None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Option: Get additional information about the deepCoadd.\n",
    "In this case, as an example, find out which visits went into constructing it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "coaddInfo = coadd.getInfo()\n",
    "coaddVisits = coaddInfo.getCoaddInputs().visits\n",
    "coaddVisits.asAstropy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get entries in the objectTable using the same dataId."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "coadd_objects = butler.get('objectTable', dataId=coaddId)\n",
    "print(len(coadd_objects))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3. Explore the retrieved data\n",
    "\n",
    "It is always good practice to do a bit of basic characterization for data retrieved from a catalog.\n",
    "\n",
    "> **Notice:** There are many more entries in the extracted coadd_object table than the calexp_source table, even though they are both about the same sized area (patch-sized and visit-sized, respectively), because the coadd_object table extends to very faint magnitudes.\n",
    "\n",
    "Show that the two samples, coadd_objects and calexp_sources, do not overlap in sky coordinate and do not have the same apparent magnitude distribution.\n",
    "\n",
    "First, pull the data to be plotted out of the data frame, and identify coadd_objects that are not flagged."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "co_ra = coadd_objects.coord_ra.values\n",
    "co_dec = coadd_objects.coord_dec.values\n",
    "co_cF = coadd_objects.r_calibFlux.values\n",
    "co_cFf = coadd_objects.r_calibFlux_flag.values\n",
    "co_diP = coadd_objects.detect_isPrimary.values\n",
    "tx = np.where((co_diP) & (co_cF > 0.0) & (co_cFf == 0))[0]\n",
    "print('Number of coadd objects to plot: ', len(tx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, make a simple, non-interactive plot to characterize the coordinates and magnitudes of the retrieved cooad_objects and calexp_sources.\n",
    "\n",
    "> **Warning:** For the purposes of this plotting demonstration it is OK to ignore the RuntimeWarning that appears when the next cell is executed, but for scientific analyses, invalid values should be investigated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(1, 2, figsize=(14, 4))\n",
    "\n",
    "ax[0].plot(co_ra[tx], co_dec[tx],\n",
    "           'o', ms=1, alpha=0.4, mew=0, label='coadd_objects')\n",
    "ax[0].plot(calexp_sources['coord_ra'], calexp_sources['coord_dec'],\n",
    "           'o', ms=1, alpha=1, mew=0, label='calexp_sources')\n",
    "ax[0].set_xlabel('RA')\n",
    "ax[0].set_ylabel('Dec')\n",
    "ax[0].legend(markerscale=8)\n",
    "\n",
    "ax[1].hist(-2.5 * np.log10(co_cF[tx]) + 31.4,\n",
    "           histtype='step', lw=2, log=True, label='coadd_objects')\n",
    "ax[1].hist(-2.5 * np.log10(calexp_sources['calibFlux']) + 31.4,\n",
    "           histtype='step', lw=2, log=True, label='calexp_sources')\n",
    "ax[1].set_xlabel('apparent magnitude')\n",
    "ax[1].set_ylabel('log(N)')\n",
    "ax[1].legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Figure 1: At left, a plot of right ascension (RA) versus declination (Dec) for objects from the coadded image (blue) and sources in the calexp image (orange), showing that there is no spatial overlap. At right, a histogram (in $log(N)$) of the apparent magnitude for the coadd's objects (blue) and calexp's sources (orange), showing that the coadd's objects' magnitude distribution extends to much fainter magnitudes."
   ]
  },
  {
   "cell_type": "markdown",
   "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. For this tutorial, we will use [Bokeh](https://docs.bokeh.org/en/latest/) as the plotting library backend for HoloViews. This is defined in Section 1, above, with the `hv.extension('bokeh')` call.  HoloViews supports several plotting libraries and there is an exercise to the user at the end of this section to explore using Holoviews with other plotting packages. \n",
    "\n",
    "The basic core primitives of HoloViews are [Elements](http://holoviews.org/Reference_Manual/holoviews.element.html) (`hv.Element`). Elements are simple wrappers around your data that provide a semantically meaningful visual representation. An Element may be a set of Points, an Image, a Curve, a Histogram, a Scatter, 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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1. Visualizing calexp images with HoloViews\n",
    "\n",
    "In this first example we will use the HoloViews [Image Element](http://holoviews.org/reference/elements/bokeh/Image.html) to quickly visualize the catalog data retrieved in Section 1 as a scatter plot. 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.  In this first example we will apply the default options and remove the toolbar. \n",
    "\n",
    "The beginner-level image-display tutorial notebooks demonstrate how to use the `lsst.afw.display` library to visualize exposure images, and how to use Firefly.\n",
    "In this tutorial we demonstrate image visualization at the pixel level with HoloViews.\n",
    "\n",
    "We will use the holoviews Image Element to visualize a calexp. We will then overlay a HoloViews DynamicMap on the image to compute and display elements dynamically, allowing exploration of large datasets. DynamicMaps generate elements on the fly allowing exploration of parameters with arbitrary resolution. DynamicMaps are lazy in the sense they only compute as much data as the user wishes to explore. An Overlay is a collection of HoloViews objects that are displayed simultaneously, e.g a Curve superimposed on a Scatter plot of data. You can build an Overlay between any two HoloViews objects, which can have different types using the * operator. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we will use the `astropy.visualization` library to define an asinh stretch and zscale interval and apply them to the calexp object. These are the same transformations that were applied in the beginner-level image-display tutorial notebooks.\n",
    "\n",
    "Apply a asinh/zscale mapping to the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "transform = AsinhStretch() + ZScaleInterval()\n",
    "scaledImage = transform(calexp.image.array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "LSST’s image classes (Image, Mask, MaskedImage, and Exposure) use a pixel indexing convention that is different from both the convention used by `numpy.ndarray` objects and the convention used in FITS images (as documented [here](https://pipelines.lsst.io/modules/lsst.afw.image/indexing-conventions.html)).  Most plotting tools assume pixel (0, 0) is in the upper left where we always assume (0,0) is in the lower left. Consequently, we flip the data array. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "scaledImage = np.flipud(scaledImage)\n",
    "bounds_img = (0, 0, calexp.getDimensions()[0], calexp.getDimensions()[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Further details can be found at [Image Indexing, Array Views, and Bounding Boxes](https://pipelines.lsst.io/modules/lsst.afw.image/indexing-conventions.html) in the Rubin Science Pipelines and Data Products. \n",
    "\n",
    "Define some default plot options for the Image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "img_opts = dict(height=600, width=700, xaxis=\"bottom\",\n",
    "                padding=0.01, fontsize={'title': '8pt'},\n",
    "                colorbar=True, toolbar='right', show_grid=True,\n",
    "                tools=['hover'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create the Image element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "img = hv.Image(scaledImage, bounds=bounds_img,\n",
    "               kdims=['x', 'y']).opts(\n",
    "    cmap=\"Greys_r\", xlabel='X', ylabel='Y',\n",
    "    title='DC2 image dataId: \"' + dataIdToString(calexpId) + '\"',\n",
    "    **img_opts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Display the Image. Use the interactive functionality to zoom in on an interesting galaxy, and watch the image automatically rescale based on the pixel values in the view region."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "rasterize(img)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Figure 2: The `calexp` image, displayed in greyscale with a scale bar at right, and axes in pixels. The sidebar of icons offers interactive functionality. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2. Output interactive image to HTML file\n",
    "\n",
    "HoloViews permits one to output interactive images like the above to an HTML file, retaining most of the interactive qualities of the original image.\n",
    "Thus, one can share an interactive image with colleagues without requiring them to run a Jupyter notebook.\n",
    "We note that the interactivity of the HTML file is limited by the proceessing capabilities of relatively simple JavaScript; so not all the interactive functionality of the notebook version is necessarily supported in the HTML file."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's output an interactive HTML file for the above interactive image.  We will output it to your home directory.  We will make use of the HoloViews `save` function to output the image to the HTML files."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, let's construct the output file name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "outputDir = os.path.expanduser('~')\n",
    "outputFileBaseName = 'nb06a_plot1.html'\n",
    "outputFile = os.path.join(outputDir, outputFileBaseName)\n",
    "\n",
    "print('The full pathname of the interactive HTML file will be '+outputFile)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And now output the interactive HTML file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "hv.save(img, outputFile, backend='bokeh')"
   ]
  },
  {
   "cell_type": "markdown",
   "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 double-click on its name (or control-click or right-click on its name and select \"Open\").\n",
    "\n",
    "This will open another tab within JupyterLab, in which one can view the HTML file.\n",
    "Since the figure is of an image, the file is fairly large file (about 85 MB), so it will take about 15 seconds to load.\n",
    "Once loading is complete, click on the \"Trust HTML\" button at the top-left of the tab's window.\n",
    "You should see an near-duplicate of the interactive image that we produced just above.\n",
    "\n",
    "You can also download the HTML file to your local computer (control-click or right-click on its name in the file browser at left and select \"Download\").\n",
    "Then load it in a browser window on your local computer and interact with it the same way."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3. Overlay source detections on the calexp\n",
    "\n",
    "Now let's overlay the sources on this calexp image. We will use the Points Element for the detections to overlay."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "coords = calexp_sources.x, calexp_sources.y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a custom hover tool for the sources."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "detHoverTool = HoverTool(\n",
    "    tooltips=[\n",
    "        ('X', '@x{0.2f}'),\n",
    "        ('Y', '@y{0.2f}'),\n",
    "    ],\n",
    "    formatters={\n",
    "        'X': 'printf',\n",
    "        'Y': 'printf',\n",
    "    },\n",
    ")\n",
    "\n",
    "detections = hv.Points(coords).opts(\n",
    "    fill_color=None, size=9, color=\"darkorange\",\n",
    "    tools=[detHoverTool])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we overlay the detected sources on the image. The `*` operator  is used to overlay one Element on to another.\n",
    "\n",
    "Reset the tools on the image and add a hover on the detections.\n",
    "In the image below, mouse-over the sources to get the coordinates of the detections. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "rasterize(img).opts(tools=[]) * detections.opts(tools=[detHoverTool])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Figure 3: Similar to Figure 2, but with orange circles drawn on at the location of sources detected in the `calexp`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4. Interactive image exploration with HoloViews Streams and DynamicMap\n",
    "\n",
    "Now let's add some interactive exploration capability using HoloViews [Streams](http://holoviews.org/user_guide/Streaming_Data.html) and [DynamicMap](https://holoviews.org/reference/containers/bokeh/DynamicMap.html). A DynamicMap is an explorable multi-dimensional wrapper around a callable that returns HoloViews objects. The core concept behind a stream is simple: it defines one or more parameters that can change over time that automatically refreshes code depending on those parameter values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First create a DynamicMap with a box stream so that we can explore selected sections of the image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "boundsxy = (0, 0, 0, 0)\n",
    "box = streams.BoundsXY(source=img, bounds=boundsxy)\n",
    "dynamicMap = hv.DynamicMap(lambda bounds: hv.Bounds(bounds), streams=[box])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Display the image and overlay the DynamicMap."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "rasterize(img).opts(tools=['box_select']) * dynamicMap"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Figure 4: This plot appears to be the same as Figure 2, but it has additional interactive capabilities as described below.\n",
    "\n",
    "Using the interactive callback features on the image plots, such as the box select (hover over tool options and their names will pop-up), we can explore regions of the image.\n",
    "Use the box select tool on the image above to select a region and then execute the cell below to get the box boundaries in pixel coordinates. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "box"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below is another version of the image with a [tap stream](http://holoviews.org/reference/streams/bokeh/Tap.html) instead of box select.\n",
    "A Tap stream allows you to click or 'tap' a position to interact with a plot.\n",
    "Try zooming in on an interesting part of the image generated below, and then 'tap' somewhere to place an 'X' marker.\n",
    "\n",
    "> **Notice:** The marker is white, and might be invisible if you select to mark a high-flux region."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "posxy = hv.streams.Tap(source=img, x=0.5 * calexp.getDimensions()[0],\n",
    "                       y=0.5 * calexp.getDimensions()[1])\n",
    "marker = hv.DynamicMap(lambda x, y: hv.Points([(x, y)]), streams=[posxy])\n",
    "rasterize(img) * marker.opts(color='white', marker='x', size=20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Figure 5: This plot appears to be the same as Figure 4, but with an 'X' to mark the spot! What's the value at that location? Execute the next cell to find out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print('The scaled/raw value at position (%.3f, %.3f) is %.3f / %.3f' %\n",
    "      (posxy.x, posxy.y, scaledImage[-int(posxy.y), int(posxy.x)],\n",
    "       calexp.image.array[-int(posxy.y), int(posxy.x)]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Exercises for the learner\n",
    "\n",
    " 1. HoloViews works with a wide range of plotting libraries, Bokeh, matplotlib, plotly, mpld3, pygal to name a few. You can change the HoloViews plotting library to be `matplotlib` instead of `bokeh` in Section 1 (e.g., `hv.extension('matplotlib')`; notice the holoviews + matplotlib icons displayed when the library is loaded successfully), and try running through Section 3 again. You will encounter some warnings about how certain options \"for Image type not valid for selected backend\", but you will also see the image display formats change to matplotlib. Try it, or try with some other plotting library. Don't forget to set the plotting library back to whichever you prefer to use for the rest of this tutorial.\n",
    " \n",
    " 2. In Section 3.1, try using the coadd image instead of the calexp image. \n",
    " \n",
    " 3. In Section 3.3, try extracting additional information about the Sources and adding it to the custom hover tool. For example, the corresponding RA/DEC or the PSF flux.\n",
    " \n",
    " 4. Try using a different stream function to interact with the images in Section 3.4.\n",
    " \n",
    " 5. Try outputting an interactive HTML file (like what was done in Section 3.2) for the interactive images in Section 3.3 and 3.4.  How much of of the interactive functionality from the notebook version of these images carries over to the HTML files?  (N.B.:  the `box` functionality from Section 3.4 does not seem to be supported in an interactive HTML file.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}