notebooks/mcorr_cnmf.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "3f221a4a-8930-4fbf-85a1-aaa6b959bf54",
   "metadata": {},
   "source": [
    "# Running this notebook\n",
    "\n",
    "**The visualizations in this notebook will run in [jupyter lab](https://github.com/jupyterlab/jupyterlab#installation), not jupyter notebook. Google colab is not supported either. VS Code notebooks _might_ work but that has not been tested.** See the fastplotlib supported frameworks for more info: https://github.com/fastplotlib/fastplotlib/#supported-frameworks "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "175ae92b-73fa-44d8-ab75-fb3399f68e12",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "from copy import deepcopy\n",
    "import os\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from matplotlib import pyplot as plt\n",
    "import fastplotlib as fpl\n",
    "\n",
    "import mesmerize_core as mc\n",
    "import mesmerize_viz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dbfceadc-8ef2-4c76-83e2-941be9bf4514",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from mesmerize_core.caiman_extensions.cnmf import cnmf_cache"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0ce7428c-b342-43a7-97b8-31770d45ad76",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "if os.name == \"nt\":\n",
    "    # disable the cache on windows, this will be automatic in a future version\n",
    "    cnmf_cache.set_maxsize(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4d9af3a4-c27b-4f97-a3c0-225962c4684a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Mac users!\n",
    "# temporary patch for Mac, won't be necessary in next release\n",
    "# Thanks Ryan Ly for the PR! :D I need to dig into it more before merging\n",
    "# conda_prefix_1_str = os.environ['CONDA_PREFIX'].replace(os.path.join(' ', 'envs', 'mescore')[1:], '')\n",
    "# os.environ['CONDA_PREFIX_1'] = conda_prefix_1_str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d8e11779-e36d-42d6-a885-8a527742195b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is just a pandas table display formatting option\n",
    "pd.options.display.max_colwidth = 120"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c16f235f-703b-4004-9cde-46794cafcf4a",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "tags": []
   },
   "source": [
    "# Paths\n",
    "\n",
    "`mesmerize-core` helps manage the outputs of caiman algorithms and organizes \"parameter variants\" - the output of a given combination of input data and algorithm parameters. In order to run the algorithms you must tell `mesmerize-core` where your _input data_ are located and decide on a **top level raw data directory**. For example consider the following directory structure of experimental data (you may organize your raw data however you wish, this is just an example). We can see that all the experimental data lies under `/data/group_name/my_name/exp_data`. Therefore we can use this `exp_data` dir as a `parent raw data path`. `mesmerize-core` will then only store the _relative_ paths to the raw data files, this allows you to move datasets between computers and filesystems. `mesmerize-core` does not store any hard file paths, only relative paths.\n",
    "\n",
    "```\n",
    "/data/group_name/my_name\n",
    "                        └── exp_data\n",
    "                            ├── axonal_imaging\n",
    "                            │   ├── mouse_1\n",
    "                            │   │   ├── exp_a.tiff\n",
    "                            │   │   ├── exp_b.tiff\n",
    "                            │   │   └── exp_c.tiff\n",
    "                            │   ├── mouse_2\n",
    "                            │   │   ├── exp_a.tiff\n",
    "                            │   │   └── exp_b.tiff\n",
    "                            │   └── mouse_3\n",
    "                            └── hippocampus_imaging\n",
    "                                ├── mouse_1\n",
    "                                │   ├── exp_a.tiff\n",
    "                                │   ├── exp_b.tiff\n",
    "                                │   └── exp_c.tiff\n",
    "                                ├── mouse_2\n",
    "                                └── mouse_3\n",
    "```\n",
    "\n",
    "**For this demo set the `caiman_data` dir as the parent raw data path**\n",
    "\n",
    "Sidenote: We recommend using [pathlib](https://docs.python.org/3/library/pathlib.html) instead of manually managing paths as strings. `pathlib` is just a part of the Python standard library, it makes it much easier to deal with paths and saves a lot of time in the long-run! It also makes your paths compatible across operating systems. Therefore even if you are on Windows you can use the regular `/` for paths, you do not have to worry about the strangeness of `\\\\` and `\\`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "233fa7a9-c623-48bd-aa2a-ef41a7204874",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "mc.set_parent_raw_data_path(\"/home/kushal/caiman_data/\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af643600-187a-4812-8fab-d277542aae45",
   "metadata": {},
   "source": [
    "### Batch path, this is where caiman outputs will be organized\n",
    "\n",
    "This can be anywhere, it does not need to be under the parent raw data path."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97455d84-91d8-4b3b-88d8-c8772d03c736",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "batch_path = mc.get_parent_raw_data_path().joinpath(\"mesmerize-batch/batch.pickle\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c78dbc4e-fda3-48b5-a736-3777ab727648",
   "metadata": {},
   "source": [
    "# Create a new batch\n",
    "\n",
    "This creates a new pandas `DataFrame` with the columns that are necessary for mesmerize. In mesmerize we call this the **batch DataFrame**. You can add additional columns relevant to your experiment, but do not modify columns used by mesmerize.\n",
    "\n",
    "Note that when you create a DataFrame you will need to use `load_batch()` to load it later. You cannot use `create_batch()` to overwrite an existing batch DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee720c3f-6eab-4552-bee4-01357d38e3cd",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# create a new batch\n",
    "df = mc.create_batch(batch_path)\n",
    "\n",
    "# to load existing batches use `load_batch()`\n",
    "# df = mc.load_batch(batch_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "363200f1-07ac-496d-9530-debbcd78e6f8",
   "metadata": {},
   "source": [
    "# View the dataframe\n",
    "\n",
    "It is empty and has the required columns for mesmerize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9b488891-0314-4d64-9f53-73e2cd8c6288",
   "metadata": {},
   "outputs": [],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f175707a-810e-4b5b-831c-bb1285707710",
   "metadata": {},
   "source": [
    "# Let's add stuff to the DataFrame!\n",
    "\n",
    "First get an input movie. An input movie must be somewhere under `parent raw data path`. It does not have to be directly under `parent raw data path`, it can be deeply nested anywhere under it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b94f1158-9d5e-40a3-94f1-cb3896b30336",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We'll use the Sue movie from caiman\n",
    "# download it if you don't have it\n",
    "from caiman.utils.utils import download_demo\n",
    "download_demo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "06afbf97-9044-497c-ad8b-ba0ad72bff5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "movie_path = mc.get_parent_raw_data_path().joinpath(\"example_movies/Sue_2x_3000_40_-46.tif\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a87d4f17-600e-4820-ae3f-384157a56e5e",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Motion correction parameters\n",
    "\n",
    "The parameters are passed **directly** to `caiman`, this means you need to use the same exact names for the parameters and you can use all the parameters that you can use with `caiman` - because it's just passing them to `caiman`.\n",
    "\n",
    "\n",
    "The parameters dict for a mesmerize batch item must have the following structure. Put all the parameters in a dict under a key called **main**. The **main** dict is then fed directly to `caiman`.\n",
    "\n",
    "```python\n",
    "{\"main\": {... params directly passed to caiman}}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "28396502-0758-49cb-a135-38430a2aa085",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# We will start with one version of parameters\n",
    "mcorr_params1 =\\\n",
    "{\n",
    "  'main': # this key is necessary for specifying that these are the \"main\" params for the algorithm\n",
    "    {\n",
    "        'max_shifts': [24, 24],\n",
    "        'strides': [48, 48],\n",
    "        'overlaps': [24, 24],\n",
    "        'max_deviation_rigid': 3,\n",
    "        'border_nan': 'copy',\n",
    "        'pw_rigid': True,\n",
    "        'gSig_filt': None\n",
    "    },\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14af1f0f-bec8-42c6-b565-8fc5516df8db",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Add a \"batch item\" to the DataFrame this is the combination of:\n",
    "* algorithm to run, `algo`\n",
    "* input movie to run the algorithm on, `input_movie_path`\n",
    "* parameters for the specified algorithm, `params`\n",
    "* a name for you to keep track of things, usually the same as the movie filename, `item_name`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0d25ff8d-a4b5-4377-afa7-ea60c7bfde72",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# add an item to the DataFrame\n",
    "df.caiman.add_item(\n",
    "    algo='mcorr',\n",
    "    input_movie_path=movie_path,\n",
    "    params=mcorr_params1,\n",
    "    item_name=movie_path.stem,  # filename of the movie, but can be anything\n",
    ")\n",
    "\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e32d04e0-1068-4583-a5d8-952db01e989b",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "We can now see that there is one item in the DataFrame. What we called a \"item\" in `mesmerize-core` DataFrames is technically called a pandas `Series` or row."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f243905-f970-443d-a106-9512c8cdeb6b",
   "metadata": {},
   "source": [
    "# Run an item\n",
    "\n",
    "There is only one item in this DataFrame and it is located at index `0`. You can run a row using `df.iloc[index].caiman.run()`\n",
    "\n",
    "Technical notes: On Linux & Mac it will run in subprocess but on Windows it will run in the local kernel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "797963a0-77d1-4479-a7c1-2cb58d314eb3",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df.iloc[0].caiman.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61bcf313-60e0-43ee-9533-c317e67a5082",
   "metadata": {},
   "source": [
    "# Reload DataFrame from disk\n",
    "\n",
    "After running one or any number of items in `mesmerize-core` you must call `df = df.caiman.reload_from_disk()`. This loads the DataFrame with references to the output files in the batch directory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07680c27-ce48-4592-88af-70073f05cbf4",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df = df.caiman.reload_from_disk()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b4cfdd3a-a9d4-436f-b5c1-8b0537919609",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c8891f9-83a9-4c5b-bb73-8031afad9087",
   "metadata": {},
   "source": [
    "# Outputs\n",
    "\n",
    "We can see that the outputs column has been populated. The entries in this column do not have to be accessed directly. The `mesmerize-core` API allows you to fetch these outputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "38723db4-3ac4-494f-ba01-0e315f66e174",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "index = 0 # we will fetch stuff from index 0 which we just ran\n",
    "\n",
    "# get the motion corrected movie memmap\n",
    "mcorr_movie = df.iloc[0].mcorr.get_output()\n",
    "mcorr_movie.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa2331c6-e190-4f05-88bc-0022d02a375a",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# path to the mcorr memmap if you ever need it\n",
    "mcorr_memmap_path = df.iloc[0].mcorr.get_output_path()\n",
    "mcorr_memmap_path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "85708edb-fafa-42ff-b3bb-ce046d5528db",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# mean projection, max and std projections are also available\n",
    "mean_proj = df.iloc[0].caiman.get_projection(\"mean\")\n",
    "mean_proj.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f82e27e1-a566-4693-91fc-da04606f2159",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# the input movie, note that we use `.caiman` here instead of `.mcorr`\n",
    "input_movie = df.iloc[0].caiman.get_input_movie()\n",
    "input_movie.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f0316b3-770c-44a5-994a-e3aca6c26939",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Note on input movies\n",
    "\n",
    "`get_input_movie()` will automatically work with most tiff files and memmaps. If you want to load other file types, you will need to pass it a function (see examples below) that returns a lazy-loadable array, or a numpy array if you have enough RAM. \n",
    "\n",
    "\n",
    "### tiff files\n",
    "\n",
    "`get_input_movie()` wil try to use `tifffile.memmap` to lazy-load tiff files. This works for some tiff files. If `tifffile.memmap` fails, `mesmerize-core` has its own `LazyTiff` implementation that it will try to fallback on. However, some not every tiff file can be lazy-loaded so it is not gaurenteed that `LazyTiff` will work. The implementation of `LazyTiff` is quite simple and you might be able to subclass it for your specific type of tiff file: https://github.com/nel-lab/mesmerize-core/blob/master/mesmerize_core/arrays/_tiff.py \n",
    "\n",
    "### hdf5 files\n",
    "\n",
    "```python\n",
    "import h5py\n",
    "\n",
    "def hdf5_reader(path):\n",
    "    f = h5py.File(path)\n",
    "    return f[\"your-key\"]\n",
    "\n",
    "input_movie = df.iloc[index].caiman.get_input_movie(hdf5_reader)\n",
    "```\n",
    "\n",
    "### avi files\n",
    "    \n",
    "```python\n",
    "from mesmerize_core.arrays import LazyVideo\n",
    "\n",
    "def video_reader(path):\n",
    "    a = LazyVideo(path)  # you can use the other args if you want\n",
    "    return a\n",
    "\n",
    "input_movie = df.iloc[index].caiman.get_input_movie(video_reader)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b44371ad-f0e8-4958-bec4-fb84a8ea43ed",
   "metadata": {},
   "source": [
    "# Visualize with mesmerize-viz!\n",
    "\n",
    "- Random-access frames\n",
    "- Slider for frame averaging over a window - useful for quality control\n",
    "- adjust cmap, vmin vmax, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6820a07d-5632-474e-9fae-eb7825a9cfce",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "viz = df.mcorr.viz()\n",
    "viz.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f22162f4-c57d-4086-bd60-25cec9a34e5d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "viz.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df5fd794-0337-48dc-a205-a13051ab3c9a",
   "metadata": {},
   "source": [
    "# Visualizations are customizable\n",
    "\n",
    "Hint: use `Shift` + `Tab` to bring up the docstring for `mcorr.viz()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15745885-4933-4379-b9ff-5da580143b77",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "viz = df.mcorr.viz(\n",
    "    data_options=[\"input\", \"mcorr\"],\n",
    "    image_widget_kwargs={\"grid_plot_kwargs\": {\"size\": (800, 400)}},\n",
    ")\n",
    "viz.show(sidecar=True)  # show in sidecar"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e99bd8cd-c3fd-400e-9adc-ca24114e2efa",
   "metadata": {},
   "source": [
    "# Customization\n",
    "\n",
    "We call `viz` a \"Viz Container\". The `McorrVizContainer` has a fastplotlib `ImageWidget` that you can access."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa1e1764-1bb1-4ce1-98e1-9240fbb853cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "viz"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff9587b8-c0bf-41a5-a580-bd61fb8118fd",
   "metadata": {},
   "source": [
    "**Use tab completion to see public methods and attributes**\n",
    "\n",
    "``viz.<Tab>``"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9b2b6224-9a5e-40a0-ac60-459260e9eb83",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "viz.image_widget"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1c74746-dc5d-4bd3-8d27-19945b07978c",
   "metadata": {},
   "source": [
    "Change colormaps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b4f7c050-cfb4-462b-adca-95a4c534974f",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "viz.image_widget.cmap = \"gray\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9ae4afc0-dac6-49f8-82b2-14d68f7f0182",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "viz.image_widget.cmap = \"viridis\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33b8dce5-0164-4b4c-8bfd-5d3b64507af5",
   "metadata": {},
   "source": [
    "Access subplots, graphics, etc. The full suite of the `fastplotlib` API"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5fcc9a47-4127-42ef-bd10-4206ede0a890",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "viz.image_widget.gridplot[\"mcorr\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b1ce3994-cd29-4de8-9652-de4e9b91bc67",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "viz.image_widget.gridplot[\"mcorr\"][\"image_widget_managed\"].cmap.vmax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2ff31184-4f97-456e-b8a6-c95def9a303c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "viz.image_widget.gridplot[\"mcorr\"][\"image_widget_managed\"].cmap.vmax = 250"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fa56fd3-4a52-42a1-bc2e-a2b609e56f0d",
   "metadata": {},
   "source": [
    "# Close visualization when we are done"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "070cb879-776f-493c-85b3-4a9d9244ee8f",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "viz.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3b1329a-56e0-4a18-bf8e-7570371d77e4",
   "metadata": {},
   "source": [
    "# Parameter variants - this is the purpose of mesmerize-core!\n",
    "\n",
    "Let's add another row to the DataFrame. We will use the same input movie but different parameters. This is the basis of how we can perform a _parameter gridsearch_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f5d0785-da70-41ed-b31c-418a407ef6ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "mcorr_params2 =\\\n",
    "{\n",
    "  'main':\n",
    "    {\n",
    "        'max_shifts': [4, 4],\n",
    "        'strides': [48, 48],\n",
    "        'overlaps': [24, 24],\n",
    "        'max_deviation_rigid': 3,\n",
    "        'border_nan': 'copy',\n",
    "        'pw_rigid': True,\n",
    "        'gSig_filt': None\n",
    "    },\n",
    "}\n",
    "\n",
    "# add other param variant to the batch\n",
    "df.caiman.add_item(\n",
    "  algo='mcorr',\n",
    "  item_name=movie_path.stem,\n",
    "  input_movie_path=movie_path,\n",
    "  params=mcorr_params2\n",
    ")\n",
    "\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26480466-d5a7-422e-a9e7-ded165ad6fcc",
   "metadata": {
    "tags": []
   },
   "source": [
    "We can see that there are two batch items for the same input movie."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1596fa77-e09e-4df5-aab9-c06dd5b93c24",
   "metadata": {},
   "source": [
    "# Parameter Gridsearch\n",
    "\n",
    "Use a `for` loop to add multiple different parameter variants more efficiently."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b66724d-8164-4c9f-996d-fe3d2e592900",
   "metadata": {},
   "outputs": [],
   "source": [
    "# copy the mcorr_params2 dict to make some changes\n",
    "new_params = deepcopy(mcorr_params2)\n",
    "\n",
    "# some variants of max_shifts\n",
    "for shifts in [2, 32]: \n",
    "    for strides in [12, 24, 64]:\n",
    "        overlaps = int(strides / 2)\n",
    "        # deep copy is the safest way to copy dicts\n",
    "        new_params = deepcopy(new_params)\n",
    "\n",
    "        # assign the \"max_shifts\"\n",
    "        new_params[\"main\"][\"max_shifts\"] = (shifts, shifts)\n",
    "        new_params[\"main\"][\"strides\"] = (strides, strides)\n",
    "        new_params[\"main\"][\"overlaps\"] = (overlaps, overlaps)\n",
    "\n",
    "        df.caiman.add_item(\n",
    "          algo='mcorr',\n",
    "          item_name=movie_path.stem,\n",
    "          input_movie_path=movie_path,\n",
    "          params=new_params\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e990f5d5-5d20-48c8-a39a-ef6f7e4d9862",
   "metadata": {},
   "outputs": [],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8912227-b00e-461f-a61d-9d572a42313f",
   "metadata": {},
   "source": [
    "# Distinguishing parameter variants\n",
    "\n",
    "We can see that there are many parameter variants, but it is not easy to see the differences in parameters between the rows that have the same `item_name`.\n",
    "\n",
    "We can use the `caiman.get_params_diffs()` to see the unique parameters between rows with the same `item_name`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6398946b-ced7-4ef2-9614-f062b7a65ad5",
   "metadata": {},
   "outputs": [],
   "source": [
    "diffs = df.caiman.get_params_diffs(algo=\"mcorr\", item_name=df.iloc[0][\"item_name\"])\n",
    "diffs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e5bf8fd-bda7-45b5-9cd7-00ea6c0bac38",
   "metadata": {},
   "source": [
    "# Run multiple batch items.\n",
    "\n",
    "`df.iterrows()` iterates through rows and returns the numerical index and row for each iteration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "406aa80b-ea16-4e0b-8447-1c091cabde68",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "for i, row in df.iterrows():\n",
    "    if row[\"outputs\"] is not None: # item has already been run\n",
    "        continue # skip\n",
    "        \n",
    "    process = row.caiman.run()\n",
    "    \n",
    "    # on Windows you MUST reload the batch dataframe after every iteration because it uses the `local` backend.\n",
    "    # this is unnecessary on Linux & Mac\n",
    "    # \"DummyProcess\" is used for local backend so this is automatic\n",
    "    if process.__class__.__name__ == \"DummyProcess\":\n",
    "        df = df.caiman.reload_from_disk()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ffc9a52c-eae1-49f1-a8ba-a79b92e897e4",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "tags": []
   },
   "source": [
    "# Outputs\n",
    "\n",
    "Load the output information into the DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ab1bfbb4-2737-4aea-9e2f-673cf539279d",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df.caiman.reload_from_disk()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fc41f7a8-e80b-4262-890a-58cfb621f017",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "069ddc1e-50fc-4e67-bd68-ef1faf439e6e",
   "metadata": {},
   "source": [
    "# Visualization using `mesmerize-viz` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78708874-f58f-4508-b1f5-b07cce0203f8",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "mcorr_viz = df.mcorr.viz(\n",
    "    data_options=[\"input\", \"mcorr\"], \n",
    "    image_widget_kwargs={\"grid_plot_kwargs\": {\"size\": (1000, 500)}}  # you can also pass kwargs to the ImageWidget that is created\n",
    ")\n",
    "mcorr_viz.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "390fe3a8-27bd-4710-b6ec-5419c13a4611",
   "metadata": {},
   "outputs": [],
   "source": [
    "# close when done\n",
    "mcorr_viz.close()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "bdbf763e-8aed-4513-834b-a9b5cb361a65",
   "metadata": {},
   "source": [
    "# Build your own visualizations using `fastplotlib`\n",
    "\n",
    "# Use `ImageWidget` to view multiple mcorr results simultaneously\n",
    "\n",
    "This type of visualization usually requires your files to be lazy-loadble, and the performance will depend on your hard drive's capabilities."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d0351fcd-58ef-47cf-9f72-6a6a116da929",
   "metadata": {},
   "outputs": [],
   "source": [
    "# first item is just the raw movie\n",
    "movies = [df.iloc[0].caiman.get_input_movie()]\n",
    "\n",
    "# subplot titles\n",
    "subplot_names = [\"raw\"]\n",
    "\n",
    "# we will use the mean images later\n",
    "means = [df.iloc[0].caiman.get_projection(\"mean\")]\n",
    "\n",
    "# get the param diffs to set plot titles\n",
    "param_diffs = df.caiman.get_params_diffs(\"mcorr\", item_name=df.iloc[0][\"item_name\"])\n",
    "\n",
    "# add all the mcorr outputs to the list\n",
    "for i, row in df.iterrows():\n",
    "    # add to the list of movies to plot\n",
    "    movies.append(row.mcorr.get_output())\n",
    "\n",
    "    max_shifts = param_diffs.iloc[i][\"max_shifts\"][0]\n",
    "    strides = param_diffs.iloc[i][\"strides\"][0]\n",
    "    overlaps = param_diffs.iloc[i][\"overlaps\"][0]\n",
    "    \n",
    "    # subplot title to show dataframe index\n",
    "    subplot_names.append(f\"ix {i}: max_sh: {max_shifts}, str: {strides}, ove: {overlaps}\")\n",
    "    \n",
    "    # mean images which we'll use later\n",
    "    means.append(row.caiman.get_projection(\"mean\"))\n",
    "\n",
    "# create the widget\n",
    "mcorr_iw_multiple = fpl.ImageWidget(\n",
    "    data=movies,  # list of movies\n",
    "    window_funcs={\"t\": (np.mean, 17)}, # window functions as a kwarg, this is what the slider was used for in the ready-made viz\n",
    "    grid_plot_kwargs={\"size\": (900, 700)},\n",
    "    names=subplot_names,  # subplot names used for titles\n",
    "    cmap=\"gnuplot2\"\n",
    ")\n",
    "\n",
    "mcorr_iw_multiple.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fae7e4f4-76a4-4fd9-a717-cd4deb901fb0",
   "metadata": {},
   "source": [
    "Optionally hide the histogram LUT tool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a374e83e-16e3-49bc-ab26-2f158c1cefa6",
   "metadata": {},
   "outputs": [],
   "source": [
    "for subplot in mcorr_iw_multiple.gridplot:\n",
    "    subplot.docks[\"right\"].size = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f0f40f5-3f92-4d6d-a372-667e8bfb5672",
   "metadata": {},
   "source": [
    "Modify the `window_funcs` at any time. This is what the slider in `mesmerize-viz` does."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cec3c2bf-e211-49fb-b7c8-bae5ceca99eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "mcorr_iw_multiple.window_funcs[\"t\"].window_size = 43"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0016f010-2f47-4e13-8b4a-574aadb2b525",
   "metadata": {},
   "outputs": [],
   "source": [
    "mcorr_iw_multiple.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de6b4f8f-b168-486a-9237-f31412b19ca8",
   "metadata": {},
   "source": [
    "# Optional, cleanup DataFrame\n",
    "\n",
    "ix `6` seems to work the best so we will cleanup the DataFrame and remove all other items.\n",
    "\n",
    "Remove batch items (i.e. rows) using `df.caiman.remove_item(<item_uuid>)`. This also cleans up the output data in the batch directory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cc1fb4fd-4cb3-41ca-9ec1-a62c15711afa",
   "metadata": {},
   "outputs": [],
   "source": [
    "# make a list of rows we want to keep using the uuids\n",
    "# rows_keep = [df.iloc[6].uuid]\n",
    "# rows_keep"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "820304a4-a1bb-4719-9ae7-a69f6752f329",
   "metadata": {},
   "source": [
    "**Note:** On windows calling `remove_item()` will raise a `PermissionError` if you have the memmap file open. The workaround is to shutdown the current kernel and then use `df.caiman.remove_item()`. For example, you can keep another notebook that you use just for cleaning unwanted mcorr items.\n",
    "\n",
    "There is currently no way to close a `numpy.memmap`: https://github.com/numpy/numpy/issues/13510"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0985f784-9ef1-4718-91ee-61c6c5b931c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# for i, row in df.iterrows():\n",
    "#     if row.uuid not in rows_keep:\n",
    "#         df.caiman.remove_item(row.uuid)\n",
    "\n",
    "# df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "147fe036-370c-4b40-ad74-c74cc62fb380",
   "metadata": {},
   "source": [
    "Indices are always reset when you use `caiman.remove_item()`. UUIDs are always preserved."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6dc1260b-634c-49cc-b99b-10c44b3af72d",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# CNMF\n",
    "\n",
    "Perform CNMF using the mcorr output.\n",
    "\n",
    "Similar to mcorr, put the CNMF params within the `main` key. The `refit` key will perform a second iteration, as shown in the `caiman` `demo_pipeline.ipynb` notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cc283595-b82a-4270-a51b-f1d9cdc78d19",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# some params for CNMF\n",
    "params_cnmf =\\\n",
    "{\n",
    "    'main': # indicates that these are the \"main\" params for the CNMF algo\n",
    "        {\n",
    "            'fr': 30, # framerate, very important!\n",
    "            'p': 1,\n",
    "            'nb': 2,\n",
    "            'merge_thr': 0.85,\n",
    "            'rf': 15,\n",
    "            'stride': 6, # \"stride\" for cnmf, \"strides\" for mcorr\n",
    "            'K': 4,\n",
    "            'gSig': [4, 4],\n",
    "            'ssub': 1,\n",
    "            'tsub': 1,\n",
    "            'method_init': 'greedy_roi',\n",
    "            'min_SNR': 2.0,\n",
    "            'rval_thr': 0.7,\n",
    "            'use_cnn': True,\n",
    "            'min_cnn_thr': 0.8,\n",
    "            'cnn_lowest': 0.1,\n",
    "            'decay_time': 0.4,\n",
    "        },\n",
    "    'refit': True, # If `True`, run a second iteration of CNMF\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31ba4f19-8764-446f-895d-7ff59912f604",
   "metadata": {},
   "source": [
    "# Add CNMF item\n",
    "\n",
    "You can provide the mcorr item row to `input_movie_path` and it will resolve the path of the input movie from the entry in the DataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "29c48dd1-0eb5-48e5-96ab-0b2633983b88",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "good_mcorr_index = 6\n",
    "\n",
    "# add a batch item\n",
    "df.caiman.add_item(\n",
    "    algo='cnmf', # algo is cnmf\n",
    "    input_movie_path=df.iloc[good_mcorr_index],  # use mcorr output from a completed batch item\n",
    "    params=params_cnmf,\n",
    "    item_name=df.iloc[good_mcorr_index][\"item_name\"], # use the same item name\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d34b4eb-e6da-46e8-9899-e322cd64b5f1",
   "metadata": {
    "tags": []
   },
   "source": [
    "See the cnmf item at the bottom of the dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "10308894-6c71-4471-8cb9-d585a8adf0ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b2c7c16-24a1-4893-976e-e52e7430a9c7",
   "metadata": {},
   "source": [
    "# Run CNMF\n",
    "\n",
    "The API is identical to running mcorr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba02626d-c9cc-4313-93d6-5ea84dc6b6e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "index = -1  # most recently added item\n",
    "df.iloc[index].caiman.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc44542f-d653-40b1-821e-6ba68df6826e",
   "metadata": {},
   "source": [
    "# Reload dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "83bcc946-d5b1-4986-86df-b67d15ed9102",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df.caiman.reload_from_disk()\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1128142-282d-43f7-83c2-0408066b5f66",
   "metadata": {},
   "source": [
    "# CNMF outputs\n",
    "\n",
    "Similar to mcorr, you can use the `mesmerize-core` API to fetch the outputs. The API reference for CNMF is here: https://mesmerize-core.readthedocs.io/en/latest/api/cnmf.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34e7f7de-6a70-4d5d-b999-611509953437",
   "metadata": {},
   "outputs": [],
   "source": [
    "index = -1  # index of the cnmf item, last item in the dataframe\n",
    "\n",
    "# temporal components\n",
    "temporal = df.iloc[index].cnmf.get_temporal()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f46abe9-ddcf-4a72-b7b2-3664cb3cbccb",
   "metadata": {},
   "outputs": [],
   "source": [
    "temporal.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75e4d6de-f397-4142-a152-26cb63bf8b55",
   "metadata": {},
   "source": [
    "Many of the cnmf functions take a rich set of arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e3a23d5-e26d-49b2-962c-fc3eefc5a80f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# get accepted or rejected components\n",
    "temporal_good = df.iloc[index].cnmf.get_temporal(\"good\")\n",
    "\n",
    "# shape is [n_components, n_frames]\n",
    "temporal_good.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f23f01a8-45c4-4dc6-8e58-f50ef534f035",
   "metadata": {},
   "outputs": [],
   "source": [
    "# get specific components\n",
    "df.iloc[index].cnmf.get_temporal(np.array([1, 5, 9]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "48b6cad9-f7f4-498b-81b7-856dd1b97613",
   "metadata": {},
   "outputs": [],
   "source": [
    "# get temporal with the residuals, i.e. C + YrA\n",
    "temporal_with_residuals = df.iloc[index].cnmf.get_temporal(add_residuals=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a6963c9-81f8-4922-8bc3-a2ce468052a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# get contours\n",
    "contours = df.iloc[index].cnmf.get_contours()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cff3ce6e-78ce-4a54-85e5-45caaeb9476f",
   "metadata": {},
   "source": [
    "Returns: `(list of np.ndarray of contour coordinates, list of center of mass)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f3d1f01a-7366-4073-9f50-051ee38e0097",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"contour 0 coordinates:\\n\\n{contours[0][0]}\\n\\n com: {contours[1][0]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "67f45923-e273-4c54-8a36-5d609e04c880",
   "metadata": {},
   "outputs": [],
   "source": [
    "len(contours)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3543a94a-5c07-4ff5-b117-cdbf12fc3b6b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# get_contours() also takes arguments\n",
    "contours_good = df.iloc[index].cnmf.get_contours(\"good\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fce4858e-d632-4a98-99f4-d10d67dfb94c",
   "metadata": {},
   "outputs": [],
   "source": [
    "len(contours_good[0]) # number of contours"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e0af648-f80c-4b71-9164-4aca607e09da",
   "metadata": {},
   "source": [
    "swap_dim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0bba44b2-644b-4691-a0af-bd820fdac683",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# get the first contour using swap_dim=True (default)\n",
    "swap_dim_true = df.iloc[index].cnmf.get_contours()[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "286bf44b-7b5d-43b5-9741-7ac0e5e21852",
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the first contour  with swap_dim=False\n",
    "swap_dim_false = df.iloc[index].cnmf.get_contours(swap_dim=False)[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9231593d-7069-455f-b0d1-409a61d26ccb",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(\n",
    "    swap_dim_true[:, 0], \n",
    "    swap_dim_true[:, 1], \n",
    "    label=\"swap_dim=True\"\n",
    ")\n",
    "plt.plot(\n",
    "    swap_dim_false[:, 0], \n",
    "    swap_dim_false[:, 1], \n",
    "    label=\"swap_dim=False\"\n",
    ")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "944252d3-d654-4394-acb7-c620ccb01f85",
   "metadata": {},
   "outputs": [],
   "source": [
    "# swap_dim swaps the x and y dims\n",
    "plt.plot(\n",
    "    swap_dim_true[:, 0], \n",
    "    swap_dim_true[:, 1], \n",
    "    linewidth=30\n",
    ")\n",
    "plt.plot(\n",
    "    swap_dim_false[:, 1], \n",
    "    swap_dim_false[:, 0], \n",
    "    linewidth=10\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c6c8e98-13fd-45c6-9afe-7fc3193ed3de",
   "metadata": {},
   "source": [
    "# Reconstructed movie - `A * C`\n",
    "# Reconstructed background - `b * f`\n",
    "# Residuals - `Y - AC - bf` \n",
    "\n",
    "Mesmerize-core provides these outputs as lazy arrays. This allows you to work with arrays that would otherwise be hundreds of gigabytes or terabytes in size."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c58ce87d-4e75-4026-840c-81b826245ba3",
   "metadata": {},
   "outputs": [],
   "source": [
    "rcm = df.iloc[index].cnmf.get_rcm()\n",
    "rcm"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2722d48c-e433-4a73-8eec-9e37e053f651",
   "metadata": {},
   "source": [
    "LazyArrays behave like numpy arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b3de689-d734-4534-b36b-4ffb7f061d7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "rcm[42]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "980b03b1-c2d3-44dc-a741-d43dd689abca",
   "metadata": {},
   "outputs": [],
   "source": [
    "rcm[10:20].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6fe2ca3-0255-43fd-9ae2-c635b2d0355a",
   "metadata": {},
   "source": [
    "# Using LazyArrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf4f70d3-badc-4339-92f8-1ac0351e64b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "rcm_accepted = df.iloc[index].cnmf.get_rcm(\"good\")\n",
    "rcm_rejected = df.iloc[index].cnmf.get_rcm(\"bad\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96b638ee-ce7e-4c58-a2e5-3d46b986d04a",
   "metadata": {},
   "outputs": [],
   "source": [
    "iw_max = fpl.ImageWidget(\n",
    "    data=[rcm_accepted.max_image, rcm_rejected.max_image],\n",
    "    names=[\"accepted\", \"rejected\"],\n",
    "    grid_plot_kwargs={\"size\": (900, 450)},\n",
    "    cmap=\"gnuplot2\"\n",
    ")\n",
    "iw_max.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0517f807-bb71-4152-b1ad-ad785d4108cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "iw_rcm_separated = fpl.ImageWidget(\n",
    "    data=[rcm_accepted, rcm_rejected],\n",
    "    names=[\"accepted\", \"rejected\"],\n",
    "    grid_plot_kwargs={\"size\": (900, 450)},\n",
    "    cmap=\"gnuplot2\"\n",
    ")\n",
    "iw_rcm_separated.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "934dc203-fa0c-4c1e-b8e9-0c6dba91ef3d",
   "metadata": {},
   "source": [
    "# All CNMF LazyArrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e2acd69-bd4b-455e-85fd-b55c588e3057",
   "metadata": {},
   "outputs": [],
   "source": [
    "rcb = df.iloc[index].cnmf.get_rcb()\n",
    "residuals = df.iloc[index].cnmf.get_residuals()\n",
    "input_movie = df.iloc[index].caiman.get_input_movie()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe635528-550a-43cd-b343-931a9a0410b8",
   "metadata": {},
   "source": [
    "`ImageWidget` accepts arrays that are sufficiently numpy-like"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9b3efeec-3578-4863-bff4-0100cc489ccb",
   "metadata": {},
   "outputs": [],
   "source": [
    "iw_rcm = fpl.ImageWidget(\n",
    "    data=[input_movie, rcm, rcb, residuals], \n",
    "    grid_plot_kwargs={\"size\": (800, 600)}, \n",
    "    cmap=\"gnuplot2\"\n",
    ")\n",
    "iw_rcm.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0cbc13a6-11a0-4f98-bc4d-a3c7bb25fc53",
   "metadata": {},
   "outputs": [],
   "source": [
    "iw_rcm.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d449a312-2af9-423e-94c2-a3ab4fa374e7",
   "metadata": {},
   "source": [
    "# Visualize everything with `mesmerize-viz`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4ec1b2f-e992-42b7-902c-14cc78ba8d99",
   "metadata": {},
   "outputs": [],
   "source": [
    "viz_cnmf = df.cnmf.viz()\n",
    "viz_cnmf.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db8c98a1-2d21-400c-9bba-fcd3e450e5da",
   "metadata": {},
   "outputs": [],
   "source": [
    "viz_cnmf.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae1b2d80-1d6f-403b-b98a-3471c96f57d6",
   "metadata": {},
   "source": [
    "# Parameter Gridsearch\n",
    "\n",
    "As shown for motion correction, the purpose of `mesmerize-core` is to perform parameter searches"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fc7684d2-3d2c-43ac-9064-ba3997f7a1c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# itertools.product makes it easy to loop through parameter variants\n",
    "# basically, it's easier to read that deeply nested for loops\n",
    "from itertools import product\n",
    "\n",
    "# variants of several parameters\n",
    "gSig_variants = [4, 6]\n",
    "K_variants = [4, 8]\n",
    "merge_thr_variants = [0.8, 0.95]\n",
    "\n",
    "# always use deepcopy like before\n",
    "new_params_cnmf = deepcopy(params_cnmf)\n",
    "\n",
    "# create a parameter grid\n",
    "parameter_grid = product(gSig_variants, K_variants, merge_thr_variants)\n",
    "\n",
    "# a single for loop to go through all the various parameter combinations\n",
    "for gSig, K, merge_thr in parameter_grid:\n",
    "    # deep copy params dict just like before\n",
    "    new_params_cnmf = deepcopy(new_params_cnmf)\n",
    "    \n",
    "    new_params_cnmf[\"main\"][\"gSig\"] = [gSig, gSig]\n",
    "    new_params_cnmf[\"main\"][\"K\"] = K\n",
    "    new_params_cnmf[\"main\"][\"merge_thr\"] = merge_thr\n",
    "    \n",
    "    # add param combination variant to batch\n",
    "    df.caiman.add_item(\n",
    "        algo=\"cnmf\",\n",
    "        item_name=df.iloc[good_mcorr_index][\"item_name\"],  # good mcorr item\n",
    "        input_movie_path=df.iloc[good_mcorr_index],\n",
    "        params=new_params_cnmf\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cb21a8e-709d-4888-bbd9-42653f700240",
   "metadata": {},
   "source": [
    "We now have lot of cnmf items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0fb3f94d-34d2-4eef-ad2d-b4f6db89fa72",
   "metadata": {},
   "outputs": [],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bf8dce3-b0f7-43b0-b719-774673b6cb25",
   "metadata": {},
   "source": [
    "View the diffs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "80b98249-b3b5-4481-a4e2-dbdcbf8d1ed9",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.caiman.get_params_diffs(algo=\"cnmf\", item_name=df.iloc[-1][\"item_name\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "628a194f-39c3-45a7-a029-53925763cc1e",
   "metadata": {},
   "source": [
    "# Run the `cnmf` batch items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee0b9ac5-f66d-4370-842c-8655f5469286",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i, row in df.iterrows():\n",
    "    if row[\"outputs\"] is not None: # item has already been run\n",
    "        continue # skip\n",
    "        \n",
    "    process = row.caiman.run()\n",
    "    \n",
    "    # on Windows you MUST reload the batch dataframe after every iteration because it uses the `local` backend.\n",
    "    # this is unnecessary on Linux & Mac\n",
    "    # \"DummyProcess\" is used for local backend so this is automatic\n",
    "    if process.__class__.__name__ == \"DummyProcess\":\n",
    "        df = df.caiman.reload_from_disk()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "348d0757-675d-4a2d-a024-559507830e31",
   "metadata": {},
   "source": [
    "# Load outputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "80f3eca7-916a-4e4e-a109-5906b4c91c7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df.caiman.reload_from_disk()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c2981938-0583-4407-8035-12d11d1535bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "597b900e-e47a-4e48-b101-63f9ebf909cd",
   "metadata": {},
   "source": [
    "# Visualize with `mesmerize-viz`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4fb527d-0444-4fb4-a703-e9d12f03cfd9",
   "metadata": {},
   "outputs": [],
   "source": [
    "viz_cnmf = df.cnmf.viz()\n",
    "viz_cnmf.show(sidecar=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3df8f51-dcc7-4e45-b968-f38147e1e415",
   "metadata": {},
   "source": [
    "# Caiman docs on component eval\n",
    "\n",
    "https://caiman.readthedocs.io/en/latest/Getting_Started.html#component-evaluation\n",
    "\n",
    "> The quality of detected components is evaluated with three parameters:\n",
    ">\n",
    "> Spatial footprint consistency (rval): The spatial footprint of the component is compared with the frames where this component is active. Other component’s signals are subtracted from these frames, and the resulting raw data is correlated against the spatial component. This ensures that the raw data at the spatial footprint aligns with the extracted trace.\n",
    ">\n",
    "> Trace signal-noise-ratio (SNR): Peak SNR is calculated from strong calcium transients and the noise estimate.\n",
    ">\n",
    "> CNN-based classifier (cnn): The shape of components is evaluated by a 4-layered convolutional neural network trained on a manually annotated dataset. The CNN assigns a value of 0-1 to each component depending on its resemblance to a neuronal soma.\n",
    "> \n",
    "> Each parameter has a low threshold:\n",
    "> - (rval_lowest (default -1), SNR_lowest (default 0.5), cnn_lowest (default 0.1))\n",
    ">\n",
    "> and high threshold\n",
    "> \n",
    "> - (rval_thr (default 0.8), min_SNR (default 2.5), min_cnn_thr (default 0.9))\n",
    "> \n",
    "> A component has to exceed ALL low thresholds as well as ONE high threshold to be accepted."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97566a87-2182-496d-9dfb-83ede10ab95f",
   "metadata": {},
   "source": [
    "# This rich visualization is still customizable!\n",
    "\n",
    "Public attributes:\n",
    "\n",
    "- `image_widget`: the `ImageWidget` in the visualization\n",
    "- `plot_temporal`: the `Plot` with the temporal\n",
    "- `plot_heatmap`: the `Plot` with the heatmap\n",
    "- `cnmf_obj`: The cnmf object currently being visualized. This object gets saved to disk when you click the \"Save Eval to disk\" button.\n",
    "- `component_index`: current component index, `int`\n",
    "\n",
    "A few public methods:\n",
    "- `show()` show the visualization\n",
    "- `set_component_index(index: int)` manually set the component index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d8d70d0-eaa4-4ce2-a9f4-e5c0fc9474ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "viz_cnmf.image_widget.cmap = \"gray\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "778a211b-a4a3-4b36-b441-32c9b367a5ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "viz_cnmf.plot_heatmap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e53a507c-a274-4b41-be16-99530de5006d",
   "metadata": {},
   "outputs": [],
   "source": [
    "viz_cnmf.plot_heatmap[\"heatmap\"].cmap = \"viridis\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bb2db848-272d-4001-92cc-369e9d2d62b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "viz_cnmf.plot_heatmap[\"heatmap\"].cmap.vmax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "33758ab0-b355-450f-8edc-dc9fa5b7364f",
   "metadata": {},
   "outputs": [],
   "source": [
    "viz_cnmf.plot_heatmap[\"heatmap\"].cmap.vmax = 2_000"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b60a5224-9945-4f15-9ecb-99d448745942",
   "metadata": {},
   "source": [
    "Customize contours"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7668b133-0431-464e-af1d-0ce353628e6e",
   "metadata": {},
   "outputs": [],
   "source": [
    "for subplot in viz_cnmf.image_widget.gridplot:\n",
    "    subplot[\"contours\"][:].thickness = 1.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e238b53-9f20-44b3-ab99-94332f93b949",
   "metadata": {},
   "outputs": [],
   "source": [
    "for subplot in viz_cnmf.image_widget.gridplot:\n",
    "    subplot[\"contours\"].visible = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "61508674-8ed6-4ae2-a232-44a55bd4c646",
   "metadata": {},
   "outputs": [],
   "source": [
    "for subplot in viz_cnmf.image_widget.gridplot:\n",
    "    subplot[\"contours\"].visible = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "29abcc5a-7ecc-4e95-8532-f1a4dcc3e1f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "viz_cnmf.plot_temporal[\"line\"].thickness()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "14ae170b-096c-421d-b47d-13042ab8e4cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "viz_cnmf.plot_temporal[\"line\"].thickness = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31dd4191-9781-45b4-84cb-35a62597fb6c",
   "metadata": {},
   "source": [
    "# Visualize fewer things"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6581e60e-8827-490d-af5f-3ff8b5308680",
   "metadata": {},
   "outputs": [],
   "source": [
    "viz_simple = df.cnmf.viz(\n",
    "    image_data_options=[\"input\", \"rcm\"],\n",
    ")\n",
    "viz_simple.show(sidecar=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5479abd-2f34-4e6e-bd64-702720e25ff4",
   "metadata": {},
   "source": [
    "# More customization of kwargs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "20845bb1-5f27-4c60-8638-2d17a03cff99",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "viz_more_custom = df.cnmf.viz(\n",
    "    image_data_options=[\"input\", \"rcm\", \"rcm-max\", \"corr\"],\n",
    "    temporal_kwargs={\"add_residuals\": True},\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e8f57c5-9f9e-495a-aa44-86f18c886eed",
   "metadata": {},
   "outputs": [],
   "source": [
    "viz_more_custom.show(sidecar=True)"
   ]
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}