notebooks/SRRFandQC.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "17e14260",
   "metadata": {},
   "source": [
    "# NanoPyx \"Codeless\" Jupyter Notebook\n",
    "\n",
    "This notebook allows you to generate a super-resolution image using SRRF (Super-Resolution Radiality Fluctuations) and then assess quality control metrics such as an Error Map (NanoJ-SQUIRREL), FRC (Fourier Ring Correlation) and Decorrelation analysis.\n",
    "\n",
    "To use this notebook you don't need to interact with any code, just run cells in order and a graphical user interface will pop-up showcasing the parameters for each step.\n",
    "When running this notebook on Colab, it will automatically prompt you to connect to your google Drive, from where you can select the input data.\n",
    "To save the output of this notebook, make sure to select the \"save output\" option. Output will be saved on the same directory as the loaded image. If using an example dataset it will be saved on the path Python is currently running (if locally running the notebook) or on Colab files (if running on Colab, files button on the left bar).\n",
    "If you found this work useful for your research please consider citing our [preprint](https://www.biorxiv.org/content/10.1101/2023.08.13.553080v1)  and out Github repo [![DOI](https://zenodo.org/badge/505388398.svg)](https://zenodo.org/badge/latestdoi/505388398)\n",
    "\n",
    "**SRRF**: Culley S, Tosheva KL, Matos Pereira P, Henriques R. SRRF: Universal live-cell super-resolution microscopy. Int J Biochem Cell Biol. 2018 Aug;101:74-79. doi: 10.1016/j.biocel.2018.05.014. Epub 2018 May 28. PMID: 29852248; PMCID: PMC6025290. \n",
    "\n",
    "**Error Map**: Culley, S., Albrecht, D., Jacobs, C. et al. Quantitative mapping and minimization of super-resolution optical imaging artifacts. Nat Methods 15, 263–266 (2018). https://doi.org/10.1038/nmeth.4605\n",
    "\n",
    "**FRC**: Nieuwenhuizen RP, Lidke KA, Bates M, Puig DL, Grünwald D, Stallinga S, Rieger B. Measuring image resolution in optical nanoscopy. Nat Methods. 2013 Jun;10(6):557-62. doi: 10.1038/nmeth.2448. Epub 2013 Apr 28. PMID: 23624665; PMCID: PMC4149789.\n",
    "\n",
    "**DecorrAnalysis**: Descloux A, Grußmayer KS, Radenovic A. Parameter-free image resolution estimation based on decorrelation analysis. Nat Methods. 2019 Sep;16(9):918-924. doi: 10.1038/s41592-019-0515-7. Epub 2019 Aug 26. PMID: 31451766.  \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7acbf83c",
   "metadata": {
    "cellView": "form"
   },
   "outputs": [],
   "source": [
    "#@title Fix OpenCL if needed in Google Colab\n",
    "import sys\n",
    "\n",
    "IN_COLAB = 'google.colab' in sys.modules\n",
    "if IN_COLAB:\n",
    "    !sudo apt-get update -qq\n",
    "    !sudo apt-get purge -qq *nvidia* -y\n",
    "    !sudo DEBIAN_FRONTEND=noninteractive apt-get install -qq nvidia-driver-530 -y\n",
    "    exit(0)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8315ab2c",
   "metadata": {
    "cellView": "form"
   },
   "outputs": [],
   "source": [
    "#@title Install NanoPyx, import necessary libraries and connect to Google Drive\n",
    "import sys\n",
    "IN_COLAB = 'google.colab' in sys.modules\n",
    "if IN_COLAB:\n",
    "    !pip install -q \"nanopyx[colab]\"\n",
    "    from google.colab import output\n",
    "    output.enable_custom_widget_manager()\n",
    "    from google.colab import drive\n",
    "    drive.mount('/content/drive')\n",
    "else:\n",
    "    !pip install -q \"nanopyx[jupyter]\"\n",
    "\n",
    "import io\n",
    "import os\n",
    "import cv2 as cv\n",
    "import skimage\n",
    "import nanopyx\n",
    "import stackview\n",
    "import numpy as np\n",
    "import tifffile as tiff\n",
    "import matplotlib as mpl\n",
    "import ipywidgets as widgets\n",
    "from PIL import Image\n",
    "from IPython.display import display, clear_output\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "from nanopyx.core.utils.easy_gui import EasyGui\n",
    "from nanopyx.core.utils.find_files import find_files\n",
    "from nanopyx.data.download import ExampleDataManager\n",
    "\n",
    "cwd = os.getcwd()\n",
    "image_folder = \"datasets\"\n",
    "image_files = []\n",
    "EDM = ExampleDataManager()\n",
    "example_datasets = EDM.list_datasets()\n",
    "\n",
    "_path = os.path.join(\"..\", image_folder)\n",
    "if os.path.exists(_path):\n",
    "    image_files += find_files(_path, \".tif\")\n",
    "if os.path.exists(image_folder):\n",
    "    image_files += find_files(image_folder, \".tif\")\n",
    "image_files += [\"Example dataset: \"+dataset for dataset in example_datasets]\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5aeb0a4c",
   "metadata": {
    "cellView": "form"
   },
   "outputs": [],
   "source": [
    "#@title Load image stack\n",
    "# Create a GUI\n",
    "gui_data = EasyGui(\"Data Loader\")\n",
    "global own_data\n",
    "own_data = True\n",
    "\n",
    "def on_button_select_own(b):\n",
    "    clear_output()\n",
    "    gui_data.add_label(\"Select data to use:\")\n",
    "    gui_data.add_file_upload(\"upload\")\n",
    "    gui_data.add_dropdown(\"cmaps\", description=\"Colormap:\",\n",
    "                          options=sorted(list(mpl.colormaps)),\n",
    "                          value=\"viridis\", remember_value=True)\n",
    "    gui_data.add_button(\"load_data_own\", description=\"Load data\")\n",
    "    gui_data[\"load_data_own\"].on_click(on_button_load_data_clicked)\n",
    "    gui_data.show()\n",
    "\n",
    "def on_button_select_example(b):\n",
    "    clear_output()\n",
    "    gui_data.add_label(\"Select data to use:\")\n",
    "    gui_data.add_dropdown(\"data_source\", options=image_files,\n",
    "                    value=\"Example dataset: \"+example_datasets[4], remember_value=True)\n",
    "    gui_data.add_dropdown(\"cmaps\", description=\"Colormap:\",\n",
    "                          options=sorted(list(mpl.colormaps)),\n",
    "                          value=\"viridis\", remember_value=True)\n",
    "    gui_data.add_button(\"load_data\", description=\"Load data\")\n",
    "    gui_data[\"load_data\"].on_click(on_button_load_data_clicked_example)\n",
    "    gui_data.show()\n",
    "\n",
    "def on_button_load_data_clicked(b):\n",
    "    clear_output()\n",
    "    gui_data.show()\n",
    "    global dataset_original\n",
    "    global own_data\n",
    "    own_data = True\n",
    "    # disable button\n",
    "    gui_data[\"load_data_own\"].disabled = True\n",
    "    gui_data[\"load_data_own\"].description = \"Loading...\"\n",
    "    dataset_original = tiff.imread(gui_data[\"upload\"].selected)\n",
    "    gui_data[\"load_data_own\"].disabled = False\n",
    "    gui_data[\"load_data_own\"].description = \"Load data\"\n",
    "    gui_data._main_display.children = gui_data._main_display.children + (stackview.slice(dataset_original, colormap=gui_data[\"cmaps\"].value, continuous_update=True),)\n",
    "\n",
    "def on_button_load_data_clicked_example(b):\n",
    "    clear_output()\n",
    "    gui_data.show()\n",
    "    global dataset_original\n",
    "    global own_data\n",
    "    own_data = False\n",
    "    # disable button\n",
    "    gui_data[\"load_data\"].disabled = True\n",
    "    gui_data[\"load_data\"].description = \"Loading...\"\n",
    "\n",
    "    if gui_data[\"data_source\"].value.startswith(\"Example dataset: \"):\n",
    "        dataset_name = gui_data[\"data_source\"].value.replace(\n",
    "            \"Example dataset: \", \"\")\n",
    "        dataset_original = EDM.get_ZipTiffIterator(dataset_name, as_ndarray=True)\n",
    "        gui_data._main_display.children = gui_data._main_display.children + (stackview.slice(dataset_original, continuous_update=True, colormap=gui_data[\"cmaps\"].value),)\n",
    "    else:\n",
    "        dataset_original = skimage.io.imread(gui_data[\"data_source\"].value)\n",
    "        gui_data._main_display.children = gui_data._main_display.children + (stackview.slice(dataset_original, continuous_update=True, colormap=gui_data[\"cmaps\"].value),)\n",
    "\n",
    "    # enable button\n",
    "    gui_data[\"load_data\"].disabled = False\n",
    "    gui_data[\"load_data\"].description = \"Load data\"\n",
    "    gui_data.save_settings()\n",
    "\n",
    "gui_data.add_button(\"use_own_data\", description=\"Use Own data\")\n",
    "gui_data[\"use_own_data\"].on_click(on_button_select_own)\n",
    "gui_data.add_button(\"use_example_data\", description=\"Use Example data\")\n",
    "gui_data[\"use_example_data\"].on_click(on_button_select_example)\n",
    "gui_data.show()\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09c3f069",
   "metadata": {},
   "source": [
    "# Use SRRF to generate a super-resolved image\n",
    "# SRRF Parameters:\n",
    "\n",
    "- **Ring Radius:** Radius of the ring used to calculate the radiality (in pixels).\n",
    "- **Magnification:** Desired magnification for the generated radiality image.\n",
    "- **SRRF order:** Flag for types of SRRF temporal correlations. Order = -1: pairwise product sum; Order = 0: maximum intensity projection; Order = 1: mean; Order = 2,3 or 4: autocorrelation function of order 2, 3 or 4.\n",
    "- **Frames-per-timepoint:** How many frames of the original image stack are used to calculated a single SRRF frame. For example, given an input image with 500 frames, if using 100 frames per timepoint, SRRF will generate an image stack with 5 super-resolved frames.   \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "85ced68d",
   "metadata": {
    "cellView": "form"
   },
   "outputs": [],
   "source": [
    "#@title Create SRRF GUI\n",
    "gui_srrf = EasyGui(\"srrf\")\n",
    "from nanopyx.methods import SRRF\n",
    "from nanopyx.core.transform.sr_temporal_correlations import calculate_SRRF_temporal_correlations\n",
    "\n",
    "def run_srrf(b):\n",
    "    clear_output()\n",
    "    gui_srrf.show()\n",
    "    gui_srrf.save_settings()\n",
    "    ring_radius = gui_srrf[\"ring_radius\"].value\n",
    "    magnification = gui_srrf[\"magnification\"].value\n",
    "    frames_per_timepoint = gui_srrf[\"frames_per_timepoint\"].value\n",
    "    srrf_order = gui_srrf[\"srrf_order\"].value\n",
    "    # disable button while running\n",
    "    gui_srrf[\"run\"].disabled = True\n",
    "    gui_srrf[\"run\"].description = \"Running...\"\n",
    "    if frames_per_timepoint == 0:\n",
    "        frames_per_timepoint = dataset_original.shape[0]\n",
    "    elif frames_per_timepoint > dataset_original.shape[0]:\n",
    "        frames_per_timepoint = dataset_original.shape[0]\n",
    "\n",
    "    output= []\n",
    "\n",
    "    for i in range(dataset_original.shape[0] // frames_per_timepoint):\n",
    "        block = dataset_original[i*frames_per_timepoint:(i+1)*frames_per_timepoint]\n",
    "        result = SRRF(block, magnification=magnification, ringRadius=ring_radius,\n",
    "                                radialityPositivityConstraint=True,\n",
    "                                doIntensityWeighting=True)\n",
    "        output.append(calculate_SRRF_temporal_correlations(result[0], srrf_order))\n",
    "\n",
    "    global dataset_srrf\n",
    "    dataset_srrf = np.array(output)\n",
    "    # enable button again\n",
    "    gui_srrf[\"run\"].disabled = False\n",
    "    gui_srrf[\"run\"].description = \"Run\"\n",
    "    if gui_srrf[\"save\"].value:\n",
    "        if own_data:\n",
    "            path = gui_data[\"upload\"].selected_path\n",
    "            name = gui_data[\"upload\"].selected_filename.split(\".\")[0]\n",
    "            tiff.imwrite(path + os.sep + name + \"_srrf.tif\", dataset_srrf)\n",
    "        else:\n",
    "            name = gui_data[\"data_source\"].value.replace(\"Example dataset: \", \"\")\n",
    "            tiff.imwrite(name + \"_srrf.tif\", dataset_srrf)\n",
    "    gui_srrf._main_display.children = gui_srrf._main_display.children + (stackview.slice(dataset_srrf, colormap=gui_srrf[\"cmaps\"].value, continuous_update=True),)\n",
    "\n",
    "gui_srrf.add_float_slider(\"ring_radius\", description=\"Ring Radius:\", min=0.1, max=3.0, value=0.5, remember_value=True)\n",
    "gui_srrf.add_int_slider(\"magnification\", description=\"Magnification:\", min=1, max=10, value=5)\n",
    "gui_srrf.add_int_slider(\"srrf_order\", description=\"SRRF order:\", min=-1, max=4, value=3)\n",
    "gui_srrf.add_label(\"-=-= Time-Lapse =-=-\")\n",
    "gui_srrf.add_int_slider(\"frames_per_timepoint\", description=\"Frames per time-point (0 - auto)\", min=1, max=dataset_original.shape[0], value=dataset_original.shape[0]//2)\n",
    "gui_srrf.add_checkbox(\"save\", description=\"Save Output\", value=True)\n",
    "gui_srrf.add_dropdown(\"cmaps\", description=\"Colormap:\",\n",
    "                      options=sorted(list(mpl.colormaps)),\n",
    "                      value=\"viridis\", remember_value=True)\n",
    "gui_srrf.add_button(\"run\", description=\"Run\")\n",
    "gui_srrf['run'].on_click(run_srrf)\n",
    "gui_srrf.show()\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1eadfed0",
   "metadata": {},
   "source": [
    "## Calculate error map for the SRRF image\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aeb89a7c",
   "metadata": {
    "cellView": "form"
   },
   "outputs": [],
   "source": [
    "#@title Create Error Map GUI\n",
    "gui_error = EasyGui(\"Error\")\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from tqdm import tqdm\n",
    "from matplotlib import pyplot as plt\n",
    "from nanopyx.core.transform import ErrorMap\n",
    "\n",
    "def run_error(b):\n",
    "    clear_output()\n",
    "    gui_error.show()\n",
    "    gui_error.save_settings()\n",
    "    gui_error[\"run\"].disabled = True\n",
    "    gui_error[\"run\"].description = \"Calculating...\"\n",
    "    global errormap\n",
    "    error_map = ErrorMap()\n",
    "    error_map.optimise(np.mean(dataset_original, axis=0), np.mean(dataset_srrf, axis=0))\n",
    "    gui_error[\"run\"].disabled = False\n",
    "    gui_error[\"run\"].description = \"Calculate\"\n",
    "    print(\"RSE: \", error_map.getRSE())\n",
    "    print(\"RSP: \", error_map.getRSP())\n",
    "    errormap = np.array(error_map.imRSE)\n",
    "    if gui_error[\"save\"].value:\n",
    "        if own_data:\n",
    "            path = gui_data[\"upload\"].selected_path\n",
    "            name = gui_data[\"upload\"].selected_filename.split(\".\")[0]\n",
    "            tiff.imwrite(path + os.sep + name + \"_error_map.tif\", errormap)\n",
    "        else:\n",
    "            name = gui_data[\"data_source\"].value.replace(\"Example dataset: \", \"\")\n",
    "            tiff.imwrite(name + \"_error_map.tif\", errormap)\n",
    "    plt.imshow(errormap)\n",
    "    plt.axis(\"off\")\n",
    "    img_buf = io.BytesIO()\n",
    "    plt.savefig(img_buf, format=\"jpeg\")\n",
    "    output_plot = widgets.Output()\n",
    "    with output_plot:\n",
    "        display(Image.open(img_buf))\n",
    "    gui_error._main_display.children = gui_error._main_display.children + (\n",
    "        widgets.Label(value=\"RSE: \"+str(error_map.getRSE())),\n",
    "        widgets.Label(value=\"RSP: \"+str(error_map.getRSP())),\n",
    "        output_plot)\n",
    "    plt.clf()\n",
    "\n",
    "def run_error_stack(b):\n",
    "    clear_output()\n",
    "    gui_error.show()\n",
    "    gui_error.save_settings()\n",
    "    gui_error[\"run\"].disabled = True\n",
    "    gui_error[\"run\"].description = \"Calculating...\"\n",
    "\n",
    "    global errormap_stack, rse_rsp_table\n",
    "    global dataset_original, dataset_srrf\n",
    "    errormap_stack = []\n",
    "    rse_rsp_table = []\n",
    "\n",
    "    # Ensure datasets are 3D\n",
    "    if np.ndim(dataset_original) == 2: \n",
    "        dataset_original = np.expand_dims(dataset_original, axis=0) \n",
    "    if np.ndim(dataset_srrf) == 2: \n",
    "        dataset_srrf = np.expand_dims(dataset_srrf, axis=0) \n",
    "\n",
    "    # Iterate through each slice\n",
    "    print(\"Processing slices...\")\n",
    "    for i in tqdm(range(dataset_original.shape[0]),desc=\"Slices processed\"): \n",
    "        slice_df = dataset_original[i] # \n",
    "        slice_sr = dataset_srrf[i] # \n",
    "        \n",
    "        error_map = ErrorMap()\n",
    "        error_map.optimise(slice_df, slice_sr)\n",
    "\n",
    "        # Store the error map and RSE/RSP values\n",
    "        errormap_stack.append(np.array(error_map.imRSE))\n",
    "        rse_rsp_table.append({\n",
    "            \"Slice\": i,\n",
    "            \"RSE\": error_map.getRSE(),\n",
    "            \"RSP\": error_map.getRSP()\n",
    "        })\n",
    "\n",
    "    # Convert results to arrays\n",
    "    errormap_stack = np.array(errormap_stack)  # 3D stack of error maps\n",
    "    rse_rsp_table = pd.DataFrame(rse_rsp_table)  # Tabular results\n",
    "    # Save error map stack as .tif and RSE/RSP table to CSV if required\n",
    "    if gui_error[\"save\"].value:\n",
    "        if own_data:\n",
    "            path = gui_data[\"upload\"].selected_path\n",
    "            name = gui_data[\"upload\"].selected_filename.split(\".\")[0]\n",
    "            tiff.imwrite(path + os.sep + name + \"_error_map_stack.tif\", errormap_stack)\n",
    "            rse_rsp_table.to_csv(path + os.sep + name + \"_rse_rsp_table.csv\", index=False)\n",
    "        else:\n",
    "            name = gui_data[\"data_source\"].value.replace(\"Example dataset: \", \"\")\n",
    "            tiff.imwrite(name + \"_error_map_stack.tif\", errormap_stack)\n",
    "            rse_rsp_table.to_csv(name + \"_rse_rsp_table.csv\", index=False)\n",
    "\n",
    "    gui_error[\"run\"].disabled = False\n",
    "    gui_error[\"run\"].description = \"Calculate\"\n",
    "\n",
    "    # Display summary\n",
    "    print(\"Calculation completed for all slices.\")\n",
    "    display(rse_rsp_table)\n",
    "    plt.imshow(errormap_stack.mean(axis=0))  # Show mean error map\n",
    "    plt.axis(\"off\")\n",
    "    plt.show()\n",
    "    plt.clf()\n",
    "\n",
    "\n",
    "gui_error.add_checkbox(\"save\", description=\"Save output\", value=True)\n",
    "gui_error.add_dropdown(\"cmaps\", description=\"Colormap:\",\n",
    "                       options=sorted(list(mpl.colormaps)),\n",
    "                       value=\"viridis\", remember_value=True)\n",
    "gui_error.add_button(\"run\", description=\"Calculate\")\n",
    "gui_error[\"run\"].on_click(run_error_stack)\n",
    "gui_error.show()\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1272841",
   "metadata": {},
   "source": [
    "## Calculate FRC resolution of the diffraction limited image\n",
    "# FRC Parameters:\n",
    "\n",
    "- **Pixel Size:** Pixel size of the image. Used to calculte resolution values.\n",
    "- **Units:** Pixel size units.\n",
    "- **First/Second Frame:** As FRC is calculated between two frames of the same image stack, these parameters determines which two frames are used for the calculation.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f62cd72a",
   "metadata": {
    "cellView": "form"
   },
   "outputs": [],
   "source": [
    "#@title create FRC GUI for original image\n",
    "gui_frc_df = EasyGui(\"FRC\")\n",
    "\n",
    "import numpy as np\n",
    "from nanopyx.core.analysis.frc import FIRECalculator\n",
    "\n",
    "def run_frc(b):\n",
    "    clear_output()\n",
    "    gui_frc_df.show()\n",
    "    gui_frc_df.save_settings()\n",
    "    pixel_size = gui_frc_df[\"pixel_size\"].value\n",
    "    units = gui_frc_df[\"units\"].value\n",
    "    first_frame = gui_frc_df[\"first_frame\"].value\n",
    "    second_frame = gui_frc_df[\"second_frame\"].value\n",
    "    gui_frc_df[\"run\"].disabled = True\n",
    "    gui_frc_df[\"run\"].description = \"Calculating...\"\n",
    "    global frc_calculator_raw\n",
    "    frc_calculator_raw = FIRECalculator(pixel_size=pixel_size, units=units)\n",
    "    frc_calculator_raw.calculate_fire_number(dataset_original[first_frame], dataset_original[second_frame])\n",
    "    gui_frc_df[\"run\"].disabled = False\n",
    "    gui_frc_df[\"run\"].description = \"Calculate\"\n",
    "    plot = frc_calculator_raw.plot_frc_curve()\n",
    "    if gui_frc_df[\"save\"].value:\n",
    "        if own_data:\n",
    "            path = gui_data[\"upload\"].selected_path\n",
    "            name = gui_data[\"upload\"].selected_filename.split(\".\")[0]\n",
    "            tiff.imwrite(path + os.sep + name + \"_original_FRC.tif\", plot)\n",
    "        else:\n",
    "            name = gui_data[\"data_source\"].value.replace(\"Example dataset: \", \"\")\n",
    "            tiff.imwrite(name + \"_FRC_df.tif\", plot)\n",
    "    plt.imshow(plot)\n",
    "    plt.axis(\"off\")\n",
    "    img_buf = io.BytesIO()\n",
    "    plt.savefig(img_buf, format=\"jpeg\")\n",
    "    output_plot = widgets.Output()\n",
    "    with output_plot:\n",
    "        display(Image.open(img_buf))\n",
    "    gui_frc_df._main_display.children = gui_frc_df._main_display.children + (output_plot,)\n",
    "    plt.clf()\n",
    "    \n",
    "gui_frc_df.add_int_slider(\"pixel_size\", description=\"Pixel Size:\", min=0.01, max=1000, value=100, remember_value=True)\n",
    "gui_frc_df.add_dropdown(\"units\", description=\"Units: \", options=[\"nm\", \"um\", \"mm\"], value=\"nm\")\n",
    "gui_frc_df.add_int_slider(\"first_frame\", description=\"First Frame:\", min=0, max=dataset_original[0].shape[0]-1, value=0)\n",
    "gui_frc_df.add_int_slider (\"second_frame\", description=\"Second Frame:\", min=0, max=dataset_original[0].shape[0]-1, value=1)\n",
    "gui_frc_df.add_checkbox(\"save\", description=\"Save Output\", value=True)\n",
    "gui_frc_df.add_button(\"run\", description=\"Calculate\")\n",
    "gui_frc_df[\"run\"].on_click(run_frc)\n",
    "gui_frc_df.show()\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf0fa835",
   "metadata": {},
   "source": [
    "## Calculate FRC resolution of the SR image\n",
    "# FRC Parameters:\n",
    "\n",
    "- **Pixel Size:** Pixel size of the image. Used to calculte resolution values.\n",
    "- **Units:** Pixel size units.\n",
    "- **First/Second Frame:** As FRC is calculated between two frames of the same image stack, these parameters determines which two frames are used for the calculation.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "06e8367f",
   "metadata": {
    "cellView": "form"
   },
   "outputs": [],
   "source": [
    "#@title create FRC GUI for SR image\n",
    "gui_frc_srrf = EasyGui(\"FRC\")\n",
    "\n",
    "import numpy as np\n",
    "from nanopyx.core.analysis.frc import FIRECalculator\n",
    "\n",
    "def run_frc(b):\n",
    "    clear_output()\n",
    "    gui_frc_srrf.show()\n",
    "    gui_frc_srrf.save_settings()\n",
    "    pixel_size = gui_frc_srrf[\"pixel_size\"].value\n",
    "    units = gui_frc_srrf[\"units\"].value\n",
    "    first_frame = gui_frc_srrf[\"first_frame\"].value\n",
    "    second_frame = gui_frc_srrf[\"second_frame\"].value\n",
    "    gui_frc_srrf[\"run\"].disabled = True\n",
    "    gui_frc_srrf[\"run\"].description = \"Calculating...\"\n",
    "    global frc_calculator_raw\n",
    "    frc_calculator_raw = FIRECalculator(pixel_size=pixel_size, units=units)\n",
    "    frc_calculator_raw.calculate_fire_number(dataset_srrf[first_frame], dataset_srrf[second_frame])\n",
    "    gui_frc_srrf[\"run\"].disabled = False\n",
    "    gui_frc_srrf[\"run\"].description = \"Calculate\"\n",
    "    plot = frc_calculator_raw.plot_frc_curve()\n",
    "    if gui_frc_srrf[\"save\"].value:\n",
    "        if own_data:\n",
    "            path = gui_data[\"upload\"].selected_path\n",
    "            name = gui_data[\"upload\"].selected_filename.split(\".\")[0]\n",
    "            tiff.imwrite(path + os.sep + name + \"_original_FRC.tif\", plot)\n",
    "        else:\n",
    "            name = gui_data[\"data_source\"].value.replace(\"Example dataset: \", \"\")\n",
    "            tiff.imwrite(name + \"_FRC_df.tif\", plot)\n",
    "    plt.imshow(plot)\n",
    "    plt.axis(\"off\")\n",
    "    img_buf = io.BytesIO()\n",
    "    plt.savefig(img_buf, format=\"jpeg\")\n",
    "    output_plot = widgets.Output()\n",
    "    with output_plot:\n",
    "        display(Image.open(img_buf))\n",
    "    gui_frc_srrf._main_display.children = gui_frc_srrf._main_display.children + (output_plot,)\n",
    "    plt.clf()\n",
    "    \n",
    "gui_frc_srrf.add_int_slider(\"pixel_size\", description=\"Pixel Size:\", min=0.01, max=1000, value=100, remember_value=True)\n",
    "gui_frc_srrf.add_dropdown(\"units\", description=\"Units: \", options=[\"nm\", \"um\", \"mm\"], value=\"nm\")\n",
    "gui_frc_srrf.add_int_slider(\"first_frame\", description=\"First Frame:\", min=0, max=dataset_srrf[0].shape[0]-1, value=0)\n",
    "gui_frc_srrf.add_int_slider (\"second_frame\", description=\"Second Frame:\", min=0, max=dataset_srrf[0].shape[0]-1, value=1)\n",
    "gui_frc_srrf.add_checkbox(\"save\", description=\"Save Output\", value=True)\n",
    "gui_frc_srrf.add_button(\"run\", description=\"Calculate\")\n",
    "gui_frc_srrf[\"run\"].on_click(run_frc)\n",
    "gui_frc_srrf.show()\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb9621fc",
   "metadata": {},
   "source": [
    "## Calculate Decorrelation analysis resolution of the diffraction limited image\n",
    "# Image Decorrelation Analysis Parameters:\n",
    "\n",
    "- **Pixel Size:** Pixel size of the image. Used to calculte resolution values.\n",
    "- **Units:** Pixel size units.\n",
    "- **Frame:** Frame to be used for decorrelation analysis\n",
    "- **Radius Min/Max:** Resolution calculation by Decorrelation Analysis is performed in the frequency space. These parameters define the range of radii to be used in the calculation. \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "14d30daa",
   "metadata": {
    "cellView": "form"
   },
   "outputs": [],
   "source": [
    "#@title Create Decorrelation Analysis GUI for eSRRF data\n",
    "gui_decorr_df = EasyGui(\"DecorrAnalysis\")\n",
    "\n",
    "from nanopyx.core.analysis.decorr import DecorrAnalysis\n",
    "\n",
    "def run_decorr(b):\n",
    "    clear_output()\n",
    "    gui_decorr_df.show()\n",
    "    gui_decorr_df.save_settings()\n",
    "    pixel_size = gui_decorr_df[\"pixel_size\"].value\n",
    "    units = gui_decorr_df[\"units\"].value\n",
    "    first_frame = gui_decorr_df[\"first_frame\"].value\n",
    "    rmin = gui_decorr_df[\"rmin\"].value\n",
    "    rmax = gui_decorr_df[\"rmax\"].value\n",
    "    gui_decorr_df[\"run\"].disabled = True\n",
    "    gui_decorr_df[\"run\"].description = \"Calculating...\"\n",
    "    global decorr_calculator\n",
    "    decorr_calculator = DecorrAnalysis(pixel_size=pixel_size, units=units, rmin=rmin, rmax=rmax)\n",
    "    decorr_calculator.run_analysis(dataset_original[first_frame])\n",
    "    gui_decorr_df[\"run\"].disabled = False\n",
    "    gui_decorr_df[\"run\"].description = \"Calculate\"\n",
    "    plot = decorr_calculator.plot_results()\n",
    "    if gui_decorr_df[\"save\"].value:\n",
    "        if own_data:\n",
    "            path = gui_data[\"upload\"].selected_path\n",
    "            name = gui_data[\"upload\"].selected_filename.split(\".\")[0]\n",
    "            tiff.imwrite(path + os.sep + name + \"_eSRRF_decorr_analysis.tif\", plot)\n",
    "        else:\n",
    "            name = gui_data[\"data_source\"].value.replace(\"Example dataset: \", \"\")\n",
    "            tiff.imwrite(name + \"_eSRRF_decorr_analysis.tif\", plot)\n",
    "    plt.imshow(plot)\n",
    "    plt.axis(\"off\")\n",
    "    img_buf = io.BytesIO()\n",
    "    plt.savefig(img_buf, format=\"jpeg\")\n",
    "    output_plot = widgets.Output()\n",
    "    with output_plot:\n",
    "        display(Image.open(img_buf))\n",
    "    gui_decorr_df._main_display.children = gui_decorr_df._main_display.children + (output_plot,)\n",
    "    plt.clf()\n",
    "\n",
    "gui_decorr_df.add_int_slider(\"pixel_size\", description=\"Pixel Size:\", min=0.01, max=1000, value=100, remember_value=True)\n",
    "gui_decorr_df.add_dropdown(\"units\", description=\"Units: \", options=[\"nm\", \"um\", \"mm\"], value=\"nm\")\n",
    "gui_decorr_df.add_int_slider(\"first_frame\", description=\"Frame to be used:\", min=0, max=dataset_original.shape[0]-1, value=0)\n",
    "gui_decorr_df.add_float_slider(\"rmin\", description=\"Radius Min:\", min=0.0, max=0.5, value=0.0)\n",
    "gui_decorr_df.add_float_slider(\"rmax\", description=\"Radius Max:\", min=0.5, max=1.0, value=1.0)\n",
    "gui_decorr_df.add_checkbox(\"save\", description=\"Save Output\", value=True)\n",
    "gui_decorr_df.add_button(\"run\", description=\"Calculate\")\n",
    "gui_decorr_df[\"run\"].on_click(run_decorr)\n",
    "gui_decorr_df.show()\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a051a495",
   "metadata": {},
   "source": [
    "## Calculate Decorrelation analysis resolution of the SR image\n",
    "# Image Decorrelation Analysis Parameters:\n",
    "\n",
    "- **Pixel Size:** Pixel size of the image. Used to calculte resolution values.\n",
    "- **Units:** Pixel size units.\n",
    "- **Frame:** Frame to be used for decorrelation analysis\n",
    "- **Radius Min/Max:** Resolution calculation by Decorrelation Analysis is performed in the frequency space. These parameters define the range of radii to be used in the calculation. \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8dc2fbb2",
   "metadata": {
    "cellView": "form"
   },
   "outputs": [],
   "source": [
    "#@title Create Decorrelation Analysis GUI for eSRRF data\n",
    "gui_decorr = EasyGui(\"DecorrAnalysis\")\n",
    "\n",
    "from nanopyx.core.analysis.decorr import DecorrAnalysis\n",
    "\n",
    "def run_decorr(b):\n",
    "    clear_output()\n",
    "    gui_decorr.show()\n",
    "    gui_decorr.save_settings()\n",
    "    pixel_size = gui_decorr[\"pixel_size\"].value\n",
    "    units = gui_decorr[\"units\"].value\n",
    "    first_frame = gui_decorr[\"first_frame\"].value\n",
    "    rmin = gui_decorr[\"rmin\"].value\n",
    "    rmax = gui_decorr[\"rmax\"].value\n",
    "    gui_decorr[\"run\"].disabled = True\n",
    "    gui_decorr[\"run\"].description = \"Calculating...\"\n",
    "    global decorr_calculator\n",
    "    decorr_calculator = DecorrAnalysis(pixel_size=pixel_size, units=units, rmin=rmin, rmax=rmax)\n",
    "    decorr_calculator.run_analysis(dataset_srrf[first_frame])\n",
    "    gui_decorr[\"run\"].disabled = False\n",
    "    gui_decorr[\"run\"].description = \"Calculate\"\n",
    "    plot = decorr_calculator.plot_results()\n",
    "    if gui_decorr[\"save\"].value:\n",
    "        if own_data:\n",
    "            path = gui_data[\"upload\"].selected_path\n",
    "            name = gui_data[\"upload\"].selected_filename.split(\".\")[0]\n",
    "            tiff.imwrite(path + os.sep + name + \"_eSRRF_decorr_analysis.tif\", plot)\n",
    "        else:\n",
    "            name = gui_data[\"data_source\"].value.replace(\"Example dataset: \", \"\")\n",
    "            tiff.imwrite(name + \"_eSRRF_decorr_analysis.tif\", plot)\n",
    "    plt.imshow(plot)\n",
    "    plt.axis(\"off\")\n",
    "    img_buf = io.BytesIO()\n",
    "    plt.savefig(img_buf, format=\"jpeg\")\n",
    "    output_plot = widgets.Output()\n",
    "    with output_plot:\n",
    "        display(Image.open(img_buf))\n",
    "    gui_decorr._main_display.children = gui_decorr._main_display.children + (output_plot,)\n",
    "    plt.clf()\n",
    "\n",
    "gui_decorr.add_int_slider(\"pixel_size\", description=\"Pixel Size:\", min=0.01, max=1000, value=100, remember_value=True)\n",
    "gui_decorr.add_dropdown(\"units\", description=\"Units: \", options=[\"nm\", \"um\", \"mm\"], value=\"nm\")\n",
    "gui_decorr.add_int_slider(\"first_frame\", description=\"Frame to be used:\", min=0, max=dataset_srrf.shape[0]-1, value=0)\n",
    "gui_decorr.add_float_slider(\"rmin\", description=\"Radius Min:\", min=0.0, max=0.5, value=0.0)\n",
    "gui_decorr.add_float_slider(\"rmax\", description=\"Radius Max:\", min=0.5, max=1.0, value=1.0)\n",
    "gui_decorr.add_checkbox(\"save\", description=\"Save Output\", value=True)\n",
    "gui_decorr.add_button(\"run\", description=\"Calculate\")\n",
    "gui_decorr[\"run\"].on_click(run_decorr)\n",
    "gui_decorr.show()\n",
    "\n"
   ]
  }
 ],
 "metadata": {},
 "nbformat": 4,
 "nbformat_minor": 5
}