04_fpl_neuro_users.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Neuroscience 🧠 using `fastplotlib` 🦜 and `pynapple` 🍍\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "import fastplotlib as fpl\n",
    "import pynapple as nap\n",
    "import numpy as np\n",
    "from ipywidgets import Layout, VBox, FloatSlider\n",
    "from skimage import measure\n",
    "from sklearn.decomposition import PCA\n",
    "from scipy.stats import zscore\n",
    "from scipy.ndimage import gaussian_filter1d\n",
    "from sidecar import Sidecar\n",
    "import workshop_utils\n",
    "from store_model import TimeStore\n",
    "from IPython.display import display"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "import warnings\n",
    "\n",
    "warnings.simplefilter('ignore')\n",
    "fpl.config.party_parrot = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load the data\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "data = nap.load_file(workshop_utils.fetch_data(\"A0634-210617.nwb\"))\n",
    "\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## View the behavior and calcium data\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "time_store = TimeStore()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "behavior_data = data[\"beh_video\"]\n",
    "print(behavior_data.shape)  # (time, x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "calcium_data = data[\"calcium_video\"]\n",
    "print(calcium_data.shape)  # (time, x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "print(data[\"x\"].min(), data[\"x\"].max())\n",
    "print(data[\"z\"].min(), data[\"z\"].max())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "data[\"x\"] = data[\"x\"] + np.abs(data[\"x\"].min())\n",
    "data[\"x\"] = data[\"x\"] * behavior_data.shape[1]\n",
    "\n",
    "data[\"z\"] = data[\"z\"] + np.abs(data[\"z\"].min())\n",
    "data[\"z\"] = data[\"z\"] * behavior_data.shape[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "tracks_data = np.column_stack([data[\"z\"], data[\"x\"]])\n",
    "\n",
    "print(tracks_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Set our view of the data to where both behavior and position data are available:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "behavior_data = behavior_data.restrict(data[\"position_time_support\"])\n",
    "calcium_data = calcium_data.restrict(data[\"position_time_support\"])\n",
    "\n",
    "print(data[\"position_time_support\"].start[0], data[\"position_time_support\"].end[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# calculate min frame across movie\n",
    "# remove vignette effect from 1p endoscopic imaging\n",
    "min_frame = calcium_data.min(axis=0)\n",
    "\n",
    "# just to show you what this looks like\n",
    "iw = fpl.ImageWidget(min_frame)\n",
    "iw.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# close the plot\n",
    "iw.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create a big viz for calcium and behavior video! 🎨\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# make figure, calcium on left, behavior on right\n",
    "nap_figure = fpl.Figure(shape=(1, 2), names=[[\"calcium\", \"behavior\"]])\n",
    "\n",
    "# image graphic to display current calcium frame\n",
    "calcium_graphic = nap_figure[\"calcium\"].add_image(data=calcium_data[0] - min_frame, name=\"calcium_frame\",\n",
    "                                                  cmap=\"gnuplot2\")\n",
    "\n",
    "# a UI tool to help set and visualize vmin-vmax\n",
    "hlut = fpl.widgets.histogram_lut.HistogramLUT(data=calcium_data, image_graphic=calcium_graphic)\n",
    "# add this to the right dock\n",
    "nap_figure[\"calcium\"].docks[\"right\"].add_graphic(hlut)\n",
    "nap_figure[\"calcium\"].docks[\"right\"].size = 80\n",
    "nap_figure[\"calcium\"].docks[\"right\"].auto_scale(maintain_aspect=False)\n",
    "nap_figure[\"calcium\"].docks[\"right\"].controller.enabled = False\n",
    "\n",
    "# image graphic to display current behavior video frame\n",
    "behavior_graphic = nap_figure[\"behavior\"].add_image(data=behavior_data[0], cmap=\"gray\")\n",
    "\n",
    "# line to display the behavior tracks\n",
    "tracks_graphic = nap_figure[\"behavior\"].add_line(tracks_data, cmap=\"winter\", thickness=.1, alpha=0.5, offset=(12, 0, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Create a slider that updates the behavior and calcium videos using `pynapple`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# This time will be in seconds\n",
    "synced_time = FloatSlider(min=data[\"position_time_support\"].start, max=data[\"position_time_support\"].end, step=0.01,\n",
    "                          description=\"s\")\n",
    "\n",
    "\n",
    "# auto-resize slider\n",
    "@nap_figure.renderer.add_event_handler(\"resize\")\n",
    "def resize_slider(ev):\n",
    "    synced_time.layout = Layout(width=f\"{ev.width}px\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Add the components of our visualization to the `TimeStore` model to be synchronized 🕰️\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# add the slider\n",
    "time_store.subscribe(subscriber=synced_time)\n",
    "\n",
    "\n",
    "def substract_min(frame):\n",
    "    \"\"\"subtract min frame from current frame\"\"\"\n",
    "    global min_frame\n",
    "\n",
    "    return frame - min_frame\n",
    "\n",
    "\n",
    "# add our calcium data\n",
    "time_store.subscribe(subscriber=calcium_graphic, data=calcium_data, data_filter=substract_min)\n",
    "\n",
    "# add our behavior data\n",
    "time_store.subscribe(subscriber=behavior_graphic, data=behavior_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "sc = Sidecar()\n",
    "with sc:\n",
    "    display(VBox([nap_figure.show(), synced_time]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualize head angle just by setting the cmap transform, it's that simple! 🪄\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# set cmap transform from \"ry\" head angle\n",
    "tracks_graphic.cmap.transform = data[\"ry\"].to_numpy()\n",
    "\n",
    "# change to a heatmap more suitable for this data\n",
    "tracks_graphic.cmap = \"hsv\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# ### Visualize other kinematics just by setting the cmap transform! :D\n",
    "def get_velocity(array):\n",
    "    return np.gradient(np.abs(gaussian_filter1d(array, sigma=10)))\n",
    "\n",
    "\n",
    "# velocity if the y-direction\n",
    "tracks_graphic.cmap.transform = get_velocity(data[\"z\"].to_numpy())\n",
    "tracks_graphic.cmap = \"seismic\"  # diverging colormap, velocities are negative and positive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# velocity in the x-direction\n",
    "tracks_graphic.cmap.transform = get_velocity(data[\"x\"].to_numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "tracks_graphic.cmap.transform = data[\"ry\"].to_numpy()\n",
    "tracks_graphic.cmap = \"hsv\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualize Calcium Imaging ROIs\n",
    "#### Calculate the spatial contours and overlay them on the raw calcium data\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# get the masks\n",
    "contour_masks = data.nwb.processing['ophys']['ImageSegmentation']['PlaneSegmentation']['image_mask'].data[:]\n",
    "# reshape the masks into a list of 105 components\n",
    "contour_masks = list(contour_masks.reshape((len(contour_masks), 166, 136)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# calculate each contour from the mask using `scikit-image.measure`\n",
    "contours = list()\n",
    "\n",
    "for mask in contour_masks:\n",
    "    contours.append(np.vstack(measure.find_contours(mask)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Add the calculated contours as an overlay to the calcium video\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "contours_graphic = nap_figure[\"calcium\"].add_line_collection(data=contours, colors=\"w\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Select only head-direction neurons\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# get the temporal data (calcium transients) from the nwb notebook\n",
    "temporal_data = data[\"RoiResponseSeries\"][:].restrict(data[\"position_time_support\"])\n",
    "temporal_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# compute 1D tuning curved based on head angle\n",
    "head_angle = data[\"ry\"]\n",
    "\n",
    "tuning_curves = nap.compute_1d_tuning_curves_continuous(temporal_data, head_angle, nb_bins=120)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Select the top 50 components\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# select good components\n",
    "good_ixs = list(np.argsort(np.ptp(tuning_curves, axis=0))[-50:])\n",
    "bad_ixs = list(np.argsort(np.ptp(tuning_curves, axis=0))[:-50])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Color the \"good\" and \"bad\" components\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "contours_graphic[good_ixs].colors = \"w\"\n",
    "contours_graphic[bad_ixs].colors = \"magenta\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sort the \"good\" components based on preferred head direction\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "sorted_ixs = tuning_curves.iloc[:, good_ixs].idxmax().sort_values().index.values\n",
    "\n",
    "print(sorted_ixs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Filter the dataset to only use the sorted \"good\" components\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "temporal_data = temporal_data[:, sorted_ixs]\n",
    "contours = [contours[i] for i in sorted_ixs]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot only the \"good\" components\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# remove the graphic of all the components\n",
    "nap_figure[\"calcium\"].remove_graphic(contours_graphic)\n",
    "\n",
    "# re-plot only the good ixs\n",
    "contours_graphic = nap_figure[0, 0].add_line_collection(data=contours, colors=\"w\", alpha=0.8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualize all calcium tracing using an `ImageGraphic` to display a heatmap\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# create a figure, 2 rows, 1 column\n",
    "temporal_fig = fpl.Figure(shape=(2,1), names=[[\"temporal-heatmap\"], [\"tuning-curve\"]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# we need to transpose our temporal data so that it is (# components, time (s))\n",
    "raw_temporal = temporal_data.to_numpy().T\n",
    "\n",
    "# use 'hsv' colormap to represent preferred head direction\n",
    "heatmap_graphic = temporal_fig[0,0].add_image(data=raw_temporal, cmap=\"plasma\", name=\"traces\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Add a `LinearSelector` that we can map to our behavior and calcium videos\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "time_selector = heatmap_graphic.add_linear_selector()\n",
    "\n",
    "# add a selector for the y-axis to select components\n",
    "component_selector = heatmap_graphic.add_linear_selector(axis=\"y\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# subscribe x-axis selector to timestore\n",
    "time_store.subscribe(subscriber=time_selector, multiplier=temporal_data.rate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's view everything together\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "@nap_figure.renderer.add_event_handler(\"resize\")\n",
    "def resize_temporal_fig(ev):\n",
    "    temporal_fig.canvas.set_logical_size(ev.width, 300)\n",
    "\n",
    "sc = Sidecar()\n",
    "\n",
    "with sc:\n",
    "    display(VBox([nap_figure.show(), temporal_fig.show(maintain_aspect=False), synced_time]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# select the first component\n",
    "ix = 0\n",
    "\n",
    "# set the first component colors to magenta\n",
    "contours_graphic[ix].colors = \"green\"\n",
    "\n",
    "# get the tuning curve of the first component\n",
    "tuning_ix = sorted_ixs[ix]\n",
    "\n",
    "tuning_curve = tuning_curves.T.iloc[tuning_ix]\n",
    "\n",
    "# add the tuning curve to the plot as a line\n",
    "tuning_graphic = temporal_fig[\"tuning-curve\"].add_line(data=tuning_curve, offset=(0,0,0))\n",
    "temporal_fig[\"tuning-curve\"].auto_scale(maintain_aspect=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Add an event handler that allows us to \"scroll\" through the components and tuning curves :D\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "@component_selector.add_event_handler(\"selection\")\n",
    "def update_selected_trace(ev):\n",
    "    ix = ev.get_selected_index()\n",
    "\n",
    "    # reset the colors of the components to white\n",
    "    contours_graphic.colors = \"w\"\n",
    "\n",
    "    # set the selected component colors to magenta\n",
    "    contours_graphic[ix].colors = \"green\"\n",
    "\n",
    "    nap_figure[\"calcium\"].camera.show_object(contours_graphic[ix].world_object)\n",
    "\n",
    "    # get tuning curve of the selected component\n",
    "    tuning_ix = sorted_ixs[ix]\n",
    "\n",
    "    tuning_curve = tuning_curves.T.iloc[tuning_ix]\n",
    "\n",
    "    # remove the current tuning curve add the new one\n",
    "    # global tuning_graphic\n",
    "    temporal_fig[\"tuning-curve\"].graphics[0].data[:, 1] = tuning_curve\n",
    "    temporal_fig[\"tuning-curve\"].auto_scale(maintain_aspect=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Downstream analysis, view a PCA of the calcium\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# ### Perform PCA\n",
    "\n",
    "pca = PCA(n_components=3)\n",
    "\n",
    "zscored = zscore(np.sqrt(temporal_data.to_numpy()), axis=1)\n",
    "calcium_pca = pca.fit_transform(gaussian_filter1d(zscored, sigma=3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Plot the PCA results\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# restrict the head angle data\n",
    "ry_restrict = data[\"ry\"].restrict(data[\"position_time_support\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "x = np.arange(0, temporal_data.shape[0])\n",
    "xp = np.linspace(0, temporal_data.shape[0], ry_restrict.shape[0])\n",
    "\n",
    "# interpolate\n",
    "ry_transform = np.interp(x, xp, fp=ry_restrict)  # use the y-values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Make plot\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "fig_pca = fpl.Figure(\n",
    "    cameras=\"3d\",\n",
    "    controller_types=\"orbit\",\n",
    ")\n",
    "fig_pca[0, 0].add_scatter(calcium_pca, cmap=\"hsv\", cmap_transform=ry_transform, sizes=4, alpha=0.4)\n",
    "marker_graphic = fig_pca[0, 0].add_scatter(calcium_pca[0], sizes=10)\n",
    "\n",
    "fig_pca.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Subscribe the PCA marker to the `TimeStore` model\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# create a `pynapple.TsdFrame` for the PCA data\n",
    "pca_data = nap.TsdFrame(t=temporal_data.t, d=calcium_pca)\n",
    "\n",
    "time_store.subscribe(subscriber=marker_graphic, data=pca_data, multiplier=temporal_data.rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "fig_pca[0, 0].controller = \"fly\""
   ]
  }
 ],
 "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}