lines.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "90d15090-fb93-4948-b00a-d4d71930d6cd",
   "metadata": {},
   "source": [
    "# Line Plots"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07e3c0e4-f15a-497d-9e50-cad632234d93",
   "metadata": {},
   "source": [
    "## 2D line plots\n",
    "\n",
    "This example plots a sine wave, cosine wave, and ricker wavelet and demonstrates how Graphic Features can be modified by slicing!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "177e0cc3-870c-4570-bf59-af3528ba94bf",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import fastplotlib as fpl\n",
    "from fastplotlib.graphics.selectors import Synchronizer\n",
    "\n",
    "import numpy as np\n",
    "from sidecar import Sidecar\n",
    "from ipywidgets import VBox\n",
    "from itertools import product"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04d043ac-2849-4222-9a91-f5dd2ff40e1d",
   "metadata": {},
   "source": [
    "### First generate some data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9bf0017a-e319-4f4c-8bf8-91cff3755099",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# linspace, create 100 evenly spaced x values from -10 to 10\n",
    "xs = np.linspace(-10, 10, 100)\n",
    "# sine wave\n",
    "ys = np.sin(xs)\n",
    "sine = np.dstack([xs, ys])[0]\n",
    "\n",
    "# cosine wave\n",
    "ys = np.cos(xs) + 5\n",
    "cosine = np.dstack([xs, ys])[0]\n",
    "\n",
    "# sinc function\n",
    "a = 0.5\n",
    "ys = np.sinc(xs) * 3 + 8\n",
    "sinc = np.dstack([xs, ys])[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b00723ea-d808-4a66-ac8b-d1f78e2e6f27",
   "metadata": {},
   "source": [
    "### We will plot all of it on the same plot. Each line plot will be an individual Graphic, you can have any combination of graphics on a plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "970a5baf-a27d-4030-9659-247fccb4eff6",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2d4371cb3aad4a3591c998144d28127f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "RFBOutputContext()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/clewis7/repos/fastplotlib/fastplotlib/graphics/_features/_base.py:34: UserWarning: converting float64 array to float32\n",
      "  warn(f\"converting {array.dtype} array to float32\")\n"
     ]
    }
   ],
   "source": [
    "# Create a plot instance\n",
    "plot_l = fpl.Plot(size=(600, 300))\n",
    "\n",
    "# plot sine wave, use a single color\n",
    "sine_graphic = plot_l.add_line(data=sine, thickness=5, colors=\"magenta\")\n",
    "\n",
    "# you can also use colormaps for lines!\n",
    "cosine_graphic = plot_l.add_line(data=cosine, thickness=12, cmap=\"autumn\")\n",
    "\n",
    "# or a list of colors for each datapoint\n",
    "colors = [\"r\"] * 25 + [\"purple\"] * 25 + [\"y\"] * 25 + [\"b\"] * 25\n",
    "sinc_graphic = plot_l.add_line(data=sinc, thickness=5, colors = colors)\n",
    "\n",
    "sc = Sidecar(title=\"lines\")\n",
    "\n",
    "with sc: \n",
    "    display(plot_l.show())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2200da08-205e-4ae0-a3e7-9ec4049606c9",
   "metadata": {},
   "source": [
    "### Graphic features support slicing! :D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "633aa156-9443-41c4-beeb-b0db4e9a1099",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# indexing of colors\n",
    "cosine_graphic.colors[:40] = \"magenta\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "df876d25-42e1-4a19-ba00-25cbaf87b706",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# more complex indexing, set the red value directly from an array\n",
    "cosine_graphic.colors[65:90, 0] = np.linspace(0, 1, 90-65)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edeb566e-2647-4bed-8bd1-698b95549383",
   "metadata": {},
   "source": [
    "### You can capture changes to a graphic feature as events"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "8bb73acd-a4a3-4660-baca-f044793b9ea5",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def callback_func(event_data):\n",
    "    print(event_data)\n",
    "\n",
    "# Will print event data when the color changes\n",
    "cosine_graphic.colors.add_event_handler(callback_func)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "ff7e76ef-5bd8-42e0-8e7f-17e586324be8",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FeatureEvent @ 0x7efe4bfa4e50\n",
      "type: colors\n",
      "pick_info: {'index': range(15, 50, 3), 'collection-index': None, 'world_object': <weakproxy at 0x7efe51c507c0 to Line at 0x7efe4bf27ed0>, 'new_data': array([[0., 1., 1., 1.],\n",
      "       [0., 1., 1., 1.],\n",
      "       [0., 1., 1., 1.],\n",
      "       [0., 1., 1., 1.],\n",
      "       [0., 1., 1., 1.],\n",
      "       [0., 1., 1., 1.],\n",
      "       [0., 1., 1., 1.],\n",
      "       [0., 1., 1., 1.],\n",
      "       [0., 1., 1., 1.],\n",
      "       [0., 1., 1., 1.],\n",
      "       [0., 1., 1., 1.],\n",
      "       [0., 1., 1., 1.]], dtype=float32)}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# more complex indexing of colors\n",
    "# from point 15 - 50, set every 3rd point as \"cyan\"\n",
    "cosine_graphic.colors[15:50:3] = \"cyan\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "44d55357-4bd9-47ba-9f39-001c12e83eb5",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "plot_l.close()\n",
    "sc.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9db0e4b-c747-4e0f-b2e8-1bee48d03f02",
   "metadata": {},
   "source": [
    "### colormaps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "2c6eda00-3883-48d2-af14-31c5a4b6bcd1",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0c3f05008a0249869be6eea987829958",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "RFBOutputContext()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot = fpl.Plot(size=(600, 300))\n",
    "\n",
    "plot.add_line(sine, thickness=10, name=\"sine\")\n",
    "\n",
    "sc = Sidecar(title=\"line plot\")\n",
    "\n",
    "with sc:\n",
    "    display(plot.show())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e3d190b5-a2c7-4ec4-918d-b934270bf1c4",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# set cmap \n",
    "plot[\"sine\"].cmap = \"jet\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "ff9eff43-16fb-477e-b201-da728f18d7e1",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# set cmap values equal sine wave y-values \n",
    "plot[\"sine\"].cmap.values = sine[:, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "74a592de-76be-4726-ae29-4a0b93ae9456",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# set cmap values equal to cosine wave y-values\n",
    "plot[\"sine\"].cmap.values = cosine[:, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "10be65e2-5dce-49d1-8bb7-c12bec835a2b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# change the cmap, cmap values remain the same\n",
    "plot[\"sine\"].cmap = \"viridis\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66de4d43-11e6-4662-be23-57b8e400ab75",
   "metadata": {
    "tags": []
   },
   "source": [
    "**Qualitative data**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "6865697d-159e-47c1-a372-9fc350e02d31",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# qualitatively set the cmap values\n",
    "cmap_values = [0] * 25 + [1] * 5 + [2] * 50 + [3] * 20\n",
    "plot[\"sine\"].cmap.values = cmap_values"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2924933-e217-4f57-8617-52032d807489",
   "metadata": {},
   "source": [
    "**Qualitative cmap**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "53c12b6b-485e-4623-a111-46127206223b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# now change the cmap to new cmap with those same cmap values\n",
    "plot[\"sine\"].cmap = \"tab10\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "bf9fbc9a-a887-45c9-921b-54d037aa1b57",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "plot.close()\n",
    "sc.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6257941-3083-47fd-8065-d40da4bca1c5",
   "metadata": {},
   "source": [
    "## Line Collections"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "817355c4-0150-41de-a1d9-4c1f3680a7bc",
   "metadata": {},
   "source": [
    "**Generate some data, 4 x 4 circles**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "5d92ecd2-2177-4cd9-8643-c8691ee1e988",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def make_circle(center, radius: float, n_points: int = 75) -> np.ndarray:\n",
    "    theta = np.linspace(0, 2 * np.pi, n_points)\n",
    "    xs = radius * np.sin(theta)\n",
    "    ys = radius * np.cos(theta)\n",
    "\n",
    "    return np.column_stack([xs, ys]) + center\n",
    "\n",
    "\n",
    "spatial_dims = (50, 50)\n",
    "\n",
    "# this makes 16 circles, so we can create 16 cmap values, so it will use these values to set the\n",
    "# color of the line based by using the cmap as a LUT with the corresponding cmap_value\n",
    "circles = list()\n",
    "for center in product(range(0, spatial_dims[0], 15), range(0, spatial_dims[1], 15)):\n",
    "    circles.append(make_circle(center, 5, n_points=75))\n",
    "\n",
    "pos_xy = np.vstack(circles)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbed2426-5d27-4f8b-91bd-5a0fe514a0ed",
   "metadata": {},
   "source": [
    "### Qualitative cmap\n",
    "\n",
    "Useful for clustering or classification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "c9f83313-60ef-4b58-baaf-bcbf3564eb31",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2ec123f30def4c7f9fa7a196fde3f490",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "RFBOutputContext()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot = fpl.Plot(size=(600, 600))\n",
    "\n",
    "# things like class labels, cluster labels, etc.\n",
    "cmap_values = [\n",
    "    0, 1, 1, 2,\n",
    "    0, 0, 1, 1,\n",
    "    2, 2, 3, 3,\n",
    "    1, 1, 1, 5\n",
    "]\n",
    "\n",
    "plot.add_line_collection(\n",
    "    circles, \n",
    "    cmap=\"tab10\", \n",
    "    cmap_values=cmap_values, \n",
    "    thickness=15\n",
    ")\n",
    "\n",
    "sc = Sidecar(title=\"lines collection\")\n",
    "\n",
    "with sc:\n",
    "    display(plot.show())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "981bbd25-ca42-492d-a722-185ffc877462",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "plot.close()\n",
    "sc.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54374981-9a79-4887-a297-8a5012ebb4b7",
   "metadata": {},
   "source": [
    "## neuro data example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6901f4b7-d1f8-4747-b8b0-de078ae4c825",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# load in movie \n",
    "movie = np.load('./fpl-scipy2023-data/neural_data/rcm.npy')\n",
    "\n",
    "# load in identified nuerons\n",
    "contours = np.load('./fpl-scipy2023-data/neural_data/contours.npy', allow_pickle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "162a1602-2201-45be-bcc2-6fd7550cf0e4",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "03ad937b478444248aac85fa2ae4c62d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "RFBOutputContext()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# for the image data and contours\n",
    "cnmf_iw = fpl.ImageWidget(\n",
    "    movie, \n",
    "    vmin_vmax_sliders=True, \n",
    "    grid_plot_kwargs={\"size\": (600, 500)},\n",
    "    cmap=\"gray\"\n",
    ")\n",
    "\n",
    "# stack the plots and show them in sidecar\n",
    "sc = Sidecar(title=\"good/bad comps\")\n",
    "\n",
    "with sc:\n",
    "    display(cnmf_iw.show())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "2e34929f-55dd-43d5-8736-8253ad11d96e",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "cnmf_iw.vmin_vmax_sliders[0].value = (-5, 15)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3189906a-d7e7-40b5-8bb5-a438ca7ecb0a",
   "metadata": {},
   "source": [
    "### Colors based on classifier output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "6a9005e6-2c6b-4561-8890-0a576273e609",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# indices of accepted_ixs components\n",
    "accepted_ixs = np.load('./fpl-scipy2023-data/neural_data/good_ixs.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "63c95616-80d2-42aa-948b-2c5ea48c349d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1,\n",
       "       0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1,\n",
       "       1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0,\n",
       "       1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1,\n",
       "       1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1,\n",
       "       0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0,\n",
       "       1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1,\n",
       "       1])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classifier = np.zeros(len(contours), dtype=int)\n",
    "classifier[accepted_ixs] = 1\n",
    "\n",
    "classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "83cb0f1b-7ade-4237-afb3-ad4516f893cd",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# add contours to the plot within the widget\n",
    "contours_graphic = cnmf_iw.gridplot[0,0].add_line_collection(\n",
    "    contours, \n",
    "    cmap=\"Set1\",\n",
    "    cmap_values=classifier,\n",
    "    thickness=3, \n",
    "    name=\"contours\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ee60d93-8be8-4cf3-8b4c-75e521379d4e",
   "metadata": {},
   "source": [
    "## Red: class 0 - rejected\n",
    "\n",
    "## Blue: class 1 - accepted"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a254ed4-370c-4b5a-8c55-8b9603af7816",
   "metadata": {},
   "source": [
    "### cmaps for quantitative metrics "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90e7e79a-2879-454a-9293-e8abda55808e",
   "metadata": {},
   "source": [
    "#### yet another measure, signal-to-noise measure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "f7490d2f-f667-445f-aeb8-d8d83de77372",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.30693739,  0.98832133,  0.61094959,  0.60680478,  0.78905172,\n",
       "        0.75528032,  0.07143519,  0.20501458,  0.82659848,  0.72253894,\n",
       "        0.50721547,  0.06808205,  0.09170267,  0.16848598,  1.21936687,\n",
       "        0.60382365,  0.46201108,  0.62335868,  0.31698763,  0.6426985 ,\n",
       "        0.60684258,  0.5431985 ,  0.59940984,  0.64724762,  0.29722249,\n",
       "        0.29662902,  0.61015591,  0.31969486,  1.19550207,  0.5710063 ,\n",
       "        0.46383772,  1.02528406,  0.72630303,  0.40776261,  0.19654701,\n",
       "        0.52004469,  0.09369996, -0.14752256,  1.05310796,  0.37688607,\n",
       "        0.41622687,  1.17317543,  0.73611689,  0.42182707,  0.3150909 ,\n",
       "        0.21921744,  0.3789719 , -0.06830937,  0.35099327, -0.08058595,\n",
       "        0.71089304,  0.44862497,  0.34431778,  0.03256675,  0.28882971,\n",
       "        0.61887717,  0.76572043,  0.51032459,  0.63065994,  0.95790937,\n",
       "        0.63282506,  0.65043055,  0.44677766,  0.31964022,  0.41866778,\n",
       "        0.18621914,  0.90540626,  0.7797958 ,  0.3603792 ,  0.51412954,\n",
       "        0.32145975,  1.16006419,  0.05515471,  0.46310168,  0.66458612,\n",
       "        0.58251201,  0.33845468,  0.46522393,  0.01540801, -0.14980613,\n",
       "        0.14016509,  0.39933608,  0.16530968,  0.15592701,  0.20202153,\n",
       "       -0.41106995,  0.1119999 ,  0.42393534,  1.22942341,  0.13633389,\n",
       "        0.22779662,  0.24890452,  0.212523  ,  0.49994003,  0.19132364,\n",
       "        0.72399517,  0.47901872,  0.01965678,  0.18721191,  0.54839699,\n",
       "        0.10548312,  0.36355986, -0.30731671,  0.57231072,  0.28601665,\n",
       "       -0.3082514 ,  0.23907098,  1.03830112,  0.14206076,  0.55663581,\n",
       "       -0.21548934,  0.38826583,  0.31809138,  0.14230872,  0.87761188,\n",
       "        0.83902665,  0.58369984,  0.419747  ,  0.47968704,  0.31675268,\n",
       "        0.84700962,  0.21892391,  0.56579811, -0.28278322,  0.61361115,\n",
       "        1.40618154,  1.23015299,  0.64253497,  1.120344  ,  1.0578779 ,\n",
       "        1.09035117,  0.52459236,  0.89245759,  0.574191  ,  0.52985482,\n",
       "        0.80768994,  0.56405192,  0.35819001,  0.69566203,  0.56113173,\n",
       "        0.97317729,  1.10191489,  0.88968622,  0.66573856,  0.79040525,\n",
       "        0.58058598,  0.71475437,  0.56642353,  0.74560174,  0.72704435,\n",
       "        0.53325174,  0.82447437,  0.59551337,  0.01806211,  1.07601128])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# load in SNR comps\n",
    "snr_comps = np.load('./fpl-scipy2023-data/neural_data/SNR_comps.npy')\n",
    "np.log10(snr_comps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "d5b21e2e-c9af-4459-86ac-2b61996ee55b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "contours_graphic.cmap = \"spring\"\n",
    "contours_graphic.cmap_values = np.log10(snr_comps)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb48230f-258f-48b1-b131-90f03ce8ca75",
   "metadata": {},
   "source": [
    "## low signal to noise: purple\n",
    "\n",
    "## high signal to noise: yellow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "32ed59ef-d956-4e83-b12f-8c496e1579e4",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "cnmf_iw.gridplot.close()\n",
    "sc.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1a34cfd-3746-489e-aeff-7373d538ab8b",
   "metadata": {},
   "source": [
    "## Line Stack - useful for time series data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4ea3e6c-39f7-4796-b784-9ca175318356",
   "metadata": {},
   "source": [
    "### 3 Generate some sine data, 3 million points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "d7d5e7ca-f32d-4d3b-8ca3-3cfa72852614",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "xs = np.linspace(0, 2_000, 3_000)\n",
    "# sine wave\n",
    "ys = np.sin(xs) * 20\n",
    "\n",
    "data = np.vstack([ys] * 1_000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "ed90fe0e-38ee-4ffd-97f7-3b62ef4dc6db",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1000, 3000)"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "a70bf880-5497-476d-ba43-4c1687b49abc",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "af520ea5065b442c9e193784e656eb62",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "RFBOutputContext()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot = fpl.Plot(size=(600, 500), canvas=\"jupyter\")\n",
    "\n",
    "# line stack takes all the same arguments as line collection\n",
    "# and behaves similarly\n",
    "plot.add_line_stack(data, cmap=\"jet\", separation=15, name=\"many-lines\")\n",
    "\n",
    "sc = Sidecar(title=\"line stack\")\n",
    "\n",
    "with sc:\n",
    "    display(plot.show(maintain_aspect=False))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff71b41c-3dae-43ad-906b-db6e34a13b6b",
   "metadata": {},
   "source": [
    "## Performant changes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "ba65f98c-42db-4c7c-80a6-daf3bad54d78",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "plot[\"many-lines\"].cmap = \"viridis\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e39322e-909a-41c1-8b07-ef12e0f67213",
   "metadata": {},
   "source": [
    "**more numpy-like indexing :D**\n",
    "\n",
    "Set the cmap of the first 500 individual lines to `plasma`. \n",
    "This sets the cmap _along the line_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "963daef5-3701-49bf-832a-74c85efcdaed",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "plot[\"many-lines\"][:500].cmap = \"plasma\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "394a267f-ff08-43df-844b-0a311e009dfd",
   "metadata": {},
   "source": [
    "Every 5th datapoint to \"white\" or \"black\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "f05b4023-f949-4043-b9ef-82d9728512e4",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "plot[\"many-lines\"][:500].colors[::5] = \"w\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "7a3b8014-a89e-4138-98ac-ed3cbf1f0d51",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "plot.close()\n",
    "sc.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52de9079-c7b2-470f-ad95-ee7cd3cbe15e",
   "metadata": {},
   "source": [
    "## Linear Region Selector\n",
    "\n",
    "Creates a linear region bounded graphic which can be moved along either the x-axis or y-axis.\n",
    "Allows sub-selecting data from a `Graphic` or from multiple `Graphic` objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "68403bc0-262c-42b9-986c-8cad25152f39",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def interpolate(subdata: np.ndarray, axis: int):\n",
    "    \"\"\"1D interpolation to display within the preallocated data array\"\"\"\n",
    "    x = np.arange(0, zoomed_prealloc)\n",
    "    xp = np.linspace(0, zoomed_prealloc, subdata.shape[0])\n",
    "    \n",
    "    # interpolate to preallocated size\n",
    "    return np.interp(x, xp, fp=subdata[:, axis])  # use the y-values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "87670f5c-ec83-4d71-87ec-1d13bb05dc47",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "77b6cedc1b2c45eb8b2f70e80a825af5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "RFBOutputContext()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# data to plot\n",
    "xs = np.linspace(0, 100, 1_000)\n",
    "sine = np.sin(xs) * 20\n",
    "cosine = np.cos(xs) * 20\n",
    "\n",
    "plot = fpl.GridPlot((5, 1), size=(600, 600))\n",
    "\n",
    "# preallocated size for zoomed data\n",
    "zoomed_prealloc = 1_000\n",
    "zoomed_init = np.column_stack([np.arange(zoomed_prealloc), np.random.rand(zoomed_prealloc)])\n",
    "\n",
    "# sines and cosines\n",
    "sines = [sine] * 2\n",
    "cosines = [cosine] * 2\n",
    "\n",
    "# make line stack\n",
    "line_stack = plot[0, 0].add_line_stack(sines + cosines, separation=50)\n",
    "\n",
    "# make selector\n",
    "selector = line_stack.add_linear_region_selector()\n",
    "\n",
    "# populate subplots with preallocated graphics\n",
    "for i, subplot in enumerate(plot):\n",
    "    if i == 0:\n",
    "        # skip the first one\n",
    "        continue\n",
    "    # make line graphics for displaying zoomed data\n",
    "    subplot.add_line(zoomed_init, name=\"zoomed\")\n",
    "\n",
    "\n",
    "def update_zoomed_subplots(ev):\n",
    "    \"\"\"update the zoomed subplots\"\"\"\n",
    "    zoomed_data = selector.get_selected_data()\n",
    "    \n",
    "    for i in range(len(zoomed_data)):\n",
    "        data = interpolate(zoomed_data[i], axis=1)\n",
    "        plot[i + 1, 0][\"zoomed\"].data = data\n",
    "        plot[i + 1, 0].auto_scale()\n",
    "\n",
    "\n",
    "selector.selection.add_event_handler(update_zoomed_subplots)\n",
    "plot.show()\n",
    "sc = Sidecar(title=\"linear region selector\")\n",
    "\n",
    "with sc: \n",
    "    display(plot.show())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "89b9ed5b-8fdb-4fa7-95f7-f955cec9ed74",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "plot.close()\n",
    "sc.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c555db89-5d44-41b9-ab5a-ebd43bc0e3fb",
   "metadata": {},
   "source": [
    "## Heatmap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d201138f-a44f-4f87-b456-33b0ad7f41ae",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "temporal = np.load('./fpl-scipy2023-data/neural_data/temporal.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a24b06d3-f9db-406a-a63d-0159007a09c6",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5a8c28a77f5c407d8aea02964e8a6988",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "RFBOutputContext()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "547a8fc6813e4931a7441670b792a3b5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "RFBOutputContext()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# create plot\n",
    "plot = fpl.GridPlot(shape=(1,2), names=[[\"heatmap\", \"timeseries\"]])\n",
    "\n",
    "def normalize(array):\n",
    "    out = np.zeros(array.shape, dtype=array.dtype)\n",
    "    for i in range(array.shape[0]):\n",
    "        a = array[i]\n",
    "        out[i] = ((a - np.min(a)) / (np.max(a - np.min(a))))\n",
    "        \n",
    "    return out\n",
    "\n",
    "temporal_norm = normalize(temporal)\n",
    "        \n",
    "# add temporal traces as heatmap\n",
    "heatmap = plot[0,0].add_heatmap(temporal_norm)\n",
    "\n",
    "# add temporal traces as line stack\n",
    "temporal_stack = plot[0,1].add_line_stack(temporal, colors=\"magenta\")\n",
    "\n",
    "for subplot in plot:\n",
    "    subplot.camera.maintain_aspect = False\n",
    "\n",
    "# heatmap support the same selectors as lines!\n",
    "heatmap_ls = heatmap.add_linear_selector()\n",
    "temporal_stack_ls = temporal_stack.add_linear_selector()\n",
    "temporal_stack_ls.position_z = 10\n",
    "\n",
    "# the corresponding imaging data and some callbacks to update frames\n",
    "cnmf_iw = fpl.ImageWidget(movie, vmin_vmax_sliders=True, cmap=\"gray\")\n",
    "\n",
    "# update the linear selectors with current frame index\n",
    "def update_linear_selector(change):\n",
    "    ix = change[\"new\"]\n",
    "    \n",
    "    heatmap_ls.selection = ix\n",
    "    temporal_stack_ls.selection = ix\n",
    "    \n",
    "def update_ipywidget(ev):\n",
    "    ix = ev.pick_info[\"selected_index\"]\n",
    "    # for line collection sends as list\n",
    "    if not isinstance(ix, int):\n",
    "        ix = ix[0]\n",
    "    cnmf_iw.sliders[\"t\"].value = ix\n",
    "    \n",
    "cnmf_iw.sliders[\"t\"].observe(update_linear_selector, \"value\")\n",
    "heatmap_ls.selection.add_event_handler(update_ipywidget)\n",
    "temporal_stack_ls.selection.add_event_handler(update_ipywidget)\n",
    "\n",
    "    \n",
    "sc = Sidecar(title=\"heatmap interactive\")\n",
    "\n",
    "with sc:\n",
    "    display(VBox([cnmf_iw.show(), plot.show()]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "c509263b-7120-4e0c-a2cd-f68b6525994c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "cnmf_iw.vmin_vmax_sliders[0].value = (-5, 15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "4447805e-c477-48b4-8dc1-8740c2a70232",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "plot.close()\n",
    "sc.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0095e961-b72b-4e41-8502-696f03b2a6e4",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}