JupyterLabHS_GUI_5D_colors.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib widget\n",
    "import hyperspy.api as hs\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from ipywidgets.widgets import HBox, VBox, Label, IntSlider, Output, IntRangeSlider\n",
    "\n",
    "# Optional, for notebook only, not lab\n",
    "#from IPython.core.display import display, HTML\n",
    "#display(HTML(\"<style>.container { width:100% !important; }</style>\"))\n",
    "\n",
    "cmap = 'jet'  #sets the colormap for the navigation image\n",
    "\n",
    "\n",
    "def plot_polar(s):\n",
    "    \"\"\"\n",
    "    Plot a 4D hyperspy dataset with the signal in polar coordinates\n",
    "    Arguments:\n",
    "    s: hyperspy signal of shape <X, Y, W| R>\n",
    "    Notes:\n",
    "    The theta-axis used is the signal axes' axis, which should be in degree units\n",
    "    (check s.axes_manager[-1].axis)\n",
    "    \n",
    "    How to use:\n",
    "    Must use the ipympl backend. %matplotlib widget\n",
    "    Best viewed in jupyter lab or in the notebook with a stretched viewport, try:\n",
    "    from IPython.core.display import display, HTML\n",
    "    display(HTML(\"<style>.container { width:100% !important; }</style>\"))\n",
    "    \"\"\"\n",
    "    # Flip the signal and navigation with .T, then sum over the former signal dimension to produce a X Y W dataset. \n",
    "    # This becomes the figure we plot on the left.\n",
    "    nav = s.T.sum() \n",
    "\n",
    "    # Set up the initial values for the rectangular region of interest marker\n",
    "    # x coordinates\n",
    "    value2index0 = nav.axes_manager[0].value2index\n",
    "    index2value0 = nav.axes_manager[0].index2value\n",
    "\n",
    "    low = nav.axes_manager[0].low_index\n",
    "    high = nav.axes_manager[0].high_index\n",
    "    left = index2value0(int(low + 1/4*(high-low)))\n",
    "    right = index2value0(round(low + 3/4*(high-low)))\n",
    "\n",
    "    # y coordinates\n",
    "    value2index1 = nav.axes_manager[1].value2index\n",
    "    index2value1 = nav.axes_manager[1].index2value\n",
    "    \n",
    "    low = nav.axes_manager[1].low_index\n",
    "    high = nav.axes_manager[1].high_index\n",
    "    top = index2value1(int(low + 1/4*(high-low)))\n",
    "    bottom = index2value1(round(low + 3/4*(high-low)))\n",
    "\n",
    "    # Since the navigator has three dimensions and we can only display two,\n",
    "    # we add a slider to control the wavelength dimension\n",
    "    wavelength_slider = IntSlider(value=0, min=0, max=nav.axes_manager[2].high_index)\n",
    "    orientation_slider = IntSlider(value=0, min=0, max=nav.axes_manager[3].high_index)\n",
    "    \n",
    "####\n",
    "    clim_slider = IntRangeSlider(value=[10000, 100000],\n",
    "        min=0,\n",
    "        max=250000,\n",
    "        step=10000,\n",
    "        description='clim:',\n",
    "        disabled=False,\n",
    "        continuous_update=True,\n",
    "        orientation='vertical',\n",
    "        readout=True,\n",
    "        readout_format='d',\n",
    "    )\n",
    "####\n",
    "    # create a dataset with only X and Y, slicing at the wavelength position\n",
    "    nav_first_two = nav.isig[...,wavelength_slider.value, orientation_slider.value] # ... means \"leave every axis until the end\", equivalent of :,: here.\n",
    "    \n",
    "    # We use normal hyperspy plotting to display the first figure, because we want to use hyperspy ROIs.\n",
    "    # Note that hs plotting really is matplotlib plotting with more on top.\n",
    "    # Prevent the matplotlib figure from being created immediately by using an Output ipywidget. \n",
    "    # This is a separate area that we will display later\n",
    "    nav_output = Output()\n",
    "    with nav_output:\n",
    "        nav_first_two.plot(cmap=cmap) #this generates the navigation image, other matplotlib parameters can be passed here.\n",
    "    # get ahold of the image displayed in this figure\n",
    "    # we will be changing the array displayed in `im` with `im.set_data()` later.   \n",
    "    im = nav_first_two._plot.signal_plot.ax.images[0] \n",
    "    \n",
    "    \n",
    "    \n",
    "    # Create the roi and place it on the left figure, then create labels that hold the name and position of the \n",
    "    # coordinates of the ROI and the wavelength index\n",
    "    roi = hs.roi.RectangularROI(left, top, right, bottom)\n",
    "    r = roi.interactive(nav_first_two)\n",
    "    # The labels use f-strings, which are a convenient way to write out strings with objects in them. The :.2f operator means \"leave two decimals and show as a float\"\n",
    "    xlabel = Label(value=f\"{nav.axes_manager[0].name}: {roi.left:.2f} : {roi.right:.2f}\")\n",
    "    ylabel = Label(value=f\"{nav.axes_manager[1].name}: {roi.top:.2f} : {roi.bottom:.2f}\")\n",
    "    wlabel = Label(value=f\"{nav.axes_manager[2].name}: {nav.axes_manager[-1].index2value(wavelength_slider.value):.2f}\")\n",
    "    olabel = Label(value=f\"{nav.axes_manager[3].name}: {nav.axes_manager[-1].index2value(orientation_slider.value):.2f}\")\n",
    "    # Plot right figure using an Output widget to prevent it being shown immediately\n",
    "    sig_output = Output()\n",
    "    with sig_output:\n",
    "        fig = plt.figure()\n",
    "    ax = plt.subplot(111, projection='polar')\n",
    "    ax.set_xticks([0,np.pi/3,2*np.pi/3,np.pi,4*np.pi/3,5*np.pi/3])\n",
    "    ax.tick_params(axis='both', labelsize=20)\n",
    "    ax.set_rticks([600, 1200])\n",
    "    ax.autoscale(enable=False)\n",
    "    thetaaxis = s.axes_manager[-1].axis * np.pi / 180 # convert x axis to radians\n",
    "    # Plot the polar plot. We return the line plotted into `lns` (which is a list of all lines)\n",
    "    lns = ax.plot(\n",
    "        thetaaxis,\n",
    "        s.data[orientation_slider.value,wavelength_slider.value,\n",
    "               value2index1(roi.top):value2index1(roi.bottom), \n",
    "               value2index0(roi.left):value2index0(roi.right)\n",
    "              ].mean((0,1)))\n",
    "    ln = lns[0] # lns only contains one line, which we will need later to update it\n",
    "\n",
    "    def update(roi):\n",
    "        \"Update the polar plot and label values from a moving ROI\"\n",
    "        # Here we index the numpy array instead of the hyperspy .inav, because the former is quite a bit faster.\n",
    "        # the numpy array is indexed in reverse order of hyperspy for some reason\n",
    "        # The specific \"roi\" object name is imporant, as the `connect` method we use later expects it.\n",
    "        \n",
    "        # Update plot with set_ydata\n",
    "        ydata = s.data[orientation_slider.value,wavelength_slider.value,\n",
    "               value2index1(roi.top):value2index1(roi.bottom), \n",
    "               value2index0(roi.left):value2index0(roi.right)\n",
    "              ].mean((0,1)) # 0 and 1 are the X and Y axes here, because we eliminate the wavelength axis by indexing it not using a range\n",
    "        ln.set_ydata(ydata)\n",
    "########ax.set_ylim(0, ydata.max()) # Polar plots look funny if we index with ydata.min() instead of 0.\n",
    "        ax.set_ylim(0, 1200)\n",
    "        \n",
    "        \n",
    "        xlabel.value=f\"{nav.axes_manager[0].name}: {roi.left:.2f} : {roi.right:.2f}\"\n",
    "        ylabel.value=f\"{nav.axes_manager[1].name}: {roi.top:.2f} : {roi.bottom:.2f}\"\n",
    "        wlabel.value=f\"{nav.axes_manager[2].name}: {nav.axes_manager[-1].index2value(wavelength_slider.value):.2f}\"\n",
    "        olabel.value=f\"{nav.axes_manager[3].name}: {nav.axes_manager[-1].index2value(orientation_slider.value):.2f}\"\n",
    "        \n",
    "    def update_from_slider(change):\n",
    "        \"Update the polar plot, label values AND left hand plot by changing the wavelength slider\"\n",
    "        # Here we index the numpy array instead of the hyperspy .inav, because the former is quite a bit faster.\n",
    "        # the numpy array is indexed in reverse order of hyperspy for some reason\n",
    "        # The `change` object name is important, ipywidget `observe` methods expect it.\n",
    "        # While I do use the change['new'] object here, I could equally use `wavelength_slider.value`\n",
    "        wavelength_index = wavelength_slider.value\n",
    "        orientation_index = orientation_slider.value\n",
    "        # Update image with set_data\n",
    "        im.set_data(s.data[orientation_index, wavelength_index].sum(-1)) # update the navigator, first index here is the wavelength, : or ... after is unnecessary.\n",
    "        \n",
    "        \n",
    "########im.autoscale() # autoscale the nav image  \n",
    "        im.set_clim(clim_slider.value)    #.  This sets the min and max of the color scale in the navigation image\n",
    "    \n",
    "    \n",
    "        # Update plot with set_ydata\n",
    "        ydata = s.data[orientation_index, wavelength_index,\n",
    "               value2index1(roi.top):value2index1(roi.bottom), \n",
    "               value2index0(roi.left):value2index0(roi.right)\n",
    "              ].mean((0,1)) # 0 and 1 are the X and Y axes here, because we eliminate the wavelength axis by indexing it not using a range\n",
    "        ln.set_ydata(ydata)\n",
    "########ax.set_ylim(0, ydata.max()) # Polar plots look funny if we index with ydata.min() instead of 0.\n",
    "        ax.set_ylim(0, 1200)\n",
    "        \n",
    "        xlabel.value=f\"{nav.axes_manager[0].name}: {roi.left:.2f} : {roi.right:.2f}\"\n",
    "        ylabel.value=f\"{nav.axes_manager[1].name}: {roi.top:.2f} : {roi.bottom:.2f}\"\n",
    "        wlabel.value=f\"{nav.axes_manager[2].name}: {nav.axes_manager[-1].index2value(wavelength_index):.2f}\"\n",
    "        olabel.value=f\"{nav.axes_manager[3].name}: {nav.axes_manager[-1].index2value(orientation_index):.2f}\"\n",
    "\n",
    "    roi.events.changed.connect(update) # Call the `update(roi=roi)` function every time the ROI changes, with the latest values of the `roi` object\n",
    "    wavelength_slider.observe(update_from_slider, names='value') # Call the `update_from_slider(change=change)` function every time the slider changes, \n",
    "    orientation_slider.observe(update_from_slider, names='value')\n",
    "    clim_slider.observe(update_from_slider, names='value')\n",
    "    # With ipympl enabled, the figure.canvas object is an ipywidget itself. \n",
    "    # That means can we can modify attributes like margin and other positioning. See the ipywidgets docs for more info\n",
    "    navfig = nav_first_two._plot.signal_plot.figure.canvas \n",
    "    \n",
    "    sigfig = fig.canvas\n",
    "\n",
    "    navfig.layout.margin = \"auto 0px auto 0px\" # This centers the figure, I think. Can't actually remember.\n",
    "    sigfig.layout.margin = \"auto 0px auto 0px\" # This centers the figure, I think. Can't actually remember.\n",
    "    sigfig.header_visible = False # removes unnecssary \"Figure 1\" info on top\n",
    "    navfig.header_visible = False\n",
    "    display(HBox([nav_output, sig_output])) # Here we acutally display the figures, wrapped in a \"Horizontal Box\" widget so that they are next to each other\n",
    "    display(HBox([Label('Wavelength:'), wavelength_slider,HBox([Label('Orientation'),orientation_slider]),clim_slider, VBox([xlabel, ylabel, wlabel, olabel])]))\n",
    "    \n",
    "# Use:\n",
    "\n",
    "#s = hs.load(r\"fixed_2020-04-06.hspy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A quick theoretical overview: \n",
    "\n",
    "(1) $P_i (\\omega_{SHG})$ = $\\epsilon_0 \\sum_{jk} \\chi_{ijk}^{(2)} (\\omega_{SHG},\\omega_{inc},\\omega_{inc})$ $E_j(\\omega_{inc}) E_k(\\omega_{inc})$\n",
    "\n",
    "This polarization field describes the Second Harmonic Generation (SHG) emission of laser light. This can be derived classically from the nonlinear anharmonic oscillator equation, or from Maxwell's equations with equal validity. The polarization field is dominated by the second order susceptibility tensor $\\chi^{2}$, which can be derived in various ways but chief among them is the density matrix formalism of quantum mechanics. In the interest of time we'll skip the derivation as it takes up nearly 11 pages in the relevant textbook<sup>1</sup>. The important thing to note here is that there is a spatial dependence in the material parameter $\\chi^{2}$, and that the density matrix approach yields information about its behavior both close to electronic resonances and far away from them. \n",
    "\n",
    "In particular, SHG has been suggested as a way to probe so-called 'dark' states, excitonic resonances that are invisible to standard absorption/emission linear optical techniques. \n",
    "\n",
    "1: Nonlinear Optics, Robert Boyd, 3rd edition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "84d5de5e1c2b4eb3bdca867ecae0d3bf",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(Output(), Output()))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2c11ee135e404e6cb76da7376e120c36",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(Label(value='Wavelength:'), IntSlider(value=0, max=70), HBox(children=(Label(value='Orientation…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "s = hs.load(r\"fixed_2020-04-06.hspy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6288ac686d024663be8218cf2eec0c0a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(Output(), Output()))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "01e34407bb684b5bbd7b8a12308c881a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(Label(value='Wavelength:'), IntSlider(value=0, max=70), HBox(children=(Label(value='Orientation…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_polar(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'im' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-19-e371e598fe9f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mim\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'im' is not defined"
     ]
    }
   ],
   "source": [
    "im"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}