gel_lane_finder.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Gel Image Manual Band Selector"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook allows a user to interactively select lanes and gel bands from an input gel image.  The gel bands must be rectangles, but these can be rotated freely.  Final selections can be saved to file in CSV format and read for analysis in accompanying analysis notebook (scroll to end of file for tutorial on how to use)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Imports and file setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib as mpl\n",
    "import numpy as np\n",
    "from mpl_toolkits.axes_grid1 import make_axes_locatable, AxesGrid\n",
    "from IPython.display import display, clear_output\n",
    "import ipywidgets as widgets\n",
    "from ipywidgets import Layout, Output\n",
    "from PIL import Image\n",
    "from matplotlib.widgets import RectangleSelector\n",
    "from matplotlib.patches import Polygon\n",
    "from numpy.linalg import lstsq\n",
    "import copy\n",
    "import json\n",
    "from scipy.signal import find_peaks\n",
    "import scipy.signal as signal\n",
    "from scipy import sparse\n",
    "from scipy.sparse.linalg import spsolve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Set filepaths according to your system\n",
    "\n",
    "base_path = r'SET INPUT FOLDER'\n",
    "main_output_loc = 'SET OUTPUT LOCATION'\n",
    "\n",
    "# Main DNA File\n",
    "base_data = os.path.join(base_path, r'LOD_v7_7:10:21/images')\n",
    "print('Main DNA file available:', os.path.isdir(base_data))\n",
    "DNA_file = os.path.join(base_data, '1_3.tif')  # 48 hour BRCA1, TBE\n",
    "\n",
    "# 24-hr DNA File\n",
    "base_data = os.path.join(base_path, r'LOD_v8_8:10:21/images')\n",
    "print('24-hr DNA file available:', os.path.isdir(base_data))\n",
    "DNA_file_24 = os.path.join(base_data, 'dna_2.tif')  # 24 hour BRCA1, TBE\n",
    "\n",
    "# TAE DNA File\n",
    "base_data = os.path.join(base_path, r'LOD_processing_v2_28:9:21/images')\n",
    "print('Better TAE DNA file available:', os.path.isdir(base_data))\n",
    "better_tae_DNA_file = os.path.join(base_data, '2_top.tif')  # 24 hour BRCA1, TAE\n",
    "\n",
    "# Main RNA File\n",
    "base_data = os.path.join(base_path, r'LOD_v6_6:10:21/images')\n",
    "print('Main RNA file available:', os.path.isdir(base_data))\n",
    "RNA_file = os.path.join(base_data, 'tbe_2_2.tif')  # 24 hour RNA, TBE\n",
    "\n",
    "# Main Aldosterone File\n",
    "base_data = os.path.join(base_path, r'LOD_v8_8:10:21/images')\n",
    "print('Main aldosterone file available:', os.path.isdir(base_data))\n",
    "Aldos_file = os.path.join(base_data, 'aldos_2.tif') # 24 hour aldosterone, TBE\n",
    "\n",
    "# Mutations Analysis\n",
    "base_data = os.path.join(base_path, r'LOD_v6_6:10:21/images')\n",
    "print('TAE Mutation file available:', os.path.isdir(base_data))\n",
    "mutations_file = os.path.join(base_data, 'tae_3_2.tif')  # 24 hour detection, TAE\n",
    "\n",
    "# Mutations Analysis (TBE)\n",
    "base_data = os.path.join(base_path, r'LOD_v6_6:10:21/images')\n",
    "print('TBE Mutation analysis file available:', os.path.isdir(base_data))\n",
    "mutations_tbe_file = os.path.join(base_data, 'tbe_1_zoomed.tif')  # 24 hour detection, TBE\n",
    "\n",
    "# Aldosterone FBS analysis (TBE)\n",
    "base_data = os.path.join(base_path,'..', r'FBS Phase 5/FBS_long_term_testing_3_7:2:22/images')\n",
    "print('Aldosterone FBS file available:', os.path.isdir(base_data))\n",
    "aldos_fbs_file = os.path.join(base_data, 'aldos_1.tif')  # 2 hour detection, TBE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Image Loading and Quick Image Display"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "image = Image.open(aldos_fbs_file)\n",
    "im_array = np.array(image)\n",
    "# fig = plt.figure(figsize=(20,20))\n",
    "plt.imshow(1-im_array, cmap='gray')\n",
    "plt.axis('off')\n",
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Main Lain Selection GUI"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Config initialization\n",
    "%matplotlib notebook\n",
    "lane = None\n",
    "trace = None\n",
    "point = None\n",
    "lane_line = None\n",
    "current_setup = 'width'\n",
    "lane_queue = []\n",
    "lane_data = {}\n",
    "patches = [] # lanes plotted on screen\n",
    "temp_patches = []\n",
    "l_lock = False\n",
    "band_line = []\n",
    "\n",
    "def dist_2_pts(p1, p2):\n",
    "    # finds distance between two points (2D)\n",
    "    return np.sqrt((p2[0] - p1[0])**2 + (p2[1] - p1[1])**2)\n",
    "\n",
    "def plot_v_line(btn):\n",
    "    # Plots a vertical line on the gel image, and a linear trace in the top plot (currently unused)\n",
    "    global lane, ax, trace\n",
    "    if lane is not None:\n",
    "        lane.remove()\n",
    "    if trace is not None:\n",
    "        trace.remove()\n",
    "        \n",
    "    lane = ax[1].axvline(slider.value)\n",
    "    trace = ax[0].scatter(range(im_array.shape[0]), im_array[:,slider.value])\n",
    "#     ax[1].scatter(x=last_mouse_click[0],y=last_mouse_click[1])\n",
    "\n",
    "def plot_point(x, y):\n",
    "    # plots a single point at the coordinate specified\n",
    "    global point\n",
    "    if point is not None:\n",
    "        point.remove()\n",
    "    point = ax[1].scatter(x=x,y=y)\n",
    "\n",
    "def plot_im_line(p1, p2):\n",
    "    # plots a line between a mouse-defined start and stop position (will delete previous line if present)\n",
    "    global ax, lane_line\n",
    "    \n",
    "    if lane_line is not None:\n",
    "        ll = lane_line.pop(0)\n",
    "        ll.remove()\n",
    "        \n",
    "    xs = [p1[0], p2[0]]\n",
    "    ys = [p1[1], p2[1]]\n",
    "    \n",
    "    lane_line = ax[1].plot(xs, ys)\n",
    "\n",
    "def plot_dbl_line(p1, p2):\n",
    "    # plots a line between a mouse-defined start and stop position (allows for max 2 to drawn)\n",
    "    global ax, band_line\n",
    "    \n",
    "    if len(band_line) == 2:\n",
    "        for band in band_line:\n",
    "            ll = band.pop(0)\n",
    "            ll.remove()\n",
    "        band_line = []\n",
    "        \n",
    "    xs = [p1[0], p2[0]]\n",
    "    ys = [p1[1], p2[1]]\n",
    "    \n",
    "    band = ax[1].plot(xs, ys)\n",
    "    band_line.append(band)\n",
    "    \n",
    "def clear_dbl_line():\n",
    "    # clears double lines\n",
    "    global band_line\n",
    "    if len(band_line) == 2:\n",
    "        for band in band_line:\n",
    "            ll = band.pop(0)\n",
    "            ll.remove()\n",
    "        band_line = []\n",
    "\n",
    "def clear_im_line():\n",
    "    # clears any single lines on screen\n",
    "    global lane_line\n",
    "    if lane_line is not None:\n",
    "        ll = lane_line.pop(0)\n",
    "        ll.remove()\n",
    "    lane_line = None\n",
    "\n",
    "def diff_check_sign(a, b):\n",
    "    # subtracts two values and returns sign of result\n",
    "    sub = a - b\n",
    "    if sub < 0:\n",
    "        return np.abs(sub), False\n",
    "    else:\n",
    "        return np.abs(sub), True\n",
    "\n",
    "def measure_width_two_clicks(p1, p2):\n",
    "    # measures distance between two clicks, and sets current lane width value\n",
    "    dist = dist_2_pts(p1, p2)\n",
    "    lane_width.value = str(int(dist))\n",
    "    \n",
    "def dual_click_mouse_capture(event):\n",
    "    # captures mouse click data and plots a line between two specified points\n",
    "    global last_mouse_click, lane_queue, current_setup, temp_patches, l_lock, lane_length, lane_data, output\n",
    "    \n",
    "    with output:  # this is required to allow printing of error callbacks\n",
    "        lane_queue.append((int(event.xdata),int(event.ydata)))\n",
    "\n",
    "        if len(lane_queue) == 2:  # will trigger only if two clicks registered\n",
    "            \n",
    "            if current_setup == 'positioning': # set start/stop positions of lane\n",
    "                p1 = (lane_queue[0][0], lane_queue[0][1])\n",
    "                p2 = (lane_queue[1][0], lane_queue[1][1])\n",
    "                if l_lock:\n",
    "                    p2 = reduce_length_to_standard(p1, p2) # reduce length to standard value if set\n",
    "                else:\n",
    "                    lane_length.value = str(int(round(dist_2_pts(p1, p2))))\n",
    "                lane_pos.value = 'Lane Position: [%d, %d] to [%d, %d]' % (p1[0], p1[1], p2[0], p2[1])\n",
    "                draw_current_lane()\n",
    "                \n",
    "            elif current_setup == 'width':  # measuring band width\n",
    "                if len(temp_patches) != 0:  # delete old patches\n",
    "                    for p in temp_patches:\n",
    "                        p.remove()\n",
    "                    temp_patches = []\n",
    "                measure_width_two_clicks(lane_queue[0], lane_queue[1])\n",
    "                \n",
    "            else: # band selection\n",
    "                found_bands = []\n",
    "\n",
    "                for lane_id, lane in lane_data.items():  # checks all saved lanes one by one\n",
    "                    lane_positions = lane['lane_divisions']\n",
    "                    for point in lane_queue:\n",
    "                        for p_index, position in enumerate(lane_positions):\n",
    "                            if point in position:\n",
    "                                plot_dbl_line(position[0], position[-1])\n",
    "                                found_bands.append((lane_id, p_index))\n",
    "                                break\n",
    "                    if len(found_bands) == 2:\n",
    "                        break\n",
    "                    if len(found_bands) == 1:\n",
    "                        print('Error in band finding, please try again.')\n",
    "                if len(found_bands) == 2:\n",
    "                    lane_data[found_bands[0][0]]['band'] = [found_bands[0][1], found_bands[1][1]]\n",
    "\n",
    "            if current_setup != 'band_select':\n",
    "                plot_im_line(lane_queue[0], lane_queue[1])\n",
    "            lane_queue = []\n",
    "\n",
    "def profile_plot(btn):\n",
    "    # using specified lane, calculates and plots pixel intensity profile (recommended to draw diagram of graphing system to understand how it works)\n",
    "    global ax, im_array, plot_intensity, lane_data\n",
    "    for lane_id, lane in lane_data.items():\n",
    "        corners = copy.copy(lane['corners'])  # extract corners data for each lane\n",
    "        \n",
    "        corners_all = copy.copy(corners)\n",
    "        max_point = 0\n",
    "        ind_max = 0\n",
    "        \n",
    "        for ind in range(corners.shape[0]):  # finding lowest coordinate (i.e. highest y-value)\n",
    "            if corners[ind][1] > max_point:\n",
    "                anchor_1 = corners[ind]\n",
    "                ind_max = ind\n",
    "            max_point = max(max_point, corners[ind][1]) \n",
    "\n",
    "        corners = np.delete(corners, ind_max, 0) # deleting lowest coordinate from central corners list\n",
    "        \n",
    "        dists = []\n",
    "        for c in corners:  # calculating distance between bottom point and the rest of the corners\n",
    "            dists.append(dist_2_pts(anchor_1, c))\n",
    "\n",
    "        dist_sort = sorted(dists)\n",
    "        anchor_2 = corners[dists.index(dist_sort[0])]  # closest corner is second from the bottom (anchor 2)\n",
    "        base_1 = corners[dists.index(dist_sort[1])]  # next closest is the base corner matching the first anchor\n",
    "        base_2 = corners[dists.index(dist_sort[2])]  # finally, this base will link to anchor 2\n",
    "\n",
    "        # eqn for rect height\n",
    "        points = [anchor_1,base_1]\n",
    "        x_coords, y_coords = zip(*points)\n",
    "        A = np.vstack([y_coords,np.ones(len(y_coords))]).T\n",
    "        m_b, c_b = lstsq(A, x_coords, rcond=None)[0]  # this is the long edge containing anchor_1 and base_1\n",
    "\n",
    "         # eqn for rect height 2\n",
    "        points = [anchor_2,base_2]\n",
    "        x_coords, y_coords = zip(*points)\n",
    "        A = np.vstack([y_coords,np.ones(len(y_coords))]).T\n",
    "        m_b2, c_b2 = lstsq(A, x_coords, rcond=None)[0]  # this is the long edge containing anchor_2 and base_2\n",
    "\n",
    "        x_as = []\n",
    "        plot_intensity = []\n",
    "        lane_divisions = []\n",
    "        for ind, i_y in enumerate(range(base_1[1], anchor_1[1]+1)):  # cycle through y values between base_1 and anchor_1\n",
    "            i_y2 = base_2[1] + ind  # find corresponding y value on other edge \n",
    "            x_a = m_b * i_y + c_b  # calculate corresponding x position for both ys\n",
    "            x_b = m_b2 * i_y2 + c_b2\n",
    "        \n",
    "            x_as.append(round(x_a))\n",
    "\n",
    "            x_coords = (round(x_a), round(x_b))\n",
    "            y_coords = (i_y, i_y2)\n",
    "            \n",
    "            A = np.vstack([x_coords,np.ones(len(x_coords))]).T\n",
    "            m_bt, c_bt = lstsq(A, y_coords, rcond=None)[0]  # find equation of line connecting the two points found on the edges of the rectangle\n",
    "            \n",
    "            if x_a > x_b:\n",
    "                direction = -1\n",
    "            else:\n",
    "                direction = 1\n",
    "                \n",
    "            x_test = range(int(round(x_a)), int(round(x_b)), direction)\n",
    "            y_test = m_bt*x_test + c_bt  # extract all available x/y pixels in this section of the profile\n",
    "            \n",
    "            data = []  # accumulate actual image data here\n",
    "            inner_divisions = []  # accumulate each line's coverage here, which will help for easy band selection\n",
    "            for x,y in zip(x_test, y_test): \n",
    "                data.append(im_array[int(round(y)), x])  # image axes flipped around in array, so have to reverse x and y\n",
    "                inner_divisions.append((x, int(round(y))))\n",
    "            plot_intensity.append(np.mean(data))  # profile intensity is an average of entire width of the lane\n",
    "            lane_divisions.append(inner_divisions)  # contains the entire pixel coverage corresponding to the position along the lane\n",
    "        \n",
    "        lane_data[lane_id]['lane_divisions'] = lane_divisions\n",
    "        lane_data[lane_id]['trace'] = plot_intensity \n",
    "        \n",
    "        ax[0].scatter(range(len(plot_intensity)), plot_intensity, label=lane_id, s=10)  # plots profile in top plot\n",
    "    ax[0].legend()\n",
    "    \n",
    "def reduce_length_to_standard(p1, p2):\n",
    "    # checks to see how long drawn lane is, and changes its size to match standard value if not equal\n",
    "    \n",
    "    target_length = int(lane_length.value)\n",
    "    actual_length = dist_2_pts(p1, p2)\n",
    "    \n",
    "    if actual_length == target_length:\n",
    "        return p2\n",
    "        \n",
    "    change, change_sign = diff_check_sign(actual_length, target_length)\n",
    "    \n",
    "    xdev, h_sign = diff_check_sign(p1[0], p2[0])\n",
    "    ydev, v_sign = diff_check_sign(p1[1], p2[1])\n",
    "    \n",
    "    if xdev == 0:\n",
    "        return (p2[0], p2[1] + change)\n",
    "\n",
    "    points_angle = np.arctan(ydev/xdev)\n",
    "           \n",
    "    v_change = np.abs(np.sin(points_angle) * change)\n",
    "    h_change = np.abs(np.cos(points_angle) * change)\n",
    "\n",
    "    if v_sign:\n",
    "        v_change = - v_change \n",
    "    if h_sign:\n",
    "        h_change = - h_change\n",
    "    if change_sign:\n",
    "        h_change = - h_change\n",
    "        v_change = - v_change\n",
    "        \n",
    "    new_p2 = (int(round(p2[0] + h_change)), int(round(p2[1] + v_change)))\n",
    "        \n",
    "    return new_p2\n",
    "    \n",
    "################## State Callbacks #################\n",
    "\n",
    "def set_width_on(btn):\n",
    "    global current_setup, mode\n",
    "    current_setup = 'width'\n",
    "    mode.value = 'Mode: %s' % current_setup\n",
    "    clear_im_line()\n",
    "    clear_dbl_line()\n",
    "    \n",
    "def set_pos_on(btn):\n",
    "    global current_setup, mode\n",
    "    current_setup = 'positioning'\n",
    "    mode.value = 'Mode: %s' % current_setup\n",
    "    clear_im_line()\n",
    "    clear_dbl_line()\n",
    "    \n",
    "def set_band_sel_on(btn):\n",
    "    global current_setup, mode\n",
    "    current_setup = 'band_select'\n",
    "    mode.value = 'Mode: %s' % current_setup\n",
    "    clear_im_line()\n",
    "    clear_dbl_line()\n",
    "    \n",
    "def get_current_lane():\n",
    "    start = lane_pos.value.split('[')[1].split(']')[0]\n",
    "    st_x = int(start.split(',')[0])\n",
    "    st_y = int(start.split(',')[1])\n",
    "    \n",
    "    stop = lane_pos.value.split('[')[2].split(']')[0]\n",
    "    sp_x = int(stop.split(',')[0])\n",
    "    sp_y = int(stop.split(',')[1])\n",
    "    return int(lane_width.value), int(lane_length.value), (st_x, st_y), (sp_x, sp_y)\n",
    "    \n",
    "def save_lane(btn):\n",
    "    # saves data in a dict for future exporting\n",
    "    width, length, start, stop = get_current_lane()\n",
    "    lane_data[current_lane.value] = {\n",
    "        'width': width,\n",
    "        'length': length,\n",
    "        'start': start,\n",
    "        'stop': stop\n",
    "    }\n",
    "    \n",
    "def save_to_csv(btn):\n",
    "    # export data to csv file\n",
    "    if 'lane_divisions' in lane_data[next(iter(lane_data))]:\n",
    "        df = pd.DataFrame.from_dict(lane_data, orient='index').drop(['lane_divisions'],axis=1)\n",
    "    else:\n",
    "        df = pd.DataFrame.from_dict(lane_data, orient='index')\n",
    "    \n",
    "    df.to_csv(output_f.value)\n",
    "    \n",
    "def load_from_csv(btn):\n",
    "    # reload previously saved data to be able to reconstruct lanes\n",
    "    global lane_data\n",
    "    df = pd.read_csv(input_f.value, header=0, index_col=0)\n",
    "    df['width'] = df['width'].astype(int)\n",
    "    df['start'] = df['start'].map(lambda x: tuple(map(int,x.lstrip('(').rstrip(')').split(','))))\n",
    "    df['stop'] = df['stop'].map(lambda x: tuple(map(int,x.lstrip('(').rstrip(')').split(','))))\n",
    "    lane_data = df.to_dict(orient='index')\n",
    "\n",
    "def rot_rect(width, p1, p2):\n",
    "    # find corners of a rotated (not horizontal/vertical) rectangle\n",
    "    rot_corners = np.zeros((4, 2), dtype=np.int)\n",
    "        \n",
    "    cx = p1[0] + (p2[0] - p1[0])/2 # with lane width + start/stop, we can find centre of lane 'rectangle'\n",
    "    cy = p1[1] + (p2[1] - p1[1])/2\n",
    "\n",
    "    height = dist_2_pts(p1, p2)\n",
    "        \n",
    "    # after finding corners of vertical rectangle, can then move on to find angle of rotation required for specified lane\n",
    "    corners = [(cx - width/2, cy+height/2), (cx+width/2, cy+height/2), (cx+width/2, cy-height/2), (cx-width/2, cy-height/2)]\n",
    "    angle = -np.arctan((p2[0] - cx) / (p2[1] - cy) )\n",
    "\n",
    "    for index, (x,y) in enumerate(corners):  # after finding angle, need to apply transformation to all corners of rectangle\n",
    "        tx = x - cx\n",
    "        ty = y - cy\n",
    "        nx = tx*np.cos(angle) - ty*np.sin(angle) + cx\n",
    "        ny = tx*np.sin(angle) + ty*np.cos(angle) + cy\n",
    "        rot_corners[index, :] = [int(nx), int(ny)]\n",
    "    \n",
    "    return rot_corners\n",
    "    \n",
    "def draw_lanes(btn):\n",
    "    # draw all saved lanes on image\n",
    "    global ax, temp_patches, patches, lane_line\n",
    "    \n",
    "    if len(patches) != 0:  # delete old patches\n",
    "        for p in patches:\n",
    "            p.remove()\n",
    "        patches = []\n",
    "        \n",
    "    if len(temp_patches) != 0:  # delete old patches\n",
    "        for p in temp_patches:\n",
    "            p.remove()\n",
    "        temp_patches = []\n",
    "    \n",
    "    clear_im_line()\n",
    "    \n",
    "    for lane_id, lane in lane_data.items():  # draws all saved lanes one by one\n",
    "        width = lane['width']\n",
    "        p1 = lane['start']\n",
    "        p2 = lane['stop']\n",
    "        rot_corners = rot_rect(width, p1, p2)\n",
    "        patch = ax[1].add_patch(Polygon(rot_corners, linewidth=1, edgecolor='r', facecolor='none'))\n",
    "        patches.append(patch)\n",
    "        lane_data[lane_id]['corners'] = rot_corners\n",
    "\n",
    "def draw_current_lane():\n",
    "    # extracts current lane parameters, and plots directly\n",
    "    global temp_patches\n",
    "    if len(temp_patches) != 0:  # delete old patches\n",
    "        for p in temp_patches:\n",
    "            p.remove()\n",
    "        temp_patches = []\n",
    "    width, length, p1, p2 = get_current_lane()\n",
    "    rot_corners = rot_rect(width, p1, p2)\n",
    "    patch = ax[1].add_patch(Polygon(rot_corners, linewidth=1, edgecolor='r', facecolor='none'))\n",
    "    temp_patches.append(patch)\n",
    "\n",
    "def lock_length(btn):\n",
    "    # ensure lanes have same length\n",
    "    global l_lock, length_lock\n",
    "    l_lock = not l_lock\n",
    "    if l_lock:\n",
    "        length_lock.description = 'Unlock Length' \n",
    "    else:\n",
    "        length_lock.description = 'Lock Length'\n",
    "        \n",
    "def update_lane_length(btn):\n",
    "    lane_length.value = str(lane_data[current_lane.value]['length'])\n",
    "    \n",
    "################## UI #################\n",
    "\n",
    "max_pixel = im_array.shape[1]\n",
    "layout = widgets.Layout(width='auto') #set width to expand to description size\n",
    "\n",
    "slider = widgets.IntSlider(\n",
    "                                value=int(max_pixel/2),\n",
    "                                min=0,\n",
    "                                max=max_pixel,\n",
    "                                step=1,\n",
    "                                description='Lane Positioning:',\n",
    "                                disabled=False,\n",
    "                                layout=Layout(width=\"80%\"),\n",
    "                                continuous_update=False,\n",
    "                                orientation='horizontal',\n",
    "                                readout=True,\n",
    "                                readout_format='d',\n",
    "                                style={'description_width': 'initial'}\n",
    "                            )\n",
    "slider.observe(plot_v_line)  # calls this function when changed\n",
    "\n",
    "\n",
    "##### Lane Info\n",
    "current_lane = widgets.Text(value='0', \n",
    "                            description='Lane ID:',\n",
    "                            style={'description_width': 'initial'},\n",
    "                            layout=widgets.Layout(display='flex', width='20%'))\n",
    "input_f = widgets.Text(\n",
    "                            description='Load CSV:',\n",
    "                            value= os.path.join(os.getcwd(),'lane_data', 'lane_file.csv'),\n",
    "                            disabled=False,\n",
    "                            style={'description_width': 'initial'},\n",
    "                            layout=widgets.Layout(display='flex', width='40%')\n",
    "                        )\n",
    "output_f = widgets.Text(\n",
    "                            description='Save CSV:',\n",
    "                            value= os.path.join(main_output_loc, 'lane_file.csv'),\n",
    "                            disabled=False,\n",
    "                            style={'description_width': 'initial'},\n",
    "                            layout=widgets.Layout(display='flex', width='40%')\n",
    "                        )\n",
    "\n",
    "lane_stack = widgets.HBox([current_lane, input_f, output_f])\n",
    "##### \n",
    "\n",
    "##### Labels\n",
    "lane_pos = widgets.Label('Lane Position:', layout=widgets.Layout(display='flex', width='30%', padding='0px 0px 0px 5px', border='solid 1px'))\n",
    "lane_width = widgets.Text(\n",
    "                            placeholder='Enter lane width here',\n",
    "                            description='Lane Width:',\n",
    "                            value='80', \n",
    "                            disabled=False,\n",
    "                            layout=widgets.Layout(display='flex', width='20%'),\n",
    "                            style={'description_width': 'initial'}\n",
    "                        )\n",
    "lane_length = widgets.Text(\n",
    "                            placeholder='Enter lane length here',\n",
    "                            description='Lane Length:',\n",
    "                            value='150', \n",
    "                            disabled=False,\n",
    "                            layout=widgets.Layout(display='flex', width='20%'),\n",
    "                            style={'description_width': 'initial'}\n",
    "                        )\n",
    "mode = widgets.Label('Mode: %s' % current_setup, layout=widgets.Layout(display='flex', width='15%'))\n",
    "\n",
    "length_lock = widgets.Button(button_style='danger', description = 'Lock Length', layout=layout)\n",
    "length_lock.on_click(lock_length)\n",
    "\n",
    "label_stack = widgets.HBox([lane_pos, lane_width, lane_length, length_lock, mode])\n",
    "##### \n",
    "\n",
    "##### Bands\n",
    "\n",
    "band_text = widgets.Text(\n",
    "                            placeholder='Enter band positions here',\n",
    "                            description='Band Positions:',\n",
    "                            value='150', \n",
    "                            disabled=False,\n",
    "                            layout=widgets.Layout(display='flex', width='20%'),\n",
    "                            style={'description_width': 'initial'}\n",
    "                        )\n",
    "update_length_btn = widgets.Button(button_style='success', description = 'Update Length from Selected Lane', layout=layout)\n",
    "update_length_btn.on_click(update_lane_length)\n",
    "band_stack = widgets.HBox([band_text, update_length_btn])\n",
    "##### \n",
    "\n",
    "##### Buttons\n",
    "\n",
    "width_btn = widgets.Button(button_style='success', description = 'Set Lane Width', layout=layout)\n",
    "width_btn.on_click(set_width_on)\n",
    "\n",
    "define_btn = widgets.Button(button_style='success',description = 'Set Lane Start/Stop', layout=layout)\n",
    "define_btn.on_click(set_pos_on)\n",
    "\n",
    "band_btn = widgets.Button(button_style='success',description = 'Set Band', layout=layout)\n",
    "band_btn.on_click(set_band_sel_on)\n",
    "\n",
    "draw_btn = widgets.Button(button_style='warning',description = 'Draw Lanes', layout=layout)\n",
    "draw_btn.on_click(draw_lanes)\n",
    "\n",
    "add_btn = widgets.Button(button_style='warning',description = 'Save Lane', layout=layout)\n",
    "add_btn.on_click(save_lane)\n",
    "\n",
    "profile_btn = widgets.Button(description = 'Plot Profile', layout=layout, button_style='primary')\n",
    "profile_btn.on_click(profile_plot)\n",
    "\n",
    "save_btn = widgets.Button(button_style='info',description = 'Save Lanes to CSV', layout=layout)\n",
    "save_btn.on_click(save_to_csv)\n",
    "\n",
    "load_btn = widgets.Button(button_style='info',description = 'Load Lanes from CSV', layout=layout)\n",
    "load_btn.on_click(load_from_csv)\n",
    "\n",
    "button_stack = widgets.HBox([width_btn, define_btn, band_btn, draw_btn, add_btn, profile_btn, save_btn, load_btn])\n",
    "##### \n",
    "\n",
    "full_stack = widgets.VBox([lane_stack, label_stack, band_stack, button_stack])\n",
    "\n",
    "display(full_stack)\n",
    "\n",
    "fig, ax = plt.subplots(nrows=2, ncols=1, figsize=(9,10), gridspec_kw={'height_ratios': [1, 3]})\n",
    "ax[1].imshow(1-im_array, cmap='gray')  # main gel image\n",
    "ax[1].axis('off')\n",
    "ax[0].set_ylabel('Average Intensity')\n",
    "ax[0].set_xlabel('Position on Lane (top to bottom)')\n",
    "plt.tight_layout()\n",
    "cb = fig.canvas.mpl_connect('button_press_event', dual_click_mouse_capture)  # general mouse capture system\n",
    "\n",
    "output = widgets.Output()  # for error checking mouse callbacks\n",
    "display(fig.canvas, output)\n",
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Usage Guidelines"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### UI Guide\n",
    "\n",
    "File IO:\n",
    "- Lane ID: Set to name of current lane (can be any string)\n",
    "- Load CSV: Filepath to load CSV file from a previous analysis (for continuation/visualization)\n",
    "- Save CSV: Filepath to save current analysis (add .csv extension manually)\n",
    "- Save Lanes to CSV: Click to save to csv file (filepath as above)\n",
    "- Load Lanes from CSV: Click to load csv file (filepath as above)\n",
    "\n",
    "Lane Specs:\n",
    "- Lane Width:  Set current lane width (in pixels)\n",
    "- Lane Length: Current lane length (in pixels)\n",
    "- Lock/Unlock Length: Toggle to enforce all subsequent lanes to have the currently specified length\n",
    "\n",
    "Lane Manipulation:\n",
    "\n",
    "- Set Lane Width: Click to activate width measurement tool.  Select two locations on current image to measure distance and set lane width for future new lanes\n",
    "- Set Lane Start/Stop: Click to activate lane length tool.  Select two locations on current image to identify a new lane.  Width will be set according to selected width (either manually entered or selected via width measurement tool)\n",
    "- Draw Lanes: Draw all lanes saved in memory (including those loaded from a CSV file)\n",
    "- Save Lane: Save current lane (width, start/stop and ID) to memory.  Subsequently saving to CSV will also save this lane to CSV.\n",
    "- Plot Profile: Plot the intensity profile of all currently saved lanes.\n",
    "\n",
    "Band Manipulation:\n",
    "\n",
    "- Set Band:  Click to activate band selection tool.  Click any two points in a lane to set the locations of a band.  These are automatically saved to memory and will be saved to CSV along with the corresponding lanes.  To overwrite a band, simply select two new spots on a lane.  The profile plot needs to be computed first before going to band selection mode.\n",
    "\n",
    "### Typical Workflow\n",
    "\n",
    "- Set width using lane measurement tool.\n",
    "- Set length of first lane using lane length tool.\n",
    "- Lock lane length for all subsequent lanes.\n",
    "- Save current lane to memory.\n",
    "- Change lane ID.  Set positions of new lane and save to memory.  Repeat for all lanes.\n",
    "- Draw all saved lanes on the plot.\n",
    "- Plot all profiles.\n",
    "- Select a band for each lane.\n",
    "- Save to CSV."
   ]
  }
 ],
 "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.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}