Trace Plotting.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib\n",
    "matplotlib.rcParams.update({'font.size': 16})\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import csv\n",
    "from tifffile import imread\n",
    "import matplotlib.gridspec as gridspec\n",
    "import cv2\n",
    "import os\n",
    "import glob\n",
    "from sklearn.cluster import KMeans\n",
    "from matplotlib.colors import LinearSegmentedColormap\n",
    "import peakutils\n",
    "from skimage import exposure\n",
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a colormap for heatmap plots."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "colormap = matplotlib.cm.get_cmap('plasma')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set min & max of z-score plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "vmin = -2\n",
    "vmax = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set the frame offset (the number of frames that were cut off from the start of the calcium imaging analysis video)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "frame_offset = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set the FPS of tail trace and calcium data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "fps_tail     = 349\n",
    "fps_calcium  = 2.75   # frames per second, for one slice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a function to be used for blending ROI overlays together to make a final ROI image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def blend_transparent(face_img, overlay_t_img):\n",
    "    # Split out the transparency mask from the colour info\n",
    "    overlay_img = overlay_t_img[:,:,:3] # Grab the BRG planes\n",
    "    overlay_mask = overlay_t_img[:,:,3:]  # And the alpha plane\n",
    "\n",
    "    # Again calculate the inverse mask\n",
    "    background_mask = 255 - overlay_mask\n",
    "\n",
    "    # Turn the masks into three channel, so we can use them as weights\n",
    "    overlay_mask = cv2.cvtColor(overlay_mask, cv2.COLOR_GRAY2BGR)\n",
    "    background_mask = cv2.cvtColor(background_mask, cv2.COLOR_GRAY2BGR)\n",
    "\n",
    "    # Create a masked out face image, and masked out overlay\n",
    "    # We convert the images to floating point in range 0.0 - 1.0\n",
    "    face_part = (face_img * (1 / 255.0)) * (background_mask * (1 / 255.0))\n",
    "    overlay_part = (overlay_img * (1 / 255.0)) * (overlay_mask * (1 / 255.0))\n",
    "\n",
    "    # And finally just add them together, and rescale it back to an 8bit integer image    \n",
    "    return np.uint8(cv2.addWeighted(face_part, 255.0, overlay_part, 255.0, 0.0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a function for calculating tail beat frequency."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_tail_beat_frequency(fps, tail_angle_array):\n",
    "    tail_angles = tail_angle_array.copy()\n",
    "\n",
    "    baseline = np.mean(tail_angles[:100])\n",
    "    tail_angles -= baseline\n",
    "\n",
    "    N = 10\n",
    "    smoothed_tail_angles = np.convolve(tail_angles, np.ones((N,))/N, mode='same')\n",
    "\n",
    "#     derivative = np.abs(np.diff(smoothed_tail_angles, append=[0]))/0.01\n",
    "#     smoothed_derivative = np.convolve(derivative, np.ones((N,))/N, mode='same')\n",
    "    derivative = np.abs(np.diff(smoothed_tail_angles))/0.01\n",
    "    smoothed_derivative = np.convolve(derivative, np.ones((N,))/N, mode='same')\n",
    "\n",
    "    threshold = 2\n",
    "    min_dist = 5\n",
    "    min_deriv = 10\n",
    "    highs = peakutils.peak.indexes(smoothed_tail_angles, thres=threshold/max(smoothed_tail_angles), min_dist=min_dist)\n",
    "    highs = np.array([ h for h in highs if smoothed_derivative[h] > min_deriv ])\n",
    "\n",
    "    lows = peakutils.peak.indexes(-smoothed_tail_angles, thres=threshold/max(-smoothed_tail_angles), min_dist=min_dist)\n",
    "    lows = np.array([ h for h in lows if smoothed_derivative[h] > min_deriv ])\n",
    "\n",
    "    low_freqs = [ 1.0/(lows[i] - lows[i-1]) for i in range(1, len(lows)) ]\n",
    "\n",
    "    low_freqs_array = np.zeros(smoothed_tail_angles.shape)\n",
    "    for i in range(len(low_freqs)):\n",
    "        low_freqs_array[lows[i]:lows[i+1]] = low_freqs[i]\n",
    "\n",
    "    high_freqs = [ 1.0/(highs[i] - highs[i-1]) for i in range(1, len(highs)) ]\n",
    "\n",
    "    high_freqs_array = np.zeros(smoothed_tail_angles.shape)\n",
    "    for i in range(len(high_freqs)):\n",
    "        high_freqs_array[highs[i]:highs[i+1]] = high_freqs[i]\n",
    "\n",
    "    freqs_array = (low_freqs_array + high_freqs_array)/2\n",
    "\n",
    "    return fps*freqs_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_cmap(n, name='hsv'):\n",
    "    '''Returns a function that maps each index in 0, 1, ..., n-1 to a distinct \n",
    "    RGB color; the keyword argument name must be a standard mpl colormap name.'''\n",
    "    return plt.cm.get_cmap(name, n)\n",
    "\n",
    "def adjust_contrast(image, contrast):\n",
    "    return image*contrast\n",
    "\n",
    "def adjust_gamma(image, gamma):\n",
    "    return exposure.adjust_gamma(image, gamma)\n",
    "\n",
    "# Optionally apply gamma and contrast adjustment\n",
    "gamma    = 1.1\n",
    "contrast = 1.5\n",
    "\n",
    "# Define a colormap for ROIs\n",
    "n_colors = 20\n",
    "cmap = get_cmap(n_colors)\n",
    "\n",
    "def create_plot(video_path, roi_path, tail_path, **kwargs):\n",
    "    save_dir = kwargs.get('save_dir', './')\n",
    "    \n",
    "    # Load all data\n",
    "    rois        = np.load(roi_path, allow_pickle=True)\n",
    "    video       = imread(video_path)\n",
    "    tail_angles = np.genfromtxt(tail_path, delimiter=\",\")[:, 1:]\n",
    "    \n",
    "    baseline = np.mean(tail_angles[:100, :])\n",
    "    \n",
    "    tail_angles -= baseline\n",
    "\n",
    "    prefix = os.path.basename(video_path)[:-4]\n",
    "\n",
    "    temporal_footprints   = rois[()]['roi_temporal_footprints']\n",
    "    temp_residuals        = rois[()]['roi_temporal_residuals']\n",
    "    spatial_footprints    = rois[()]['roi_spatial_footprints']\n",
    "    bg_temp_footprints    = rois[()]['bg_temporal_footprints']\n",
    "    bg_spatial_footprints = rois[()]['bg_spatial_footprints']\n",
    "    removed_rois          = rois[()]['all_removed_rois']\n",
    "\n",
    "    # Create x arrays\n",
    "    one_frame    = fps_tail/fps_calcium # number of tail angle frames in one frame of calcium imaging data (single plane)\n",
    "    total_frames = int(np.floor(one_frame*(video.shape[0]+frame_offset+1))) # number of tail angle frames in all frames of calcium imaging data (single plane)\n",
    "    x   = np.linspace(0, video.shape[0], total_frames) # x array in calcium imaging frames\n",
    "    x_s = np.linspace(0, (video.shape[0]+frame_offset+1)/fps_calcium, total_frames) # x array in seconds\n",
    "    \n",
    "    # Create the figure\n",
    "    fig = plt.figure(figsize=(30, 25), dpi=200)\n",
    "    \n",
    "    # Create gridspecs\n",
    "    gs0 = gridspec.GridSpec(1, 4, width_ratios=[1, 2, 2, 1])\n",
    "    gs1 = gridspec.GridSpecFromSubplotSpec(int(video.shape[1]/2)*3+2, 2, width_ratios=[0.9, 0.05], height_ratios=[1, 0.1]+[0.1, 0.8, 0.1]*int(video.shape[1]/2), subplot_spec=gs0[0])\n",
    "    gs2 = gridspec.GridSpecFromSubplotSpec(int(video.shape[1]/2)*3+2, 2, width_ratios=[0.1, 1.9], height_ratios=[1, 0.1]+[0.1, 0.8, 0.1]*int(video.shape[1]/2), subplot_spec=gs0[1], wspace=0)\n",
    "    gs3 = gridspec.GridSpecFromSubplotSpec(int(video.shape[1]/2)*3+2, 2, width_ratios=[0.1, 1.9], height_ratios=[1, 0.1]+[0.1, 0.8, 0.1]*int(video.shape[1]/2), subplot_spec=gs0[2], wspace=0)\n",
    "    gs4 = gridspec.GridSpecFromSubplotSpec(int(video.shape[1]/2)*3+2, 2, width_ratios=[0.05, 0.9], height_ratios=[1, 0.1]+[0.1, 0.8, 0.1]*int(video.shape[1]/2), subplot_spec=gs0[3])\n",
    "    \n",
    "    # -- Z-SCORE COLORBAR PLOT -- #\n",
    "    ax = plt.subplot(gs4[0:2, 0])\n",
    "    fig.add_subplot(ax)\n",
    "    \n",
    "    norm = matplotlib.colors.Normalize(vmin=vmin, vmax=vmax)\n",
    "    cb1 = matplotlib.colorbar.ColorbarBase(plt.gca(), cmap=colormap,\n",
    "                                norm=norm,\n",
    "                                orientation='vertical')\n",
    "    plt.ylabel('Z-score')\n",
    "    \n",
    "    # -- TAIL BEAT FREQUENCY COLORBAR PLOT -- #\n",
    "    tail_beat_frequency = calculate_tail_beat_frequency(fps_tail, tail_angles[:total_frames, -1])\n",
    "\n",
    "    ax = plt.subplot(gs1[0:2, 1])\n",
    "    fig.add_subplot(ax)\n",
    "    \n",
    "    norm = matplotlib.colors.Normalize(vmin=np.amin(tail_beat_frequency), vmax=np.amax(tail_beat_frequency))\n",
    "    cb1 = matplotlib.colorbar.ColorbarBase(plt.gca(), cmap=colormap,\n",
    "                                norm=norm,\n",
    "                                orientation='vertical')\n",
    "    ax.yaxis.set_label_position(\"left\")\n",
    "    ax.yaxis.set_ticks_position('left')\n",
    "    plt.ylabel('Tail Beat Frequency')\n",
    "    \n",
    "    for j in range(2):\n",
    "        # -- TAIL ANGLE PLOT -- #\n",
    "        if j == 0:\n",
    "            ax = plt.subplot(gs2[0, 1])\n",
    "        else:\n",
    "            ax = plt.subplot(gs3[0, 1])\n",
    "        fig.add_subplot(ax)\n",
    "        \n",
    "        plt.plot(x_s, tail_angles[:total_frames, -1], c='b', lw=0.5)\n",
    "        plt.xlim(0, (video.shape[0]+frame_offset+1)/fps_calcium)\n",
    "        plt.ylabel('Tail Angle (Degrees)')\n",
    "        plt.xlabel('Time (s)')\n",
    "        plt.gca().get_xaxis().set_visible(False)\n",
    "        plt.gca().spines['right'].set_visible(False)\n",
    "        plt.gca().spines['top'].set_visible(False)\n",
    "        plt.gca().spines['bottom'].set_visible(False)\n",
    "        plt.gca().yaxis.set_ticks_position('left')\n",
    "        plt.ylim(-180, 180)\n",
    "        plt.yticks([-180, -90, 0, 90, 180])\n",
    "        \n",
    "        # -- TAIL BEAT FREQUENCY PLOT -- #\n",
    "        if j == 0:\n",
    "            ax = plt.subplot(gs2[1, 1])\n",
    "        else:\n",
    "            ax = plt.subplot(gs3[1, 1])\n",
    "        fig.add_subplot(ax)\n",
    "        \n",
    "        plt.imshow(tail_beat_frequency[np.newaxis, :], aspect='auto', cmap=colormap, extent=[0, (video.shape[0]+frame_offset+1)/fps_calcium, 0, 1])\n",
    "        plt.title('Tail Beat Frequency (Hz)')\n",
    "        plt.xlabel('Time (s)')\n",
    "        plt.gca().get_yaxis().set_visible(False)\n",
    "        plt.gca().spines['right'].set_visible(False)\n",
    "        plt.gca().spines['top'].set_visible(False)\n",
    "        plt.gca().spines['left'].set_visible(False)\n",
    "        plt.gca().margins(2)\n",
    "    \n",
    "    # Copy the temporal footprints list\n",
    "    temp_footprints = temporal_footprints[:]\n",
    "    for z in range(video.shape[1]):\n",
    "        all_colors = [ (np.random.uniform(50, 200), np.random.uniform(50, 200), np.random.uniform(50, 200)) for i in range(10000) ]\n",
    "        \n",
    "        # Make a list of ROIs to plot (just the kept ROIs)\n",
    "        kept_rois = [ i for i in range(temporal_footprints[z].shape[0]) if i not in removed_rois[z] ]\n",
    "        \n",
    "        # Compute z-scored data\n",
    "#         zscore = (temporal_footprints[z][kept_rois] - np.mean(temporal_footprints[z][kept_rois], axis=1)[:, np.newaxis])/np.std(temporal_footprints[z][kept_rois], axis=1)[:, np.newaxis]\n",
    "\n",
    "#Handles undefined z scores which arise when using autoregressive order 1 with a z score that doesn't change thus giving a standard deviation of 0 for the denominator\n",
    "        zscoreNum = temporal_footprints[z][kept_rois] - np.mean(temporal_footprints[z][kept_rois], axis=1)[:, np.newaxis]\n",
    "        zscorePreDen = np.std(temporal_footprints[z][kept_rois], axis=1)[:, np.newaxis]\n",
    "        preDenBoolArr = np.isnan(zscorePreDen)\n",
    "        mmzscoreDen = np.where(zscorePreDen != 0, zscorePreDen, 1)\n",
    "        zscore = zscoreNum / mmzscoreDen\n",
    "        \n",
    "        # Compute sorted data based on correlations of z-scored data\n",
    "        correlations = np.corrcoef(zscore)\n",
    "        i, j = np.unravel_index(correlations.argmin(), correlations.shape)\n",
    "\n",
    "        temp_footprints[z] = temporal_footprints[z][kept_rois]\n",
    "        temp_footprints[z][0] = zscore[i]\n",
    "        temp_footprints[z][-1] = zscore[j]\n",
    "        \n",
    "        sorted_kept_rois = kept_rois[:]\n",
    "        \n",
    "        sorted_kept_rois[0] = kept_rois[i]\n",
    "        sorted_kept_rois[-1] = kept_rois[j]\n",
    "\n",
    "        remaining_indices = [ index for index in range(temp_footprints[z].shape[0]) if index not in (i, j) ]\n",
    "            \n",
    "        for k in range(1, temp_footprints[z].shape[0]-1):\n",
    "            corrs_1 = [ correlations[i, index] for index in remaining_indices ]\n",
    "            corrs_2 = [ correlations[j, index] for index in remaining_indices ]\n",
    "\n",
    "            difference = [ corrs_1[l] - corrs_2[l] for l in range(len(remaining_indices)) ]\n",
    "            l = np.argmax(difference)\n",
    "            index = remaining_indices[l]\n",
    "\n",
    "            temp_footprints[z][k] = zscore[index]\n",
    "            \n",
    "            sorted_kept_rois[k] = kept_rois[index]\n",
    "            \n",
    "            del remaining_indices[l]\n",
    "        \n",
    "        # Create the background image (mean of the video)\n",
    "        video_max = np.amax(video)\n",
    "        image = np.mean(video[:, z, :, :], axis=0)\n",
    "        image = adjust_gamma(adjust_contrast(image, contrast), gamma)\n",
    "        image = 255.0*image/video_max\n",
    "        image[image > 255] = 255\n",
    "        image = cv2.cvtColor(image.astype(np.uint8), cv2.COLOR_GRAY2RGB)\n",
    "        \n",
    "        kept_footprints = temp_footprints[z]\n",
    "        \n",
    "        # Create the ROI overlays\n",
    "        roi_spatial_footprints = spatial_footprints[z].toarray().reshape((video.shape[2], video.shape[3], spatial_footprints[z].shape[-1])).transpose((0, 1, 2))\n",
    "        overlays = np.zeros((roi_spatial_footprints.shape[-1], image.shape[0], image.shape[1], 4)).astype(np.uint8)\n",
    "        total_mask = np.zeros((image.shape[0], image.shape[1]))\n",
    "        \n",
    "        roi_contours = []\n",
    "\n",
    "        for j in range(len(kept_rois)):\n",
    "            i = kept_rois[j]\n",
    "            sorted_roi_index = (len(kept_rois) - j) - 1\n",
    "            maximum = np.amax(roi_spatial_footprints[:, :, i])\n",
    "            mask = (roi_spatial_footprints[:, :, i] > 0).copy()\n",
    "\n",
    "            contours = cv2.findContours(mask.astype(np.uint8), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)[-2]\n",
    "\n",
    "            contour = max(contours, key=cv2.contourArea)\n",
    "            \n",
    "            roi_contours.append(contour)\n",
    "\n",
    "            M = cv2.moments(contour)\n",
    "            if M[\"m00\"] != 0:\n",
    "                center_x = int(M[\"m10\"] / M[\"m00\"])\n",
    "                center_y = int(M[\"m01\"] / M[\"m00\"])\n",
    "            else:\n",
    "                center_x = 0\n",
    "                center_y = 0\n",
    "            \n",
    "            color = cmap(sorted_roi_index % n_colors)[:3]\n",
    "            color = [255*color[0], 255*color[1], 255*color[2]]\n",
    "    \n",
    "            overlay = np.zeros((image.shape[0], image.shape[1], 4)).astype(np.uint8)\n",
    "\n",
    "            overlay[mask, :-1] = color\n",
    "            overlay[mask, -1] = 205.0*roi_spatial_footprints[mask, i]/maximum + 50\n",
    "            overlays[i] = overlay\n",
    "            \n",
    "            total_mask += mask\n",
    "        \n",
    "        # Create the final ROI image (blending the mean image and the overlays)\n",
    "        denominator = np.count_nonzero(overlays[kept_rois], axis=0)\n",
    "        denominator[denominator == 0] = 1\n",
    "        roi_overlay = (np.sum(overlays[kept_rois], axis=0)/denominator).astype(np.uint8)\n",
    "        \n",
    "        image = blend_transparent(image, roi_overlay)\n",
    "    \n",
    "        # -- ROI SPATIAL FOOTPRINTS PLOT -- #\n",
    "        if z < video.shape[1]/2:\n",
    "            ax = plt.subplot(gs1[z*3+2:z*3+5, 0:2])\n",
    "        else:\n",
    "            ax = plt.subplot(gs4[(z-5)*3+2:(z-5)*3+5, 0:2])\n",
    "        fig.add_subplot(ax)\n",
    "        \n",
    "        plt.imshow(image)\n",
    "        \n",
    "        # Add text label for each ROI\n",
    "        for j in range(len(kept_rois)):\n",
    "            i = sorted_kept_rois[j]\n",
    "            \n",
    "            sorted_roi_index = (len(kept_rois) - j) - 1\n",
    "            mmvar = str(i) + ', ' + str(sorted_roi_index)\n",
    "            x = np.amax(roi_contours[j][:, 0, 0])\n",
    "            y = np.amax(roi_contours[j][:, 0, 1])\n",
    "            \n",
    "            color = cmap(sorted_roi_index % n_colors)[:3]\n",
    "            \n",
    "            plt.text(x, y, sorted_roi_index, color=color, size=7)\n",
    "        \n",
    "        plt.axis('off')\n",
    "        \n",
    "        # -- ROI IDENTIFICATION PLOT -- #\n",
    "        if z < video.shape[1]/2:\n",
    "            ax = plt.subplot(gs2[z*3+3, 0])\n",
    "        else:\n",
    "            ax = plt.subplot(gs3[(z-5)*3+3, 0])\n",
    "        fig.add_subplot(ax)\n",
    "        \n",
    "        # Create image to plot next to ROI traces which identifies each ROI's color and number\n",
    "        arr = np.zeros((len(kept_rois), 1, 3)).astype(np.uint8)\n",
    "        for i in range(len(kept_rois)):\n",
    "            arr[i, :, :] = all_colors[kept_rois[i]]\n",
    "            \n",
    "            color = cmap(i % n_colors)[:3]\n",
    "            color = [255*color[0], 255*color[1], 255*color[2]]\n",
    "            arr[i, :, :] = color\n",
    "        plt.imshow(arr, aspect='auto', extent=[0, 1, 0, len(kept_rois)])\n",
    "        \n",
    "        # Add text label for each ROI\n",
    "        for i in range(len(kept_rois)):\n",
    "            j = sorted_kept_rois[i]\n",
    "            sorted_roi_index = (len(kept_rois) - i) - 1\n",
    "            sorted_label = str(j) + ', ' + str(sorted_roi_index)\n",
    "            plt.text(0, i, sorted_roi_index, size=9)\n",
    "        \n",
    "        plt.gca().get_xaxis().set_visible(False)\n",
    "        plt.gca().spines['right'].set_visible(False)\n",
    "        plt.gca().spines['top'].set_visible(False)\n",
    "        plt.gca().spines['bottom'].set_visible(False)\n",
    "        plt.gca().yaxis.set_ticks_position('left')\n",
    "        plt.ylabel('ROI #')\n",
    "        plt.yticks([0, kept_footprints.shape[0]])\n",
    "        \n",
    "        # -- ROI TEMPORAL TRACES PLOT -- #\n",
    "        if z < video.shape[1]/2:\n",
    "            ax = plt.subplot(gs2[z*3+3, 1])\n",
    "        else:\n",
    "            ax = plt.subplot(gs3[(z-5)*3+3, 1])\n",
    "        \n",
    "        fig.add_subplot(ax)\n",
    "        \n",
    "        # Plot z-scored traces sorted using correlations\n",
    "        # Handles 0 values so there are no empty bars when plotting if z score did not change\n",
    "        #left ## heatmap commented out but still present as the original code to plot the heatmap\n",
    "        heatmap_numerator = (kept_footprints - np.mean(kept_footprints, axis=1)[:, np.newaxis]) \n",
    "        heatmap_stdev = np.std(kept_footprints, axis=1)[:, np.newaxis]\n",
    "        heatmap_denominator = np.where(heatmap_stdev != 0, heatmap_stdev, 0.01)\n",
    "        heatmap = heatmap_numerator / heatmap_denominator\n",
    "##         heatmap = (kept_footprints - np.mean(kept_footprints, axis=1)[:, np.newaxis])/np.std(kept_footprints, axis=1)[:, np.newaxis]        \n",
    "        plt.imshow(heatmap, aspect='auto', cmap=colormap, extent=[(frame_offset + z/video.shape[1])/fps_calcium, (frame_offset + temp_footprints[z].shape[1]+z/video.shape[1])/fps_calcium, 0, temp_footprints[z].shape[0]], vmin=vmin, vmax=vmax)\n",
    "\n",
    "        plt.gca().get_yaxis().set_visible(False)\n",
    "        plt.xlabel('Time (s)')\n",
    "        plt.gca().spines['right'].set_visible(False)\n",
    "        plt.gca().spines['top'].set_visible(False)\n",
    "        plt.gca().spines['left'].set_visible(False)\n",
    "        plt.ylim(0, kept_footprints.shape[0])\n",
    "        plt.xlim(0, (video.shape[0]+frame_offset+1)/fps_calcium)\n",
    "    \n",
    "    plt.tight_layout()\n",
    "    \n",
    "    # Save the plot\n",
    "    plt.savefig(save_dir + \"{}_zscore_{}_to_{}.png\".format(prefix, vmin, vmax))\n",
    "#     plt.savefig(save_dir + \"{}_zscore_{}_to_{}.svg\".format(prefix, vmin, vmax))\n",
    "    \n",
    "    # (Optional) Show the plot\n",
    "    # plt.show()\n",
    "\n",
    "    plt.cla()\n",
    "    plt.clf()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a function to create and save the plot given paths to the video, ROI data and tail trace."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\mmart\\anaconda3\\envs\\caiman\\lib\\site-packages\\numpy\\lib\\function_base.py:2400: RuntimeWarning: invalid value encountered in true_divide\n",
      "  c /= stddev[:, None]\n",
      "C:\\Users\\mmart\\anaconda3\\envs\\caiman\\lib\\site-packages\\numpy\\lib\\function_base.py:2401: RuntimeWarning: invalid value encountered in true_divide\n",
      "  c /= stddev[None, :]\n",
      "C:\\Users\\mmart\\anaconda3\\envs\\caiman\\lib\\site-packages\\ipykernel_launcher.py:135: RuntimeWarning: invalid value encountered in true_divide\n",
      "C:\\Users\\mmart\\anaconda3\\envs\\caiman\\lib\\site-packages\\ipykernel_launcher.py:291: RuntimeWarning: invalid value encountered in true_divide\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 6000x5000 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "main_path  = 'C:/Users/mmart/Documents/Analysis/FilesToAnalyze/Feb.25.20_HUC6f_5dpf_loom_lv30_1C-1_mc/'\n",
    "video_path = main_path+\"Feb.25.20_HUC6f_5dpf_loom_lv30_1C-1_mc.tif\"\n",
    "roi_path   = main_path+\"roi_data.npy\"\n",
    "tail_path  = main_path+\"Feb.25.20_1C_tail_angles1.csv\"\n",
    "# tail_path = 'C:/Users/mmart/Documents/Analysis/FilesToAnalyze/Mar.10.20_HUC6f_fish2_6dpf_loom_lv30_2C-1_mc/Mar.10.20_2C_tail_angles1.csv'\n",
    "\n",
    "# C:\\Users\\Michael\\Documents\\Analysis\\JCaImAn\\Calcium-Imaging-Analysis\n",
    "\n",
    "# the important part - run the function to create the plot\n",
    "create_plot(video_path, roi_path, tail_path, save_dir=main_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:caiman]",
   "language": "python",
   "name": "conda-env-caiman-py"
  },
  "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.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}