{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# BSSD - Blind Source Separation Denoising"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**main function: denoise(** *ROIs_means_corrected, time, inactive_msk, t_sig_onset, method='ICA', n_comp=2, wavelet='Haar', autoselect='auto', whiten=True* **)**\n",
    "\n",
    "Return ROIs means filtered by Blind Source Separations (BSS) methods, estimated sources (components) of the observations, index of the selected source and estimated Signal-to-Noise Ratio in each ROI.\n",
    "\n",
    "Estimates noise power from inactive interval defined by *inactive_mask*. Then, applies a BSS method defined by *method* (with the wavelet filtering defined by *wavelet* if 'wPCA' or 'wICA' are chosen) and selects one or more components as representing the sources of the signal(s). Source selection can be manual or automatic. If auto, components are plotted and user must type source(s) number(s). If manual, source selection is done based on portions of the components that are higher than 2 times the noise standard deviation (only 1 source is selected when using *autoselect*='auto'). After that, inverse transformation is executed to rebuild the observations using just the selected source(s). Finally, signal power is calculated, as well as Signal-to-Noise Ratio (SNR) in each observation.\n",
    "\n",
    "**Parameters:**  \n",
    "- **ROIs_means_corrected: array**\n",
    "    - (F x R) array, where F are frames and R are ROI numbers. Also called observations.\n",
    "- **time: array**\n",
    "    - (F,) array, where F are time points.\n",
    "- **inactive_msk: boolean array**\n",
    "    - (F) boolean array, where F are frames.\n",
    "- **t_sig_onset: float**\n",
    "    - time instant (in seconds) when signal is supposed to start.\n",
    "- **method: string, optional**\n",
    "    - *PCA*, *ICA*, *wPCA* or *wICA*.\n",
    "- **n_comp: int, optional**\n",
    "    - Number of components to allocate estimated sources (same as *n_components* input in [FastICA](https://scikit-learn.org/stable/modules/generated/sklearn.decomposition.fastica.html#sklearn.decomposition.fastica) and [PCA](https://scikit-learn.org/stable/modules/generated/sklearn.decomposition.PCA.html#sklearn.decomposition.PCA)) except when n_comp=1, which means to separate into 2 components (minimum allowed by ICA or PCA) for later source selection (only 1 source is selected if autoselect='auto').\n",
    "- **wavelet: string, optional**\n",
    "    - string representing the wavelet to be used (same as in [Pywavelets](https://pywavelets.readthedocs.io/en/latest/ref/wavelets.html#wavelet-families)). Tested wavelets are 'dmey' and 'Haar'.\n",
    "- **autoselect: string, optional**\n",
    "    - string that determines whether source selection will be done manually (autoselect='manual') or automatically (autoselect='auto'). If 'auto', n_comp will always be 1, which means only one source is returned.\n",
    "- **whiten: bool, optional**\n",
    "    - defines if PCA should whiten data.\n",
    "    \n",
    "**Returns:** \n",
    "- **ROIs_means_filtered: array**\n",
    "    - (F x R) array, where F are frames and R are ROI numbers.\n",
    "- **components: array**\n",
    "    - (F x n_comp) array, where F are frames and n_comp is the number of components.\n",
    "- **selected_source_idx: int**\n",
    "    - index of the selected source.\n",
    "- **SNR_dB: array**\n",
    "    - (R,) array, where R are ROI numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "testing = (__name__ == \"__main__\")\n",
    "if testing:\n",
    "#     %matplotlib inline\n",
    "    import matplotlib.pyplot as plt\n",
    "    import matplotlib.image as mpimg\n",
    "    import numpy as np\n",
    "    import sys,os\n",
    "    bssdpath = os.path.abspath('')\n",
    "    if bssdpath not in sys.path:\n",
    "        sys.path.append(bssdpath)\n",
    "    items = os.listdir(bssdpath)\n",
    "    if 'MESS.py' not in items:\n",
    "        ! jupyter nbconvert --to 'python' MESS.ipynb\n",
    "    if 'Remove_Photobleaching.py' not in items:\n",
    "        ! jupyter nbconvert --to 'python' Remove_Photobleaching.ipynb\n",
    "    import MESS as mes\n",
    "    import Remove_Photobleaching as rpb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mandatory Parameters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "if testing:\n",
    "    from skimage import io\n",
    "    fpath = 'Data\\\\Cell1\\\\videos_AP'\n",
    "    fr = 55.78\n",
    "    \n",
    "    fname = 'vid1.tif'\n",
    "    fullpath = fpath + '\\\\' + fname\n",
    "    video = io.imread(fullpath)\n",
    "    \n",
    "    mname = 'cellmask.tif'\n",
    "    fullpath = fpath + '\\\\' + mname\n",
    "    mask = io.imread(fullpath)\n",
    "    \n",
    "    transitory=True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optional Parameters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "if testing:\n",
    "    t_sig_onset=0.5\n",
    "    t_sig_end=1\n",
    "    autoselect='manual'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Apply MESS and Remove_Photobleaching:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "if testing:\n",
    "    ROIs_masks, label_ROIs, ROIs_means, time  = mes.segment(mask,video, fr)\n",
    "    ROIs_means_corrected, inactive_msk,t_sig_onset,t_sig_end  = rpb.photob_remove(video,time, mask,ROIs_means,transitory,t_sig_onset,t_sig_end)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# BSSD functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_noise_power(ROIs_means_corrected,time,inactive_msk=None):\n",
    "    import numpy as np\n",
    "    nregions = ROIs_means_corrected.shape[1]\n",
    "    if np.any(inactive_msk)==None:\n",
    "        inactive_msk = np.ones_like(time,dtype=bool)\n",
    "    noise = np.zeros((nregions,))\n",
    "    for j in range(nregions):\n",
    "        #Get NOISE POWER\n",
    "        noise[j] = np.sum(np.square(abs(ROIs_means_corrected[inactive_msk,j])),axis=0)/(ROIs_means_corrected[inactive_msk,:].shape[0])\n",
    "    return(noise)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def guess_t_sig_active_time(sources, t_sig_onset_idx):\n",
    "    '''Returns indices of time vector later then t_sig_onset and when they are bigger than channel background noise'''\n",
    "    import numpy as np\n",
    "    noise_threshold = np.mean(sources[:t_sig_onset_idx,:],axis=0) + 2*np.std(sources[:t_sig_onset_idx,:],axis=0)\n",
    "    t_sig_active = np.empty_like(sources,dtype=bool)\n",
    "    for i in range(len(noise_threshold)):\n",
    "        t_sig_active[:,i] = np.where(sources[:,i]>noise_threshold[i],True,False)\n",
    "        t_sig_active[:t_sig_onset_idx,i] = False\n",
    "    return(noise_threshold, t_sig_active)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_signal_power(ROIs_means_corrected,time,inactive_msk=None):\n",
    "    import numpy as np\n",
    "    nregions = ROIs_means_corrected.shape[1]\n",
    "    if np.any(inactive_msk)==None:\n",
    "        inactive_msk = np.ones_like(time,dtype=bool)\n",
    "    active_mask = np.invert(inactive_msk)\n",
    "    #Get SIGNAL POWER\n",
    "    signal_power = np.sum(np.square(abs(ROIs_means_corrected[active_mask])),axis=0)/(len(active_mask))\n",
    "    return(signal_power)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def manual_select():\n",
    "    import numpy as np\n",
    "    nb = input('Enter one or more sources number (separate numbers by \",\" if number of sources > 1): ')\n",
    "    selected_source_idx = []\n",
    "    if nb.find(',')==-1: #Single source selected\n",
    "        try:\n",
    "            number = int(nb)\n",
    "            selected_source_idx.append(number)\n",
    "        except ValueError:\n",
    "            print(\"Invalid number\")\n",
    "    else:\n",
    "        nb = nb.replace(\" \",\"\")\n",
    "        commas_idx = []\n",
    "        import re\n",
    "        for m in re.finditer(',', nb):\n",
    "            commas_idx.append(m.start())\n",
    "        try:\n",
    "            number = int(nb[:commas_idx[0]])\n",
    "            selected_source_idx.append(number)\n",
    "            for i in range(len(commas_idx)):\n",
    "                if i==len(commas_idx)-1:\n",
    "                    number = int(nb[commas_idx[i]+1:])\n",
    "                else:\n",
    "                    number = int(nb[commas_idx[i]+1:commas_idx[i+1]])\n",
    "                selected_source_idx.append(number)\n",
    "        except ValueError:\n",
    "            print(\"Invalid number list\")\n",
    "    return(np.array(selected_source_idx))\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def wavelet_denoise(S, time, wave='dmey'):\n",
    "    import numpy as np\n",
    "    import pywt\n",
    "    from statsmodels.robust.scale import mad\n",
    "    w = pywt.Wavelet(wave)\n",
    "    shape = S.shape\n",
    "    n = shape[0]\n",
    "    #Denoise just one component\n",
    "    if len(shape)==1:\n",
    "        if (n%2!=0):\n",
    "            Y = np.zeros((n+1,))\n",
    "        else:\n",
    "            Y = np.zeros_like(S)\n",
    "        max_level = pywt.dwt_max_level(n, w)\n",
    "        coeff = pywt.wavedec(S, w, mode='periodization',level=max_level)\n",
    "\n",
    "        sigma = mad(coeff[-1])\n",
    "        K = np.sqrt(2*np.log(time.shape[0]))*sigma\n",
    "\n",
    "        coeff_T = []\n",
    "        for j in range(len(coeff)):\n",
    "            c = pywt.threshold(coeff[j], K, 'hard')\n",
    "            coeff_T.append(c)\n",
    "        Y = pywt.waverec(coeff_T, w ,mode='periodization')\n",
    "        if (n%2!=0):\n",
    "            Y = Y[:len(Y)-1]\n",
    "    return(Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def auto_select_signal(sources, time, t_sig_onset_idx):\n",
    "    import numpy as np\n",
    "    noise_threshold = 2*np.std(sources[:t_sig_onset_idx,:],axis=0)\n",
    "    t_sig_active = np.where(abs(sources-np.mean(sources[:t_sig_onset_idx,:],axis=0))>noise_threshold,True,False)\n",
    "    t_sig_active[:t_sig_onset_idx] = False\n",
    "    sources_abovenoise_power = np.empty((sources.shape[1],))\n",
    "    for i in range(sources.shape[1]):\n",
    "        active_idxs = get_longest_ones_seq_idx(t_sig_active[:,i])\n",
    "        if np.any(active_idxs)==None:\n",
    "            sources_abovenoise_power[i] = 0  \n",
    "        else:\n",
    "            sources_abovenoise_power[i] = np.sum(np.square(sources[active_idxs,i]))\n",
    "    sources_idx_sorted = np.argsort(sources_abovenoise_power)\n",
    "    sources_idx_sorted_inverse = sources_idx_sorted[::-1] #sorts from max to min\n",
    "    return(sources_idx_sorted_inverse)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_longest_ones_seq_idx(t_sig_active):\n",
    "    import numpy as np\n",
    "    ones_pos = np.nonzero(t_sig_active)[0]\n",
    "    if ones_pos.size==0:\n",
    "        return(None)\n",
    "    else:\n",
    "        d_ones_pos = np.diff(ones_pos)\n",
    "        d_ones_pos = np.insert(d_ones_pos,len(d_ones_pos),0)\n",
    "        seq=0\n",
    "        maxseq=0\n",
    "        for i in range(len(ones_pos)):\n",
    "            if d_ones_pos[i]==1:\n",
    "                seq+=1\n",
    "            else:\n",
    "                if ((seq+1)>maxseq):\n",
    "                    maxseq = seq+1\n",
    "                    pos = ones_pos[i] - seq\n",
    "                    pos_end = ones_pos[i]+1\n",
    "                seq = 0\n",
    "        longest_idxs = np.arange(pos,pos_end)\n",
    "    return(longest_idxs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Main Function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def denoise(ROIs_means_corrected,time,inactive_msk,t_sig_onset,method='ICA',n_comp=2,wavelet='Haar',autoselect='auto',whiten=True):\n",
    "    import numpy as np\n",
    "    import matplotlib.pyplot as plt\n",
    "    if n_comp==1:\n",
    "        n_comp=2\n",
    "        autoselect='auto'\n",
    "    \n",
    "    noise_power = get_noise_power(ROIs_means_corrected,time,inactive_msk=inactive_msk)\n",
    "    \n",
    "    if (method=='ICA') | (method=='wICA'):\n",
    "        from sklearn.decomposition import FastICA\n",
    "        bss = FastICA(n_components=n_comp,max_iter=2000,tol=0.01)\n",
    "    if (method=='PCA') | (method=='wPCA'):\n",
    "        from sklearn.decomposition import PCA\n",
    "        bss = PCA(n_components=n_comp,whiten=whiten)\n",
    "    t_sig_onset_idx = np.argmin(abs(time-t_sig_onset))\n",
    "    \n",
    "    components = bss.fit_transform(ROIs_means_corrected)  # Estimate sources\n",
    "    components_filt = np.zeros_like(components)\n",
    "    if autoselect=='auto':\n",
    "        sources_idx_sorted_inverse = auto_select_signal(components, time, t_sig_onset_idx)\n",
    "        selected_source_idx = sources_idx_sorted_inverse[0]\n",
    "    else:\n",
    "        plt.figure(figsize=[15,n_comp*2])\n",
    "        plt.title('Type source numbers that countain signal')\n",
    "        for i in range(n_comp):\n",
    "            plt.subplot(n_comp,1,i+1)\n",
    "            plt.plot(time,components[:,i])\n",
    "            plt.axvline(t_sig_onset,color='k',linestyle='--',alpha=0.3)\n",
    "            ymax = np.mean(components[inactive_msk,i]) + 2*np.std(components[inactive_msk,i])\n",
    "            ymin = np.mean(components[inactive_msk,i]) - 2*np.std(components[inactive_msk,i])\n",
    "            span = plt.axhspan(ymin=ymin,ymax=ymax,alpha=0.1,label='Noise CI95')\n",
    "            s = 'Source #'+str(i)\n",
    "            plt.ylabel(s,fontsize='large')\n",
    "            ymin = 1.8*np.amin(components[:,i])\n",
    "            ymax = 1.8*np.amax(components[:,i])\n",
    "            plt.ylim(ymin, ymax)\n",
    "            plt.legend(handles=[span],loc='upper right')\n",
    "        plt.show()\n",
    "        selected_source_idx = manual_select()\n",
    "        plt.close()\n",
    "    components_filt[:,selected_source_idx] = components[:,selected_source_idx]\n",
    "    selected_source_idx = np.atleast_1d(selected_source_idx)\n",
    "\n",
    "    if (method=='wPCA') | (method=='wICA'):\n",
    "        for i in range(np.size(selected_source_idx)):\n",
    "            components_filt[:,selected_source_idx[i]] = wavelet_denoise(components_filt[:,selected_source_idx[i]],time,wave=wavelet)\n",
    "    ROIs_means_filtered = bss.inverse_transform(components_filt)\n",
    "    ROIs_means_filtered = ROIs_means_filtered - np.median(ROIs_means_filtered[inactive_msk,:],axis=0)\n",
    "    \n",
    "    signal_power = get_signal_power(ROIs_means_filtered,time,inactive_msk)\n",
    "    \n",
    "    SNR = signal_power/noise_power\n",
    "    SNR_dB = np.zeros_like(SNR)\n",
    "    SNR_dB[SNR>0] = 10*np.log10(SNR[SNR>0])\n",
    "    \n",
    "    return(ROIs_means_filtered,components,selected_source_idx,SNR_dB)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter one or more sources number (separate numbers by \",\" if number of sources > 1): 0\n"
     ]
    }
   ],
   "source": [
    "if testing:\n",
    "    ROIs_means_filtered,components,selected_source_idx,SNR_dB = denoise(ROIs_means_corrected,time,inactive_msk,t_sig_onset,method='ICA',n_comp=2,wavelet='dmey',autoselect=autoselect)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Time of main function execution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.4 ms ± 283 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "if testing:\n",
    "    %timeit ROIs_means_filtered,components,selected_source_idx,SNR_dB = denoise(ROIs_means_corrected,time,inactive_msk,t_sig_onset,method='ICA',n_comp=2,wavelet='dmey',autoselect='auto')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "if testing:\n",
    "    nregions = np.amax(label_ROIs).astype(int)\n",
    "    ncolors = nregions\n",
    "    from matplotlib import cm\n",
    "    from matplotlib.colors import ListedColormap\n",
    "    brg = cm.get_cmap('brg', nregions)\n",
    "    newcolors = np.tile((np.arange(0,ncolors))/(ncolors-1),nregions//(ncolors-1))\n",
    "    newcolors = newcolors[:nregions]\n",
    "    newcolors = brg(newcolors)\n",
    "    black = np.array([0, 0, 0, 1])\n",
    "    newcolors = np.insert(newcolors,0,black,axis=0)\n",
    "    newcmp = ListedColormap(newcolors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "if testing:\n",
    "    fig, ax1 = plt.subplots(figsize=[15,5])\n",
    "    for i in range(nregions):\n",
    "        ax1.plot(time,ROIs_means_filtered[:,i],color=newcolors[i+1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Signal-to-Noise Ratio:\n",
      " [ -1.56258601  -8.114154    -6.93879319  -9.75810273  -4.5334674\n",
      "  -8.2366414  -18.20804492  -7.78777329  -5.4313694  -11.57397825\n",
      "  -8.73639673  -3.18183032  -7.0738015   -1.69845836  -6.30645372\n",
      "  -9.4648783   -5.43335844  -1.20409924  -2.79920424  -0.06542616\n",
      "  -0.11296821  -2.57787561  -1.69184026  -5.34092841  -6.79923808\n",
      "  -8.41517151  -3.99045085  -1.61041264  -0.15079158  -2.47607509\n",
      "  -0.43103385  -4.56057309] dB\n"
     ]
    }
   ],
   "source": [
    "if testing:\n",
    "    print('Signal-to-Noise Ratio:\\n',SNR_dB,'dB')"
   ]
  },
  {
   "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}