NOVEMBER_Progenitor.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import pickle\n",
    "import os\n",
    "import cv2\n",
    "import imageio\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.colors import ListedColormap\n",
    "import seaborn as sns\n",
    "import torch\n",
    "import cmath\n",
    "from sklearn.decomposition import PCA\n",
    "from run_VAE import sites_NOVEMBER, RAW_NOVEMBER, INTERMEDIATE_NOVEMBER\n",
    "from HiddenStateExtractor.cv2_feature import get_density, get_angle_apr, get_aspect_ratio_no_rotation\n",
    "from HiddenStateExtractor.vq_vae import VQ_VAE, rescale\n",
    "plt.switch_backend('module://ipykernel.pylab.backend_inline')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "sites = sites_NOVEMBER\n",
    "RAW_NOVEMBER = '/gpfs/CompMicro/Projects/learningCellState/microglia/raw_for_segmentation/NOVEMBER/raw'\n",
    "INTERMEDIATE_NOVEMBER = '/gpfs/CompMicro/Projects/learningCellState/microglia/raw_for_segmentation/NOVEMBER/supp'\n",
    "wells = {'B4', 'B5', 'B2', 'C5', 'C4'}\n",
    "wells_ = {'B4', 'B5', 'B2', 'C5'}\n",
    "raw_folder = RAW_NOVEMBER\n",
    "supp_folder = INTERMEDIATE_NOVEMBER\n",
    "\n",
    "JUNE_sites = sum([['D%d-Site_%d' % (i, j) for j in range(9)] for i in range(3, 6)], [])\n",
    "JUNE_DATA_PATH = '/gpfs/CompMicro/Projects/learningCellState/microglia/data_processed'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B2-Site_0\n",
      "B2-Site_1\n",
      "B2-Site_2\n",
      "B2-Site_5\n",
      "C5-Site_1\n",
      "C5-Site_2\n",
      "C5-Site_3\n",
      "C5-Site_5\n",
      "B4-Site_0\n",
      "B4-Site_2\n",
      "B4-Site_3\n",
      "B4-Site_6\n",
      "C4-Site_0\n",
      "C4-Site_2\n",
      "C4-Site_3\n",
      "C4-Site_5\n",
      "B5-Site_1\n",
      "B5-Site_2\n",
      "B5-Site_6\n",
      "B5-Site_7\n"
     ]
    }
   ],
   "source": [
    "### Load All Data ###\n",
    "dats = {}\n",
    "fs = {}\n",
    "traj_inds = {}\n",
    "trajs = {}\n",
    "traj_positions = {}\n",
    "traj_mg_ratios = {}\n",
    "for well in wells:\n",
    "    path = os.path.join(raw_folder, '%s_latent_space_PCAed.pkl' % well)\n",
    "    dats[well] = pickle.load(open(path, 'rb'))\n",
    "    \n",
    "    path = os.path.join(raw_folder, '%s_file_paths.pkl' % well)\n",
    "    fs[well] = pickle.load(open(path, 'rb'))\n",
    "\n",
    "    well_sites = [s for s in sites if s.startswith(well)]\n",
    "    for site in well_sites:\n",
    "        print(site)\n",
    "        path = os.path.join(supp_folder, '%s-supps' % well, '%s' % site, 'cell_traj.pkl')\n",
    "        cell_trajectories_inds, cell_trajectories_positions = pickle.load(open(path, 'rb'))\n",
    "\n",
    "        path = os.path.join(supp_folder, '%s-supps' % well, '%s' % site, 'cell_pixel_assignments.pkl')\n",
    "        cell_pixel_assignments = pickle.load(open(path, 'rb'))\n",
    "\n",
    "        path = os.path.join(raw_folder, '%s_NNProbabilities.npy' % site)\n",
    "        segmentation_stack = np.load(path)\n",
    "\n",
    "        for i, (t, t_pos) in enumerate(zip(cell_trajectories_inds, cell_trajectories_positions)):\n",
    "            ratios = []\n",
    "            for t_point in t:\n",
    "                cell_id = t[t_point]\n",
    "                inds = np.where(cell_pixel_assignments[t_point][1] == cell_id)\n",
    "                cell_pixels = cell_pixel_assignments[t_point][0][inds]\n",
    "                cell_segmentation = segmentation_stack[t_point][(cell_pixels[:, 0], cell_pixels[:, 1])]\n",
    "                mg_ratio = (cell_segmentation[:, 1] > 0.5).sum() / cell_segmentation.shape[0]\n",
    "                ratios.append(mg_ratio)            \n",
    "\n",
    "            trajs[site + '/%d' % i] = t\n",
    "            traj_positions[site + '/%d' % i] = t_pos\n",
    "            traj_mg_ratios[site + '/%d' % i] = ratios\n",
    "    path = os.path.join(raw_folder, '%s_trajectories.pkl' % well)\n",
    "    well_traj_inds = pickle.load(open(path, 'rb'))\n",
    "    traj_inds.update({k: v for k, v in well_traj_inds.items() if k in trajs})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# with open('NOVEMBER_all_dat_save.pkl', 'wb') as f:\n",
    "#     pickle.dump([dats, fs, traj_inds, trajs, traj_positions, traj_mg_ratios], f)\n",
    "dats, fs, traj_inds, trajs, traj_positions, traj_mg_ratios = pickle.load(open('NOVEMBER_all_dat_save.pkl', 'rb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "_trajs = {}\n",
    "_traj_positions = {}\n",
    "_traj_inds = {}\n",
    "for t_name, ratios in traj_mg_ratios.items():\n",
    "    well = t_name[:2]\n",
    "    if not well in wells_: \n",
    "        continue\n",
    "    assert len(ratios) == len(trajs[t_name])\n",
    "    positions = np.stack(traj_positions[t_name].values(), 0)\n",
    "    if np.percentile(positions[:, 0], 50) < 128 or np.percentile(positions[:, 0], 50) > (2048-128) or \\\n",
    "       np.percentile(positions[:, 1], 50) < 128 or np.percentile(positions[:, 1], 50) > (2048-128):\n",
    "        continue\n",
    "    if np.percentile(ratios, 30) < 0.7:\n",
    "        for start in range(len(ratios)):\n",
    "            if ratios[start] < 0.2:\n",
    "                break\n",
    "        for end in range(len(ratios)-1, 0, -1):\n",
    "            if ratios[end] < 0.2:\n",
    "                break\n",
    "        \n",
    "        if end - start < 10:\n",
    "            continue\n",
    "        if (end - start) < 50 and np.percentile(ratios[start:(end+1)], 60) > 0.5:\n",
    "            continue\n",
    "        \n",
    "        t_points = sorted(trajs[t_name].keys())\n",
    "        valid_t_points = t_points[start:(end+1)]\n",
    "        _trajs[t_name] = {k: v for k,v in trajs[t_name].items() if k in valid_t_points}\n",
    "        _traj_positions[t_name] = {k: v for k,v in traj_positions[t_name].items() if k in valid_t_points}\n",
    "        _traj_inds[t_name] = traj_inds[t_name][start:(end+1)]\n",
    "        assert len(_traj_inds[t_name]) == len(_trajs[t_name])\n",
    "\n",
    "with open('NOVEMBER_dat_nonmg_save.pkl', 'wb') as f:\n",
    "    pickle.dump([None, None, _traj_inds, _trajs, _traj_positions], f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "# site = 'B4-Site_0'\n",
    "# image_stack = np.load(os.path.join(raw_folder, '%s.npy' % site))\n",
    "# for t in _trajs:\n",
    "#     if t.startswith('B4-Site_0'):\n",
    "#         stack = []\n",
    "#         for frame_id in sorted(_trajs[t].keys()):\n",
    "#             k = frame_id\n",
    "#             mat = cv2.resize(image_stack[k, :, :, 0], (512, 512))\n",
    "#             output_image = np.clip(enhance_contrast(mat, phase_a, phase_b), 0, 65535).astype('uint16')\n",
    "#             output_image = np.stack([output_image] * 3, 2)\n",
    "#             output_image = output_image / 65535.\n",
    "\n",
    "#             box_center = traj_positions[t][k] / (2048/512)\n",
    "#             box_range = [(max(box_center[0] - 16., 0), min(box_center[0] + 16., 512)),\n",
    "#                          (max(box_center[1] - 16., 0), min(box_center[1] + 16., 512))]\n",
    "\n",
    "#             # Left edge\n",
    "#             x = box_range[0][0]\n",
    "#             x_ = (int(max(x - 1., 0)), int(min(x + 1., 512)))\n",
    "#             output_image[x_[0]:x_[1], int(box_range[1][0]):int(box_range[1][1])] = np.array([1., 0., 0.]).reshape((1, 1, 3))\n",
    "#             # Right edge\n",
    "#             x = box_range[0][1]\n",
    "#             x_ = (int(max(x - 1., 0)), int(min(x + 1., 512)))\n",
    "#             output_image[x_[0]:x_[1], int(box_range[1][0]):int(box_range[1][1])] = np.array([1., 0., 0.]).reshape((1, 1, 3))\n",
    "#             # Top edge\n",
    "#             y = box_range[1][0]\n",
    "#             y_ = (int(max(y - 1., 0)), int(min(y + 1., 512)))\n",
    "#             output_image[int(box_range[0][0]):int(box_range[0][1]), y_[0]:y_[1]] = np.array([1., 0., 0.]).reshape((1, 1, 3))\n",
    "#             # Bottom edge\n",
    "#             y = box_range[1][1]\n",
    "#             y_ = (int(max(y - 1., 0)), int(min(y + 1., 512)))\n",
    "#             output_image[int(box_range[0][0]):int(box_range[0][1]), y_[0]:y_[1]] = np.array([1., 0., 0.]).reshape((1, 1, 3))\n",
    "#             stack.append(output_image)\n",
    "#         stack = (np.stack(stack, 0)*255).astype('uint8')\n",
    "#         imageio.mimwrite('nonmg_analysis/%s.gif' % t.replace('/', '_'), stack)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load NOVEMBER progenitor cell data\n",
    "dats, fs, mg_traj_inds, mg_trajs, mg_traj_positions = pickle.load(open('NOVEMBER_dat_save.pkl', 'rb'))\n",
    "_, _, traj_inds, trajs, traj_positions = pickle.load(open('NOVEMBER_dat_nonmg_save.pkl', 'rb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "selected_ts = [t for t in traj_inds if len(traj_inds[t]) > 10]\n",
    "traj_inds = {k:v for k,v in traj_inds.items() if k in selected_ts}\n",
    "trajs = {k:v for k,v in trajs.items() if k in selected_ts}\n",
    "traj_positions = {k:v for k,v in traj_positions.items() if k in selected_ts}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load JUNE progenitor cell data\n",
    "june_dats_ = pickle.load(open('JUNE_nonmg_traj_dats_pcaed.pkl', 'rb'))\n",
    "june_fs = pickle.load(open('JUNE_nonmg_traj_fs.pkl', 'rb'))\n",
    "JUNE_progenitor_dats = pickle.load(open('JUNE_nonmg_traj_dats.pkl', 'rb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C5\n",
      "B4\n",
      "B2\n",
      "C4\n",
      "B5\n"
     ]
    }
   ],
   "source": [
    "### Load All RAW Data ###\n",
    "all_patches = {}\n",
    "for well in wells:\n",
    "    print(well)\n",
    "    site_dat = torch.load(os.path.join(raw_folder, '%s_adjusted_static_patches.pt' % well))\n",
    "    site_dat = rescale(site_dat)\n",
    "    for i, f in enumerate(fs[well]):\n",
    "        all_patches[f] = site_dat[i:(i+1)][0]\n",
    "\n",
    "dats_full = {} \n",
    "for well in wells:\n",
    "    path = os.path.join(raw_folder, '%s_latent_space.pkl' % well)\n",
    "    dats_full[well] = pickle.load(open(path, 'rb'))\n",
    "\n",
    "# june_patches = torch.load('JUNE_nonmg_trajs.pt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Load NOVEMBER+JUNE progenitor cell data (before PCA)\n",
    "# progenitor_dats = []\n",
    "# progenitor_names = []\n",
    "# for t, inds in traj_inds.items():\n",
    "#     well = t[:2]\n",
    "#     for i in inds:\n",
    "#         progenitor_dats.append(dats_full[well][i])\n",
    "#         progenitor_names.append(fs[well][i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 364,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NOVEMBER_progenitor_dats = np.stack(progenitor_dats, 0)\n",
    "# NOVEMBER_progenitor_names = progenitor_names\n",
    "# pca = PCA(5)\n",
    "# NOVEMBER_progenitor_dats_pcaed = pca.fit_transform(NOVEMBER_progenitor_dats)\n",
    "# for pc in range(5):\n",
    "#     for i in range(5):\n",
    "#         inds = np.where((NOVEMBER_progenitor_dats_pcaed[:, pc] > np.percentile(NOVEMBER_progenitor_dats_pcaed[:, pc], i*20)) &\n",
    "#                         (NOVEMBER_progenitor_dats_pcaed[:, pc] < np.percentile(NOVEMBER_progenitor_dats_pcaed[:, pc], (i+1)*20)))[0]\n",
    "#         fs_of_interest = [NOVEMBER_progenitor_names[i] for i in inds]\n",
    "#         patches_of_interest = [all_patches[f][0, 0] for f in fs_of_interest]\n",
    "#         patch_averaged = np.stack(patches_of_interest, 0).mean(0)\n",
    "#         plt.clf()\n",
    "#         plt.imshow(patch_averaged, vmin=0.4, vmax=0.8)\n",
    "#         plt.savefig(\"nonmg_analysis/NOVEMBER_PC%d_Q%d.png\" % (pc+1, i), dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NJ_progenitor_dats = np.concatenate([NOVEMBER_progenitor_dats, JUNE_progenitor_dats], 0)\n",
    "# NJ_progenitor_names = NOVEMBER_progenitor_names + june_fs\n",
    "# pca2 = PCA(5)\n",
    "# NJ_progenitor_dats_pcaed = pca2.fit_transform(NJ_progenitor_dats)\n",
    "# colors = [(1, 0, 0)] * len(NOVEMBER_progenitor_names) + [(0, 0, 1)] * len(june_fs)\n",
    "# for pc in range(5):\n",
    "#     for i in range(5):\n",
    "#         inds = np.where((NJ_progenitor_dats_pcaed[:, pc] > np.percentile(NJ_progenitor_dats_pcaed[:, pc], i*20)) &\n",
    "#                         (NJ_progenitor_dats_pcaed[:, pc] < np.percentile(NJ_progenitor_dats_pcaed[:, pc], (i+1)*20)))[0]\n",
    "#         fs_of_interest = [NJ_progenitor_names[i] for i in inds]\n",
    "#         patches_of_interest = [all_patches[f][0, 0] if isinstance(f, str) else \n",
    "#                                june_patches[june_fs.index(f)][0][0] for f in fs_of_interest]\n",
    "#         patch_averaged = np.stack(patches_of_interest, 0).mean(0)\n",
    "#         plt.clf()\n",
    "#         plt.imshow(patch_averaged, vmin=0.4, vmax=0.8)\n",
    "#         plt.savefig(\"nonmg_analysis/NJ_PC%d_Q%d.png\" % (pc+1, i), dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Define Extra Functions ###\n",
    "phase_a = 2.\n",
    "phase_b = -50000.\n",
    "\n",
    "legends = {\n",
    "    'B2': 'GBM',\n",
    "    'B4': 'IL17',\n",
    "    'B5': 'IFN beta',\n",
    "    'C4': 'Rubella',\n",
    "    'C5': 'Control'\n",
    "}\n",
    "\n",
    "def hex_to_rgb(s):\n",
    "    s = s.lstrip('#')\n",
    "    s = list(int(s[i:i+2], 16)/256. for i in (0, 2, 4)) + [1.] # hex to rgb\n",
    "    return s\n",
    "\n",
    "def rgb_to_hex(rgb):\n",
    "    return '#%02x%02x%02x' % rgb\n",
    "\n",
    "def generate_color_vectors(start, end, N=256):\n",
    "    start = hex_to_rgb(start)\n",
    "    end = hex_to_rgb(end)\n",
    "    output = np.zeros((N, 4))\n",
    "    for i in range(4):\n",
    "        output[:, i] = np.linspace(start[i], end[i], N)\n",
    "    return output\n",
    "\n",
    "cmaps = {\n",
    "    'B2': ListedColormap(generate_color_vectors('#ffffff', '#438548')),\n",
    "    'B4': ListedColormap(generate_color_vectors('#ffffff', '#ce103d')),\n",
    "    'B5': ListedColormap(generate_color_vectors('#ffffff', '#d44d00')),\n",
    "    'C4': ListedColormap(generate_color_vectors('#ffffff', '#f0ba00')),\n",
    "    'C5': ListedColormap(generate_color_vectors('#ffffff', '#005082')),\n",
    "    'all': ListedColormap(generate_color_vectors('#ffffff', '#111111'))\n",
    "}\n",
    "\n",
    "colors = {w: cmaps[w](0.8) for w in cmaps}\n",
    "\n",
    "def enhance_contrast(mat, a=1.5, b=-10000):\n",
    "  mat2 = cv2.addWeighted(mat, a, mat, 0, b)\n",
    "  return mat2\n",
    "\n",
    "def save_movie(traj, path):\n",
    "  well = traj[:2]\n",
    "  site = traj.split('/')[0]\n",
    "  stacks = []\n",
    "  for ind in traj_inds[traj]:\n",
    "    f = fs[well][ind]\n",
    "    p = os.path.join(supp_folder, '%s-supps' % well, '%s' % site, 'stacks_%s.pkl' % f.split('/')[-1].split('_')[0])\n",
    "    mat = pickle.load(open(p, 'rb'))[f]['mat'][:, :, 0]\n",
    "    mat2 = np.clip(enhance_contrast(mat, phase_a, phase_b), 0, 65535).astype('uint16')\n",
    "    stacks.append(mat2)\n",
    "  output = (np.stack(stacks, 0).astype('float')/256).astype('uint8')\n",
    "  imageio.mimsave(path, output)\n",
    "\n",
    "def save_traj_bbox(traj, path):\n",
    "  output_images = np.zeros((len(traj_inds[traj]), 512, 512))\n",
    "  site = traj.split('/')[0]\n",
    "  image_stack = np.load(os.path.join(raw_folder, '%s.npy' % site))\n",
    "  for i, k in enumerate(sorted(trajs[traj].keys())):\n",
    "    mat = cv2.resize(image_stack[k, :, :, 0], (512, 512))\n",
    "    output_images[i] = np.clip(enhance_contrast(mat, phase_a, phase_b), 0, 65535).astype('uint16')\n",
    "\n",
    "  output_images = np.stack([output_images] * 3, 3)\n",
    "  output_images = output_images / 65535.\n",
    "\n",
    "  for i, k in enumerate(sorted(trajs[traj].keys())):\n",
    "    box_center = traj_positions[traj][k] / (2048/512)\n",
    "    box_range = [(max(box_center[0] - 16., 0), min(box_center[0] + 16., 512)),\n",
    "                 (max(box_center[1] - 16., 0), min(box_center[1] + 16., 512))]\n",
    "    \n",
    "    # Left edge\n",
    "    x = box_range[0][0]\n",
    "    x_ = (int(max(x - 1., 0)), int(min(x + 1., 512)))\n",
    "    output_images[i, x_[0]:x_[1], int(box_range[1][0]):int(box_range[1][1])] = np.array([1., 0., 0.]).reshape((1, 1, 3))\n",
    "    # Right edge\n",
    "    x = box_range[0][1]\n",
    "    x_ = (int(max(x - 1., 0)), int(min(x + 1., 512)))\n",
    "    output_images[i, x_[0]:x_[1], int(box_range[1][0]):int(box_range[1][1])] = np.array([1., 0., 0.]).reshape((1, 1, 3))\n",
    "    # Top edge\n",
    "    y = box_range[1][0]\n",
    "    y_ = (int(max(y - 1., 0)), int(min(y + 1., 512)))\n",
    "    output_images[i, int(box_range[0][0]):int(box_range[0][1]), y_[0]:y_[1]] = np.array([1., 0., 0.]).reshape((1, 1, 3))\n",
    "    # Bottom edge\n",
    "    y = box_range[1][1]\n",
    "    y_ = (int(max(y - 1., 0)), int(min(y + 1., 512)))\n",
    "    output_images[i, int(box_range[0][0]):int(box_range[0][1]), y_[0]:y_[1]] = np.array([1., 0., 0.]).reshape((1, 1, 3))\n",
    "  # tifffile.imwrite(path, (output_images*255).astype('uint8'))\n",
    "  imageio.mimwrite(path, (output_images*255).astype('uint8'))\n",
    "  return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Process Data and Generate Trajectory Summaries ###\n",
    "t_lag = 1\n",
    "bins_PC1 = np.linspace(-4, 6, 15)\n",
    "bins_PC2 = np.linspace(-3, 8, 15)\n",
    "bins_speed = np.linspace(1.0, 5.2, 15) # Log um/h scale\n",
    "\n",
    "traj_PC1 = {well: [] for well in wells}\n",
    "traj_PC2 = {well: [] for well in wells}\n",
    "traj_speed = {well: [] for well in wells}\n",
    "traj_names = {well: [] for well in wells}\n",
    "for t in trajs:\n",
    "    well = t[:2]\n",
    "    if not well in wells:\n",
    "        continue \n",
    "    traj_names[well].append(t)\n",
    "    traj_PC1[well].append(np.mean([dats[well][ind, 0] for ind in traj_inds[t]]))\n",
    "    traj_PC2[well].append(np.mean([dats[well][ind, 1] for ind in traj_inds[t]]))\n",
    "\n",
    "    t_keys = sorted(trajs[t].keys())\n",
    "    dists = []\n",
    "    for t_point in t_keys:\n",
    "        if (t_point + t_lag) in t_keys:\n",
    "            d = np.linalg.norm(traj_positions[t][t_point+t_lag] - \\\n",
    "                               traj_positions[t][t_point], ord=2)\n",
    "            dists.append(d)    \n",
    "    traj_speed[well].append(np.log(np.mean(dists) * 0.325 / 0.1518)) # Unit of pixel(0.325um) per frame(9.11 min) to um per hour"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Trajectory averaged PC1, PC2, speed for JUNE data progenitor cells ###\n",
    "traj_PC1_june = {}\n",
    "traj_PC2_june = {}\n",
    "for f, d in zip(june_fs, june_dats_):\n",
    "    if not f[0] in traj_PC1_june:\n",
    "        traj_PC1_june[f[0]] = []\n",
    "        traj_PC2_june[f[0]] = []\n",
    "    traj_PC1_june[f[0]].append(d[0])\n",
    "    traj_PC2_june[f[0]].append(d[1])\n",
    "\n",
    "traj_PC1_june = [np.mean(traj_PC1_june[k]) for k in traj_PC1_june]\n",
    "traj_PC2_june = [np.mean(traj_PC2_june[k]) for k in traj_PC2_june]\n",
    "\n",
    "traj_motions_june = {}\n",
    "for site in sum([['D%d-Site_%d' % (i, j) for j in range(9)] for i in range(3, 6)], []): \n",
    "    nonmg_traj = pickle.load(open(os.path.join(JUNE_DATA_PATH, 'D-supps', site, 'non_mg_traj.pkl'), 'rb'))\n",
    "    for i, (traj, traj_position) in enumerate(zip(*nonmg_traj)):\n",
    "        name = site + '/' + str(i) + '_nonmg'\n",
    "        traj_motions_june[name] = traj_position\n",
    "        \n",
    "traj_speed_june = {}\n",
    "t_lag = 1\n",
    "for t, motion in traj_motions_june.items():\n",
    "    dists = []\n",
    "    t_keys = sorted(motion.keys())\n",
    "    for t_point in t_keys:\n",
    "        if (t_point + t_lag) in t_keys:\n",
    "            d = np.linalg.norm(motion[t_point+t_lag] - \\\n",
    "                               motion[t_point], ord=2)\n",
    "            dists.append(d)    \n",
    "    traj_speed_june[t] = np.log(np.mean(dists) * 0.325 / 0.1518)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 397,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B2-Site_0/3\n",
      "B2-Site_0/18\n",
      "B2-Site_0/62\n",
      "B2-Site_1/20\n",
      "B2-Site_1/27\n",
      "B2-Site_1/36\n",
      "B2-Site_1/68\n",
      "B2-Site_1/93\n",
      "B2-Site_1/94\n",
      "B2-Site_1/99\n",
      "B2-Site_1/111\n",
      "B2-Site_1/155\n",
      "B2-Site_1/159\n",
      "B2-Site_1/170\n",
      "B2-Site_1/178\n",
      "B2-Site_1/199\n",
      "B2-Site_1/205\n",
      "B2-Site_1/217\n",
      "B2-Site_1/236\n",
      "B2-Site_1/250\n",
      "B2-Site_1/259\n",
      "B2-Site_1/277\n",
      "B2-Site_2/37\n",
      "B2-Site_2/38\n",
      "B2-Site_2/72\n",
      "B2-Site_2/237\n",
      "B2-Site_2/316\n",
      "B2-Site_5/28\n",
      "B2-Site_5/74\n",
      "B2-Site_5/103\n",
      "B2-Site_5/111\n",
      "B2-Site_5/119\n",
      "B2-Site_5/138\n",
      "B2-Site_5/167\n",
      "B2-Site_5/215\n",
      "B2-Site_5/270\n",
      "B2-Site_5/309\n",
      "C5-Site_1/34\n",
      "C5-Site_1/84\n",
      "C5-Site_1/103\n",
      "C5-Site_1/120\n",
      "C5-Site_1/165\n",
      "C5-Site_1/199\n",
      "C5-Site_1/209\n",
      "C5-Site_1/250\n",
      "C5-Site_1/263\n",
      "C5-Site_1/457\n",
      "C5-Site_1/468\n",
      "C5-Site_1/516\n",
      "C5-Site_2/42\n",
      "C5-Site_2/83\n",
      "C5-Site_2/87\n",
      "C5-Site_2/88\n",
      "C5-Site_2/92\n",
      "C5-Site_2/142\n",
      "C5-Site_2/161\n",
      "C5-Site_2/180\n",
      "C5-Site_2/237\n",
      "C5-Site_3/53\n",
      "C5-Site_3/117\n",
      "C5-Site_3/261\n",
      "C5-Site_3/367\n",
      "C5-Site_3/383\n",
      "C5-Site_5/62\n",
      "C5-Site_5/101\n",
      "C5-Site_5/152\n",
      "C5-Site_5/279\n",
      "C5-Site_5/427\n",
      "B4-Site_0/16\n",
      "B4-Site_0/59\n",
      "B4-Site_0/61\n",
      "B4-Site_0/63\n",
      "B4-Site_0/83\n",
      "B4-Site_0/84\n",
      "B4-Site_0/111\n",
      "B4-Site_0/129\n",
      "B4-Site_0/196\n",
      "B4-Site_0/202\n",
      "B4-Site_0/209\n",
      "B4-Site_0/213\n",
      "B4-Site_0/235\n",
      "B4-Site_0/285\n",
      "B4-Site_0/292\n",
      "B4-Site_2/177\n",
      "B4-Site_2/178\n",
      "B4-Site_2/184\n",
      "B4-Site_2/224\n",
      "B4-Site_2/261\n",
      "B4-Site_3/50\n",
      "B4-Site_3/165\n",
      "B4-Site_3/262\n",
      "B4-Site_6/83\n",
      "B4-Site_6/88\n",
      "B4-Site_6/137\n",
      "B4-Site_6/191\n",
      "B4-Site_6/213\n",
      "B4-Site_6/278\n",
      "B4-Site_6/316\n",
      "B4-Site_6/320\n",
      "B4-Site_6/335\n",
      "B5-Site_1/13\n",
      "B5-Site_1/33\n",
      "B5-Site_1/53\n",
      "B5-Site_1/59\n",
      "B5-Site_1/90\n",
      "B5-Site_1/97\n",
      "B5-Site_1/125\n",
      "B5-Site_1/142\n",
      "B5-Site_1/150\n",
      "B5-Site_1/186\n",
      "B5-Site_1/248\n",
      "B5-Site_1/294\n",
      "B5-Site_1/299\n",
      "B5-Site_2/40\n",
      "B5-Site_2/107\n",
      "B5-Site_2/140\n",
      "B5-Site_2/158\n",
      "B5-Site_2/225\n",
      "B5-Site_7/39\n",
      "B5-Site_7/119\n",
      "B5-Site_7/165\n",
      "B5-Site_7/189\n",
      "B5-Site_7/240\n",
      "B5-Site_7/242\n",
      "B5-Site_7/248\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(123)\n",
    "for t in trajs:\n",
    "    print(t)\n",
    "    save_traj_bbox(t, 'nonmg_analysis/sample_%s.gif' % t.replace('/', '_'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Sample trajectories with traj marked ###\n",
    "traj_represented = ['B4-Site_0/63',\n",
    "                    'B4-Site_3/50']\n",
    "cs = [(220, 220, 0)] * 2\n",
    "\n",
    "for t, c in zip(traj_represented, cs):\n",
    "    well = t[:2]\n",
    "    traj = traj_inds[t]\n",
    "    \n",
    "    site = t.split('/')[0]\n",
    "    image_stack = np.load(os.path.join(raw_folder, '%s.npy' % site))\n",
    "    \n",
    "    t_pos = traj_positions[t]\n",
    "    \n",
    "    init_t_point = sorted(t_pos.keys())[28]\n",
    "    init_position = t_pos[init_t_point]\n",
    "    if init_position[0] < 256 or init_position[0] > (2048-256) or init_position[1] < 256 or init_position[1] > (2048-256):\n",
    "        continue\n",
    "\n",
    "    f0 = image_stack[init_t_point, \n",
    "                     (init_position[0]-256):(init_position[0]+256),\n",
    "                     (init_position[1]-256):(init_position[1]+256),\n",
    "                     0]\n",
    "    \n",
    "    f0 = enhance_contrast(f0, phase_a, phase_b)\n",
    "    mat = np.zeros((f0.shape[0], f0.shape[1], 3), dtype='uint8')\n",
    "    mat[:, :] = (np.expand_dims(f0, 2) / 256).astype('uint8')\n",
    "    try:\n",
    "        t_pos = traj_positions[t]\n",
    "        positions = np.stack([t_pos[k] for k in sorted(t_pos.keys())])\n",
    "        center_position = positions[init_t_point] - np.array([256, 256])\n",
    "        for i in range(positions.shape[0] - 1):\n",
    "            start = positions[i] - center_position\n",
    "            end = positions[i + 1] - center_position\n",
    "            mat = cv2.line(mat, (start[1], start[0]), (end[1], end[0]), c, thickness=2)\n",
    "        cv2.imwrite('nonmg_analysis/NOVEMBER_nonmg_sample_%s.png' % t.replace('/', '_'), mat)\n",
    "    except Exception as e:\n",
    "        print(e)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_trajs = {}\n",
    "for well in wells_:\n",
    "    ct = len([t for t in trajs if t.startswith(well)])\n",
    "    n_trajs[well] = ct"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n",
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPQAAABkCAYAAACxSR29AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO2deVyU1f7H32dmgGEHWQRBBPcNREFxy61cK5fUdrPs5m2xxdI269Yvy+xm3bLdm5mpXUvLNXNNM8wlVFwRRQQBF/Z9BmY5vz8GJsdhVWRQ5/16zevFPOc85/k+wPc55znnfL5fIaXEjh07NwYKWxtgx46dhsPu0Hbs3EDYHdqOnRsIu0PbsXMDYXdoO3ZuIFS2urCvr68MDQ211eXt2Lku2b9/f7aU0q+6cps5dGhoKHFxcba6vB071yVCiNSaym3m0DcauUUaPFycUClt8xaj0+lIT09Hq9Xa5Pp2Gha1Wk1wcDAODg71Os/u0A1AsaacYf+3lHG9OzJrwi02sSE9PR13d3dCQ0MRQtjEBjsNg5SSnJwc0tPTCQsLq9e59kmxBmDbkTMARLUJtJkNWq0WHx8fuzPfAAgh8PHxuaLRlt2hG4CNB5II9vFgeGQbm9phd+Ybhyv9W9od+irJLCgh7vQ5RvZoy/7T5/lio32iz47tsDv0VbLvVAZSwsgebTmcepGFWw+SmpVva7NsgkajYeDAgRgMBlJSUhBC8Mknn5jLp02bxrfffluntvbt20dkZCSRkZF069aNVatWAZCWlsbgwYPp1KkTXbp04eOPPzafM2PGDH777bcq23v44YdZuXIlAIMGDbJaYcnJyWHw4MG4ubkxbdo08/GioiKzHZGRkfj6+vLcc8/V6R5sQZ0cWggxQgiRKIRIEkK8XEO9CUIIKYSIbjgTmzZ3RLdn3av3EuLnyeieHVAqBKv3JNraLJvwzTffcNddd6FUKgHw9/fn448/pry8vN5tde3albi4OOLj49m4cSP//Oc/0ev1qFQqPvjgAxISEtizZw+fffYZx48fB+Dpp59m7ty5V2S7Wq1m9uzZzJs3z+K4u7s78fHx5k+rVq246667rugajUGts9xCCCXwGTAUSAf+EkKslVIev6yeO/AMsPdaGNqUCWzmDoCvhwsDurRiXdxJnhgZjaNKaTObUp/7t9Uxj0E98R47GKO2jLSXP7Yq9xzRD68R/dAXFJHxxhcWZa0+erHWay5btozvv//e/N3Pz49+/fqxePFiHnvssXrZ7+LiYv5Zq9Wa3ykDAwMJDDRNPrq7u9OpUycyMjLo3LkzrVq1IicnhwsXLhAQEFCv67m6utK/f3+SkpKqrXPq1CkyMzO55RbbrGTUhbr00L2AJCllspSyHFgOjKmi3mzg38BNsxD69dYDvLJ0G0bj35ryu3p3JL9Ey/YjKbYzzAaUl5eTnJzM5bv/Xn75ZT744AMMBoPF8ffff99iKFv5eeaZZ8x19u7dS5cuXQgPD+fLL79EpbLsf1JSUjh48CAxMTHmYz169GDXrl0Nf4PA//73P+65554mPflYl3XoICDtku/pQMylFYQQ3YGWUsr1QogZ1TUkhJgKTAUICQmpv7VNCCkla/cmEuLniULx9x84pl0wPVoHYrRx4IiaelSF2qnGcpWne5165EvJzs7Gy8vL6nhYWBi9evWy6LkBZs6cycyZM2tsMyYmhmPHjpGQkMDkyZMZOXIkarUagOLiYsaPH89HH32Eh4eH+Rx/f3/OnTtXL9vryvLly1myZMk1abuhqItDV/U4Mv+3CiEUwH+Ah2trSEq5AFgAEB0dfV2HSjmUcpFzecVMHR5lcVyhECx48g4bWWU7nJ2dq103ffXVV5kwYQIDBgwwH3v//fdZtmyZVd0BAwYwf/58i2OdOnXC1dWVo0ePEh0djU6nY/z48TzwwANW77NarRZnZ+cGuCNLDh06hF6vJyoqqvbKNqQuDp0OtLzkezBw6SPQHegK7KgYigQAa4UQo6WU19Uajj63gPwNf9BswlAUaidKDiSgOWL9TuXz4Cg2HkjCSakg4nAC2ccSQSHwGNobxwBfAHR6A6lZBbQNbNbYt2ETvL29MRgMaLVacy9aSceOHencuTPr16+nV69eQO099JkzZ2jZsiUqlYrU1FQSExMJDQ1FSsmjjz5Kp06deP75563OO3nyJBMnTmzYm8M03L7vvvsavN2Gpi4O/RfQTggRBmQA9wL3VxZKKQsA38rvQogdwIzrzZkBshevJX/t73jdMRCF2onS/QnkfL/Bqp7H3cPYciiZXk6C0iXrKK04XnY6naA3HwdgzspY/kg4y4bX7692ciwtJx1fdx/2Jv1FK98QwvxDr9GdNQ7Dhg0jNjaW2267zaps1qxZdO/evc5txcbGMnfuXBwcHFAoFHz++ef4+voSGxvLkiVLCA8PJzIyEoA5c+YwatQodDodSUlJREfXvshy++23m/dJ9+nThxUrVhAaGkphYSHl5eWsXr2azZs307lzZwB+/PFHNmyw/l9ockgpa/0Ao4CTwGlgVsWxt4DRVdTdAUTX1mZUVJRsSuiLS+WJEU/KjHcXSqPRKKWU0mgwVPkpKtXKL379S+5LTDMfu/j5DzLh1qmyPCtPSinl7hNpMuqFBXLjgaQqr5dZkCWnL5kpF/3+nZy+ZKZcuP3bq7L/+PHjV3V+Q3DgwAH54IMP2uz6P//8s3zttddsdv2Gpqq/KRAna/CrOokzpJQbgA2XHftXNXUHXdGTxcYUbt6N1JbhPXaweRZTKKpeBHBzduLxEZa9gNfYwTi1a4XSwxWAXu2CCGrmzqo9CQzvbrklVKfX8d/tCxEI7uw+CieVE3+e2k1J2URcnVy4XunevTuDBw/GYDCY16IbE71ezwsvvNDo121K2HeKYRql5K3ZgbpDKM4da1a3lGjL2XksFZ3echnGMdAPz9tiUDiahnEKhWBsTEfiTp+32jn2496fSMtJ5+EBk/Bx96Fv+97oDXrikvc37I3ZgClTptjEmQEmTpxY5Uz7zYTdoQFjiQbHIH+8xw6ute6OY6k8v2gzx9KyrNsp15Hzv18piTsGwJ0926NUCLYeOmOuszdpH7GJuxgeMZTwkK4AhPi0JMi7BbtP7WmgO7Jzs2LXQwNKNxeC35lWe0VMyqoW3m50C21uVSaUSvLWbMcxuDmu0V3w9XBh2fS7aBPgba4T3CyYvu37cGeP2/8+Twj6tu/DgZSDaHVlqB2crv6m7NyU3PQ9tKGgmPJz1r1tVeQUlbL3ZAbDe7StcreQUCrwumMApfsTKE+7AEDbwGYIITAYTUP0oGYtmNT/fpQKy2Hp4M4DmXH7dLsz27kqbnqHzluzneRJr6LLrl0htSU+GaOUjOzetto6XqNuAZWSvLW/m48t2naQ5xb/m6Wx31euBFhR+YAo1hajN+jreRd27Ji4qR1aGgzkr9+JS49OOPjWPpnyV9I52rfwofUlQ+jLUTXzxH1AFAUbd2HUlgFwsTABvTyHSuFW4z7gs9lpvLz8NY6mHav/zTQBGkM+CaaJN39/f7p27WpxTk3ySYB58+bRsWNHunbtSrdu3fjuu+/qd4MV7Nixgz///LPe53377bcW0sxrwU3t0MW7D6PPysN7TO2TYQDvTx7K/H+MqLWe95hBOHdujaGgmJSsFNLz91FQ7MGFbP8azwtuFoS72p0/r9PJscaQT4JJ27xx40arc2qST3755Zds2bKFffv2cfToUXbu3FntaKk2anLoShttxU09KZa3ZjsqP2/c+kTUqb5CIfD1qH2d2CWiPS4R7SnWlvDfNR/j6eqJs4hh/f5TPDmqZ7U7xxQKBTFte7L5yFbySwvwcvGs1/1cytTP11sdG9qtNRP7dUZbrueZr60d4s6e7bmzZ3vyS7S8uHirRVld9qc3hnwSTPu9U1JSrM6pST45Z84ctm/fbhZyeHp6MnnyZAC2bdvGjBkz0Ov19OzZky+++AInJydCQ0OZPHky69atQ6fTsWLFCtRqNV9++SVKpZKlS5fyySefsHDhQpo1a8bBgwfp0aMHs2bNYsqUKSQnJ+Pi4sKCBQuIiKjb/9jVctP20Pr8IjSHTuJ1xwBELeumUkoe/XQtK3Ydr7He5aSfSaRcV8bUIY8yvm9EnWSVfdv1RkrJ3qR99bqWrbGFfLIqqpJPFhUVUVRURJs21jHftFotDz/8MD/88ANHjhxBr9fzxRd/a8F9fX05cOAATzzxBPPmzSM0NJTHH3+c6dOnEx8fb9ZGnzx5kq1bt/LBBx/wxhtv0L17dw4fPsycOXN46KGHarW7obhpe2iVlzttfvg34pLeUhoN6HIycPBtadEjHEvL4lDKRUb36lDn9o3lOhQzFzGtfzda+YbQspnkwYHhFktYVeHv6U/b5m3YfWoPw8Jvu2LtbU09qtpRVWO5l6u63oqxxpZPVkdV8kkpZbW/x8TERMLCwmjfvj0AkydP5rPPPjOHGapUc0VFRfHzzz9Xe92JEyeaXzViY2P56aefABgyZAg5OTkUFBTUaHdDcVM6dOUfWOXtYXE8Z918CnYswzGwDe4xY3CPGoXSzYuNB5JwVCm5NbxuMZITz58kI/ccnW7tReGvuzA8cS9KTzeeu7N3nc6fGDMeZ0fnJi2kv5zGlE/WRFXySQ8PD1xdXUlOTqZ169YWZbW9Rzs5mZYRlUplje/Hrq6uNbbZWH/Lm3LIXbBxF6lPz8VQUGw+JqVEqBxx6dQP4eBEzuoPSXlzJAVxG9kcn0z/TiG4OTvW2nZ+aQELt3/LH4m7cL2jP1KnJ3/T30PAhPQsth5KrrGNEN+W+Hn41linqXGpfPJyLpVPVjJz5kyLWF2Vn0pnPnPmjNmBLpVP1sbJkyetZr8BXnnlFZ566ikKCwsBKCwsZMGCBXTs2JGUlBRz6KElS5YwcODAGq/h7u5OUVFRteUDBgwwP6x27NiBr6+vRRCGa8lN6dD5a3ZgKCpF4fH3U1UIgc/tTxHw2EcET/+O4JnL8ew3gRPSh9xiDWMDSsnd+BW63PPVtmswGli4fRFl+jKmDp6CR7swnMPbkb9mB9JoBGDRtkO8+1MsZbqaZ0PPZqfx39++Qasra5ibbgQq5ZNVMWvWLNLT0+vcVmxsLN26dSMyMpJx48aZ5ZMA9913H3369CExMZHg4GAWLlwIUKN88oknnmDw4MH07NmTrl27MnDgQFxcXFCr1SxatIiJEycSHh6OQqHg8ccfr9G2O++8k1WrVhEZGckff/xhVf7mm28SFxdHREQEL7/8MosXL67zfV81NUmxruXHVvLJ0oRkmTDoUZn78zbzsfzYFbIkcW+V9U+dy5HvrvxDZv7ypUyaHi2TpkfLjM+flEUHNkmjrsyi7s/7VsvHF06Te5P2mY8VbN0jE26dKjWnUqWUUu5ONMkqfz1wqkY7ky6clo8vnCb/PLm7Tvdll0/a5ZNSypuvh85fswOhdsJjWB8Ayi8kk71qHkV71wBQrC2hUFNk/vh7OTBzXB/8Rv2TwFdW4jL4IcoyU7j43auc/ehhCjVFGI1GMgsy2XJ0G7d07E+vNj3N13MfEEXbH95D3dYUQ61X2yCCfNz5efeJGu1s7R+Gv4c/f568ftakL5VP2gK7fPImmxQzFBZT+Ns+PIf3RenqjDQayFw+G4XaFd9xM9h5Ipb//fmD1XmzxrxMsE8Q+7JS+CHrJCI4jBCvZjgaDZz636vMHjcL/Y/vML3bEEKjLWeHhYMKlY9p9lcajSgUCsbFdOTTDX+RkplPqH/VO9RMgo3erI5by8WCTJp71rwppakwZcoUm137WoQeut64qRxaODjg//hEXCJNy08FsSsoSz2C/wNvoXTzJrJVNzILMs0TUiv/PE5mQSkezqYNHu0C2nFvH8t/mijASVtMaXY6ih/nUFyUi9etj1gER5AGA2kvf4xzxzD8Hh3HHdHtWfr7Ec5czKvWoQF6t+3F2v3r2X1qD2OjRzfwb8POjchN5dAKZye8xw0BQJ9/kdxfPsOlU1/cokYC4OHszoQY07pjfomWFxed5P4B/fBwcQNMSqmgZi2qbNt1xvdk/fgOuRu+QJtS8ZBwMc1sCqUShaMD+b/sxPehO/H1cGHjvx6oNZe0p4sn/Tv0xcvl5hbt26k7N807tObYafLW/o6xXAeA0sMPn9HP4jvhFYzSyNfbF3Hqwt8RPrfEJ2MwSkb2qF5ZdSkKJ2f8H5yN7/gXKU3cQ9YPsy3KvcYMxpBXRNEfBwBQKRVIKSkorTkvwX1972FQ5wE11rFjp5IGyW0lhHheCHFcCHFYCLFNCNGq4U29OnKWbyT7G5NiRxoNCIUCz34TcGgWyIEzB9l/5gDF2r/XpX89mETr5t60q0cYXiEEnv3vJmjaf/EZbdppJCukkK7RnXFo4Ufemu3m+tO/2cTMb7dW2dal6A16kjPP1FrPjp1aHfqS3FYjgc7AfUKIzpdVO4gp0mcEsBJTSpwmgy4zl+I/4/G8/RaMZUWkvTuBkuOm9VKjNLLx8GYCvALo1sq0gb6wtIzTF3IZFVV1IIPaUIeG4+AThJSSi4tfJvOHt5EGHV6jB6E5fAptsmk9NjIsgAPJ50nJrFmLvf7gBj7c8DFFmuo3MzQFGkM+mZiYaLH328PDg48++gioXT754Ycf0rFjR8LDw+nWrRvPP/88Op1pxBYaGmoODRweHs6aNWvM5wkhmDRpkvm7Xq/Hz8+PO+5oegkVGiS3lZRyu5SyMjz1HkzB+JsM+et3ggSvOweSs+p9dHkXcPAxmXg07Rjn8s4zImIoCmH6dXi4OLHpjQeZ2Pfy51Y9kUYcAlpTtGc1GfMfxTWmNf5P3o2Dv6nXr4w5tmpPzUtYPdtEYzAa2JfctEOdN4Z8skOHDuZdZfv378fFxYVx48YBtcsnN2/ezJ49ezhy5Ah//fUX/v7+aDQac53t27cTHx/PypUrLUQildtOK+tu2bKFoKCget9TY9Agua0u41Hg16oKbJHbSur05P/yB669w9FlH6P44BaajXwcx+amLAy/HtqMj1szolubUpzIin24agcVOFzdtYVCic+oJ1G3Cidz2b84v2Aq/g/MRulmkgb6uLswJDyMlX8ep5m7Mw8NiqhyRBDk3YJWviHsPrmHIZ0H1WnU8OEG6+ySUWHdGdhpAOX6cj7d/IVVeZ92MfRp15tibTELfltoUfb8qGdrvWZjyScr2bZtG23atKFVK9MbXk3yyXfeeYedO3eaBSSOjo68/HLVmZELCwvx9rYU0YwcOZJffvmFCRMmmLNoVLVLzNbUpYeuMbeVRUUhHgSigferKpdSLpBSRkspo/38/Opu5VWgzynAIcAHz5ExZK2ci2NgW7yGTK60h5g2PRkTPdoc4yvxXA73zFvJiYzsBrPBtcstBD+/BFWzQLJ+eIu8ddvMk2Mzxvahd4dgTqRn1+iofdv3ISPvHGdz0qqtY0tsIZ9cvny5VXqa6uSTxcXFhIXVLK4ZPHiweVvo22+/bVF27733snz5crRaLYcPH7bIeNmkqGkbWUVv1QfYdMn3V4BXqqh3G5AA+NfWprTB1s/83atl0vSeUpN6tMZ6/1m7W8a8+LXML9E0uA2GMo3UZpyUyY/9nzw95XWpK8ozl5Xp9FJKKZMv5Mq5P8XKwlKtxbkl2hL59LfT5Zq4dVW2beutnxkZGbJDhw7m72fOnJFdunSRUko5adIk+d1338mnnnpKLlq0qN5tHz9+XPbs2VNqNH//TcrKyqSPj4+8cOGCRd1XX31Vzp8/3+JYQUGB9Pb2Nn/fuHGj7Natm2zVqpXctWuXlFLKVq1ayaysLCmllElJSbJVq1ayqKhISimlq6urlFLKqKgo+c0338hXXnlFbt++Xd5+++31vpf6cK22fppzWwkhHDHltlp7aYWKdLJfYUqNk9lAz5qrRp9bYFZUefYeQ8uXfkQd0gUwiR/+OBGLzqAz1zcYjWw6eJq+HVvi6VKz7vZKUDiqcWrRDu8xg9CXHCBt7j1oU48CmKOY7D99np92JzDh3yvYEn/a/Arg4uTCrLEvW4T/bUrUJp987733MFYIVKBuPXQll8onK/n111/p0aMHzZtbhlOuST555oxppWD48OHEx8fTtWvXKt/v27RpQ/PmzTl+3DKgxejRo5kxY0aTTlpXq0NLKfXANGATph74RynlMSHEW0KIyu1L7wNuwAohRLwQYm01zTUq2Ut/4fSDL6I9mwiAY/NQc9kv8b+yOm6dObwuQFzSebIKSxnZ3TqyRUPiMSQGdH5ITTkZn/yDgtgVZsed0Lczi58dg5+HK68s/Y1nF24iI8ck+Wvu6d9kNdKNLZ+sLhtkTfLJJ554gvx804qClLLaB1BmZiZnzpwxv5tXMmXKFP71r38RHh5ey2/DdjRIbisppXW6QRtj1Ggp3PQnTt10ZMx/mJBZq3DwNk2UZOSe4/DZI9zefSRqB1NPbDAamf/LXnzcnbmly7VdRlc4O+E5eDh567fgcaea7J/eQ5tyGL+Jr6JwcqZTsB/fPjOGFX8e54uNcazae4Jpo0xpWH+N30RGXgb/GGy7PdPV0RjZJwFKS0vZsmULX331lcU5tcknS0tLiYmJwcnJCTc3N/r162dh0+DBg1Eqleh0OubOnWvV+wcHB/Pss7VPDtqUmsbj1/Jzrd+hc9fskAkj75NJ03vKi/97y6Ls6+2L5LOLn5fF2mKL478fTZF/HE+9pnZVok09L5Mf+z9ZevKMzN30X3l6Rp8q3+/P5xXJUm25lFLK+DMX5Ne//SifWPi0zC7Ksahn63doKe3yyYbmmmWfvN6QUpK3ZhsObS+gdPPGZ/TfT9XMwiz2nznArV2G4Orkaq4vhGDANe6ZL8UpJICwBaZBjnO7f+AeMwaVp2nmv/z8aRwDTcP+AC838zlfbozjcGomEe0kvyfs4q6edzaavXXBnn3S9tyQe7nLU86hLz4IykJ8J7xkFkkAaMo1tPYL47aupljcUkqe/XojS3YctomthuJSyjMyzc5cmriHtH/fQ87aj83bRiuZ9/BQxvfpQWGxGxsO/s6mg0lXHFv6WmHPPmlbbkiHdgoLwvuuQbiGD8EtYohFWSvfEGbcMR3PipjXa/86yZ+J6biqr3IXyRUgpST1yXe48NFSs2M6t+mBR7+J5G9fwrkvnkRf+Pd6uKvakedH9+HuPsNwUJUxd9U6fj+W2uh222m6NOkhd97WRRTuXm11PGTWKoRCQc6Gzynev8myUChp9drP+N3zglXvdTw9gRDfENzUpqF2dmEpH63bQ4/WAYzt1fGa3Ud1CCHwHHULWV+tJH/1drzHDUGoHPGb8BLq0HCyfnyH9A8epPnkuTi3jjSfN7J7P0p1WQzpGMqAzqbXBJ3BUGO4Wjs3B03aoVXNWqBu3a3acgefYItyQ0ExJfuOk7fqN5NzXPLPXawt5qvfvia6dRST+t8PwLzVf1KmM/DqhFtQKGzjCM3uHobmyCkufrocx5AAXKNM+8fdo0fh2KI9F799EV1WqoVDO6ocua/v3ebvxZpycos0JF/MI9DbHRenxh9t2GkaNGmHdu8xHPcew6st94gZjUeMaSlcl5VH6hNvo3CIxH1IT6u6vx3bgU6v47aupiF4SmY+24+m8M/hUTVGDbnWCIWCwFmPcXbau2S8+SWhX87CMci0XOLUoi3BM75H4WhaWtMk7ccpuCOKihHGubzz7Enay9jo0Xi6qDEaJSmZ+Xi7qvH3dEVZSwAFOzceN8Rf3KgtI+P1zzCWagme8zQqT3eLck25hh0JO4kM7Uagl2ktOtTfiyXPjeOhQdWPABoLpYuaoHem4d4/EqW3ZT6rSmc2aIq4sPB50v/zEOXnTwNw5OwRthzZxoq9P6N2VNE6wBsfd2fyS7ScvpiH3mC0uta1pCHlk1u2bCEqKorw8HCioqIsZJGDBg2iQ4cO5t1lmZmmzYmffvopixYtqrK9N998k3nz5gGmZHdhYWHm8ys3s4SGhjJ+/HjzOStXruThhx+2autKskjOmTOnXvWvlBvCoS+8vxjtyVQCZz2GU5i1rG1nwh9oyjUMjxgKQGqWabdQ+xY+tYYBaiwcA/0IfGkKShc1Rm0Z8jIxg9LZnYBHP8SoKSb9o8kUHdjIsIih3NplMDuO/05pWSkKIWju5UZocy+8XdXmezMYG8exG1I+6evry7p16zhy5AiLFy+20CODSdlVubvM398UQHHKlClWWTeq4/333zeff+l207i4OI4da/h0vo3l0E16yF1X3AZEoe4Yinu/yCrLMwuz6BzUiVa+IcSfucBjn69j9v2DGVFD4nZbYdSUkfrMXFwiO9L8qXssypzbRhH8wjJT0IQlr1GWcoS7xr5AuUGHRqelUFOIp4snzo4O5C54igzAKCVl5XpUKiVeUcPw6n83xnIt5xdY75l273UnHr3uxFCcz4VvX7QoC5q2oFbbG1I+eekOri5duqDVaikrKzOnpqkKFxcXQkND2bdvH7169arX9SqZMWMGc+bMqTJNz6WkpaUxYsQIzpw5w/33388bb7wBwNKlS5k/fz7l5eXExMTw+eefM2vWLDQaDZGRkXTp0oVly5YxduxY0tLS0Gq1PPvss0ydOvWK7L2cptE9XSGGYlNMBY+BUTSbOKzaepNueYAnbptKud7A2yv+IMDLzTw73NRQODvhEt6OvJVbyN9gnYVC5elLi6e+xHPQAyAUKBQK7u0zESeVI1qd1mpmXyBQKBTo9AZyCkspLdNZtdkQXAv5ZCU//fQT3bt3t3DmRx55hMjISGbPnm1xz9HR0XXSKc+cOdN8zSNHjpiP33333Rw4cMCcGqc69u3bZx4lrFixgri4OBISEvjhhx/YtWsX8fHxKJVKli1bxty5c3F2diY+Pt78oPjmm2/Yv38/cXFxzJ8/n5ycnFptrgvXbQ+tTUrj7PT3CXzpEdz7V71HWG/Qk1eSh5+HHyqliq827SclM5/5/xjRpGeC/Z+6h7Kz57nwnyU4tmyOS3g7i3KhVOE7Zrr5H7k87QQuSgf8PPwQQiCltOpRizRlXMgrNk2auTnT4qmvql3iUrp51alHvpRrkX0S4NixY7z00ubqmv8AAAyWSURBVEts3rzZfGzZsmUEBQVRVFTE+PHjWbJkiTllq7+/PydO1BwBBkwPlAkTJlgdVyqVzJw5k3fffZeRI0dWe/7QoUPx8fEBTBkqY2NjUalU7N+/n549TZOyGo3G/DpwOfPnzzeHVUpLS+PUqVPm9q6G67KH1ucVkv7aJyjUTjh3ql60vu90HG/8NJu0nHSSzuey6Ld4RvZoS9+OLRvR2vojlEqC3ngchwBfMv71OboLVT+9Kx0yb+NXGIpyMRblYjAauFhwkWJtiUVdd2cn86SZUiEafL36Wsgn09PTGTduHN99951FbufK8D/u7u7cf//97Nv3dy7tquST9WXSpEns3LmTs2fPVlvn8t9f5YN08uTJ5nfzxMRE3nzzTatzd+zYwdatW9m9ezeHDh2ie/fu1f7u6st159DGch0Z//ocQ34xwW8/Zc5KYVXPaGTT4S0EeQcR3CyIs9kFNPdy5YUxfRrZ4itD6e5K8DvTcGwZgJQ1T2o1n/wuCkdn9AWZGHIyUAA5xTmUlJVa1FMqFDT3csPf07TsVaIt52xWAeW6q09d09Dyyfz8fG6//Xbeffdd+vXrZz5Pr9eTnW3aPafT6Vi/fr2FXLI6+WR9cHBwYPr06ebgg1WxZcsWcnNz0Wg0rF69mn79+nHrrbeycuVK86x7bm4uqamp5jYrAxIWFBTg7e2Ni4sLJ06cYM+ehkt3dF05tJSSi/9ZiuZoEoEvPYK6Q2i1dQ+mxJNZmMmIbsMQQjAkPIyfXrwbL9eGD1xwrXAKCSTk4xdxDPQzqWmqma1WOLmgdPNC5RWAUVuCZ2kRzgoVOUXZaMo1VZ4DoDcaKS3XkXwxj+zCUoxXuS+8IbNPfvrppyQlJTF79myL5amysjKGDx9OREQEkZGRBAUFWUy47dq1q0r5Zn159NFHa8wH3b9/fyZNmkRkZCTjx48nOjqazp078/bbbzNs2DAiIiIYOnQo58+bspVOnTqViIgIHnjgAUaMGIFeryciIoLXX3+d3r3rlje8TtQkxbqWnyuRTxqNRpm5aLXM/GZ1rfXeXvWufGPlWzIjp0Cu3ZcojUZjva/XVDDqdDL9zS9k5sJV1daplNoZtCWyPDtd6g16eS7vvEzNOis1ZdWHUyrX6WVaVoE8djZTJp3PkSUVUs0rwdbySVtfv6G5oeWT0mBAKJX4PTym1rrn8y9wIf8i9/W9h/d+/pMDyefp3T4IP0/XWs9tkiiVKFzU5CxZj1NoCzyGVL8ko3ByQeFkipjp5+pNae45lIrqB2IOKiXBvh7mSTOtTn/FE4a2lk9mZ2cze/bs2ivewFwXQ+6ys+dJnvw6muPJ1dbR6so4mnaM9Jx0WngHMnviG+QXebPrRBpPjux5/TozpgmXgOcexDmiHeffW4QmMaVu55VpcCzXILPTMerK0RuqH0K6OzvRJsAb74pXkoJSLQUl1stgtWFL+eTQoUOtls1uNhoqFY6TEOKHivK9QojQhjLQUFhM+qufYCzVoPL5e1uklJJTF5JYf2AD8375Dy8sfZHPtnzJH4mVIVzVfLh2H11a+nF3v6sMmN8EEA4qgv7vSZTeHmS89im6bOtsG5c7n9LNCwfflki9jvKLyeTkpFOur37XlkKhMM/eFpSUkZFbxNnswgaZNLNTP+r7IK2koVLhPArkSSnbAv8B3rsiay5DGgxkvPUVuos5BL75BBdUpRxN+3tb3jc7FrMhfiN6g57bug7hmeFPMb6XKYvCh2t3U6Qp4/W7B9Q45LyeUHm5E/zONFAq0WdaLmWp1WpycnKsndrZHYfmYQilA55lpRTknrOIdFodLX09CPB2Q9OAk2Z26oaUkpycHNTq+k/gitqeBEKIPsCbUsrhFd9fqbjou5fU2VRRZ7cQQgVcAPxkDY1HR0fLuLiaU7sc+Hghh0/sJ69vCOkij9LyUjycPXj3ntkoFAqOp5/G1ckDZ8e/sywIwM/TldjjZ0nLKeS+W65uCaMpInV6hIMKY7nOHKZYbzBwriCXMp0OUbGHWxqNl6REkBg0RRRhRAgFbk4uKFEA8hJHFSCEKbe1NCKkaR94cVk55XoDHs5OOKhUSCGgcsa9Mi67wJRKSCFMl5Sy4kO9y42AkBKMsuISl5VLEFiWC2FSriEUGKW8+vJK+6osN/1urMuVIMQVlysdHM0jJLVaTXBwMA4OlvMZQoj9UkrrKIgVNFQqHHMdKaVeCFEA+ABXnH5CGgx8b0ilpKeSstJMCkvcKCrxobDEDe4x3fTqPef4eY9lcjK1g4rYdx+hf+fGSbVjC4SDCiklucs3kr1ojUWZAui4/WsAzs/7joJfdlqUGVqoWTXShX8cisXpsuH3US8/NrY07W9//uheFBXr35WPywM+AfzWIgyl0cj0Y3ut7NrjF0RsQAhqvY5pCdYP653NQ9jnH4RHuZapiQetyrcFhnLQNxBfbQkPn7IOCfVrcBuOefvToqSI+5OPWpWvCWnPKU8fQovymZCSYFW+IrQTqe5etCvIYczZk1bly1p35byrO13yMhmZftqq/Nt2EWSrXemefZ5bz6dYlS/o0J1CRzUxmencctE6w8mnnaLRqhy45UIqMVnnrMqbvbgK78Cr2/RUF4euSyqcOqXLqU9uK6FUMnbEfZzJzMPVydtiZ07lj6Oi2tEp2DKljtJGgQpsgVOblgS88FC15Z7DeuPcMdTiWIBKSfs+7cjyCcOjUGLIL+KcPp8yqcdb7cld3qE4dw5DF9AR33yJsaiEdF0eOgz4OzfjLp8QMtzdOKFogVMhyDIdhaIAlUIS3CyQ8f4hpDk5cUIVglOBEVmup1Dk46gQhPm2IMQ/hFSFINGxNQ55etAbKBB5OCkUtPcNpk1ACGcMek46t0eVU4bRYKBIFOCsVNDFL4ROgSGc0ZRwyr0TykwNRmmkSBTgolIQ6RtGZItgThcWcMozHOXFUgwYKBaFuKkU9PRpQ3SLIFLyckny6o4iswQDeopFEe4qJf2atcXYogVpHpmc9o5GZJWgQ0epKMbTQclAr/bogwI573ae075FFeXllIoSvByU3ObVEV1gAFmuaST7lUJ2CeWUoxEleDsqGeXZmbKA5uS6pJDsXwY5xZSjRSM0+DiqCPK4el1+kx5y27Fjx5LahtwNkgqn4vvkip8nAL/V5Mx27Ni5NtTaQwMIIUYBHwFK4Bsp5TtCiLcw7VpZK4RQA0uA7kAucK+UsvpFY1ObWUAq4MtVvGs3Ek3dRrt9V09Tt7HSvlZSympTt9bJoa8lQoi4moYQTYGmbqPdvqunqdtYV/tujAVaO3bsAHaHtmPnhqIpOHT9QmPYhqZuo92+q6ep21gn+2z+Dm3Hjp2Goyn00Hbs2Gkg7A5tx84NRJNyaCHEDCGEFEL42tqWSxFCvC+EOCGEOCyEWCWEaDI5S2uTttoSIURLIcR2IUSCEOKYEOLZ2s9qfIQQSiHEQSHE+tprNz5CCC8hxMqK/8GEit2bVdJkHFoI0RIYClQfatF2bAG6SikjgJPAKza2B6iztNWW6IEXpJSdgN7AU03MvkqeBazVHE2Hj4GNUsqOQDdqsLXJODQmHfWLVCHqsDVSys1SyspwH3uAYFvacwm9gCQpZbKUshxYDtQeo6mRkFKel1IeqPi5CNM/onWuIhsihAgGbge+trUtVSGE8AAGAAsBpJTlUkrr6BYVNAmHFkKMBjKklIdsbUsdmAL8amsjKqhK2tqkHKaSiig23QFr3aVt+QhTR9K4mf3qTmsgC1hU8VrwtRCi2nhajRYkUAixFQioomgW8CpQfS6bRqAm+6SUayrqzMI0jKw58VHjUSfZqq0RQrgBPwHPSSkLbW1PJUKIO4BMKeV+IcQgW9tTDSqgB/C0lHKvEOJj4GXg9eoqNwpSyiqDJQshwoEw4FCF5jkYOCCE6CWlvGBr+yoRQkwG7gBubUJKsnTgUkV8MGCtnLchQggHTM68TEr5s63tuYx+wOgK8ZEa8BBCLJVSPmhjuy4lHUiXUlaObFZicugqaXIbS4QQKUC0lLLJKF+EECOAD4GBUsosW9tTSYX2/CRwK5CBSep6v5Sy4fOhXgHC9IReDORKKZ+ztT01UdFDz5BS3mFrWy5HCPEH8A8pZaIQ4k3AVUpZZWKw6yYut435FHACtlSMIvZIKR+3rUnmcE/TgE38LW1tEs5cQT9gEnBECBFfcexVKeUGG9p0PfI0sKwiHkEy8Eh1FZtcD23Hjp0rp0nMctuxY6dhsDu0HTs3EHaHtmPnBsLu0Hbs3EDYHdqOnRsIu0PbsXMDYXdoO3ZuIP4fckv5ADMOIPoAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 252x108 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.clf()\n",
    "f = plt.figure(figsize=(3.5, 1.5))\n",
    "for well in wells_:\n",
    "    freqs, bins = np.histogram(traj_PC1[well], bins=bins_PC1)\n",
    "    freqs = freqs/freqs.sum()\n",
    "    x = (bins[:-1] + bins[1:])/2\n",
    "    plt.plot(x, freqs, '--', c=colors[well], label='(N=%d) ' % n_trajs[well] + legends[well]) \n",
    "    \n",
    "# freqs, bins = np.histogram(traj_PC1_june, bins=bins_PC1)\n",
    "# freqs = freqs/freqs.sum()\n",
    "# x = (bins[:-1] + bins[1:])/2\n",
    "# plt.plot(x, freqs, c='k', label='June batch')\n",
    "\n",
    "plt.xlabel(\"\")\n",
    "plt.ylabel(\"\")\n",
    "plt.legend()\n",
    "plt.grid(b=False, which='major', axis='x')\n",
    "plt.tight_layout()\n",
    "plt.savefig('nonmg_analysis/NOVEMBER_nonmg_PC1.eps')\n",
    "plt.savefig('nonmg_analysis/NOVEMBER_nonmg_PC1.png', dpi=300)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 252x108 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.clf()\n",
    "f = plt.figure(figsize=(3.5, 1.5))\n",
    "for well in wells_:\n",
    "    freqs, bins = np.histogram(traj_PC2[well], bins=bins_PC2)\n",
    "    freqs = freqs/freqs.sum()\n",
    "    x = (bins[:-1] + bins[1:])/2\n",
    "    plt.plot(x, freqs, '--', c=colors[well], label=legends[well])\n",
    "\n",
    "# freqs, bins = np.histogram(traj_PC2_june, bins=bins_PC2)\n",
    "# freqs = freqs/freqs.sum()\n",
    "# x = (bins[:-1] + bins[1:])/2\n",
    "# plt.plot(x, freqs, c='k', label='June batch')\n",
    "\n",
    "plt.xlabel(\"\")\n",
    "plt.ylabel(\"\")\n",
    "plt.grid(b=False, which='major', axis='x')\n",
    "plt.tight_layout()\n",
    "plt.savefig('nonmg_analysis/NOVEMBER_nonmg_PC2.eps')\n",
    "plt.savefig('nonmg_analysis/NOVEMBER_nonmg_PC2.png', dpi=300)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 252x108 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.clf()\n",
    "f = plt.figure(figsize=(3.5, 1.5))\n",
    "for well in wells_:\n",
    "    freqs, bins = np.histogram(traj_speed[well], bins=bins_speed)\n",
    "    freqs = freqs/freqs.sum()\n",
    "    x = (bins[:-1] + bins[1:])/2\n",
    "    plt.plot(x, freqs, '--', c=colors[well], label=legends[well])\n",
    "\n",
    "# freqs, bins = np.histogram(list(traj_speed_june.values()), bins=bins_speed)\n",
    "# freqs = freqs/freqs.sum()\n",
    "# x = (bins[:-1] + bins[1:])/2\n",
    "# plt.plot(x, freqs, c='k', label='June batch')\n",
    "\n",
    "plt.xlabel(\"\")\n",
    "plt.ylabel(\"\")\n",
    "plt.grid(b=False, which='major', axis='x')\n",
    "speed_ticks = [4, 8, 16, 32, 64, 128]\n",
    "plt.gca().set_xticks(np.log(speed_ticks))\n",
    "plt.gca().set_xticklabels(speed_ticks)\n",
    "plt.tight_layout()\n",
    "plt.savefig('nonmg_analysis/NOVEMBER_nonmg_speed.eps')\n",
    "plt.savefig('nonmg_analysis/NOVEMBER_nonmg_speed.png', dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "### GMM to multiple states ###\n",
    "t_lag = 1\n",
    "mg_traj_properties = {}\n",
    "X = []\n",
    "Y = []\n",
    "mg_t_arrays = []\n",
    "for t in mg_trajs:\n",
    "    well = t[:2]\n",
    "    if not well in wells_:\n",
    "        continue\n",
    "    t_keys = sorted(mg_trajs[t].keys())\n",
    "    dists = []\n",
    "    for t_point in t_keys:\n",
    "        if (t_point + t_lag) in t_keys:\n",
    "            d = np.linalg.norm(mg_traj_positions[t][t_point+t_lag] - \\\n",
    "                               mg_traj_positions[t][t_point], ord=2)\n",
    "            dists.append(d)\n",
    "        \n",
    "    mg_traj_PC = [dats[well][ind] for ind in mg_traj_inds[t]]\n",
    "    mg_traj_dist = dists\n",
    "    mg_traj_properties[t] = (mg_traj_PC, mg_traj_dist)\n",
    "    X.append(np.concatenate([np.array(np.log(np.mean(mg_traj_dist) * 0.325 / 0.1518)).reshape((-1,)), np.mean(mg_traj_PC, 0)]))\n",
    "    Y.append(sorted(wells_).index(well))\n",
    "    mg_t_arrays.append(t)\n",
    "    \n",
    "mg_X = np.array(X)\n",
    "mg_Y = np.array(Y)\n",
    "std_unit = np.std(X, 0)\n",
    "std_unit = np.clip(std_unit, 0.6, 10.)\n",
    "# std_unit[1:] = np.clip(std_unit[1:], std_unit[1], 10.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.37812864 0.62187136]\n",
      " [0.90453349 0.09546651]\n",
      " [0.98587016 0.01412984]\n",
      " [0.13003503 0.86996497]]\n"
     ]
    }
   ],
   "source": [
    "### GMM ###\n",
    "def calculate_sample_prob_mat(X, centers, stds):\n",
    "    # Sample prob mat should be N * 2\n",
    "    n_feat = X.shape[1]\n",
    "    X_ = X.reshape((-1, 1, n_feat))\n",
    "    centers_ = np.array(centers).reshape((1, -1, n_feat))\n",
    "    stds_ = np.array(stds).reshape((1, -1, n_feat))\n",
    "    prob_mat = np.square((X_ - centers_)/stds_).sum(2)\n",
    "    prob_mat = prob_mat - prob_mat.min(1, keepdims=True)\n",
    "    prob_mat = np.exp(-0.5 * prob_mat)\n",
    "    return prob_mat\n",
    "\n",
    "\n",
    "def initialize_well_prob_mat(sample_prob_mat, y):\n",
    "    # Well prob mat should be 5*2\n",
    "    classes = sorted(np.unique(y))\n",
    "    prob_mat = np.zeros((len(classes), sample_prob_mat.shape[1]))\n",
    "    for i, c in enumerate(classes):\n",
    "        line = sample_prob_mat[np.where(y == c)].sum(0)\n",
    "        line = line/line.sum()\n",
    "        prob_mat[i] = line\n",
    "    return prob_mat\n",
    "\n",
    "\n",
    "def get_merged_prob_mat(X, y, centers, stds, well_prob_mat):\n",
    "    # E-step\n",
    "    sample_prob_mat = calculate_sample_prob_mat(X, centers, stds)\n",
    "    prob_mat = []\n",
    "    for i in range(len(X)):\n",
    "        prob_ = sample_prob_mat[i] * well_prob_mat[y[i]]\n",
    "        prob_ = prob_/prob_.sum()\n",
    "        prob_mat.append(prob_)\n",
    "    prob_mat = np.stack(prob_mat, 0)\n",
    "    return prob_mat\n",
    "    \n",
    "\n",
    "def calculate_new_centers(X, y, prob_mat):\n",
    "    # M-step\n",
    "    classes = sorted(np.unique(y))\n",
    "    weights = prob_mat\n",
    "\n",
    "    outlying = np.zeros((X.shape[0],))\n",
    "    for i, c in enumerate(classes):\n",
    "        inds = np.where(y == c)\n",
    "        X_c = X[inds]\n",
    "        median_X_c = np.median(X_c, keepdims=True, axis=0)\n",
    "        outlying[inds] = np.linalg.norm(X_c - median_X_c, axis=1, ord=2)  \n",
    "  \n",
    "    outlying = (1 - 0.7 * (outlying - outlying.min())/(outlying.max() - outlying.min())) ** 10.\n",
    "    weights = weights * outlying.reshape((-1, 1))\n",
    "  \n",
    "    centers = []\n",
    "    stds = []\n",
    "    for i in range(weights.shape[1]):\n",
    "        w = weights[:, i:(i+1)]\n",
    "        center = (w * X).sum(0)/w.sum()\n",
    "        centers.append(center)\n",
    "        std = np.sqrt(((w * (X - center) ** 2).sum(0)/w.sum()))\n",
    "        ratio = np.median((std/std_unit)[:5])\n",
    "        stds.append(ratio * std_unit)\n",
    "\n",
    "    well_prob_mat = []\n",
    "    for i, c in enumerate(classes):\n",
    "        inds = np.where(y == c)\n",
    "        well_prob_mat.append(weights[inds].sum(0)/weights[inds].sum())\n",
    "    well_prob_mat = np.stack(well_prob_mat, 0)\n",
    "    return centers, stds, well_prob_mat\n",
    "  \n",
    "    \n",
    "# Two states or three states\n",
    "init_center1 = np.median(mg_X[np.where(mg_Y == 1)], 0)\n",
    "init_center2 = np.median(mg_X[np.where(mg_Y == 3)], 0)\n",
    "init_center1 += np.random.normal(0, 0.1, init_center1.shape)\n",
    "init_center2 += np.random.normal(0, 0.1, init_center1.shape)\n",
    "centers = [init_center1, init_center2]\n",
    "stds = [0.6*std_unit for c in centers]\n",
    "well_prob_mat = initialize_well_prob_mat(calculate_sample_prob_mat(mg_X, centers, stds), mg_Y)\n",
    "\n",
    "for i in range(20): \n",
    "    prob_mat = get_merged_prob_mat(mg_X, mg_Y, centers, stds, well_prob_mat)\n",
    "    centers, _, well_prob_mat = calculate_new_centers(mg_X, mg_Y, prob_mat)\n",
    "print(well_prob_mat)\n",
    "\n",
    "### Calculate trajectory states ###\n",
    "state_cmaps = [plt.get_cmap(name) for name in ['Blues', 'Reds', 'Greens', 'Oranges']]\n",
    "traj_states = {well: [] for well in wells_}\n",
    "prob_mat = get_merged_prob_mat(mg_X, mg_Y, centers, stds, well_prob_mat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Non-MG cell properties ###\n",
    "t_lag = 1\n",
    "nonmg_traj_properties = {}\n",
    "X = []\n",
    "Y = []\n",
    "t_arrays = []\n",
    "for t in trajs:\n",
    "    well = t[:2]\n",
    "    if not well in wells_:\n",
    "        continue\n",
    "    t_keys = sorted(trajs[t].keys())\n",
    "    dists = []\n",
    "    for t_point in t_keys:\n",
    "        if (t_point + t_lag) in t_keys:\n",
    "            d = np.linalg.norm(traj_positions[t][t_point+t_lag] - \\\n",
    "                               traj_positions[t][t_point], ord=2)\n",
    "            dists.append(d)\n",
    "        \n",
    "    traj_PC = [dats[well][ind] for ind in traj_inds[t]]\n",
    "    traj_dist = dists\n",
    "    nonmg_traj_properties[t] = (traj_PC, traj_dist)\n",
    "    X.append(np.concatenate([np.array(np.log(np.mean(traj_dist) * 0.325 / 0.1518)).reshape((-1,)), np.mean(traj_PC, 0)]))\n",
    "    Y.append(sorted(wells_).index(well))\n",
    "    t_arrays.append(t)\n",
    "\n",
    "X = np.array(X)\n",
    "Y = np.array(Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Calculate Cell Motion Directions ###\n",
    "\n",
    "cell_aps = pickle.load(open(os.path.join(raw_folder, 'all_patches_cell_aspect_ratios.pkl'), 'rb'))\n",
    "traj_orientations = {}\n",
    "traj_orientations2 = {}\n",
    "traj_orientation_stds = {}\n",
    "patch_orientations = {}\n",
    "patch_displacements = {}\n",
    "t_lag = 1\n",
    "\n",
    "angs1_all = []\n",
    "angs2_all = []\n",
    "ang_diffs_all = []\n",
    "for t in traj_inds:\n",
    "    well = t[:2]\n",
    "    traj_fs = [fs[well][ind] for ind in traj_inds[t]]\n",
    "    t_keys = sorted(trajs[t].keys())\n",
    "    \n",
    "    valid_fs = []\n",
    "    ds = []\n",
    "    d_angs = []\n",
    "    for i, f in enumerate(traj_fs):\n",
    "        t_point = t_keys[i]\n",
    "        if (t_point + t_lag) in t_keys:\n",
    "            d = np.linalg.norm(traj_positions[t][t_point+t_lag] - \\\n",
    "                               traj_positions[t][t_point], ord=2)\n",
    "            d_ang = traj_positions[t][t_point+t_lag] - traj_positions[t][t_point]\n",
    "            d_ang = cmath.polar(complex(d_ang[1], d_ang[0]))[1]\n",
    "            valid_fs.append(f)\n",
    "            ds.append(d)\n",
    "            d_angs.append(d_ang)\n",
    "\n",
    "    traj_cell_aps = [cell_aps[f][0] for f in valid_fs]\n",
    "    traj_cell_angs = [cell_aps[f][1] for f in valid_fs]\n",
    "\n",
    "    angs1 = [a for i, a in enumerate(d_angs) if traj_cell_aps[i] > 1.1] # Orientation of movement, 0 ~ 2pi\n",
    "    angs2 = [a for i, a in enumerate(traj_cell_angs) if traj_cell_aps[i] > 1.1]\n",
    "    angs2 = [a if a > 0 else a + np.pi for a in angs2] # Orientation of cell long axis, 0~pi\n",
    "    angs1_all.extend(angs1)\n",
    "    angs2_all.extend(angs2)\n",
    "    ds = [d for i, d in enumerate(ds) if traj_cell_aps[i] > 1.1]\n",
    "    valid_fs_ = [f for i, f in enumerate(valid_fs) if traj_cell_aps[i] > 1.1]\n",
    "    if len(angs1) <= 2:\n",
    "        continue\n",
    "    \n",
    "    ang_diffs = [(a1 - a2)%(np.pi) for a1, a2 in zip(angs1, angs2)]\n",
    "    #ang_diffs = [a if a < np.pi/2 else a - np.pi for a in ang_diffs]\n",
    "    ang_diffs_all.extend(ang_diffs)\n",
    "    for f, a in zip(valid_fs_, ang_diffs):\n",
    "        patch_orientations[f] = a\n",
    "    for f, d in zip(valid_fs_, ds):\n",
    "        patch_displacements[f] = d\n",
    "    \n",
    "    # Pool angles along the traj\n",
    "    merged_x = sum([d * np.cos(2 * ang) for d, ang in zip(ds, ang_diffs)])\n",
    "    merged_y = sum([d * np.sin(2 * ang) for d, ang in zip(ds, ang_diffs)])\n",
    "    merged_d, merged_ang_diff = cmath.polar(complex(merged_x, merged_y))\n",
    "    \n",
    "    assert np.allclose(merged_d, np.sqrt(merged_x**2 + merged_y**2))\n",
    "    traj_orientations[t] = merged_ang_diff / 2\n",
    "    traj_orientations2[t] = np.arctan(merged_y/merged_x) / 2\n",
    "    traj_orientation_stds[t] = merged_d/sum(ds)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Calculate Cell Motion Directions ###\n",
    "\n",
    "cell_aps = pickle.load(open(os.path.join(raw_folder, 'all_patches_cell_aspect_ratios.pkl'), 'rb'))\n",
    "mg_traj_orientations = {}\n",
    "mg_traj_orientations2 = {}\n",
    "mg_traj_orientation_stds = {}\n",
    "patch_orientations = {}\n",
    "patch_displacements = {}\n",
    "t_lag = 1\n",
    "\n",
    "angs1_all = []\n",
    "angs2_all = []\n",
    "ang_diffs_all = []\n",
    "for t in mg_traj_inds:\n",
    "    well = t[:2]\n",
    "    mg_traj_fs = [fs[well][ind] for ind in mg_traj_inds[t]]\n",
    "    t_keys = sorted(mg_trajs[t].keys())\n",
    "    \n",
    "    valid_fs = []\n",
    "    ds = []\n",
    "    d_angs = []\n",
    "    for i, f in enumerate(mg_traj_fs):\n",
    "        t_point = t_keys[i]\n",
    "        if (t_point + t_lag) in t_keys:\n",
    "            d = np.linalg.norm(mg_traj_positions[t][t_point+t_lag] - \\\n",
    "                               mg_traj_positions[t][t_point], ord=2)\n",
    "            d_ang = mg_traj_positions[t][t_point+t_lag] - mg_traj_positions[t][t_point]\n",
    "            d_ang = cmath.polar(complex(d_ang[1], d_ang[0]))[1]\n",
    "            valid_fs.append(f)\n",
    "            ds.append(d)\n",
    "            d_angs.append(d_ang)\n",
    "\n",
    "    mg_traj_cell_aps = [cell_aps[f][0] for f in valid_fs]\n",
    "    mg_traj_cell_angs = [cell_aps[f][1] for f in valid_fs]\n",
    "\n",
    "    angs1 = [a for i, a in enumerate(d_angs) if mg_traj_cell_aps[i] > 1.1] # Orientation of movement, 0 ~ 2pi\n",
    "    angs2 = [a for i, a in enumerate(mg_traj_cell_angs) if mg_traj_cell_aps[i] > 1.1]\n",
    "    angs2 = [a if a > 0 else a + np.pi for a in angs2] # Orientation of cell long axis, 0~pi\n",
    "    angs1_all.extend(angs1)\n",
    "    angs2_all.extend(angs2)\n",
    "    ds = [d for i, d in enumerate(ds) if mg_traj_cell_aps[i] > 1.1]\n",
    "    valid_fs_ = [f for i, f in enumerate(valid_fs) if mg_traj_cell_aps[i] > 1.1]\n",
    "    if len(angs1) <= 2:\n",
    "        continue\n",
    "    \n",
    "    ang_diffs = [(a1 - a2)%(np.pi) for a1, a2 in zip(angs1, angs2)]\n",
    "    #ang_diffs = [a if a < np.pi/2 else a - np.pi for a in ang_diffs]\n",
    "    ang_diffs_all.extend(ang_diffs)\n",
    "    for f, a in zip(valid_fs_, ang_diffs):\n",
    "        patch_orientations[f] = a\n",
    "    for f, d in zip(valid_fs_, ds):\n",
    "        patch_displacements[f] = d\n",
    "    \n",
    "    # Pool angles along the traj\n",
    "    merged_x = sum([d * np.cos(2 * ang) for d, ang in zip(ds, ang_diffs)])\n",
    "    merged_y = sum([d * np.sin(2 * ang) for d, ang in zip(ds, ang_diffs)])\n",
    "    merged_d, merged_ang_diff = cmath.polar(complex(merged_x, merged_y))\n",
    "    \n",
    "    assert np.allclose(merged_d, np.sqrt(merged_x**2 + merged_y**2))\n",
    "    mg_traj_orientations[t] = merged_ang_diff / 2\n",
    "    mg_traj_orientations2[t] = np.arctan(merged_y/merged_x) / 2\n",
    "    mg_traj_orientation_stds[t] = merged_d/sum(ds)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 252x252 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "\n",
    "traj_orientations[t]\n",
    "\n",
    "plt.clf()\n",
    "f = plt.figure(figsize=(3.5, 3.5))\n",
    "ax = plt.subplot(111, projection='polar')\n",
    "bins = np.arange(-np.pi/2, np.pi/2 + np.pi/41, np.pi/41)\n",
    "\n",
    "line, _ = np.histogram(list(traj_orientations.values()), bins=bins)\n",
    "_x = (bins[:-1] + bins[1:])/2\n",
    "ax.plot(_x, line/line.sum(), color=(0, 0, 0), label='Progenitor (PG)')\n",
    "\n",
    "line, _ = np.histogram(list(mg_traj_orientations.values()), bins=bins)\n",
    "_x = (bins[:-1] + bins[1:])/2\n",
    "ax.plot(_x, line/line.sum(), color=(0.6, 0.6, 0.6), label='Microglia (MG)')\n",
    "\n",
    "ax.set_theta_zero_location('N')\n",
    "ax.set_rorigin(-0.15)\n",
    "ax.set_rticks([0., 0.2])\n",
    "ax.set_thetagrids([-90, -45, 0, 45, 90])\n",
    "ax.set_thetamin(-90)\n",
    "ax.set_thetamax(90)\n",
    "ax.legend(fontsize=10, loc=(-0.2, 0.35))\n",
    "plt.savefig('NOVEMBER_nonmg_direction.png', dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n",
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 252x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "speed_ticks = [4., 8., 16., 32., 64., 128.]\n",
    "\n",
    "plt.clf()\n",
    "f = plt.figure(figsize=(3.5, 3))\n",
    "np.random.seed(128)\n",
    "random_selected_inds = np.random.choice(np.arange(len(mg_X)), (1000,), replace=False)\n",
    "for i in random_selected_inds:\n",
    "    t = mg_t_arrays[i]\n",
    "    merged_ang_diff = mg_traj_orientations[t]\n",
    "    merged_d = np.exp(mg_X[i, 0])/200\n",
    "    #merged_d = (1 - traj_orientation_stds[t])/2 # Longer marker indicates more consistent movement (smaller circular SD)\n",
    "    arrow_vec = (merged_d * np.sin(merged_ang_diff), merged_d * np.cos(merged_ang_diff))\n",
    "    x_center = mg_X[i, 1]\n",
    "    y_center = mg_X[i, 2]\n",
    "    dx = arrow_vec[0]\n",
    "    dy = arrow_vec[1]\n",
    "    x = x_center - dx/2\n",
    "    y = y_center - dy/2\n",
    "    plt.arrow(x, y, dx, dy, color=(0.8, 0.8, 0.8), width=0.001, head_width=0.)\n",
    "\n",
    "random_selected_inds = np.random.choice(np.arange(len(X)), (100,), replace=False)\n",
    "for i in random_selected_inds:\n",
    "    t = t_arrays[i]\n",
    "    if not t in traj_orientations:\n",
    "        continue\n",
    "    merged_ang_diff = traj_orientations[t]\n",
    "    merged_d = np.exp(X[i, 0])/200\n",
    "    #merged_d = (1 - traj_orientation_stds[t])/2 # Longer marker indicates more consistent movement (smaller circular SD)\n",
    "    arrow_vec = (merged_d * np.sin(merged_ang_diff), merged_d * np.cos(merged_ang_diff))\n",
    "    x_center = X[i, 1]\n",
    "    y_center = X[i, 2]\n",
    "    dx = arrow_vec[0]\n",
    "    dy = arrow_vec[1]\n",
    "    x = x_center - dx/2\n",
    "    y = y_center - dy/2\n",
    "    plt.arrow(x, y, dx, dy, color=(0., 0., 0.), width=0.01, head_width=0.)\n",
    "\n",
    "plt.xlabel(\"\")\n",
    "plt.ylabel(\"\")\n",
    "plt.xlim(-5, 7)\n",
    "plt.ylim(-3, 9)\n",
    "\n",
    "import matplotlib.patches as mpatches\n",
    "plt.plot([-10], [-1], '|', color=(0.8, 0.8, 0.8), label='Microglia (MG)')\n",
    "plt.plot([-10], [-1], '|', color=(0., 0., 0.), label='Progenitor (PG)')\n",
    "plt.legend()\n",
    "\n",
    "plt.savefig('nonmg_analysis/NOVEMBER_mg_nonmg_PC12.eps')\n",
    "plt.savefig('nonmg_analysis/NOVEMBER_mg_nonmg_PC12.png', dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n",
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 252x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_feat = 5\n",
    "stds_ = np.ones((1, 49))\n",
    "dist_within = np.linalg.norm((X/stds_)[:, :n_feat].reshape((-1, 1, n_feat)) - \\\n",
    "                             (X/stds_)[:, :n_feat].reshape((1, -1, n_feat)), axis=2, ord=2)\n",
    "\n",
    "dist_to_g1 = np.linalg.norm((X/stds_)[:, :n_feat].reshape((-1, 1, n_feat)) - \\\n",
    "                            (mg_X[np.where(prob_mat[:, 0] > 0.5)]/stds_)[:, :n_feat].reshape((1, -1, n_feat)), axis=2, ord=2)\n",
    "#                             (centers[0]/stds_)[:, :n_feat].reshape((-1, 1, n_feat)), axis=2, ord=2)\n",
    "dist_to_g2 = np.linalg.norm((X/stds_)[:, :n_feat].reshape((-1, 1, n_feat)) - \\\n",
    "                            (mg_X[np.where(prob_mat[:, 1] > 0.5)]/stds_)[:, :n_feat].reshape((1, -1, n_feat)), axis=2, ord=2)\n",
    "#                             (centers[1]/stds_)[:, :n_feat].reshape((-1, 1, n_feat)), axis=2, ord=2)\n",
    "dist_within = np.concatenate([dist_within[i, (i+1):] for i in range(dist_within.shape[0]-1)])\n",
    "dist_to_g1 = dist_to_g1.flatten()\n",
    "dist_to_g2 = dist_to_g2.flatten()\n",
    "\n",
    "unit = np.median(dist_within)\n",
    "dist_within = dist_within/unit\n",
    "dist_to_g1 = dist_to_g1/unit\n",
    "dist_to_g2 = dist_to_g2/unit\n",
    "\n",
    "bins = np.arange(0, 4, 0.1)\n",
    "line_within, x = np.histogram(dist_within, bins=bins)\n",
    "line_g1, x = np.histogram(dist_to_g1, bins=bins)\n",
    "line_g2, x = np.histogram(dist_to_g2, bins=bins)\n",
    "plt.clf()\n",
    "f = plt.figure(figsize=(3.5, 3))\n",
    "plt.plot(x[:-1], line_within/line_within.sum(), color=(0.3, 0.3, 0.3), label='PG vs PG')\n",
    "plt.plot(x[:-1], line_g1/line_g1.sum(), color=state_cmaps[0](0.8), label='PG vs MG (State 1)')\n",
    "plt.plot(x[:-1], line_g2/line_g2.sum(), color=state_cmaps[1](0.8), label='PG vs MG (State 2)')\n",
    "plt.legend(loc=4)\n",
    "plt.savefig('nonmg_analysis/NOVEMBER_nonmg_dist.eps')\n",
    "plt.savefig('nonmg_analysis/NOVEMBER_nonmg_dist.png', dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 320,
   "metadata": {},
   "outputs": [
    {
     "ename": "ModuleNotFoundError",
     "evalue": "No module named 'umap'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-320-37b10e7e2353>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m### UMAP of morphodynamic features ###\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0;32mimport\u001b[0m \u001b[0mumap\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mmatplotlib\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpyplot\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mpickle\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mn\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'umap'"
     ]
    }
   ],
   "source": [
    "### UMAP of morphodynamic features ###\n",
    "import umap\n",
    "import matplotlib.pyplot as plt\n",
    "import pickle\n",
    "n = 10\n",
    "d = 0.1\n",
    "mg_X_ = mg_X/std_unit\n",
    "X_ = X/std_unit\n",
    "combined_X_ = np.concatenate([mg_X_, X_], 0)\n",
    "reducer = umap.UMAP(n_neighbors=n, min_dist=d)\n",
    "embedding = reducer.fit_transform(combined_X_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "embedding_mg = embedding[:len(mg_X_)]\n",
    "embedding_nonmg = embedding[len(mg_X_):]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.stats import gaussian_kde\n",
    "def density_estimation(m1, m2):\n",
    "    xmin, xmax = m1.min()-0.5, m1.max()+0.5\n",
    "    ymin, ymax = m2.min()-0.5, m2.max()+0.5\n",
    "    xint = (xmax - xmin) / 100\n",
    "    yint = (ymax - ymin) / 100\n",
    "    X, Y = np.mgrid[xmin:xmax:xint, ymin:ymax:yint]\n",
    "    positions = np.stack([X.ravel(), Y.ravel()], 0)\n",
    "    values = np.stack([m1, m2], 0)\n",
    "    kernel = gaussian_kde(values)\n",
    "    Z = np.reshape(kernel(positions), X.shape)\n",
    "    return X, Y, Z\n",
    "\n",
    "m1, m2 = embedding_mg[:, 0], embedding_mg[:, 1]\n",
    "cont_X, cont_Y, cont_Z = density_estimation(m1, m2)\n",
    "xmin, xmax = m1.min()-0.5, m1.max()+0.5\n",
    "ymin, ymax = m2.min()-0.5, m2.max()+0.5\n",
    "\n",
    "plt.clf()\n",
    "f = plt.figure(figsize=(4, 3))\n",
    "\n",
    "selected_inds = np.random.choice(np.arange(len(embedding_mg)), (1000,), replace=False)\n",
    "plt.plot(embedding_mg[selected_inds][:, 0], \n",
    "         embedding_mg[selected_inds][:, 1], \n",
    "         '.',\n",
    "         c=(0.3, 0.3, 0.3), \n",
    "         markersize=3.,\n",
    "         label='Microglia')\n",
    "plt.plot(embedding_nonmg[:, 0], \n",
    "         embedding_nonmg[:, 1], \n",
    "         '.',\n",
    "         c='r', \n",
    "         markersize=3.,\n",
    "         label='Progenitor')\n",
    "plt.contourf(cont_X, cont_Y, cont_Z>cont_Z.max()*0.15, levels=1, colors=[(1., 1., 1.), (0.95, 0.95, 0.95)])\n",
    "plt.xlim(xmin-0.5, xmax+0.5)\n",
    "plt.ylim(ymin-0.5, ymax+0.5)\n",
    "plt.legend()\n",
    "plt.savefig('nonmg_analysis/NOVEMBER_mg_nonmg_umap.eps')\n",
    "plt.savefig('nonmg_analysis/NOVEMBER_mg_nonmg_umap.png', dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.16827545\n",
      "0.03427312\n"
     ]
    }
   ],
   "source": [
    "import torch.nn.functional as F\n",
    "model = VQ_VAE(alpha=0.0005, gpu=True)\n",
    "model = model.cuda()\n",
    "model.load_state_dict(torch.load('HiddenStateExtractor/save_0005_bkp4.pt'))\n",
    "\n",
    "all_nonmg_fs = []\n",
    "for t in traj_inds:\n",
    "    well = t[:2]\n",
    "    traj_fs = [fs[well][i] for i in traj_inds[t]]\n",
    "    all_nonmg_fs.extend(traj_fs)\n",
    "    \n",
    "test_r_losses = []\n",
    "for i, k in enumerate(all_nonmg_fs):\n",
    "  sample = all_patches[k]\n",
    "  sample = sample.cuda()\n",
    "  output, loss = model.forward(sample)\n",
    "  recon_loss = torch.mean(F.l1_loss(output, sample, reduction='none')/model.channel_var)\n",
    "  test_r_losses.append(recon_loss.data.cpu().numpy())\n",
    "\n",
    "print(np.mean(test_r_losses))\n",
    "print(np.std(test_r_losses))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}