TEMPLATE_max_project.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "TEMPLATE_max_project.ipynb",
      "provenance": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.7"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/lauraluebbert/confocal_z-stack_analysis/blob/master/TEMPLATE_max_project.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZU7vSRr6pLno"
      },
      "source": [
        "(Ignore this if not running this notebook in Google Colab.) To demonstrate how this notebook works in Google Colab, I compressed a few sample tif images into a .tar folder. This tar folder is downloaded from a public Google Drive link and unzipped. If you want to your own images using this notebook in Google Colab, compress your images into a .tar folder (click [here](https://www.youtube.com/watch?v=EWONqLqSxYc) for more information), upload this .tar folder into Google Drive (make sure to change the sharing settings such that \"everybody with the link can view\"), and replace eveything after \"id=\" with the Google Drive ID of your .tar folder (the ID is part of your Google Drive shareable link)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FNAztW3gi1jj"
      },
      "source": [
        "### Ignore this code cell if you are not running this notebook in Google Colab\n",
        "# Install bokeh catplot\n",
        "!pip install bokeh_catplot\n",
        "# Download data from Google Drive using gdown\n",
        "!pip install gdown\n",
        "!gdown https://drive.google.com/uc?id=18_YmrDlG5qDLImpaAOnN13JLihPPW4HF\n",
        "# Extract images from tar directory\n",
        "!tar xvf *.tar"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YSoiPfpxqzQb"
      },
      "source": [
        "___"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D7sjWI4p4XwJ"
      },
      "source": [
        "# Computing maximum projections from z-stack images"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RHy9_zY_4XwK"
      },
      "source": [
        "This notebook computes the maximum projection of confocal z-stack images. It then saves the images in a separate folder with or without a scalebar (define below). Image matrices are saved to a dictionary and continuously linked to their sample ID, channel, condition, and filename.\n",
        "\n",
        "#### Name images as follows: \n",
        "X_samplecondition_sample_channel , where \"X\" is optional and can be filled as desired by the user (do not use spaces).  \n",
        "- \"Samplecondition\" can be a string of text separated by \"-\", e.g. \"GCaMP-30C-6d_sample_channel\" (Do not use spaces or \"_\" within the condition, else part of it will be cut out in the dictionary.)  \n",
        "- \"Sample\" and \"channel\" can be a simple number or a description, e.g.: \"samplecondition_1_1\" or \"samplecondition_Brain1_DAPI\". (Do not use spaces or \"_\" within the sample or channel.)  \n",
        "\n",
        "#### Click \"Run all\" after defining the parameters below.\n",
        "If working in Google Colab, you can download the newly created images/files using the folder panel on the left (new data is saved under \"content\"). \n",
        "\n",
        "Written by Laura Luebbert, 20th of August 2020.  \n",
        "\n",
        "Modified on: / "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hy5hepLD4XwK"
      },
      "source": [
        "# Define the parameters:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iOVwOJ8g4XwL"
      },
      "source": [
        "### Define the directory containing the tif files:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vokUDPYx4XwM"
      },
      "source": [
        "data_dir = \"/content\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wlEJo_lt4XwO"
      },
      "source": [
        "### Define microscope and magnification (to get interpixel distance) OR define interpixel distance directly if different microscope/magnification used:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m8uJn1VG4XwP"
      },
      "source": [
        "# Define microscope used (\"Lois\", \"LSM800\" or define interpixel distance manually below)\n",
        "microscope = \"LSM800\"\n",
        "\n",
        "# Define magnification (\"20\" or define interpixel distance manually below)\n",
        "magnification = \"20\"\n",
        "\n",
        "# Uncomment (remove the #) and define interpixel distance if different microscope/magnification used:\n",
        "# interpixel_distance = "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eXHWPDXW4XwR"
      },
      "source": [
        "### Scale bar options:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4xX3xYPq4XwS"
      },
      "source": [
        "# Turn scale bar on/off (define as \"True\" or \"False\")\n",
        "scale_bar = True\n",
        "\n",
        "# Set scalebar color (\"white\" or \"black\")\n",
        "scale_bar_color = \"white\"\n",
        "\n",
        "# Define the desired scale bar size and width in length unit.\n",
        "scale_bar_length = 100\n",
        "scale_bar_width = 5\n",
        "\n",
        "# Define position of scale bar:\n",
        "# Distance from top (Distance in % of total length of image)\n",
        "y_pos = 95\n",
        "# Distance of rightmost end of scale bar from left end of image (Distance in % of total length of image)\n",
        "x_pos = 95"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-5v8oQ-q4XwU"
      },
      "source": [
        "### Saving options:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6UeedKmZ4XwU"
      },
      "source": [
        "# Directory where maximum projection image folder will be created.\n",
        "saving_dir = data_dir\n",
        "\n",
        "# Set the file format the images should be saved as:\n",
        "file_format = \"tif\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mMskXcKA4XwX"
      },
      "source": [
        "### Define colors/LUTs of each channel for maximum projections:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W3a-d3i24XwX"
      },
      "source": [
        "# Define dictionary with the channel#/channel-name (exactly as defined in the filename) coupled to \"green\", \"red\", or \"blue\"\n",
        "# e.g. \"1\":\"green\" or \"DAPI\":\"blue\"  \n",
        "color_dict = {\"GFP\":\"green\", \"C00\":\"red\", \"channel3\":\"blue\"}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6yQKd7SB4XwZ"
      },
      "source": [
        "### Filter options for maximum projections:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3u2S93q24Xwa"
      },
      "source": [
        "# Despeckling using median filter (skimage.filters.rank.median) (define as \"True\" or \"False\")\n",
        "despeckle = False\n",
        "despeckle_parameter = 3\n",
        "\n",
        "# Contrast is optimized using the skimage.exposure.equalize_adapthist function (define as \"True\" or \"False\")\n",
        "optimize_contrast = False"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sFxgogU24Xwc"
      },
      "source": [
        "___"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Dd1P8Vtx4Xwd"
      },
      "source": [
        "___"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XpYgO2gm4Xwd"
      },
      "source": [
        "# %load_ext blackcellmagic\n",
        "%config InlineBackend.figure_format = 'retina'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pJn9ojH_4Xwh"
      },
      "source": [
        "# Tools to read in the image files and filenames\n",
        "import glob\n",
        "import os\n",
        "import re \n",
        "\n",
        "# Calculation and data frame tools\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "\n",
        "# Image processing tools\n",
        "import skimage\n",
        "import skimage.io\n",
        "import skimage.morphology\n",
        "\n",
        "# Tools to create new folders\n",
        "from pathlib import Path\n",
        "\n",
        "# Tools to save dictionaries\n",
        "import pickle\n",
        "\n",
        "# To make a copy of a dictionary\n",
        "import copy\n",
        "\n",
        "# Plotting tools\n",
        "import bokeh\n",
        "import bokeh_catplot\n",
        "bokeh.io.output_notebook()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s8rTziXA4Xwj"
      },
      "source": [
        "___"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s-HgDnbX4Xwj"
      },
      "source": [
        "# Get the interpixel distance"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3PxpmiXH4Xwk"
      },
      "source": [
        "if microscope == \"LSM800\":\n",
        "    if magnification == \"20\":\n",
        "        interpixel_distance = 0.3119629\n",
        "        \n",
        "if microscope == \"Lois\":\n",
        "    if magnification == \"20\":\n",
        "        interpixel_distance = 0.690534"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_6dklqsz4Xwm"
      },
      "source": [
        "___"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o5PnrQya4Xwn"
      },
      "source": [
        "# Load in the data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F9Ofpb_q4Xwn"
      },
      "source": [
        "# Glob string for images (loads all .tif files)\n",
        "im_glob = os.path.join(data_dir, \"*.tif\")\n",
        "\n",
        "# Get list of files in directory\n",
        "im_list = sorted(glob.glob(im_glob))\n",
        "\n",
        "# Let's look at the first 10 entries\n",
        "im_list[:10]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GKeYPuIg4Xwp"
      },
      "source": [
        "Create a nested dictionary with information about each sample coupled to the z-stack image matrix, as well as space for matrices added later:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lvCp77kI4Xwp"
      },
      "source": [
        "dicts = {}\n",
        "\n",
        "for i in range(len(im_list)):\n",
        "    # Get sample condition\n",
        "    condition = im_list[i].split(\"/\")[-1].split(\"_\")[-3]\n",
        "    \n",
        "    # Make sure we do not overwrite a previous dictionary entry    \n",
        "    if dicts.get(condition) == None:\n",
        "        dicts[condition] = {}\n",
        "    \n",
        "    # Get sample number\n",
        "    sample = im_list[i].split(\"/\")[-1].split(\"_\")[-2]\n",
        "    \n",
        "    # Make sure we do not overwrite a previous dictionary entry\n",
        "    if dicts.get(condition, {}).get(sample) == None:\n",
        "        dicts[condition][sample] = {}\n",
        "    \n",
        "    # Get channel number    \n",
        "    channel = im_list[i].split(\"/\")[-1].split(\"_\")[-1].split(\".\")[0]\n",
        "    \n",
        "    # Add empty arrays to dictionary to populate with images later\n",
        "    dicts[condition][sample][channel] = {\n",
        "        \"matrix_orig\": [],      # Original image z-stack matrix\n",
        "        \"matrix_max\": [],       # Image matrix of maximum projection image \n",
        "        \"matrix_max_8\": [],     # Image matrix of maximum projection as 8-bit image \n",
        "        \"matrix_max_8_SB\": [],  # Image matrix of maximum projection as 8-bit image with scale bar \n",
        "        \"filename\": [],         # The original filename, just in case\n",
        "    }    \n",
        "    \n",
        "    # Populate dictionary with original image matrix\n",
        "    dicts[condition][sample][channel][\"matrix_orig\"] = skimage.io.imread(im_list[i])\n",
        "    \n",
        "    # Populate dictionary with original filename\n",
        "    dicts[condition][sample][channel][\"filename\"] = im_list[i].split(\"/\")[-1].split(\".\")[-2]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QXYuSy3D4Xwr"
      },
      "source": [
        "___"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UkszcL6H4Xws"
      },
      "source": [
        "# Compute maximum projections\n",
        "Find the maximum pixel value across the frames for each channel for each image:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D9V-0jXa4Xws"
      },
      "source": [
        "selem = skimage.morphology.square(despeckle_parameter)\n",
        "\n",
        "# Loop through every image in the dictionary\n",
        "for k1_condition, v1_sample in dicts.items():\n",
        "    for k2_sample, v2_channel in v1_sample.items():\n",
        "        for k3_channel, im in v2_channel.items():\n",
        "            \n",
        "            image = np.array(im[\"matrix_orig\"])\n",
        "\n",
        "            # Create a matrix of zeros in the same size as our image (x-pixels, y-pixels) to fill color channels we do not need\n",
        "            zeros = np.zeros((image.shape[1], image.shape[2]))\n",
        "\n",
        "            # np.max with axis=0 returns the maximum of each column (each row equals to a frame)\n",
        "            max_channel = image.max(axis=0)\n",
        "\n",
        "            # Image filter options\n",
        "            if despeckle == True:\n",
        "                max_channel = skimage.filters.rank.median(max_channel, selem)   \n",
        "\n",
        "            if optimize_contrast == True:  \n",
        "                max_channel = skimage.exposure.equalize_adapthist(max_channel)\n",
        "\n",
        "            # Populate maximum projections dictionary with the max projection and name of the image\n",
        "            # The color/LUT is based on its axis in the array (red, green or blue):\n",
        "            if color_dict[k3_channel] == \"red\":\n",
        "                dicts[k1_condition][k2_sample][k3_channel][\"matrix_max\"] = np.dstack((max_channel, zeros, zeros))\n",
        "\n",
        "            if color_dict[k3_channel] == \"green\":\n",
        "                dicts[k1_condition][k2_sample][k3_channel][\"matrix_max\"] = np.dstack((zeros, max_channel, zeros))\n",
        "\n",
        "            if color_dict[k3_channel] == \"blue\":\n",
        "                dicts[k1_condition][k2_sample][k3_channel][\"matrix_max\"] = np.dstack((zeros, zeros, max_channel))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qk0GdHbD4Xwu"
      },
      "source": [
        "___"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xh6IHmZr4Xwv"
      },
      "source": [
        "# Save maximum projections"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7cXYChiH4Xwv"
      },
      "source": [
        "#### Scale down images:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WK0bF-Ip4Xwv"
      },
      "source": [
        "To save the images using skimage, we need to scale them down to 8 bit."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PtCBYlZ64Xww"
      },
      "source": [
        "# Scale down images to 8 bits\n",
        "\n",
        "for k1_condition, v1_sample in dicts.items():\n",
        "    for k2_sample, v2_channel in v1_sample.items():\n",
        "        for k3_channel, im in v2_channel.items():\n",
        "            # Linearly scale image down to 8-bit.\n",
        "            image = (im[\"matrix_max\"] / im[\"matrix_max\"].max()) * 255\n",
        "\n",
        "            # Change list to array and change type to 8-bit array.\n",
        "            image = np.array(image)\n",
        "            image = image.astype(np.uint8)\n",
        "\n",
        "            dicts[k1_condition][k2_sample][k3_channel][\"matrix_max_8\"] = image"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "32zP1Cac4Xwy"
      },
      "source": [
        "### Display the last maximum projection using skimage:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Byj2VQJG4Xwz"
      },
      "source": [
        "skimage.io.imshow(dicts[k1_condition][k2_sample][k3_channel][\"matrix_max_8\"])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IQpirAJB4Xw1"
      },
      "source": [
        "#### Burn in scale bars:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2hslMgJl4Xw1"
      },
      "source": [
        "Scale bar is burned into image by changing the pixel value to 1000 (white scale bar) or 0 (black scale bar) in scale bar area defined in the corresponding \"parameters\" cell above:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gPhPw6u24Xw1"
      },
      "source": [
        "if scale_bar == True:\n",
        "\n",
        "    scalebar = 1 / interpixel_distance * scale_bar_length\n",
        "    scalebar_width = 1 / interpixel_distance * scale_bar_width\n",
        "\n",
        "    if scale_bar_color == \"white\":\n",
        "        for k1_condition, v1_sample in dicts.items():\n",
        "            for k2_sample, v2_channel in v1_sample.items():\n",
        "                for k3_channel, im in v2_channel.items():\n",
        "                    y_value = int((im[\"matrix_max_8\"].shape[0]/100)*y_pos)\n",
        "                    x_value = int((im[\"matrix_max_8\"].shape[1]/100)*x_pos) \n",
        "\n",
        "                    im[\"matrix_max_8\"][y_value : y_value + int(scalebar_width), x_value - int(scalebar) : x_value] = 255\n",
        "\n",
        "                    # Populate dict with 8-bit images containing a scale bar\n",
        "                    dicts[k1_condition][k2_sample][k3_channel][\"matrix_max_8_SB\"] = im[\"matrix_max_8\"]\n",
        "\n",
        "    elif scale_bar_color == \"black\":\n",
        "        for k1_condition, v1_sample in dicts.items():\n",
        "            for k2_sample, v2_channel in v1_sample.items():\n",
        "                for k3_channel, im in v2_channel.items():\n",
        "                    y_pos = int((im[\"matrix_max_8\"].shape[0]/100)*y_pos)\n",
        "                    x_pos = int((im[\"matrix_max_8\"].shape[1]/100)*x_pos)\n",
        "\n",
        "                    im[\"matrix_max_8\"][y_pos : y_pos + int(scalebar_width), x_pos - int(scalebar) : x_pos] = 0\n",
        "\n",
        "                    # Populate dict with 8-bit images containing a scale bar\n",
        "                    dicts[k1_condition][k2_sample][k3_channel][\"matrix_max_8_SB\"] = im[\"matrix_max_8\"]\n",
        "            \n",
        "else:\n",
        "    for k1_condition, v1_sample in dicts.items():\n",
        "        for k2_sample, v2_channel in v1_sample.items():\n",
        "            for k3_channel, im in v2_channel.items():\n",
        "            \n",
        "                dicts[k1_condition][k2_sample][k3_channel][\"matrix_max_8_SB\"] = im[\"matrix_max_8\"]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CzBznbk24Xw3"
      },
      "source": [
        "Display one image with scale bar:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cuWG4h4g4Xw4"
      },
      "source": [
        "skimage.io.imshow(dicts[k1_condition][k2_sample][k3_channel][\"matrix_max_8_SB\"])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9L1PwV9-4Xw5"
      },
      "source": [
        "### Create max projection folder:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qLZq75SX4Xw6"
      },
      "source": [
        "Create folder in saving directory to save maximum projections to (unless the folder already exists):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pnapjM7H4Xw6"
      },
      "source": [
        "path = (\"{}/{}_max_projections\").format(saving_dir, im_list[0].split(\"/\")[-2])\n",
        "Path(path).mkdir(parents=True, exist_ok=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Rsgv0t-c4Xw8"
      },
      "source": [
        "### Save all images with a scale bar:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hAn4pqYH4Xw8"
      },
      "source": [
        "for k1_condition, v1_sample in dicts.items():\n",
        "    for k2_sample, v2_channel in v1_sample.items():\n",
        "        for k3_channel, im in v2_channel.items():\n",
        "            skimage.io.imsave(\n",
        "                (\"{}/{}_max.{}\").format(path, im[\"filename\"], file_format),\n",
        "                im[\"matrix_max_8_SB\"],\n",
        "                plugin=None,\n",
        "                check_contrast=True,\n",
        "            )"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f3RAWu_E4Xw-"
      },
      "source": [
        "### Pickle image data dictionary:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HxJkCoEA4Xw-"
      },
      "source": [
        "# Use pickle to save dictionaries\n",
        "\n",
        "# The advantage of HIGHEST_PROTOCOL is that files get smaller. This makes unpickling sometimes much faster.\n",
        "with open(\n",
        "    (\"{}/{}.pickle\").format(saving_dir, im_list[0].split(\"/\")[-2]), \"wb\"\n",
        ") as handle:\n",
        "    pickle.dump(dicts, handle, protocol=pickle.HIGHEST_PROTOCOL)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ha4hYfX_4XxB"
      },
      "source": [
        "___"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ulkYb0zj4XxC"
      },
      "source": [
        "# Computing environment"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1TfGOjK74XxC"
      },
      "source": [
        "%load_ext watermark\n",
        "\n",
        "%watermark -v -p re,numpy,pandas,skimage,bokeh,bokeh_catplot,jupyterlab"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}