BLAST_CelltypeDeconvolution.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import os\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib as mpl\n",
    "from matplotlib import rcParams\n",
    "import pandas as pd\n",
    "import scanpy as sc\n",
    "import numpy as np\n",
    "from scipy.spatial.distance import jensenshannon\n",
    "from scipy.stats import pearsonr,ttest_ind,mannwhitneyu\n",
    "from sklearn.metrics import mean_squared_error\n",
    "rcParams['pdf.fonttype'] = 42\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Import Pacakages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "sys.path.append('./')\n",
    "import Benchmarking.DeconvolutionSpot as DeconvolutionSpot\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Predicting cell type deconvolution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Please note: In this result, we used tangram function 'tg.project_cell_annotations' as deconvolution result;\n",
    "### you can also use function 'tg.count_cell_annotations' to deconvolute the spots."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Please install the version described in README.md file. We will update the code for new version tools."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "### please add the your SpatialBenchmarking dir into the python path \n",
    "sys.path.append('./')\n",
    "import Benchmarking.DeconvolutionSpot as DeconvolutionSpot\n",
    "\n",
    "### for Cell2location, Stereoscope, Tangram, DestVI, you must have .h5ad files as input.\n",
    "\n",
    "RNA_h5ad = 'ExampleData/Simulated_STARmap/starmap_sc_rna.h5ad'\n",
    "Spatial_h5ad = 'ExampleData/Simulated_STARmap/starmap_spatial.h5ad'\n",
    "celltype_key = 'celltype'\n",
    "output_path = 'FigureData/Figure4/Dataset10_STARmap/Result_STARmap/'\n",
    "if not os.path.exists(output_path):\n",
    "    os.mkdir(output_path)\n",
    "\n",
    "test = DeconvolutionSpot.Deconvolutions(RNA_h5ad = RNA_h5ad, Spatial_h5ad = Spatial_h5ad, celltype_key = celltype_key, output_path = output_path)\n",
    "Methods = ['Cell2location', 'Stereoscope','Tangram', 'DestVI']\n",
    "Result = test.Dencon(Methods)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "sys.path.append('./')\n",
    "import Benchmarking.DeconvolutionSpot as DeconvolutionSpot\n",
    "### for SpatialDWLS, RCTD, Seurat, SPOTlight, you must have .h5seurat files as input.\n",
    "### for SpatialDWLS, you must add my_python_path.\n",
    "\n",
    "RNA_h5Seurat = 'ExampleData/Simulated_STARmap/starmap_sc_rna.h5seurat'\n",
    "Spatial_h5Seurat = 'ExampleData/Simulated_STARmap/starmap_spatial.h5seurat'\n",
    "celltype_key = 'celltype'\n",
    "my_python_path = '/home/qukun/xuhao/miniconda3/envs/cellpymc/bin/python'\n",
    "output_path = 'FigureData/Figure4/Dataset10_STARmap/Result_STARmap/'\n",
    "if not os.path.exists(output_path):\n",
    "    os.mkdir(output_path)\n",
    "\n",
    "# set the parameter k.filter=50=30 when use Seurat\n",
    "test = DeconvolutionSpot.Deconvolutions(RNA_h5Seurat = RNA_h5Seurat, Spatial_h5Seurat = Spatial_h5Seurat, celltype_key = celltype_key, python_path = my_python_path, output_path = output_path)\n",
    "Methods = ['SpatialDWLS','RCTD', 'Seurat', 'SPOTlight']\n",
    "Result = test.Dencon(Methods)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sys.path.append('./')\n",
    "import Benchmarking.DeconvolutionSpot as DeconvolutionSpot\n",
    "\n",
    "### for STRIDE, have count matrix files as input.\n",
    "\n",
    "RNA_file = 'ExampleData/Simulated_STARmap/starmap_sc_rna.tsv'\n",
    "Spatial_file = 'ExampleData/Simulated_STARmap/starmap_spatial.tsv'\n",
    "celltype_file = 'ExampleData/Simulated_STARmap/starmap_sc_rna_celltype.tsv'\n",
    "output_path = 'FigureData/Figure4/Dataset10_STARmap/Result_STARmap/'\n",
    "if not os.path.exists(output_path):\n",
    "    os.mkdir(output_path)\n",
    "\n",
    "test = DeconvolutionSpot.Deconvolutions(RNA_file = RNA_file, Spatial_file = Spatial_file, celltype_file = celltype_file, output_path = output_path)\n",
    "Methods = ['STRIDE']\n",
    "Result = test.Dencon(Methods)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SpaOTsc, novoSpaRc, Tangram result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "sc_rna_meta = pd.read_csv('FigureData/Figure4/Dataset10_STARmap/Rawdata/starmap_sc_rna_celltype.tsv', sep = '\\t', header = None, index_col = 0)\n",
    "\n",
    "tangram_results = pd.read_csv('FigureData/Figure4/Dataset10_STARmap/Result_STARmap/Tangram_result.txt',index_col=0)\n",
    "tangram_results = tangram_results.loc[:,np.unique(tangram_results.columns)]\n",
    "\n",
    "spa_map = np.load('FigureData/Figure4/Dataset10_STARmap/Result_STARmap/SpaOTsc_alignment.npy')\n",
    "spa_results=pd.DataFrame(np.zeros((spa_map.shape[1],len(np.unique(sc_rna_meta[1])))),columns=np.unique(sc_rna_meta[1]))\n",
    "spa_pro_results = pd.DataFrame(np.zeros((len(spa_results.index), len(np.unique(spa_results.columns)))),columns=np.unique(spa_results.columns))\n",
    "for i,l in enumerate(np.argmax(spa_map, axis=1)):\n",
    "    spa_results.loc[l,sc_rna_meta.iloc[i,0]] += 1\n",
    "\n",
    "novo_map = np.load('FigureData/Figure4/Dataset10_STARmap/Result_STARmap/novoSpaRc_alignment.npy')\n",
    "novo_results=pd.DataFrame(np.zeros((novo_map.shape[1],len(np.unique(sc_rna_meta[1])))),columns=np.unique(sc_rna_meta[1]))\n",
    "novo_pro_results = pd.DataFrame(np.zeros((len(novo_results.index), len(np.unique(novo_results.columns)))),columns=np.unique(novo_results.columns))\n",
    "for i,l in enumerate(np.argmax(novo_map, axis=1)):\n",
    "    novo_results.loc[l,sc_rna_meta.iloc[i,0]] += 1\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cell2location, RCTD, Seurat, Stereoscope, SPOTlight, SpatialDWLS, DestVI, DSTG, STRIDE result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "cell2loc_results = pd.read_csv('FigureData/Figure4/Dataset10_STARmap/Result_STARmap/Cell2location_result.txt',index_col=0)\n",
    "cell2loc_results.index = np.arange(len(cell2loc_results))\n",
    "cell2loc_results.columns = [c.split('q05cell_abundance_w_sf_')[1] for c in cell2loc_results.columns]\n",
    "cell2loc_results = cell2loc_results.loc[:,np.unique(cell2loc_results.columns)]\n",
    "\n",
    "RCTD_results = pd.read_csv('FigureData/Figure4/Dataset10_STARmap/Result_STARmap/RCTD_result.txt',index_col=0)\n",
    "RCTD_results.index = np.arange(len(RCTD_results))\n",
    "RCTD_results = RCTD_results.loc[:,np.unique(RCTD_results.columns)]\n",
    "RCTD_results.columns = tangram_results.columns\n",
    "\n",
    "spatialdwls_results = pd.read_csv('FigureData/Figure4/Dataset10_STARmap/Result_STARmap/SpatialDWLS_result.txt',index_col=0)\n",
    "spatialdwls_results.index = np.arange(len(spatialdwls_results))\n",
    "spatialdwls_results = spatialdwls_results.iloc[:,1:]\n",
    "spatialdwls_results = spatialdwls_results.loc[:,np.unique(spatialdwls_results.columns)]\n",
    "\n",
    "stereo_results = pd.read_csv('FigureData/Figure4/Dataset10_STARmap/Result_STARmap/Stereoscope_result.txt',index_col=0)\n",
    "stereo_results.index = np.arange(len(stereo_results))\n",
    "stereo_results = stereo_results.loc[:,np.unique(stereo_results.columns)]\n",
    "stereo_results.columns = tangram_results.columns\n",
    "stereo_results = (stereo_results.T/stereo_results.sum(axis=1)).T\n",
    "stereo_results = stereo_results.fillna(0)\n",
    "\n",
    "destvi_results = pd.read_csv('FigureData/Figure4/Dataset10_STARmap/Result_STARmap/DestVI_result.txt',index_col=0)\n",
    "destvi_results.index = np.arange(len(destvi_results))\n",
    "destvi_results = destvi_results.loc[:,np.unique(destvi_results.columns)]\n",
    "destvi_results.columns = tangram_results.columns\n",
    "destvi_results = (destvi_results.T/destvi_results.sum(axis=1)).T\n",
    "destvi_results = destvi_results.fillna(0)\n",
    "\n",
    "spotlight_results = pd.read_csv('FigureData/Figure4/Dataset10_STARmap/Result_STARmap/SPOTlight_result.txt',index_col=0)\n",
    "spotlight_results.index = np.arange(len(spotlight_results))\n",
    "spotlight_results = spotlight_results.loc[:,np.unique(spotlight_results.columns)]\n",
    "spotlight_results.columns = tangram_results.columns\n",
    "spotlight_results = (spotlight_results.T/spotlight_results.sum(axis=1)).T\n",
    "spotlight_results = spotlight_results.fillna(0)\n",
    "\n",
    "stride_results = pd.read_csv('FigureData/Figure4/Dataset10_STARmap/Result_STARmap/STRIDE_result.txt',index_col=0,sep='\\t')\n",
    "stride_results.index = np.arange(len(stride_results))\n",
    "stride_results = stride_results.loc[:,np.unique(stride_results.columns)]\n",
    "stride_results.columns = tangram_results.columns\n",
    "stride_results = (stride_results.T/stride_results.sum(axis=1)).T\n",
    "stride_results = stride_results.fillna(0)\n",
    "\n",
    "seurat_results = pd.read_csv('FigureData/Figure4/Dataset10_STARmap/Result_STARmap/Seurat_result.txt',index_col=0)\n",
    "seurat_results = seurat_results.iloc[:,1:-1]\n",
    "seurat_results = seurat_results.loc[:,np.unique(seurat_results.columns)]\n",
    "seurat_results.columns = tangram_results.columns\n",
    "\n",
    "def get_dstg_results(results_path,celltype=None):\n",
    "    results = pd.read_csv(results_path + '/DSTG_result.txt',sep=',',header=None)\n",
    "    label = pd.read_csv(results_path + '/Label.csv',sep=',')\n",
    "    results.columns = label.columns\n",
    "    if celltype is not None:\n",
    "        results.loc[:,np.setdiff1d(celltype,results.columns)] = 0\n",
    "    results = results.loc[:,np.unique(results.columns)]\n",
    "    return results\n",
    "dstg_results = get_dstg_results('FigureData/Figure4/Dataset10_STARmap/Result_STARmap/')\n",
    "dstg_results.columns = tangram_results.columns\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "tangram_results = (tangram_results.T/tangram_results.sum(axis=1)).T\n",
    "seurat_results = (seurat_results.T/seurat_results.sum(axis=1)).T\n",
    "cell2loc_results = (cell2loc_results.T/cell2loc_results.sum(axis=1)).T\n",
    "novo_results = (novo_results.T/novo_results.sum(axis=1)).T\n",
    "spa_results = (spa_results.T/spa_results.sum(axis=1)).T\n",
    "\n",
    "tangram_results = tangram_results.fillna(0)\n",
    "seurat_results = seurat_results.fillna(0)\n",
    "cell2loc_results = cell2loc_results.fillna(0)\n",
    "novo_results = novo_results.fillna(0)\n",
    "spa_results = spa_results.fillna(0)\n",
    "\n",
    "tangram_results = tangram_results.drop(columns=['Other','Neuron Other','Inhibitory Other'])\n",
    "seurat_results = seurat_results.drop(columns=['Other','Neuron Other','Inhibitory Other'])\n",
    "RCTD_results = RCTD_results.drop(columns=['Other','Neuron Other','Inhibitory Other'])\n",
    "cell2loc_results = cell2loc_results.drop(columns=['Other','Neuron Other','Inhibitory Other'])\n",
    "stereo_results = stereo_results.drop(columns=['Other','Neuron Other','Inhibitory Other'])\n",
    "destvi_results = destvi_results.drop(columns=['Other','Neuron Other','Inhibitory Other'])\n",
    "spotlight_results = spotlight_results.drop(columns=['Other','Neuron Other','Inhibitory Other'])\n",
    "spatialdwls_results = spatialdwls_results.drop(columns=['Other','Neuron Other','Inhibitory Other'])\n",
    "dstg_results = dstg_results.drop(columns=['Other','Neuron Other','Inhibitory Other'])\n",
    "stride_results = stride_results.drop(columns=['Other','Neuron Other','Inhibitory Other'])\n",
    "novo_results = novo_results.drop(columns=['Other','Neuron Other','Inhibitory Other'])\n",
    "spa_results = spa_results.drop(columns=['Other','Neuron Other','Inhibitory Other'])\n",
    "\n",
    "gd_results = pd.read_table('FigureData/Figure4/Dataset10_STARmap/Simulated_STARmap/combined_spot_clusters.txt', sep = '\\t', header = 0, index_col = 0)\n",
    "gd_results.columns = ['Astro', 'Endo', 'Excitatory L2/3', 'Excitatory L4', 'Excitatory L5', 'Excitatory L6', 'HPC', 'Micro', 'Npy'\n",
    "                     , 'Olig', 'Other', 'Inhibitory Pvalb', 'Smc', 'Inhibitory Sst', 'Inhibitory Vip']\n",
    "gd_results = (gd_results.T/gd_results.sum(axis=1)).T\n",
    "\n",
    "gd_results = gd_results.drop(columns=['Other','Npy', 'HPC'])\n",
    "gd_results = gd_results.loc[:,np.unique(gd_results.columns)]\n",
    "\n",
    "gd_results = gd_results.fillna(0)\n",
    "\n",
    "gd_loc = pd.read_csv('FigureData/Figure4/Dataset10_STARmap/Simulated_STARmap/combined_Locations.txt',sep='\\t')\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plot celltype distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_starmap_celltype(celltype=None,celltype_ind=None,save=None,return_fig=False):\n",
    "    if celltype is not None:\n",
    "        celltype_ind = np.where(celltype == tangram_results.columns)[0]\n",
    "    elif celltype_ind is not None:\n",
    "        celltype = tangram_results.columns[celltype_ind]\n",
    "    else:\n",
    "        raise Error('error')\n",
    "    print(celltype)\n",
    "    c_ind = celltype_ind\n",
    "    fig,axes = plt.subplots(ncols=13,nrows=1,figsize=(62,8.0))\n",
    "    # fig.tight_layout()\n",
    "    axes[0].scatter(x=gd_loc['x'],y=gd_loc['y'],c=gd_results.iloc[:,c_ind],s=500,marker='s')\n",
    "    axes[0].scatter(x=5,y=18,c=0,s=500,marker='s')\n",
    "    axes[0].set_xlim(-0.5,9.5)\n",
    "    axes[0].set_ylim(-0.5,18.5)\n",
    "    axes[0].axis('off')\n",
    "    axes[0].set_title('Ground Truth')\n",
    "\n",
    "    axes[1].scatter(x=gd_loc['x'],y=gd_loc['y'],c=cell2loc_results.iloc[:,c_ind],s=500,marker='s')\n",
    "    axes[1].scatter(x=5,y=18,c=0,s=500,marker='s',)\n",
    "    axes[1].set_xlim(-0.5,9.5)\n",
    "    axes[1].set_ylim(-0.5,18.5)\n",
    "    axes[1].axis('off')\n",
    "    axes[1].set_title('Cell2location')\n",
    "\n",
    "    axes[2].scatter(x=gd_loc['x'],y=gd_loc['y'],c=spatialdwls_results.iloc[:,c_ind],s=500,marker='s')\n",
    "    axes[2].scatter(x=5,y=18,c=0,s=500,marker='s',)\n",
    "    axes[2].set_xlim(-0.5,9.5)\n",
    "    axes[2].set_ylim(-0.5,18.5)\n",
    "    axes[2].axis('off')\n",
    "    axes[2].set_title('SpatialDWLS')\n",
    "\n",
    "    axes[3].scatter(x=gd_loc['x'],y=gd_loc['y'],c=RCTD_results.iloc[:,c_ind],s=500,marker='s')\n",
    "    axes[3].scatter(x=5,y=18,c=0,s=500,marker='s',)\n",
    "    axes[3].set_xlim(-0.5,9.5)\n",
    "    axes[3].set_ylim(-0.5,18.5)\n",
    "    axes[3].axis('off')\n",
    "    axes[3].set_title('RCTD')\n",
    "\n",
    "    axes[4].scatter(x=gd_loc['x'],y=gd_loc['y'],c=stride_results.iloc[:,c_ind],s=500,marker='s')\n",
    "    axes[4].scatter(x=5,y=18,c=0,s=500,marker='s',)\n",
    "    axes[4].set_xlim(-0.5,9.5)\n",
    "    axes[4].set_ylim(-0.5,18.5)\n",
    "    axes[4].axis('off')\n",
    "    axes[4].set_title('STRIDE')\n",
    "\n",
    "    axes[5].scatter(x=gd_loc['x'],y=gd_loc['y'],c=stereo_results.iloc[:,c_ind],s=500,marker='s')\n",
    "    axes[5].scatter(x=5,y=18,c=0,s=500,marker='s',)\n",
    "    axes[5].set_xlim(-0.5,9.5)\n",
    "    axes[5].set_ylim(-0.5,18.5)\n",
    "    axes[5].axis('off')\n",
    "    axes[5].set_title('Stereoscope')\n",
    "\n",
    "    axes[6].scatter(x=gd_loc['x'],y=gd_loc['y'],c=tangram_results.iloc[:,c_ind],s=500,marker='s')\n",
    "    axes[6].scatter(x=5,y=18,c=0,s=500,marker='s',)\n",
    "    axes[6].set_xlim(-0.5,9.5)\n",
    "    axes[6].set_ylim(-0.5,18.5)\n",
    "    axes[6].axis('off')\n",
    "    axes[6].set_title('Tangram')\n",
    "\n",
    "    axes[7].scatter(x=gd_loc['x'],y=gd_loc['y'],c=destvi_results.iloc[:,c_ind],s=500,marker='s')\n",
    "    axes[7].scatter(x=5,y=18,c=0,s=500,marker='s',)\n",
    "    axes[7].set_xlim(-0.5,9.5)\n",
    "    axes[7].set_ylim(-0.5,18.5)\n",
    "    axes[7].axis('off')\n",
    "    axes[7].set_title('DestVI')\n",
    "\n",
    "    axes[8].scatter(x=gd_loc['x'],y=gd_loc['y'],c=seurat_results.iloc[:,c_ind],s=500,marker='s')\n",
    "    axes[8].scatter(x=5,y=18,c=0,s=500,marker='s',)\n",
    "    axes[8].set_xlim(-0.5,9.5)\n",
    "    axes[8].set_ylim(-0.5,18.5)\n",
    "    axes[8].axis('off')\n",
    "    axes[8].set_title('Seurat')\n",
    "\n",
    "    axes[9].scatter(x=gd_loc['x'],y=gd_loc['y'],c=spotlight_results.iloc[:,c_ind],s=500,marker='s')\n",
    "    axes[9].scatter(x=5,y=18,c=0,s=500,marker='s',)\n",
    "    axes[9].set_xlim(-0.5,9.5)\n",
    "    axes[9].set_ylim(-0.5,18.5)\n",
    "    axes[9].axis('off')\n",
    "    axes[9].set_title('SPOTlight')\n",
    "    \n",
    "    axes[10].scatter(x=gd_loc['x'],y=gd_loc['y'],c=dstg_results.iloc[:,c_ind],s=500,marker='s')\n",
    "    axes[10].scatter(x=5,y=18,c=0,s=500,marker='s',)\n",
    "    axes[10].set_xlim(-0.5,9.5)\n",
    "    axes[10].set_ylim(-0.5,18.5)\n",
    "    axes[10].axis('off')\n",
    "    axes[10].set_title('DSTG')\n",
    "    \n",
    "    axes[11].scatter(x=gd_loc['x'],y=gd_loc['y'],c=spa_results.iloc[:,c_ind],s=500,marker='s')\n",
    "    axes[11].scatter(x=5,y=18,c=0,s=500,marker='s',)\n",
    "    axes[11].set_xlim(-0.5,9.5)\n",
    "    axes[11].set_ylim(-0.5,18.5)\n",
    "    axes[11].axis('off')\n",
    "    axes[11].set_title('SpaOTsc')\n",
    "    \n",
    "    axes[12].scatter(x=gd_loc['x'],y=gd_loc['y'],c=novo_results.iloc[:,c_ind],s=500,marker='s')\n",
    "    axes[12].scatter(x=5,y=18,c=0,s=500,marker='s',)\n",
    "    axes[12].set_xlim(-0.5,9.5)\n",
    "    axes[12].set_ylim(-0.5,18.5)\n",
    "    axes[12].axis('off')\n",
    "    axes[12].set_title('novoSpaRc')\n",
    "    if save is not None:\n",
    "        plt.savefig(save,bbox_inches='tight',dpi=300)\n",
    "    if not return_fig:\n",
    "        plt.show()\n",
    "    else:\n",
    "        plt.close()\n",
    "        return fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Excitatory L2/3\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 4464x576 with 13 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Excitatory L4\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 4464x576 with 13 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Excitatory L5\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 4464x576 with 13 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Excitatory L6\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 4464x576 with 13 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_starmap_celltype(celltype_ind=2,save=os.path.join('FigureData/Figure4/Dataset10_STARmap/Result_STARmap/','starmap_Excitatory_L2_3.pdf'))\n",
    "plot_starmap_celltype(celltype_ind=3,save=os.path.join('FigureData/Figure4/Dataset10_STARmap/Result_STARmap/','starmap_Excitatory_L4.pdf'))\n",
    "plot_starmap_celltype(celltype_ind=4,save=os.path.join('FigureData/Figure4/Dataset10_STARmap/Result_STARmap/','starmap_Excitatory_L5.pdf'))\n",
    "plot_starmap_celltype(celltype_ind=5,save=os.path.join('FigureData/Figure4/Dataset10_STARmap/Result_STARmap/','starmap_Excitatory_L6.pdf'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ssim(im1,im2,M=1):\n",
    "    im1, im2 = im1/im1.max(), im2/im2.max()\n",
    "    mu1 = im1.mean()\n",
    "    mu2 = im2.mean()\n",
    "    sigma1 = np.sqrt(((im1 - mu1) ** 2).mean())\n",
    "    sigma2 = np.sqrt(((im2 - mu2) ** 2).mean())\n",
    "    sigma12 = ((im1 - mu1) * (im2 - mu2)).mean()\n",
    "    k1, k2, L = 0.01, 0.03, M\n",
    "    C1 = (k1*L) ** 2\n",
    "    C2 = (k2*L) ** 2\n",
    "    C3 = C2/2\n",
    "    l12 = (2*mu1*mu2 + C1)/(mu1 ** 2 + mu2 ** 2 + C1)\n",
    "    c12 = (2*sigma1*sigma2 + C2)/(sigma1 ** 2 + sigma2 ** 2 + C2)\n",
    "    s12 = (sigma12 + C3)/(sigma1*sigma2 + C3)\n",
    "    ssim = l12 * c12 * s12\n",
    "    return ssim\n",
    "\n",
    "def rmse(x1,x2):\n",
    "    return mean_squared_error(x1,x2,squared=False)\n",
    "def mae(x1,x2):\n",
    "    return np.mean(np.abs(x1-x2))\n",
    "\n",
    "from collections.abc import Iterable\n",
    "def compare_results(gd,result_list,metric='pcc',columns=None,axis=1):\n",
    "    if metric=='pcc':\n",
    "        func = pearsonr\n",
    "        r_ind = 0\n",
    "    if metric=='mae':\n",
    "        func = mae\n",
    "        r_ind = None\n",
    "    if metric=='jsd':\n",
    "        func = jensenshannon\n",
    "        r_ind = None\n",
    "    if metric=='rmse':\n",
    "        func = rmse\n",
    "        r_ind = None\n",
    "    if metric=='ssim':\n",
    "        func = ssim\n",
    "        r_ind = None\n",
    "    if isinstance(result_list, pd.DataFrame):\n",
    "        c_list = []\n",
    "        if axis == 1:\n",
    "            print('axis: ',1)\n",
    "            for i,c in enumerate(gd.columns):\n",
    "                r = func(gd.iloc[:,i].values, np.clip(result_list.iloc[:,i],0,1))\n",
    "                if isinstance(result_list, Iterable):\n",
    "                    if r_ind is not None:\n",
    "                        r = r[r_ind]\n",
    "                c_list.append(r)\n",
    "        else:\n",
    "            print('axis: ',0)\n",
    "            for i,c in enumerate(gd.index):\n",
    "                r = func(gd.iloc[i,:].values, np.clip(result_list.iloc[i,:],0,1))\n",
    "                if isinstance(result_list, Iterable):\n",
    "                    if r_ind is not None:\n",
    "                        r = r[r_ind]\n",
    "                c_list.append(r)\n",
    "        df = pd.DataFrame(c_list,index=gd.columns,columns=columns)\n",
    "    else:\n",
    "        df_list = []\n",
    "        for res in result_list:\n",
    "            c_list = []\n",
    "            if axis == 1:\n",
    "                for i,c in enumerate(gd.columns):\n",
    "                    r = func(gd.iloc[:,i].values, np.clip(res.iloc[:,i],0,1))\n",
    "                    if isinstance(res, Iterable):\n",
    "                        if r_ind is not None:\n",
    "                            r = r[r_ind]\n",
    "                    c_list.append(r)\n",
    "                df_tmp = pd.DataFrame(c_list,index=gd.columns)\n",
    "            else:\n",
    "                for i,c in enumerate(gd.index):\n",
    "                    r = func(gd.iloc[i,:].values, np.clip(res.iloc[i,:],0,1))\n",
    "                    if isinstance(res, Iterable):\n",
    "                        if r_ind is not None:\n",
    "                            r = r[r_ind]\n",
    "                    c_list.append(r)\n",
    "                df_tmp = pd.DataFrame(c_list,index=gd.index)\n",
    "            df_list.append(df_tmp)\n",
    "        df = pd.concat(df_list,axis=1)\n",
    "        df.columns = columns\n",
    "    return df\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/qukun/wen2017/.local/lib/python3.6/site-packages/scipy/stats/stats.py:3845: PearsonRConstantInputWarning: An input array is constant; the correlation coefficent is not defined.\n",
      "  warnings.warn(PearsonRConstantInputWarning())\n",
      "/home/qukun/wen2017/miniconda2/envs/Py3/lib/python3.6/site-packages/ipykernel_launcher.py:2: RuntimeWarning: invalid value encountered in true_divide\n",
      "  \n",
      "/home/qukun/wen2017/.local/lib/python3.6/site-packages/scipy/spatial/distance.py:1279: RuntimeWarning: invalid value encountered in true_divide\n",
      "  p = p / np.sum(p, axis=0)\n",
      "/home/qukun/wen2017/.local/lib/python3.6/site-packages/scipy/spatial/distance.py:1280: RuntimeWarning: invalid value encountered in true_divide\n",
      "  q = q / np.sum(q, axis=0)\n"
     ]
    }
   ],
   "source": [
    "starmap_spots_pcc = compare_results(\n",
    "    gd_results,\n",
    "    [RCTD_results,cell2loc_results,tangram_results,seurat_results,stereo_results,spotlight_results,spatialdwls_results,destvi_results,dstg_results,stride_results,spa_results,novo_results],\n",
    "    columns = ['RCTD','Cell2location','Tangram','Seurat','Stereoscope','SPOTlight','SpatialDWLS','DestVI','DSTG','STRIDE','SpaOTsc','NovoSparc'],\n",
    "    axis=0,\n",
    "    metric='pcc'\n",
    ")\n",
    "starmap_clusters_pcc = compare_results(\n",
    "    gd_results,\n",
    "    [RCTD_results,cell2loc_results,tangram_results,seurat_results,stereo_results,spotlight_results,spatialdwls_results,destvi_results,dstg_results,stride_results,spa_results,novo_results],\n",
    "    columns = ['RCTD','Cell2location','Tangram','Seurat','Stereoscope','SPOTlight','SpatialDWLS','DestVI','DSTG','STRIDE','SpaOTsc','NovoSparc'],\n",
    "    axis=1,\n",
    "    metric='pcc'\n",
    ")\n",
    "starmap_spots_ssim = compare_results(\n",
    "    gd_results,\n",
    "    [RCTD_results,cell2loc_results,tangram_results,seurat_results,stereo_results,spotlight_results,spatialdwls_results,destvi_results,dstg_results,stride_results,spa_results,novo_results],\n",
    "    columns = ['RCTD','Cell2location','Tangram','Seurat','Stereoscope','SPOTlight','SpatialDWLS','DestVI','DSTG','STRIDE','SpaOTsc','NovoSparc'],\n",
    "    axis=0,\n",
    "    metric='ssim'\n",
    ")\n",
    "starmap_clusters_ssim = compare_results(\n",
    "    gd_results,\n",
    "    [RCTD_results,cell2loc_results,tangram_results,seurat_results,stereo_results,spotlight_results,spatialdwls_results,destvi_results,dstg_results,stride_results,spa_results,novo_results],\n",
    "    columns = ['RCTD','Cell2location','Tangram','Seurat','Stereoscope','SPOTlight','SpatialDWLS','DestVI','DSTG','STRIDE','SpaOTsc','NovoSparc'],\n",
    "    axis=1,\n",
    "    metric='ssim'\n",
    ")\n",
    "starmap_spots_rmse = compare_results(\n",
    "    gd_results,\n",
    "    [RCTD_results,cell2loc_results,tangram_results,seurat_results,stereo_results,spotlight_results,spatialdwls_results,destvi_results,dstg_results,stride_results,spa_results,novo_results],\n",
    "    columns = ['RCTD','Cell2location','Tangram','Seurat','Stereoscope','SPOTlight','SpatialDWLS','DestVI','DSTG','STRIDE','SpaOTsc','NovoSparc'],\n",
    "    axis=0,\n",
    "    metric='rmse'\n",
    ")\n",
    "starmap_clusters_rmse = compare_results(\n",
    "    gd_results,\n",
    "    [RCTD_results,cell2loc_results,tangram_results,seurat_results,stereo_results,spotlight_results,spatialdwls_results,destvi_results,dstg_results,stride_results,spa_results,novo_results],\n",
    "    columns = ['RCTD','Cell2location','Tangram','Seurat','Stereoscope','SPOTlight','SpatialDWLS','DestVI','DSTG','STRIDE','SpaOTsc','NovoSparc'],\n",
    "    axis=1,\n",
    "    metric='rmse'\n",
    ")\n",
    "starmap_spots_jsd = compare_results(\n",
    "    gd_results,\n",
    "    [RCTD_results,cell2loc_results,tangram_results,seurat_results,stereo_results,spotlight_results,spatialdwls_results,destvi_results,dstg_results,stride_results,spa_results,novo_results],\n",
    "    columns = ['RCTD','Cell2location','Tangram','Seurat','Stereoscope','SPOTlight','SpatialDWLS','DestVI','DSTG','STRIDE','SpaOTsc','NovoSparc'],\n",
    "    axis=0,\n",
    "    metric='jsd'\n",
    ")\n",
    "starmap_clusters_jsd = compare_results(\n",
    "    gd_results,\n",
    "    [RCTD_results,cell2loc_results,tangram_results,seurat_results,stereo_results,spotlight_results,spatialdwls_results,destvi_results,dstg_results,stride_results,spa_results,novo_results],\n",
    "    columns = ['RCTD','Cell2location','Tangram','Seurat','Stereoscope','SPOTlight','SpatialDWLS','DestVI','DSTG','STRIDE','SpaOTsc','NovoSparc'],\n",
    "    axis=1,\n",
    "    metric='jsd'\n",
    ")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x504 with 8 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig,axes = plt.subplots(ncols=4,nrows=2,figsize=(12,7))\n",
    "order = ['Cell2location','SpatialDWLS','RCTD','STRIDE','Stereoscope','Tangram','DestVI', 'Seurat', 'SPOTlight','DSTG','SpaOTsc','NovoSparc']\n",
    "colors = [\"#9de846\", '#F9EC31', \"#BBA8D1\",\"#D6DE23\", \"#7BD1F1\", \"#F5A8C7\",  \"#A2CBCF\", \"#988DC3\", \"#79c06e\",'#00CED1']\n",
    "sns.boxplot(data=starmap_spots_pcc,order=order,palette=colors,ax=axes[0,0],orient='h', showfliers = False,showmeans=True)\n",
    "axes[0,0].set_title('PCC of locations')\n",
    "sns.boxplot(data=starmap_spots_ssim,order=order,palette=colors,ax=axes[0,1],orient='h', showfliers = False,showmeans=True)\n",
    "axes[0,1].set_title('SSIM of locations')\n",
    "sns.boxplot(data=starmap_spots_rmse,order=order,palette=colors,ax=axes[0,2],orient='h', showfliers = False,showmeans=True)\n",
    "axes[0,2].set_title('RMSE of locations')\n",
    "sns.boxplot(data=starmap_spots_jsd,order=order,palette=colors,ax=axes[0,3],orient='h', showfliers = False,showmeans=True)\n",
    "axes[0,3].set_title('JSD of locations')\n",
    "\n",
    "sns.boxplot(data=starmap_clusters_pcc,order=order,palette=colors,ax=axes[1,0],orient='h', showfliers = False,showmeans=True)\n",
    "axes[1,0].set_title('PCC of clusters')\n",
    "sns.boxplot(data=starmap_clusters_ssim,order=order,palette=colors,ax=axes[1,1],orient='h', showfliers = False,showmeans=True)\n",
    "axes[1,1].set_title('SSIM of clusters')\n",
    "sns.boxplot(data=starmap_clusters_rmse,order=order,palette=colors,ax=axes[1,2],orient='h', showfliers = False,showmeans=True)\n",
    "axes[1,2].set_title('RMSE of clusters')\n",
    "sns.boxplot(data=starmap_clusters_jsd,order=order,palette=colors,ax=axes[1,3],orient='h', showfliers = False,showmeans=True)\n",
    "axes[1,3].set_title('JSD of clusters')\n",
    "plt.savefig(os.path.join('FigureData/Figure4/Dataset10_STARmap/Result_STARmap','starmap_all_metrics.pdf'),dpi=300,bbox_inches='tight')\n",
    "plt.show()\n",
    "# plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Result For 32 simulation datasets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Please Note: \n",
    "### In our manuscript, we have completed 28 of the 32 datasets because of memory error when we used STRIDE for our analysis. \n",
    "### Here, we completed the prediction results for the remaining 4 datasets.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "def str_remove_spe(string):\n",
    "    s_list = []\n",
    "    for s in string:\n",
    "        if s.isalnum():\n",
    "            s_list.append(s)\n",
    "        else:\n",
    "            s_list.append('_')\n",
    "    new_string = ''.join(s_list)\n",
    "    return new_string\n",
    "\n",
    "def get_ce_results(results_path,celltype=None):\n",
    "    results = pd.read_csv(results_path,index_col=0)\n",
    "    results.columns = [str_remove_spe(c) for c in results.columns]\n",
    "    if celltype is not None:\n",
    "        results.loc[:,np.setdiff1d(celltype,results.columns)] = 0\n",
    "    results = results.loc[:,np.unique(results.columns)]\n",
    "    return results\n",
    "\n",
    "def get_RCTD_results(results_path,celltype=None):\n",
    "    results = pd.read_csv(results_path,index_col=0)\n",
    "    results.columns = [str_remove_spe(c) for c in results.columns]\n",
    "    if celltype is not None:\n",
    "        results.loc[:,np.setdiff1d(celltype,results.columns)] = 0\n",
    "    results = results.loc[:,np.unique(results.columns)]\n",
    "    return results\n",
    "\n",
    "def get_tangram_results(results_path,celltype=None):\n",
    "    results = pd.read_csv(results_path,index_col=0)\n",
    "    results.columns = [str_remove_spe(c) for c in results.columns]\n",
    "    if celltype is not None:\n",
    "        results.loc[:,np.setdiff1d(celltype,results.columns)] = 0\n",
    "    results = results.loc[:,np.unique(results.columns)]\n",
    "    return results\n",
    "\n",
    "def get_seurat_results(results_path,celltype=None):\n",
    "    results = pd.read_csv(results_path,index_col=0)\n",
    "    results = results.iloc[:,1:-1]\n",
    "    results.columns = [str_remove_spe(c.split('prediction.score.')[1]) for c in results.columns]\n",
    "    if celltype is not None:\n",
    "        results.loc[:,np.setdiff1d(celltype,results.columns)] = 0\n",
    "    results = results.loc[:,np.unique(results.columns)]\n",
    "    return results\n",
    "\n",
    "def get_c2l_results(results_path,celltype=None):\n",
    "    results = pd.read_csv(results_path,index_col=0)\n",
    "    results.columns = [str_remove_spe(c.split('q05cell_abundance_w_sf_')[1]) for c in results.columns]\n",
    "    if celltype is not None:\n",
    "        results.loc[:,np.setdiff1d(celltype,results.columns)] = 0\n",
    "    results = results.loc[:,np.unique(results.columns)]\n",
    "    results = (results.T/results.sum(axis=1)).T\n",
    "    return results\n",
    "\n",
    "def get_stereo_results(results_path,celltype=None):\n",
    "    results = pd.read_csv(results_path,index_col=0)\n",
    "    results.columns = [str_remove_spe(c) for c in results.columns]\n",
    "    if celltype is not None:\n",
    "        results.loc[:,np.setdiff1d(celltype,results.columns)] = 0\n",
    "    results = results.loc[:,np.unique(results.columns)]\n",
    "    return results\n",
    "\n",
    "def get_spotlight_results(results_path,celltype=None):\n",
    "    results = pd.read_csv(results_path,index_col=0)\n",
    "    results.columns = [str_remove_spe(c) for c in results.columns]\n",
    "    if celltype is not None:\n",
    "        results.loc[:,np.setdiff1d(celltype,results.columns)] = 0\n",
    "    results = results.loc[:,np.unique(results.columns)]\n",
    "    return results\n",
    "\n",
    "def get_spatialdwls_results(results_path,celltype=None):\n",
    "    results = pd.read_csv(results_path,index_col=0)\n",
    "    results = results.iloc[:,1:]\n",
    "    results.columns = [str_remove_spe(c) for c in results.columns]\n",
    "    if celltype is not None:\n",
    "        results.loc[:,np.setdiff1d(celltype,results.columns)] = 0\n",
    "    results = results.loc[:,np.unique(results.columns)]\n",
    "    return results\n",
    "\n",
    "def get_destvi_results(results_path,celltype=None):\n",
    "    if (not os.path.exists(results_path)) and (celltype is not None):\n",
    "        results = pd.DataFrame(np.zeros((1000,len(celltype))),index=range(1000),columns=celltype)\n",
    "        results = results.loc[:,np.unique(results.columns)]\n",
    "        print(f'not found: {results_path}')\n",
    "    else: \n",
    "        results = pd.read_csv(results_path,index_col=0)\n",
    "        results.columns = [str_remove_spe(c) for c in results.columns]\n",
    "        if celltype is not None:\n",
    "            results.loc[:,np.setdiff1d(celltype,results.columns)] = 0\n",
    "        results = results.loc[:,np.unique(results.columns)]\n",
    "    return results\n",
    "\n",
    "def get_stride_results(results_path,celltype=None):\n",
    "    if (not os.path.exists(results_path)) and (celltype is not None):\n",
    "        results = pd.DataFrame(np.zeros((1000,len(celltype))),index=range(1000),columns=celltype)\n",
    "        results = results.loc[:,np.unique(results.columns)]\n",
    "        print(f'not found: {results_path}')\n",
    "    else:    \n",
    "        results = pd.read_csv(results_path,index_col=0,sep='\\t')\n",
    "        results = results.fillna(0)\n",
    "        results.columns = [str_remove_spe(c) for c in results.columns]\n",
    "        if celltype is not None:\n",
    "            results.loc[:,np.setdiff1d(celltype,results.columns)] = 0\n",
    "            results = results.loc[:,celltype]\n",
    "        results = results.loc[:,np.unique(results.columns)]\n",
    "    return results\n",
    "\n",
    "def get_dstg_results(results_path,celltype=None):\n",
    "    results = pd.read_csv(results_path+'/DSTG_Result/predict_output.csv',sep=',',header=None)\n",
    "    label = pd.read_csv(results_path+'/Datadir/Real_Label2.csv',sep=',')\n",
    "    results.columns = label.columns\n",
    "    results.columns = [str_remove_spe(c) for c in results.columns]\n",
    "    if celltype is not None:\n",
    "        results.loc[:,np.setdiff1d(celltype,results.columns)] = 0\n",
    "    results = results.loc[:,np.unique(results.columns)]\n",
    "    return results\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Put the prediction results files: 'DeconvolutionPrediction' and raw datasets in the correct loc.\n",
    "### We have 32 simulation datasets and we named them as dataset1-16 and dataset1_r-16_r\n",
    "### Or you can skip this steps and use the PCC/SSIM/RMSE/JS files in FigureData/Figure4/32SimulationData/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_dataset_results(dataset):\n",
    "    DataNamed = {'1' : '1', '2' : '2', '3' : '3', '4' : '4', '5' : '5', '6' : '6', '7' : '7', '8' : '8',\n",
    "                 '9' : '9', '10' : '10', '11' : '11', '12' : '12', '13' : '13', '14' : '14', '15' : '15', '16' : '16',\n",
    "                 '1_r' : '17', '2_r' : '18', '3_r' : '19', '4_r' : '20', '5_r' : '21', '6_r' : '22', '7_r' : '23', '8_r' : '24', \n",
    "                 '9_r' : '25', '10_r' : '26', '11_r' : '27', '12_r' : '28', '13_r' : '29', '14_r' : '30', '15_r' : '31', '16_r' : '32'}\n",
    "    st = sc.read_h5ad(f'../../SimualtedSpatalData/dataset{DataNamed[dataset]}/Spatial.h5ad')\n",
    "    gd = st.uns['density']\n",
    "    gd.columns = [str_remove_spe(c) for c in gd.columns]\n",
    "    gd = (gd.T/gd.sum(axis=1)).T\n",
    "    gd = gd.loc[:,np.unique(gd.columns)]\n",
    "    celltype = gd.columns\n",
    "    RCTD_results = get_RCTD_results(f'FigureData/Figure4/32SimulationData/DeconvolutionPrediction/RCTD_dataset{dataset}_ds_results.csv',celltype=celltype)\n",
    "    c2l_results = get_c2l_results(f'FigureData/Figure4/32SimulationData/DeconvolutionPrediction/c2l_dataset{dataset}_ds10_results.csv',celltype=celltype)\n",
    "    tangram_results = get_tangram_results(f'FigureData/Figure4/32SimulationData/DeconvolutionPrediction/tangram_dataset{dataset}_ds_results.csv',celltype=celltype)\n",
    "    seurat_results = get_seurat_results(f'FigureData/Figure4/32SimulationData/DeconvolutionPrediction/seurat_dataset{dataset}_ds_results.csv',celltype=celltype)\n",
    "    stereo_results = get_stereo_results(f'FigureData/Figure4/32SimulationData/DeconvolutionPrediction/stereo_dataset{dataset}_ds_results.csv',celltype=celltype)\n",
    "    spotlight_results = get_spotlight_results(f'FigureData/Figure4/32SimulationData/DeconvolutionPrediction/spotlight_dataset{dataset}_ds_results.csv',celltype=celltype)\n",
    "    spatialdwls_results = get_spatialdwls_results(f'FigureData/Figure4/32SimulationData/DeconvolutionPrediction/spatialdwls_dataset{dataset}_ds_results.csv',celltype=celltype)\n",
    "    destvi_results = get_destvi_results(f'FigureData/Figure4/32SimulationData/DeconvolutionPrediction/destvi_dataset{dataset}_ds_results.csv',celltype=celltype)\n",
    "    stride_results = get_stride_results(f'FigureData/Figure4/32SimulationData/DeconvolutionPrediction/dataset{dataset}_spot_celltype_frac.txt',celltype=celltype)\n",
    "    dstg_results = get_dstg_results(f'FigureData/Figure4/32SimulationData/DeconvolutionPrediction/DSTG/dataset{dataset}/',celltype=celltype)\n",
    "    return gd,RCTD_results,c2l_results,tangram_results,seurat_results,stereo_results,spotlight_results,spatialdwls_results,destvi_results,stride_results,dstg_results\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Calculate accuracy metrics for each methods with 32 simulation datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.stats import pearsonr\n",
    "from collections.abc import Iterable\n",
    "from scipy.spatial.distance import jensenshannon\n",
    "def jsd(v1,v2):\n",
    "    return jensenshannon(v1-v2)\n",
    "from sklearn.metrics import mean_squared_error\n",
    "def rmse(x1,x2):\n",
    "    return mean_squared_error(x1,x2,squared=False)\n",
    "\n",
    "def ssim(im1,im2,M=1):\n",
    "    im1, im2 = im1/im1.max(), im2/im2.max()\n",
    "    mu1 = im1.mean()\n",
    "    mu2 = im2.mean()\n",
    "    sigma1 = np.sqrt(((im1 - mu1) ** 2).mean())\n",
    "    sigma2 = np.sqrt(((im2 - mu2) ** 2).mean())\n",
    "    sigma12 = ((im1 - mu1) * (im2 - mu2)).mean()\n",
    "    k1, k2, L = 0.01, 0.03, M\n",
    "    C1 = (k1*L) ** 2\n",
    "    C2 = (k2*L) ** 2\n",
    "    C3 = C2/2\n",
    "    l12 = (2*mu1*mu2 + C1)/(mu1 ** 2 + mu2 ** 2 + C1)\n",
    "    c12 = (2*sigma1*sigma2 + C2)/(sigma1 ** 2 + sigma2 ** 2 + C2)\n",
    "    s12 = (sigma12 + C3)/(sigma1*sigma2 + C3)\n",
    "    ssim = l12 * c12 * s12\n",
    "    return ssim\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compare_results(gd,result_list,metric='pcc',columns=None,axis=1):\n",
    "    if metric=='pcc':\n",
    "        func = pearsonr\n",
    "        r_ind = 0\n",
    "    if metric=='jsd':\n",
    "        func = jensenshannon\n",
    "        r_ind = None\n",
    "    if metric=='rmse':\n",
    "        func = rmse\n",
    "        r_ind = None\n",
    "    if metric=='ssim':\n",
    "        func = ssim\n",
    "        r_ind = None\n",
    "    if isinstance(result_list, pd.DataFrame):\n",
    "        c_list = []\n",
    "        if axis == 1:\n",
    "            print('axis: ',1)\n",
    "            for i,c in enumerate(gd.columns):\n",
    "                r = func(gd.iloc[:,i].values, np.nan_to_num(np.clip(result_list.iloc[:,i],0,1)))\n",
    "                if isinstance(result_list, Iterable):\n",
    "                    if r_ind is not None:\n",
    "                        r = r[r_ind]\n",
    "                c_list.append(r)\n",
    "        else:\n",
    "            print('axis: ',0)\n",
    "            for i,c in enumerate(gd.index):\n",
    "                r = func(gd.iloc[i,:].values, np.nan_to_num(np.clip(result_list.iloc[i,:],0,1)))\n",
    "                if isinstance(result_list, Iterable):\n",
    "                    if r_ind is not None:\n",
    "                        r = r[r_ind]\n",
    "                c_list.append(r)\n",
    "        df = pd.DataFrame(c_list,index=gd.columns,columns=columns)\n",
    "    else:\n",
    "        df_list = []\n",
    "        for n,res in enumerate(result_list):\n",
    "            #print('- '+str(n))\n",
    "            c_list = []\n",
    "            if axis == 1:\n",
    "                for i,c in enumerate(gd.columns):\n",
    "                    r = func(gd.iloc[:,i].values, np.nan_to_num(np.clip(res.iloc[:,i],0,1)))\n",
    "                    if isinstance(res, Iterable):\n",
    "                        if r_ind is not None:\n",
    "                            r = r[r_ind]\n",
    "                    c_list.append(r)\n",
    "                df_tmp = pd.DataFrame(c_list,index=gd.columns)\n",
    "            else:\n",
    "                for i,c in enumerate(gd.index):\n",
    "                    r = func(gd.iloc[i,:].values, np.nan_to_num(np.clip(res.iloc[i,:],0,1)))\n",
    "                    if isinstance(res, Iterable):\n",
    "                        if r_ind is not None:\n",
    "                            r = r[r_ind]\n",
    "                    c_list.append(r)\n",
    "                df_tmp = pd.DataFrame(c_list,index=gd.index)\n",
    "            df_list.append(df_tmp)\n",
    "        df = pd.concat(df_list,axis=1)\n",
    "        df.columns = columns\n",
    "    return df\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_datasets = np.array(['1','2','3','4','5','6','7','8','9','10','11','12','13','14','15','16','1_r','2_r','3_r','4_r','5_r','6_r','7_r','8_r','9_r','10_r','11_r','12_r','13_r','14_r','15_r','16_r'])\n",
    "df_list = []\n",
    "for d in all_datasets:\n",
    "    gd,RCTD_results,c2l_results,tangram_results,seurat_results,stereo_results,spotlight_results,spatialdwls_results,destvi_results,stride_results,dstg_results=get_dataset_results(d)\n",
    "    df = compare_results(\n",
    "        gd,\n",
    "        [RCTD_results,c2l_results,tangram_results,seurat_results,stereo_results,spotlight_results,spatialdwls_results,destvi_results,stride_results,dstg_results],\n",
    "        columns = ['RCTD','Cell2location','Tangram','Seurat','Stereoscope','SPOTlight','SpatialDWLS','DestVI','STRIDE','DSTG'],\n",
    "        axis=1,\n",
    "        metric='pcc'\n",
    "    )\n",
    "    df['dataset'] = d\n",
    "    df_list.append(df)\n",
    "pcc_all_clusters = pd.concat(df_list,axis=0)\n",
    "\n",
    "\n",
    "df_list = []\n",
    "for d in all_datasets:\n",
    "    gd,RCTD_results,c2l_results,tangram_results,seurat_results,stereo_results,spotlight_results,spatialdwls_results,destvi_results,stride_results,dstg_results=get_dataset_results(d)\n",
    "    df = compare_results(\n",
    "        gd,\n",
    "        [RCTD_results,c2l_results,tangram_results,seurat_results,stereo_results,spotlight_results,spatialdwls_results.fillna(0),destvi_results,stride_results,dstg_results],\n",
    "        columns = ['RCTD','Cell2location','Tangram','Seurat','Stereoscope','SPOTlight','SpatialDWLS','DestVI','STRIDE','DSTG'],\n",
    "        axis=1,\n",
    "        metric='jsd'\n",
    "    )\n",
    "    df['dataset'] = d\n",
    "    df_list.append(df)\n",
    "jsd_all_clusters = pd.concat(df_list,axis=0)\n",
    "\n",
    "df_list = []\n",
    "for d in all_datasets:\n",
    "    gd,RCTD_results,c2l_results,tangram_results,seurat_results,stereo_results,spotlight_results,spatialdwls_results,destvi_results,stride_results,dstg_results=get_dataset_results(d)\n",
    "    df = compare_results(\n",
    "        gd,\n",
    "        [RCTD_results,c2l_results,tangram_results,seurat_results,stereo_results,spotlight_results,spatialdwls_results.fillna(0),destvi_results,stride_results,dstg_results],\n",
    "        columns = ['RCTD','Cell2location','Tangram','Seurat','Stereoscope','SPOTlight','SpatialDWLS','DestVI','STRIDE','DSTG'],\n",
    "        axis=1,\n",
    "        metric='rmse'\n",
    "    )\n",
    "    df['dataset'] = d\n",
    "    df_list.append(df)\n",
    "rmse_all_clusters = pd.concat(df_list,axis=0)\n",
    "\n",
    "df_list = []\n",
    "for d in all_datasets:\n",
    "    gd,RCTD_results,c2l_results,tangram_results,seurat_results,stereo_results,spotlight_results,spatialdwls_results,destvi_results,stride_results,dstg_results=get_dataset_results(d)\n",
    "    df = compare_results(\n",
    "        gd,\n",
    "        [RCTD_results,c2l_results,tangram_results,seurat_results,stereo_results,spotlight_results,spatialdwls_results.fillna(0),destvi_results,stride_results,dstg_results],\n",
    "        columns = ['RCTD','Cell2location','Tangram','Seurat','Stereoscope','SPOTlight','SpatialDWLS','DestVI','STRIDE','DSTG'],\n",
    "        axis=1,\n",
    "        metric='ssim'\n",
    "    )\n",
    "    df['dataset'] = d\n",
    "    df_list.append(df)\n",
    "ssim_all_clusters = pd.concat(df_list,axis=0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "pcc_all_clusters.to_csv('FigureData/Figure4/32SimulationData/PCC.csv')\n",
    "jsd_all_clusters.to_csv('FigureData/Figure4/32SimulationData/JS.csv')\n",
    "rmse_all_clusters.to_csv('FigureData/Figure4/32SimulationData/RMSE.csv')\n",
    "ssim_all_clusters.to_csv('FigureData/Figure4/32SimulationData/SSIM.csv')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plot result for 32 simulation datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmEAAAHaCAYAAABIEJ5gAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAMTQAADE0B0s6tTgAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3Xe4FdXZ/vHvTQdBAQUBiWIsEEE8gooidgkmMYoYozExEonljQkqyi8mCipqEmOCxpLXEnslCYjGgq8gFkBRygHBgKKCgqgooKLSn98few5uD6fsU+eU+3Ndc7lnZq01z2zOflwzs2ZGEYGZmZmZVa8GaQdgZmZmVh+5E2ZmZmaWAnfCzMzMzFLgTpiZmZlZCtwJMzMzM0uBO2FmZmZmKXAnzMzMzCwF7oSZmZmZpcCdMDMzM7MUuBNmZmZmloJGaQdgRWvatGm0a9cu7TDM6rVly5atj4imacdRFs4dZukqS95wJ6yGateuHUuXLk07DLN6TdKKtGMoK+cOs3SVJW+4E1ZDfblxJXfM/2naYZjVWkO6P5B2CKlw7jArmzRzhceEmZmZmaXAnTAzMzOzFLgTZmZmZpaCKu+ESWok6TJJCyTNk5Qv6TZJrUuoM1jS+OTz4ZLyk8+dJD0taaGkuZLGSmqXVS9KarcC+9Ba0sWFlv1D0hGVvS0zy9i0cTOP/f01Lv3h44wc+ARXnPgk914+nS8/W19snanj3+amoS8A8Nxzz5GXlwfA+++/z4ABA+jatSs9e/bkxBNPZMWKr8fOSmL16tWVvg/OHWZWkuo4E3YHsB9wUET0APYFngHalqOtTcCVEdE1InoCbwPXVlqkxWsNfCORRsQvI2JyNWzbrF66e+R0Fs//hN/d/11Gjf8BI//9PfY6qCNffFp8J6w4DRs2ZMSIESxcuJC5c+fy7W9/m+HDh1dB1Ftx7jCzYlVpJ0zS7sBJwC8iYhVAZPwrIt6WdJqk6ZJmSXpB0j4ltRcRH0bElKxF04EuxWx7P0nTkjNmr0g6OGvdDyS9KmlOcmauT7L8AUkzkjpPSOqQVLkFaJWUnZGUfU7SwORze0njJL2WnO07O2tbiyWNkvSSpHckXVrGr9Gs3vnw3c+Z+X/v8ourDmSb7ZoAmbNV+w3YmXbfaslLj73D1T95mlEnPcU1pz/DewtWldjejjvuSL9+/bbM9+nTh8WLFxdZdsaMGfTt25eePXsCtHfuMLOqUtWPqOgFvBkRHxdekSS2nwCHRsQ6SYcADwLdc2lYUkPg18CjRaxrAowDzoyIpyX1A8YmncJOwF3JdhdIagy0SKqeHxErkjYuBi4Hzkmm/IjIKyacG4GFETFIUntgpqQ5EfFysr51RBwkaQfgLUl3RcSyXPbTrD569/WVtN+5Fa3aNNtq3ZuzVjD+r2+w995706BBA1avXs1fTn+BPn36sHz5p6xYsZYHh37AqlXDeOuttzjqqKO+UT8imD17NiNHjtyq7fXr1zNo0CBuv/12BgwYgKTVOHeY1UoPDv0gt3IcVXqhLJMmTSpPOEVK8zlhxwP7ANMlFSxrK6l5aRWVqfB3YBXwtyKKdAU2R8TTABExRdKHQF6yzQkRsSBZtwH4NKl3qqTTgGbJtFXnsRhHA72T9j6SNC5ZVpBIH0zWfSzpbWBX4BuJVNIwYFjBfPOWjXPctFn9kj95KZ9//jkzZszYsmzDhg1s2rSp1LoRwcKFC2nUqBHnnXfeVusXLlxIgwYNGDBgQMGi9cAnOHeYWRWo6k7YLGAPSdtHxCeF1gm4JyJ+X7hSVqesODcA3wIGRsTmHGOJklYmZ8uGkhm79pGk44BRObZd2rbWZn3eRBHfe0SMBkYXzLft0KLEeM3qsp33astH737OmtXraNm60Ns/Ajp27Mhuu+1W5nbffPNN1q1bt+UsWo6cO8ysSlRpJywiFkkaC9whaXBErE7OYg0CHgfuk3RLRLwrqQHQKyJmlNSmpBuA3cl0wIobobsQaCCpf0Q8I6kv0AHIBz4ARkrqVuiSQhvgc+CT5HLm2VntfQY0l9SkmG1OBM4ELknu1hxEZiycmZXDjju3otfR3+LukdM546oDabFtEyKCWRPfo+dhnXh1wksM+F0e23fchs2bg3dfX0mXHtszdfyXzH72c069oQO7rRjB+eefv+XSwdChQ2nSpAnjx4+nadOiX+vWtWtXNm/ezDPPPEP//v0BmuDcYVYrnXpDh9ILke4T86vjcuQZwKVkLjtuJHMzwAvAb4H/BzwiqRGZZPcEUGwnLBlH9htgAV9fxnwnIk7ILhcR6yUNAm6Q9FcyR5M/iog1wCJJvwDuT5LoJjLjNiYAPyPTgfuETHLcKWlvpaR7gbmS1kTEfoVCGwr8r6TXyJzhuzoippfjuzKzxOArD+SJW+dx9alP07BhAzZvDvbcrz0/uiCPHw3L4+bzXmDzxmDjhs30PLQTXXpsX2xbU6dO5cYbb6Rbt2706dMHgF133ZVHHnnkG+WaNGnCuHHjGDp0KBdeeCFk7m480rnDzKqCInzmuiZq26FFXDvphNILmlmRKuPoVtKyiOhcCeFUG+cOs7Kp7DNhZckbfmK+mZmZWQrcCTMzMzNLgS9H1lCdO3eOpUuXph2GWb1WGy9HOneYpcuXI83MzMxqOHfCzMzMzFLgTpiZmZlZCtJ8bZGVYNPGT1jy3x+kHYZZqnb5zhNph1DrOHdYfVeb8obPhJmZmZmlwJ0wMzMzsxS4E2ZmZmaWgmrphEkaJGmmpHxJCyQ9m7ywu7ztXS6pWdb8KEk/zaHe3ZLOTz4PlvSppNmS/itpjqTLJDVP1l8m6R9ZdftJCkmHZy27RdKVyefFkvKK2Obeyf7OkTRP0quSepR3383qk3HjxtG7d2/y8vLo1q0bRx55JJs3by53e5dffjlr167dMj9y5EgeeKD0V5Y4d5hZVajygfmSOgK3Ab0jYkmyrBdQkafEXgZcT+bF3ETEyHK2MzkiBiYxtQf+AYwBjgMmA3dmlT0CmA4cDjyXteycUrbxEDAiIh5JtvMtYF054zWrNz5asZazzjqLmTNnsssuuwAwa9YsJJW7zSuuuILzzz+fZs0yx3CjRo0qb1POHWZWYdVxJmxHYBOwsmBBRMyKiEiOAK9NzpItkjS8oIykvyRHfvmSXpDUNVl+S1LkxWRd+0JHqUdJeik5Sp0vaUguQUbER8DpwNGSugMvA50kFTz19nBgVPLfgs7lzsBLpTTdGViWtZ33km2ZWQlWfLyehg0b0rZt2y3LevXqhSS6dOnC8OHD6d27N7vvvjvXXnvtljIXXXQR+++/P3l5eRx66KEsXLgQgHPOyfR5DjnkEPLy8vjoo48YPHgw119/PQCTJk3ioIMOYt9996V79+7ccccdOcXp3GFm5VUdj6iYC0wBlkh6HpgGPBgRBcllR2A/YHtglqSpETENuCYiLgKQdArwN+CYiDhH0tnAIRGxOlmfvb1ZQL+I2CSpLTBb0tMRUep7PCJilaQ3ge4RMV/SNOAISf8Edo2IJyXdkFwKPQJ4KSLWltgoXAlMlvQymeT874iYXVosZnXJGb8u7WeytYjGRARt27aldevWbLfddnTo0IGmTZvy4Ycfcv/99/Od73yHFi1aMGLECMaMGcN2223H+vXrefXVVwF4+OGHOe+885gwYQK33HILt956Ky+++CKtW7feanu9evViypQpNGzYkJUrV7LvvvsCNMwtVucOs8pQnlyxtaMqVHvSpEmVEENuqrwTFhGbgRMldQMOA74HXCJpv6TIHZF5geXHksYBR5PpqPWX9BugFZkzdm23br1I2wN3SNoT2JjM9wByfZlado9uMpmj1yXAK8myl4GDkuWTS2ssIv4q6X7gSOBQMmfwhkTEmG9sVBoGDCuYb9XSj3Cz+k0Se++9N1988QWrV6/mk08+YcmSJey3XyZ1dOzYEUk0adKEdu3asXLlSrbbbjtWrlzJQQcdxOeff87mzZtZuXJlKVvK+OSTTxgyZAhvvPEGjRo14pNPPoGy5UjnDjMrk2q7OzIiFkTErck4ipfJjJ0osqiknYGbgJ9FRA/gFKBZMeULu4XMmbe9IyIPeCPXupLaALsD85JFk8kctR7B12M5ns9a9mwu7UbEhxHxUET8D3AVsNVNBBExOiI6F0zbbONEagawzTbbsNNOO9GzZ0+23XZbPv7442LLrl27ljfeeIP777+fefPm8fDDD39jIH5JzjnnHPr168drr71Gfn4+e+65J3yzY1Us5w4zK4/qGJi/E9AlIqYm822AXYG3kiKDgeeTS4cnAD8BtgM2AMuVudb460LNfp6UWV3EJtsAS5IxZ4cC++QYZzsyNxBMjIjXk8WvAu3JJL6CTuPzwONAR74+wi2p3ROAxyNig6RGQE++3nezeuHOm3I9hvraBx+uZWPjURx88MEArFq1igMPPJA///nPnHfeeeyzzz7cddddWy4d3n///bRq1Yqjjz6ajh07EhHcdNNN32izVatWfPrpp0Vejly1ahW77LILknjhhReYM2dOTnE6d5hVnvLkisL8xPxvagSMlPSGpHzgReCeiHg0Wb9C0kwySemmiJgWEa8BDwPzySSzdwu1+VfgmYKB+YXWXQz8KdnWGWTuSirOEckA/gXARGAOcHLByojYQOasWquIWJAse4PMJdIpyfpsT0tamjV1BgYB8yTNTdpfR+buTjMrwcaNwahRo9hzzz3Jy8vjkEMO4fTTT+f4448HoF27dvTu3ZsDDjiAX//61/Tt25e9996bU045he7du7P//vuz8847f6PNCy+8kP79+28ZmJ/tT3/6ExdffDF5eXnceeed9OnTp6TwnDvMrMKUGY6V0salxcDAiMhPLYgaqmOH5vHy5CPTDsMsVcUd0Xbp0oXx48eTl7fV47UqlaRlEdG59JI1h3OH1XdpnwkrS97wE/PNzMzMUpDqCM6I6JLm9s2sdlq8eHHaIZiZVZhvo6mhGjbaPvVTqmZW+zh3mNUevhxpZmZmlgJ3wszMzMxS4E6YmZmZWQo8JqyGWvfVBiaOm5l2GGZV5uhBvdMOoU5y7rC6pi7nCp8JMzMzM0uBO2FmZmZmKXAnzMzMzCwF7oSZmZmZpcAD89nyDst1wFdAc+CuiPhTsq49cA1wGPApEMC/gZXAOUkTOyd1VyTzFwCnA/2Bj4CWwIfArRFxX9XvkZlVB+cOM6sId8K+dnJE5EvaCXhd0rPAa8DzwBhgj4jYJKkFcGZE3ALcAiDpbiA/Iq4vaEzS6cC1Bcsk5QFjJLWLiNHVumdmVpWcO8ysXNwJKyQilklaAOwC7A18HhGXZ63/EvhbOdrNl3QecI+k6yIiKitmszT98eb/V8565d/mpEmTyl+5ijh3mJUsjVwBNTNfFPCYsEIkdQO2B54DegMvVWLz04H2QLsitjtM0tKC6au1X1biZs2sqjl3mFlZuRP2tTGS/gu8DtwYEStKq1AOKm5FRIyOiM4FU/NmLapg82ZWBZw7zKxcfDnyawXjOo4G/pOM65gJnFWJ29gf+CgiPqrENs1S9btz/1yuenXoKdjOHWY5cK7Yms+EFRIRE4H/Ba4CHgJaSxohqSGApOaShpa1XUk9gevJ3C1lZnWMc4eZlZXPhBXtSmAR8B0yt5f/CVgkaQ2Z28wfzLGd4ZIGAy3I3G7+x4i4t/LDNbMawrnDzHLmThgQEV0Kza8iM8C2wOBS6m+1vqhlZla3OHeYWUX4cqSZmZlZCtwJMzMzM0uBL0fWUE2bN67Td4SYWdVw7jCrPXwmzMzMzCwF7oSZmZmZpcCdMDMzM7MUeExYDbV+/QpeePngtMMwqxEOPXBq2iHUGs4dVpvVt9+6z4SZmZmZpcCdMDMzM7MUuBNmZmZmloI6PyZM0iDgEqAh0Ax4H1gLdEqK7APMAzYBn0fEIZIiWbYZaAxcGxF3Je0dDlwfEXnJfEHZSNqfCVwZEa8n6y8HzgWWZYX1r4i4uop22cwqwbhx4wDaS8rHucPMqkCd7oRJ6gjcBvSOiCXJsl7A7IiIZD6AQyJidaHqh0TEakn7AK9KmhARy4vZVEHZBsBZwFRJvSLinWT9AxFxfmXvn5lVjeXLl3PWWWcBfJLVaXLuMLNKVac7YcCOZI5SVxYsiIhZZWkgIuZIWgV0BopLpAVlNwO3JEe8vwKGlzVgs7rqikuaVaD2UeWqNWnSpHLV+/DDD2nYsCFkzmgBzh1mJanY7ztb+X7rhZX3t1/d6vqYsLnAFGCJpEckDZe0U1kakHQY8DEwpwzVpgPds+Z/Kik/azq5iO0Mk7S0YPryy01lCdPMKlHPnj3p168fQEfnDjOrKnX6TFhydHmipG7AYcD3gEsk7RcRi0qp/qKk5sCuwI8iYn0ZNq1C86VeUoiI0cDogvn27ZtGGbZnZpWoQYMGjB07FkkfARNw7jCzKlCnO2EFImIBsAC4VdIE4DiyklYxCsZqDAbuljQtIj7McZP7kxlwa2aJy65eW+66KT7AcWNE3Ipzh1mJKvL7zuaHtdYhknaSdHDWfBsyR6dv5dpGRNwNTAJ+n8P2Gkg6EzgG+N8yB2xmNcKyZcuYOvXr/xk4d5hZVajrZ8IaASMl7Qp8mczfExGPlrGd3wIzJf25mPUvJndKNQNmAQdn3d0EmXEdh2fNT46IC8oYg5lVk40bNzJq1CiAHZNHVDh3mFmlU3K3tdUw7ds3jX8/tl/aYZjVCGldopC0LCI6p7LxcnLusNqsLlyOLEveqNOXI83MzMxqKnfCzMzMzFJQ18eE1VpNmrSrE6dlzax6OXeY1R4+E2ZmZmaWAnfCzMzMzFLgTpiZmZlZCjwmrIZas2ET1776XtphmFWZ4ft/K+0Q6iTnDqvp/Nv/ms+EmZmZmaXAnTAzMzOzFLgTZmZmZpaCetUJk7RY0kJJcyQtkvSopL4VaO98SR2SzwdI+kBSo0JlTpA0N/n8nKSBFdsLM6tuzh1mVhXqVScscXJE7BMRuwP3AE9K6lPOts4HOgBExCvACuB7hcoMAe4ob7BmVmM4d5hZparXd0dGxDhJBwAXSToVuBI4EmgCvAGcHRGrJP0SGAasBxoCvwQGAJ2AMZK+AgaTSZhnAP8BkNQROAI4vTr3y6y6TLh4cPnrVmC7kyZNqkDtinPusPqoIr/3b7RTKa1kpJ0LKqrETpik75e0PiKerNxwUjEdOA4YDnwREQcASBoBXAWcC/wV6BYRyyU1BppGxHRJZ5A5Os5P6iwFrpLULiJWkEmgj0fEJ6UFIWkYmWQNQLOWrSp1J82q08cff1zi+h122KGaIqlSzh1mViGlnQn7XQnrAqgLnTAl/x0IbCfpxGS+CbA4+TwJuE/Sf4CnIuKNohqKiI8lPQmcBowGfgH8JpcgImJ0UgeA1jt2jDLuh1mNsWTJkhLX15FOmHOHmVVIiZ2wiDikugJJ0f7APGBX4DcR8X9FlDkR6A0cTmYcyKUR8XAx7d0B/EXSK0AzYGLlh2xWMxzzp7uLXp5D3TrwwEbnDqtXivu9l1Ud+O1XmpzHhEk6AeifzD4dEY9WTUjVR9LxwP+QGaNxNHCBpCkR8aWkFmSS60KgS0TMAGZI2gE4AHgY+AzYrlCzzyTLrgPuiojN1bM3ZjXTvMkTePOVFwHY88DD6H7Yd1OOqOKcO8ysMuTUCZN0CfBj4D4ylyEvl7RXRPyxKoOrImMkrQW2AV4Hvp+M0ZgJNAWmSyo4nX8NsAi4U1JbYCOZu5h+kay/Abhd0pfA4IjIj4jNku4CRgA/qr7dMqt5Jt15I3MnPk6v7w8CiWduv44P33mDIwf/Ou3QysO5w8wqlSJKHz4g6TXgoIhYk8y3BF6KiL2rOL56q/WOHeOSx19JOwyzChn9k/6ce8d4mrbYBoB1X37BzUMGMuyhZ2rFJQlJyyKic9pxlIVzh9V0teG3XxFlyRs5PyesoANW+LOZWUkKOmCFP5uZ1Xe5jgmbkZwmvz2Z/yUwo2pCMrO6ovN3evLPURdywMCfAPDKow/T+Ts9U47KzKxmyPVyZEvgCuCoZNFE4HKfEas6nTt3jqVLl6YdhlmFrFmzhssuu2zLAxWPPvpoLr/8clq2bJlyZLmpjZcjnTvM0lWWvJFTJ8yqnxOpWfrcCTOzsqr0MWGSWkr6m6TXk+m65OyYmVmx1qxZw3nnncdee+3FXnvtxQUXXMCaNT6BbmYGuQ/MvxloCfyczBOdtwH+XlVBmVndcO6557JmzRruvfde7rvvPr744gt+9atfpR2WmVmNkOvA/H0jIns07VmS5lZFQJaxee16Pv6PbzO32mmHHx4AwOzZs5k79+tUcdttt9GzpwfmVyXnDquJCnKCfVOuZ8IkaZusmW34+r1pZmZFigi++OKLLfNffPEFHodqZpaR65mwB4CXJBW88+xkMk/PNzMr1k9/+lMOOuggTjnlFADGjBnDaaedlnJUZmY1Q06dsIj4k6R5ZN6RBnBJRDxedWGZWV1w8cUX06NHDyZOzLyL+uqrr+bYY49NOSozs5qhxE6YpIci4icASaerQh0vSYOAS4CGQDPgfTIdu6HAwxHxQUXaN7Oa4Sc/+QkPPfQQAMcee2yFO17jxo3j6quvZtOmTaxdu5ZOnToxceJEbrjhBk455RQ6dOhQGWGbmVWr0s6EdausDUnqCNwG9I6IJcmyXmReCH4+8BxQpk6YpEYRsbGyYjSzyrFgwYJKa2v58uWcddZZzJw5k1122QWAWbNmIYnrr7+eww8/vMydsI0bN9KoUa6jMczMqkZpA/MrcwTtjsAmYOWWxiNmASOATsAYSfmS8iQ1lvQnSa8ky/4pqQ2ApLsl3SnpBWBesmx/Sc9KmiFptqSTCrYh6TRJc5PpCUk7JcsPlDQzaX+epP9Jlm8n6R/JsjmS7kyWt0y2Oy+ZLsvaxnOSbpT0qqRFkv4qScm6Dkn8r0h6TdJVlfidmtVIyZ9/pfjwww9p2LAhbdu23bKsV69eXHnllbz//vucfPLJ5OXlkZ+fz4YNG7j44os54IADyMvL48c//jGrVq0CYPDgwZxxxhkceuih9OjRA4BXX32VI488kv322499992Xf/3rX1u2cd999wG0d+4ws6pS2qFgT0kri1guICKibRHrijMXmAIskfQ8MA14MCJGSToDODki8gEk/R74IiIOSOZHAFcB5yZt9Qb6RcTnklqTOcP2/YhYLmkHYJakaUAb4FoyZ9+WSboE+AfwPeB3wF8i4qFkG22Stq8HvgJ6RsRmSe2S5SOApkBPoDkwRdKCiBiTrN8L6As0Bl4AfgI8CNwD/CEinpfUCHhc0kkR8XW2N6vhTr7+d2Uqn5+fT+PGjYtdf+ihh35jvuC1RkXp2bMn/fr1Y5ddduGwww6jb9++nHrqqYwcOZI777yTMWPGkJeXB8Af/vAHttlmG155JfOIhiuvvJJLL72Um2++GYCZM2cyZcoUWrVqxerVqznrrLN48skn6dixIx9//DG9evWib9++rFq1iuHDhwN8HBE9nTusvitrDtjK9eWrVlJuqAtK64QtBL5fGRuKiM3AiZK6AYeRSWaXSNqviOIDge0knZjMNwEWZ63/V0R8nnzuC3wbeKrQ0XdXoDswISKWJcv+DoyU1BCYDIyQtAfwbERMScocC/RJ4iUiViTLjwYuTJZ/IeleoD9QkEjvjYgNwAZJ9wNHS3qUzPs2d8yKrWUS2zdIGgYMK5jftoVfSGC1V4sWLSrteWANGjRg7NixLFiwgOeff56nnnqKq6++mhkzZmxVdvz48Xz66aeMHTsWgPXr19OlS5ct60866SRatWoFwLRp03j77bf53ve+9402Fi5cyPz58znmmGO45557NieLnTvMrNKV1glbVzB+q7JExAJgAXCrpAnAcUUUE/CbiPi/YppZU6js/Ijou1UjUvfCm8+K4/ok0R0N/EHSvIgoy6O8S7tUG3z9LLUDI2JtiYUjRgOjC+Y77dDeD1OyWksSzZs3r9Q2u3XrRrdu3Tj77LM55phjeOyxx7YqExHceOONfPe73y2yjewXh0cE3bt3Z9q0aVuVmz9//lZNZ9Vz7jCzSlFaJ6zSBnYk4ym6RMTUZL4NsCvwFvAZsF1W8fHABZKmRMSXkloAu0bEVpmRzGXNXSUdHRETk7bzgNfJHLFeIqlTRLwPnANMiohNkrpGxELgdknvAX9I2nsMuEjSrwsuKSRHtBOBIcml1BZkXt90TVYcP5P0IJnv9FTguohYI2kycDFweRJbJ6BBRPgNu1ZrjDn/j2Uq33/k2ZV2GWHZsmUsXryYgw8+GIBVq1bxzjvvsNtuu7Htttvy6aefbik7cOBArrvuOvr160eLFi348ssveeedd+jevfDxGPTt25d33nmHiRMncvTRmafv5Ofns9dee3HEEUdw9dVXw9fjZp07rF4raw4ozE/ML1qJnbCI2LeStzVS0q7Al8n8PRHxaDJ24nZJXwKDySSopsB0SQVHddcAWx+eRqyS9APgL5L+SmZcxbvAwIiYJ2k4MCE5pf8ecGZS9deSjgTWk7lh4MJk+QXAdcBrkjYAryZ1rgRuAF5Lyv0rIv6ZFcp/galAW+BRoODBtj8FRivznLUAvgDOBpxIrc6aPXt2pbW1ceNGRo0axTvvvEOLFi3YuHEjp59+OscffzwrVqzgzDPPpEWLFtx999389re/Zd26dfTp02fLzQG//e1vi+yEtWnThieeeIKLLrqICy+8kA0bNrDzzjszfvx4evTowbXXXsvPf/7zHZR5RZtzh5lVOvkVIhUn6Tng+ogYX1ltdtqhfcy9y8/Dtdqprhz1SloWEZ2rsP3ncO6weqCu5IRclCVv5PruSDMzMzOrRH5aYSWIiMPTjsHMah/nDrP6zZ2wGqpBsyb16vStmVUO5w6z2sOXI83MzMxS4E6YmZmZWQrcCTMzMzNLgceE1VBfrV/PmJdeSTsMs1SdfJDHNpWVc4fVVvXx9+4zYWZmZmYpcCfMzMzMLAXuhJmZmZmloNaNCZOUn3xsAnTl6/exLYyIk9OJysxqury8PADWr1/PwoUL2XvvvQHo2rUrY8aMSTM0M6unal0nLCLyACR1AfIL5qvrkrnBAAAgAElEQVSLpEYRsbE6t2lmFZefnzl+W7x4MXl5eVvmq4tzh5kVVqcuR0raSdJkSTMlzZf0N0lK1v1S0tOSHpb0mqRXko5cQd2rJC2S9KqkqyUtSpbvLuljSX+RNAv4H0nflfSSpFmS5kkanNXO/ZJukTRJ0juSbpd0oKTnJb0t6c/V+62YWWmWLVvGEUccQe/evenevTvnnXceEQE4d5hZ1al1Z8JKsRL4YUSskdQI+A9wIvDvZH0fYJ+IWCLpL8Bw4FxJxwM/BPKAL4B7C7W7PTArIi4CkNQG6BcRmyTtAMyS9HRELE/K9wCOSj4vANoARwPNgLcl3RkRCyp9781qmdsu/V3J63NsZ9KkSRWKo23btvznP/+hZcuWbNy4kR/+8IeMHTs2u4hzh1k5lPYb/0bZMrRb0d98TVGnzoSR2Z9rJc0BZgH7kkmOBaZExJLk80vAbsnno4B/RsSayBz+3lGo3bXAQ1nz7YB/S5oHTATaAt2z1o+PiHURsQ6YB0yIiA0R8TmZxLp74cAlDZO0tGBa++VXZd97MyuXzZs3M3z4cPbZZx969erF7NmzC1+udO4ws0pX1zphw8kcOfaJiJ7AP8kcQRZYm/V5E8WfCYxC819EwbWJjNuA54C9kzFpb5eynVK3GxGjI6JzwdSsRfNiQjOzynbttdeyatUqpk+fzty5c/nxj3/M2rXZP1vnDjOrfHXtcmQbYHlErJXUEfgR8GAO9Z4FLpN0PfAlcEYO21kcESHpCDKXEMysjM666o8lrq+uJ2ivWrWKjh070qxZM5YvX86///1vTj311FyqOneYlaC033i2+vjE/LrWCbse+Gdyqv994JlcKkXEeEkHAPnAp8ALwOoSqvwWuFHSFWQue75aoajNLFXnn38+P/7xj+nRowedOnWif//+OdVz7jCzitA3z5TXX5JaRcTnyd2UfyPz3fwmrXi2b98+/v7o42lt3qxGSPvIWNKyiOhcShnnDrNKkPbvvbLkkjcK1LUzYRXxgKRvkRmf8RpwTsrxmFnt4NxhZuXiTlgiIo5LOwYzq32cO8ysvOra3ZFmZmZmtYLPhNVQzZs0qTPXx82s+jh3mNUePhNmZmZmlgJ3wszMzMxS4MuRNdSXX6zjjpvrxruxrG4Ycu5RpRey1Dl3WFVyHqhcPhNmZmZmlgJ3wszMzMxS4E6YmZmZWQrcCTMzMzNLQb3qhEkaJGmmpHxJCyQ9K6lavgNJeZJOqY5tmVnlcu4ws6pQb+6OlNQRuA3oHRFLkmW9gEp5g7mkRhGxsYQiecBA4OHK2J6ZVQ/nDjOrKvWmEwbsCGwCVhYsiIhZAJL2AK4H2gNNgdsi4qZkXQBtImJ1Mv8xsF9ELJa0GBgDHAG8KelC4CFgWzIv850MDAV2AEYB20nKB16OCL/k16rNg+P+kHobkybV2scmOHdYnVHR33E9zgNVoj51wuYCU4Alkp4HpgEPAh+QSX4/i4gFkloAL0uaHhGv5tDu9kCfiAhJzYAfRsQaSQ2BR4EfR8TDkkYCAyNiYFGNSBoGDCuYb95smwrsqplVIucOM6sS9WZMWERsjogTgb7ABOBgYD7QPZkeTo40pwGtgL1ybPruiCi4LNEAuEbSHGA2sB+ZSwm5xDc6IjoXTM2aNc9118ysCjl3mFlVqU9nwgCIiAXAAuBWSROAHwIrI6K4hLcJaJg136zQ+jVZn4eRuSzRJyLWShpdRHmzanfqoN9XuI36/qRs5w6rCyqaC+p7Hqhs9eZMmKSdJB2cNd8G2BWYB3wm6RdZ63aX1DaZXQT0SZYPAko6198G+CBJoh2Ak7LWfQZsVyk7Y2bVxrnDzKpKvemEkTnrN1LSG8mlgxeBeyLiUeBYYJCkuZLmA3cABef0LwD+JmkWsC/wSQnb+BvQJ2njPmBi1rpJQNNkG7dU6p6ZWVVy7jCzKlFvLkcmt5YPKGbdW2QuLRS17ilgj6xFI7LWdSlU9l3ggGLa+ZTMmBIzq0WcO8ysqtSnM2FmZmZmNYY7YWZmZmYp0Nd3SFtN0rlz51i6dGnaYZjVa5KWRUTntOMoC+cOs3SVJW/4TJiZmZlZCtwJMzMzM0uBO2FmZmZmKag3j6iobT5f+xmjnvpd2mGYVbuR3/tj2iHUas4dVtn8m6w6PhNmZmZmlgJ3wszMzMxS4E6YmZmZWQpqTSdM0iBJMyXlS1og6VlJDSQ9J+mdZPlCSVdl1dlO0q2S3k7qvCrp+8m645I6+ZI+kLQia/6nku6WdH5S9hxJw3OI8fDk3XJFrWst6eLK+j7MLDfjxo2jd+/e5OXl0a1bN4488kg2b97M4Ycfzq677kpeXh5du3bl0ksv3VLn008/5eyzzwbo4NxhZlWlVgzMl9QRuA3onbzHDUm9gIInzV4QEeMltQFmS5oOPA48CcwG9oyIjZLygCckDY6Ix4DHkrYuB1pHxPlZ2+xf8DkiKuOlua2Bi4E/VUJbZpaD5cuXc9ZZZzFz5kx22WUXAGbNmoUkAK677joGDhzIqlWr2HfffenTpw/HHnss3//+99l3330BPoiIbs4dZlYVakUnDNgR2ASsLFgQEbOALck0WbZK0itAV+ArYBfgiIjYmKzPl3Q1mRfpPpPrxrMTraTGwN+Ao5N4ppLpHB6eFG8k6e/AwWS+39MjYgZwC9AqOdrdGBH7lfVLMKvNnv/LKzmVO+ovR5Wp3UmTJhW77sMPP6Rhw4a0bdt2y7JevXptVa5NmzYccMABLFy4kObNm7NkyRImT57MzTffDDh3WN2R6+8wW2X+Ju2basvlyLnAFGCJpEckDZe0U+FCkjoD/YCZQC9gZkSsL1TsJaB3BWI5C9gD6A4cAvQstL4bcE9E7APcCFydLD8H+Dwi8opKopKGSVpaMK37qnDYZlZWPXv2pF+/fuyyyy6ccMIJXHvttSxbtmyrckuXLmXKlCn07t2bWbNm0bt3b5o0aVK4mHOHmVWqWtEJi4jNEXEi0BeYQOZIcb6k3ZMi1yVHiY8AV0bE5CoM5yjg/ojYEBEbgHsKrV8UEdOTzy8Bu+XSaESMjojOBVPT5lv9D8DMyqhBgwaMHTuWadOmccwxxzB16lS6d+/OokWLALjgggvIy8vjhBNOYMSIERxxxBFVGY5zh5l9Q225HAlARCwAFgC3SpoAHJesuiAixhcqPgsYKqlxkvAKHJSsq7SwCs2vzfq8iVr2HZtVlcMuOiCnclXxYMhu3brRrVs3zj77bI455hgee+wx4OsxYdl69erFDTfcwIYNGwo349xhtV6uv8Nsflhr1akVZ8Ik7STp4Kz5NsCuwFslVHsWeI/MWbJGSb084BLgqhLqleZZ4FRJjZMxHj/Psd5nQHNJPkw1qybLli1j6tSpW+ZXrVrFO++8w267FX+S6cgjj+Rb3/oWF1xwwZZlzh1mVhVqRSeMzBHhSElvJJcdXyQzduLR4ipExGbge0BT4E1JC4F/AOdExNMViOVWYDHwOpmBtW8Bq0urFBErgXuBuZJmVGD7ZpajjRs3MmrUKPbcc0/y8vI45JBDOP300zn++OOLrdOgQQOeeuop1q1bB5lHVDh3mFmVUEThM+JWGkmtIuLz5Gj2ATI3AFxTmdvYbodt48L7zq3MJs1qhZp06UPSsojoXIntOXdYrVOTfpO1QVnyhscclM9ESU2BZmTu2rwh5XjMrHZw7jCzLdwJK4eI6JN2DGZW+zh3mFk2X46soTp37hxLly5NOwyzeq2yL0dWB+cOs3SVJW/UloH5ZmZmZnWKO2FmZmZmKXAnzMzMzCwFHphfQ322bh0jnsv5PcFWT115eP+0Q7AaxrmjbvFvvG7zmTAzMzOzFLgTZmZmZpYCd8LMzMzMUuAxYYCkxcA6YC2wDTAfuCYipklqDdwE5AGbyXRc/wCsAUYlTXQAGgLLkvlrI+IBSf2BEUBnYGVS/x8RcVt17JeZVR3nDTOrKHfCvnZyROQDSBoEPClpAHAasALYOyJCUiugQ0S8CTyWlL8caB0R5xc0Jum7wN3AjyJiWrKsM3Bm9e2SmVUx5w0zKzd3wooQEeMkHQBcBDQGpkXyaoGI+Bz4PIdmRgKjChJpUncpcFkVhGxmKXPeMLOycieseNOB44BzgX9LOhl4CZgQEY/nUL8X8JsqjM9quGlX/qnKt3FUFW5j0qRJVdZ2Hea8UU9V1e+9Kn/j4N952jwwv3gCiIjJwM5kxmisBm6VdHOZG5MekJQv6QNJ2xaxfpikpQXT+q++qmj8Zlb9qjVvJGWcO8xqKXfCirc/MA8gIr6IiCcj4lLgRDLjPUozGzigYCYifhoRecCOFPG9R8ToiOhcMDVp3rxSdsLMqlW15o2kjHOHWS3ly5FFkHQ88D/AgGSg7KsRsSpZ3Rt4K4dmrgTukDQnIl5O2t2mSgK2GqnviIurfBt+mnbN4bxRv1XV792/8brNnbCvjZFUcKv568D3I2K6pAuBv0oSmVvFlwM/K62xiJggaQhwraROZO6UWk9mvEcuA3TNrOZz3jCzcnMnDIiILiWs+yvw11LqX17M8gnAhIrEZmY1k/OGmVWUx4SZmZmZpcCdMDMzM7MUKHmWoNUwnTt3jqVLl6Ydhlm9JmlZRHROO46ycO4wS1dZ8obPhJmZmZmlwGfCaihJG4EP0o6jErQk89Li2s77UbNU1360i4im1bCdSlOHckdR6srfb2F1db+g7u5bSfuVc97w3ZE11we17TJIUSQt9X7UHN6PeqFO5I6i1NV/97q6X1B3962y9suXI83MzMxS4E6YmZmZWQrcCau5RqcdQCXxftQs3o+6ry5/N3V13+rqfkHd3bdK2S8PzDczMzNLgc+EmZmZmaXAnTAzMzOzFLgTliJJe0iaJukNSa9K6l5MuSGS3pT0lqTbJTWu7lhLkst+SDpS0iuSXpc0X9KfJdWov79c/z2SspL0rKTV1RljLsrwd7W3pOck/TeZBlV3rCXJ8e+qgaTRyd/VXEmTJe2eRrzVqa7kjsLqSi4pSl3JL4XVlXxTlGrJQRHhKaUJeBYYnHz+EfBqEWV2Bd4HOgACHgPOTTv2cuzHvsC3k8/NgCkFdWrKlMt+ZJUdBtwOrE477nL+e7QA3gb6JfMNyTxgMPX4y7gfA4HpQONk/lLgn2nHXkO+mxqfO8q5XzU+l5R337LK1tj8Us5/sxqfbyqwbxXKQanvZH2dgPbAZ0CjZF5knnK9e6Fyw4Fbsua/D0xJO/6y7kcR9W4CLk87/vLsB9AdeAHYraYlyTL8Xf0SeDDteCthP44H8oFWSZk/A6PTjr+GfDc1OneUd7+KqFejcklF960m55fy7ldNzzcV3LcK5aAafwq3DvsWsDwiNgJE5l/zXWDnQuV2BpZkzS8uokyact2PLSR1IHNU8Xi1RJibnPYjuZxzO3A2sKm6g8xBrv8eewHrJD0uKV/SvZLaVXOsJcl1P/4DPEcmOS4HjgJGVl+YqagruaOwupJLilJX8kthdSXfFKVacpA7YVatJG1L5o/2zxExI+14yuEyYFxE/DftQCqoEXA0mWS/L7AM+N9UIyqf/YAewE5AJ2AScEuqEVm1qAO5pCh1Jb8UVlfyTVEqlIPcCUvPe0BHSY0gMxCTTA/73ULl3gV2yZrvUkSZNOW6H0hqBUwAHo2ImvYAv1z34zDgN5IWkxmLsq2kxTXoqK4sf1eTI2JZcoR3P3BgtUZaslz34+fAsxGxOiI2A/cAR1RrpNWvruSOwupKLilKXckvhdWVfFOUaslB7oSlJCI+AmYBP0sWnQgsjYhFhYqOBY6T1CH5IzgHeLj6Ii1ZrvshqSWZpDkhIq6q3ihLl+t+RMQhEbFLRHQB+gGfRUSXiFhRrQEXowx/V/8E9k/OJkBmvNCc6omydGXYj7eBIyU1SeaPBeZVT5TpqCu5o7C6kkuKUlfyS2F1Jd8UpdpyUNqD3+rzBHQFXgLeAGYAeyfL/wEcl1XuTOCtZLqD5C6MmjLlsh/AJcAGMgMYC6ZL0o69PP8eWeW7UAMHzpbh7+q0JFnMBZ4CvpV27OX4u2pKZgzNf5P9+D+SO+fq8lRXckc5/81rfC6pyL9ZVvkamV/Ku181Pd+Ud98qmoP82iIzMzOzFPhypJmZmVkK3AkzMzMzS4E7YWZmZmYpcCfMzMzMLAXuhJmZmZmlwJ0wMzMzsxS4E2Z1gqRWktZIuiPtWHIhqbGkGyTNlzRH0uuShqUdl1l949xhaXInzOqKk4GZwKDkidqVouCVFVXgPDLvGdsnIvYBegFPV1bjkhpWVltmdZxzRxbnjurlTpjVFUOAa4AXyCRVJL0hab+CApIGS3ok+dxB0j8lvSLpNUlXZZVbLOkaSa8A9yRlJ0uamRx93iSpQVK2saS/J9t6WdJfJT2X1dZpkqZLmiXpBUn7JKs6Ax9FxEaAiFgbEfOz6v1CUn5ypDtDUpes9uYm0xOSdsrat8mSxkp6DTigpH00sy2cO5w70pP2awE8earoBOwFLAUaAscB05Llvwduyir3PPDD5PPTwGHJ50Zk3kV3UjK/mMxrKQreKNEMaJl8bgg8DpySzJ8LPAM0TqZngOeSdQcDTwJNk/lDgPnJ5+5kXhD7XzKvvDgFaJisOxx4B+iYzLdIph7AB8BOyfJLgKeSz4OBL4GuWftb7D568uTJuSP57NyR4lRVp0vNqtMQ4N6I2CTpSeBWSd8B7gVmS7oQ2AnYE3hK0jbAUcCOkgraaEnmPWEF7o4kA5E5Y3yNpH6AgPZk3oH2cNLO/RGxAUDSPcAvk3rHA/sA07O201ZS84iYL2k3Mi/p7QtcQebdaj9IpvsiYjlARHyZtH0EmZcWL0va+jswMuvywbSIWJiUzWUfzeo7544M546UuBNmtZqkxmQS0AZJpyaLWwBDIuIiSTPIJLTuZBLeRknNknIHRsTaYppek/V5GJnk2Sci1koaTeYItyjZL2MVcE9E/L7IghHrgWeBZyX9A1guqW2JO1z8tgrHXJA9S9pHs3rLuaPYmJ07qpHHhFltdxzwdkTsFBFdIqILcCBwWpJk7wLOAH4O3AkQEWuAycDFBY1I6iSpczHbaAN8kCTRDsBJWeueBU5Nxnc0TrZT4DHgZ5J2TrbRoGCciaRDJXXMKtsbWAmsBv6T1OuYlG0hqUUS8zGSOiV1zgEmRcSmwgGXYx/N6hvnDueO1PlMmNV2Q4AHshdExH8lLQN+CDwK/C/wZkT8N6vYT4HRkuaROSr8AjibzPiQwv4G/FvSfOB9YGLWuluBvYHXgVXADDJ3LhERL0r6f8Ajytwp1QR4IimzM3B9cmS9nsyR6PERsRl4QdIVwNOSIln/o4iYJ2k4MCG5TPAecGYJ301Z9tGsvnHuKJ5zRzUpGDxoZuUkqVVEfJ4czT4AzIyIa9KOy8xqNucOcyfMrIIkTQeakhnrMQX4TUR8lW5UZlbTOXeYO2FmZmZmKfDAfDMzM7MUuBNmZmZmlgJ3wszMzMxS4E6YmZmZWQrcCTMzMzNLgR/WWkM1bdo02rVrl3YYZvXasmXL1kdE07TjKAvnDrN0lSVvuBNWQ7Vr146lS/1wYrM0SVqRdgxl5dxhlq6y5A13wmqoLzeu5I75P007jHpvSPcHSi9kVoM4d9Q/zlO1l8eEmZmZmaXAnTAzMzOzFLgTZmZmZpaCKu+ESWok6TJJCyTNk5Qv6TZJrUuoM1jS+OTz4ZLyk8+dJD0taaGkuZLGSmqXVS9KarcC+9Ba0sWFlv1D0hGVvS0zy9i4cSNXXHEF3bp1o0ePHuTl5XHWWWexevXqYuvcfffdDBw4EIDnnnuOvLw8AN5//30GDBhA165d6dmzJyeeeCIrVnw9dlZSie2Wl3OHmZWkOs6E3QHsBxwUET2AfYFngLblaGsTcGVEdI2InsDbwLWVFmnxWgPfSKQR8cuImFwN2zarl4YMGcKMGTN46aWXmDdvHrNnz6Z///6sXLmyzG01bNiQESNGsHDhQubOncu3v/1thg8fXgVRb8W5w8yKVaV3R0raHTgJ2DkiVgFERAD/StafBvwaaAysAX4TEXOKay8iPgQ+zFo0Palf1Lb3A24AWgJrgQsiYmqy7gfA5UATIICzI2K6pAeArsny94AhEfEBcAvQKjkjtzEi9pP0HHB9RIyX1D4pswcg4MaIuDXZ1mLgXqA/0AG4IyKuyukLtEr14NAPyl6Ho8pcZ9KkSWWuY9+0aNEi/vWvf/Huu+/Spk0bIHO26qSTTgLgvvvu46abbmLDhg20bNmSG2+8kX322afY9nbccUd23HHHLfN9+vThpptuKrLsjBkzGDp0KGvWrAFoL+lg5w6rauXJT1vqliNPFcf5q3pV9SMqegFvRsTHhVdIOhj4CXBoRKyTdAjwINA9l4YlNSTTAXu0iHVNgHHAmRHxtKR+wNikU9gJuCvZ7gJJjYEWSdXzI2JF0sbFZJLtOcmUHxF5xYRzI7AwIgYlSXWmpDkR8XKyvnVEHCRpB+AtSXdFxLJCMQ8DhhXMN2/ZOJevwaxOmjVrFnvssQc77LDDVuumTp3KQw89xAsvvEDTpk158cUXOfXUU5k/f35ObW/atImbbrqJ448/fqt169evZ9CgQdx+++0MGDAASatx7jCzKpLmc8KOB/YBpksqWNZWUvPSKipT4e/AKuBvRRTpCmyOiKcBImKKpA+BvGSbEyJiQbJuA/BpUu/U5Oxcs2TaqvNYjKOB3kl7H0kalywrSKQPJus+lvQ2sCvwjUQaEaOB0QXzbTu0iBy3bVavPProo8yZM4c+ffpsWbZy5Uq++uqrUutGBL/61a9o06YN55133lbrFy5cSIMGDRgwYEDBovXAJzh3mFkVqOpO2CxgD0nbR8QnhdYJuCcifl+4UlanrDg3AN8CBkbE5hxjKTExJWfLhpIZu/aRpOOAUTm2Xdq21mZ93oQfkpuKU2/oUOY6fghiOnr16sWbb77JJ598wvbbb/+NdRHB6aefzh/+8Icytzt06FDee+89xo8fT4MGOQ+Jde6wKlee/FTAear2qtKB+RGxCBgL3FFw16IyTgQeB34maedkeYNkHFeJJN0A7A6cEBHriym2EGggqX9Spy+ZMRX5wNPAAEndknWNJW0HtAE+Bz5JLmeendXeZ0DzZHlRJgJnJu21AwaRufnAzMph991358QTT2TIkCFb7lqMCMaOHcuxxx7L/fffz7vvvgvA5s2bmTFjRqltDh06lEWLFvHII4/QpEnRP+WuXbuyefNmnnlmy8+3Cc4dZlZFquPuyDOAOWQuO84HXge+myz7f8AjkuYA84FTSmooGUf2G6BL0l6+/n979x5nRV3/cfz1BkFA0SBFURL8aUKisIKKoua9yJ93M00zLRMs7SeipKUioqZmoqmVtww1UyrwUiEl4A3wgsCKYmgWaBDeEQVFbp/fHzOLx5XdPWf37M45u+/n4zEPz8x85zuf2cP5+J3vfGdGuq96ubRxdjRwiaQ5wHXA1yNiWdow/A7wu3S/T5NcvpxI0nh7CXiCJOlW1fcuyQDZOZLWl+3/D/iSpOeBR4DLI+LpfP44ZrZ+t99+O3379mXAgAH07t2bHXfckb///e/07duXn/3sZxx11FH07duX3r17c++999Za17Rp07jhhhtYsGABAwYMoKKigqOOOuoz5dq2bcv48eO5+OKL6dOnDyR3Nzp3mFmjUHKzopWazlt2iKsnf/Z/Eta03M3fsklaFBHdso6jEM4dLY/zVGkpJG/4iflmZmZmGXAjzMzMzCwDvhxZorp16xYLFy7MOgyzFq0cL0c6d5hly5cjzczMzEqcG2FmZmZmGXAjzMzMzCwDfvpyiVqz+h1e/cf/Zh2GNYLuX/pr1iFYM+bc0XI4l5Q/94SZmZmZZcCNMDMzM7MMuBFmZmZmloEmaYRJOlrSzPRdj/MkTZFU731LGimpXc78KEkn5rHdGElD08+nSFoqabakf0h6TtLFktqn6y+WdFvOtntLCkn75Sy7SdKl6ecFkirWs8+d0+N9TtILkmZI2qm+x27WkowfP57+/ftTUVFBr169OOCAA1i7dm296xs5ciQrVqxYNz9ixAjuvrvuV744d5hZY2j0gfmSugK3AP0j4tV0WT+gIU+JvZjkpdwrACJiRD3reSQijkxj6gLcBowFDid5me7tOWX3J3lh737AoznLTq9jH/cAF0XEfel+vgB8XM94zVqMxYsXM3jwYGbOnEn37t0BmDVrFpLqXecll1zC0KFDadcuOYcbNWpUfaty7jCzBmuKuyO3ANYA71YtiIhZkJwBAn8EDgA2BW6OiKvTdT8H9gXaAO8Dp0XES5JuSqt5QtIa4CvAz4DKiLhO0oHAZUA7oC0wOiJ+U1eQEfGmpJOBRZJ6A08BW0nqFhELSRLoKOBHaXxdgW2AJ+uouhuwKGc//6krFis/3z1zRd2F1jmwoLonT55cWDDNxBtvvEHr1q3p3LnzumX9+vUDoEePHhx77LFMmTKFpUuXMmTIEIYPHw7Aueeey2OPPcaqVavYZJNNuPXWW+nZsyenn560efbZZx9at27N3//+d370ox9RUVHB0KFDmTx5MhdeeCErVqxg5cqVDBs2LK84nTusUIXli9oUlkvy0VLzTVaa4nLkHGAq8Kqk+yQNl7R1zvotgF2BPYAfShqYLr8qInaLiArgV8AvACKi6uxxn4ioiIg3q+1vFrB3ROwC7AOMkJTX6wMiYgnwT6B3RKwEpgP7S9oQ2DYiJgDd0kuh+wNPRkRdv6ZLgUckTZZ0uaRd1ldI0jBJC6um5ctX5xOyWbPVp08f9t57b7p3785RRx3F1VdfzaJF69okvPHGGzz77LM89dRT3HDDDUyfPh2A8847jxkzZlBZWckPfvADzjrrLABuuik5f3viiSeorKykS5cun9pfv379mDp1KrNnz+aJJ56o6iVrnU+szh1mVjlCg0MAACAASURBVB+N3giLiLURcQwwEJgI7AXMlbR9WuQ3kXgbGA8clC4/WNKTkl4ARgCfGTNRg88Df0y3m5LOFzKOIvdaxyMkZ7EDgGfSZU8Be6bLH6mrsoi4BvgfkssVnUl68I5bT7nREdGtatpoIz/CzVq2Vq1aMW7cOKZPn86gQYOYNm0avXv35pVXXgHg1FNPRRKbbbYZRx99NJMmTQLg4YcfZs8992SnnXZi1KhRVFZW5rW/d955h2OPPZaddtqJAw44gHfeeQcKu1rg3GFmBWmyX2tEzAPmATdLmkgydmK9RSVtA9wI7BYR/5LUB3g8z13dBEwAjomIkDSL5NJknSR1ArYHXkgXPQKcCrzGJ2M5HiM5k90fOCWfeiPiDZLxHfdIehU4kWT8iDUTt9+Y1z8xwA9YLFSvXr3o1asXQ4YMYdCgQTz44IPrLSeJ1157jTPPPJMZM2aw3XbbMWfOHL785S/ntZ/TTz+dQw45hHHjxiGJfv36MXv27LwGoDl3WCEKyRe1cS4pf43eEyZpa0l75cx3ArYF/pUuOiVd3hk4CphMMj5sFbBYySjcM6tV+0FaZn06Aa+mDbAvA33zjHNzksG0kyLixXTxDKALSeJ7NF32GHA80JVPznBrq/coSW3SzxsAffjk2M2sBosWLWLatGnr5pcsWcL8+fPZbrvtABgzZgwA7777Lvfddx8HHnggS5cupU2bNnTt2pWI4MYbb/xUnR07dmTp0qXr3d+SJUvo3r07knj88cd57rnn8orTucPM6qspxoRtQDIu62VJlcATwB0R8UC6/i1JM0mS0o0RMT0ingfuBeaSJLPXqtV5DfCwkkdedKm27nzgynRf3yW5K6km+6e3mc8DJgHPAeu6+yNiFcl4to5pTx4R8TLQEZiars/1t9yxGelYtKOBFyTNSev/mOTuTjOrxerVqxk1ahQ77LADFRUV7LPPPpx88skcccQRAGy++eb079+f3XffnTPPPJOBAwey8847c/zxx9O7d2922203ttlmm0/Vec4553DwwQdTUVHBm29+ejjplVdeyfnnn09FRQW33347AwYMqC085w4zazBFNORJEQ3ceXJ35JERkd+gjRak65bt46lHDsg6DGsEvoTQcD169OD++++noiLfoaL1I2lRROR1Y0+pcO5oOZxLSlMhecNPzDczMzPLQKa30UREjyz3b2blacGCBVmHYGbWYL6XuUS13uDz7mo2s4I5d5iVD1+ONDMzM8uAG2FmZmZmGXAjzMzMzCwDHhNWoj7+aBWTxs/MOgxrgIOO7p91CNYCOXdYfThfZcM9YWZmZmYZcCPMzMzMLANuhJmZmZllwGPCWPf6pI+Bj4D2wG8j4sp0XRfgKmBfYCkQwJ+Ad4HT0yq2Sbd9K50/GzgZOBh4E9gYeAO4OSLuavwjMrOm4NxhZg3hRtgnjouISklbAy9KmgI8DzwGjAW+GBFrJHUATouIm4CbACSNASoj4rqqyiSdDFxdtUxSBTBW0uYRMbpJj8zMGpNzh5nViy9HVhMRi4B5QHfgBOCDiBgZEWvS9R9GxC/qUW8lcBZwniQVM2Yzy55zh5kVyj1h1UjqBXweeBS4BHiyiNU/DXQBNie51GBl5Ipf/qjA8vXbz+TJk+u3oWXKucOyUGheqrmeolTzGc5ntXMj7BNjJa0FegJnR8RbjXDSWWOFkoYBw6rmN+qwcbH3bWaNw7nDzOrFlyM/cVxEfAn4CnClpJ2BmcAeRdzHbsCbEfGZM9mIGB0R3aqm9u06FHG3ZtaInDvMrF7cE1ZNREyS9GvgMuCbwI8kXQT8NB1c255kcO31hdQrqQ9wHcndUlaGfnzGzwoq7ydQtyzOHZaFQvNSTZyvsuFG2PpdCrwCfInk9vIrgVckLSO5zfz3edYzXNIpQAeScRxXRMSdxQ/XzEqEc4eZ5c2NMCAielSbX0IywLbKKXVs/5n161tmZs2Lc4eZNYTHhJmZmZllwI0wMzMzswz4cmSJ2rB9Gw+UNLOCOXeYlQ/3hJmZmZllwI0wMzMzswy4EWZmZmaWAY8JK1ErV77F40/tlXUYVmRf3mNa1iFYM+fcYY3Neax43BNmZmZmlgE3wszMzMwy4EaYmZmZWQaa/ZgwSUcDFwCtgXbAf4EVwFZpkb7AC8Aa4IOI2EdSpMvWAm2AqyPit2l9+wHXRURFOl9VNtL6ZwKXRsSL6fqRwBnAopyw/hgRlzfSIZtZEYwfPx6gi6RKnDvMrBE060aYpK7ALUD/iHg1XdYPmB0Rkc4HsE9EvFdt830i4j1JfYEZkiZGxOIadlVVthUwGJgmqV9EzE/X3x0RQ4t9fGbWOBYvXszgwYMB3slpNDl3mFlRNffLkVuQnKW+W7UgImZVJdF8RMRzwBKgWx5l10bETcDfgB8UHq6ZlYI33niD1q1bQ9KjBTh3mFnxNeueMGAOMBV4VdJjwHTg9xGxqPbNPiFpX+Bt4LkC9vs0cHDO/InppYgqV0TE2ALqsxJzyQXt6rnlgfXe5+TJk+u9rRWmT58+7L333owfP76rpPtw7rBmov65K1f981hNWmp+a9aNsIhYCxwjqRewL/A14AJJu0bEK3Vs/oSk9sC2wNcjYmUBu1a1+TovKUgaBgyrmt9oo9YF7M7MiqlVq1aMGzcOSW8CE3HuMLNG0NwvRwIQEfMi4uaIOBJ4Cjg8j832iYjtgVOBMZK2KGCXu5EMuC0kxtER0a1q6tDBidSsBKx27jCzxtKse8IkbQ30iIhp6XwnkrPTf+VbR0SMkXQ48BPgrDr214ok8Q4C+tU3bit9F1++ol7b+UnT5WHRokUsWLBg3bxzhzUX9c1duZzHiqdZN8JIjm+EpG2BD9P5OyLigQLrOQ+YKelnNax/Ir1Tqh0wC9gr5+4m+Oy4jkci4uwCYzCzJrJ69WpGjRoFsEX6iArnDjMrOhVws481oS5dNow/Pbhr1mFYkfkMsrxIWhQRdd7dWEqcO6yxOY/VrpC80SLGhJmZmZmVGjfCzMzMzDLgRpiZmZlZBpr7wPyy1bbt5r7ubmYFc+4wKx/uCTMzMzPLgBthZmZmZhnw5cgStWzVGq6e8Z+sw7AMDd/tC1mHYGXIucMai3NS8bknzMzMzCwDboSZmZmZZcCNMDMzM7MMuBFmZmZmloEW1QiTtEDSS5Kek/SKpAckDWxAfUMlbZl+3l3S65I2qFbmKElz0s+PSjqyYUdhZk3NucPMGkOLaoSljouIvhGxPXAHMEHSgHrWNRTYEiAingHeAr5WrcypwG/qG6yZlQznDjMrqhb9iIqIGC9pd+BcSScAlwIHAG2Bl4EhEbFE0veAYcBKoDXwPeCrwFbAWEkfAaeQJMzvAn8GkNQV2B84uSmPy7I18fxTilNPUWpJTJ48uYi1mXOHlYti5SMobk7K1ZLzU62NMEmH1LY+IiYUN5xMPA0cDgwHlkfE7gCSLgIuA84ArgF6RcRiSW2ADSPiaUnfJTk7rky3WQhcJmnziHiLJIH+JSLeqSsIScNIkjUA7TbuWNSDNGtKEybUnhoOOaTW1FIunDvMrEHq6gn7cS3rAmgOjTCl/z0S2FTSMel8W2BB+nkycJekPwMPRcTL66soIt6WNAE4CRgNfAf4YT5BRMTodBsAPrdF1yjwOMxKxhVXXFHjOknNpRHm3GFmDVJrIywi9mmqQDK0G/ACsC3ww4j4+3rKHAP0B/YjGQdyYUTcW0N9vwF+LukZoB0wqfghWykbdOWYotRTzk+nfuKJJ7IOoSk4d1jJK1Y+gvLOSaUq7zFhko4CDk5n/xYRDzROSE1H0hHA90nGaBwEnC1pakR8KKkDSXJ9CegREc8Cz0raDNgduBd4H9i0WrUPp8uuBX4bEWub5mjMStN9993Hww8/DMBXv/pVjjjiiIwjajjnDjMrhrwaYZIuAL4B3EVyGXKkpB0jouZrDqVrrKQVwEbAi8Ah6RiNmcCGwNOSqrrzrwJeAW6X1BlYTXIX03fS9dcDt0r6EDglIiojYq2k3wIXAV9vusMyKz2XX345f/jDHzjppJOQxMiRI3nxxRf58Y9rG+lQspw7zKyoFFH38AFJzwN7RsSydH5j4MmI2LmR42uxPrdF17jgL89kHYZlqDl0/e+88848+eSTbLzxxgAsW7aMPffck+effz7jyPIjaVFEdMs6jkI4d1hjaQ45qSkUkjfyfk5YVQOs+mczs9pUNcCqfzYza+nyHRP2bNpNfms6/z3g2cYJycyai1133ZXvfOc7nHbaaQDcdttt7LrrrhlHZWZWGvK9HLkxcAlwYLpoEjDSPWKNp1u3brFw4cKswzBrkGXLlnHxxRevexjjQQcdxMiRI8umR6wcL0c6d5hlq5C8kVcjzJqeE6lZ9twIM7NCFX1MmKSNJf1C0ovpdG3aO2ZmVqNly5Zx1llnseOOO7Ljjjty9tlns2yZO9DNzCD/gfm/BDYGvk3yROeNgF81VlBm1jycccYZLFu2jDvvvJO77rqL5cuX84Mf/CDrsMzMSkK+A/N3iYg+OfODJc1pjIAssXbFSt7+s28zt/rZ7LDdsw4BgNmzZzNnziep4pZbbqFPnz61bGEN5dxhxVYq+aQ5yrcnTJI2ypnZiE/em2Zmtl4RwfLly9fNL1++HI9DNTNL5NsTdjfwpKSqd54dR/L0fDOzGp144onsueeeHH/88QCMHTuWk046KeOozMxKQ16NsIi4UtILJO9IA7ggIv7SeGGZWXNw/vnns9NOOzFpUvIu6ssvv5xDDz0046jMzEpDrY0wSfdExDcB0kZXgxpeko4GLgBaA+2A/5I07P4PuDciXm9I/WZWGr75zW9yzz33AHDooYc2uOE1fvx4Lr/8ctasWcOKFSvYaqutmDRpEtdffz3HH388W265ZTHCNjNrUnX1hPUq1o4kdQVuAfpHxKvpsn4kLwQfCjwKFNQIk7RBRKwuVoxmVhzz5s0rWl2LFy9m8ODBzJw5k+7duwMwa9YsJHHdddex3377FdwIW716NRtskO9oDDOzxlFXFirmCNotgDXAu+sqj5glaQSwFTBW0kfAKcBc4FLgAKAt8DIwJCKWSBoDrAW2B7oAvSTtBlwFbELSy/bTiPgjgKSTgOHpLv8DDI6IRZL2IHn0RmuSv8MvI+LXkjYFrgH2SOOdGRHfTZ+Ldj1QdZvIHyPiknQfjwLPp9t0Ah4Azo2IkLRlul0PoD3wQERc2PA/pzU3x1334+JVdl3xqqpS9dT7fEjFu2/njTfeoHXr1nTu3Hndsn79+jFq1Cj++9//ctxxx9G+fXvGjBlD7969ueiii5gyZQorV65khx124Oabb6ZTp06ccsoptGrVildeeYU333yTefPmMWPGDM477zzef/991qxZw09+8hOOPfZYAO666y6ALumd4M4dVvbqnWMamE8KyR0tTV2NsD6S3l3PcgEREZ3Xs64mc4CpwKuSHgOmA7+PiFGSvgscFxGVAJJ+AiyPiN3T+YuAy4Az0rr6A3tHxAeSPkfSw3ZIRCyWtBkwS9J0kqR2NUnv2yJJFwC3AV8Dfgz8PCLuSffRKa37OuAjoE9ErJW0ebr8ImBDoA9JQpwqaV5EjE3X7wgMBNoAjwPfBH4P3EHSKHxM0gbAXyQdW9VIXPcHlYYBw6rmN+ngZ+Fa+ZozZ86nGk1VIgJJvPvu+tLK+vXp04e9996b7t27s++++zJw4EBOOOEERowYwe23387YsWOpqKgA4Kc//SkbbbQRzzyTPKLh0ksv5cILL+SXv/wlADNnzmTq1Kl07NiR9957j8GDBzNhwgS6du3K22+/Tb9+/Rg4cCBLlixh+PDhAG9HRB/nDjNrDHU1wl4CDinGjiJiLXCMpF7AviTJ7AJJ63ub75HAppKOSefbAgty1v8xIj5IPw8E/gd4qNrZd0+gNzAxIhaly34FjJDUGngEuEjSF4EpETE1LXMoMCCNl4h4K11+EHBOuny5pDuBg4GqRHpnRKwCVkn6HXCQpAdI3re5RU5sG6exVf/7jAZGV81vtVkX38dvZatnz55MmDChKHW1atWKcePGMW/ePB577DEeeughLr/8cp599tnPlL3//vtZunQp48aNA2DlypX06NFj3fpjjz2Wjh07AjB9+nT+/e9/87Wvfe1Tdbz00kvMnTuXQYMGcccdd6xNFzt3mFnR1dUI+7hq/FaxRMQ8YB5ws6SJwOHrKSbghxHx9xqqWVat7NyIGPiZSqTe1XefE8d1aaI7CPippBciopBHedeV6IJPnqW2R0SsKKBua4HGDr2iaHVl/XDFDTfccN34rWLp1asXvXr1YsiQIQwaNIgHH3zwM2UightuuIGvfOUr660j98XhEUHv3r2ZPn36Z8rNnTv3M1XnbOfcYWWpvjkm63zSnNX1sNaiDeyQtLWkvXLmOwHbAv8C3gc2zSl+P3C2pA5p2Q7raVBVmQ5sK6nq8RlIqpDUluSMdZCkrdJVpwOTI2KNpJ4RMT8ibgV+SjImA+BB4FxJrdK6qi4pTAJOVWIjktc35TYSvyWpjaT2wAnApIhYlsZwfk5sW0kqqxcCmxWqmA9kXbRoEdOmTVs3v2TJEubPn892223HJptswtKlS9etO/LII7n22mv58MMPAfjwww/X16ACYODAgcyfP3/d4zMAKisrWblyJfvvvz8TJ06ET3Kkc4eZFV2tPWERsUuR9zVC0rbAh+n8HRHxQJqsbpX0IcnA/KtIxlA8Lakqm19FMmC/eoxLJP0v8HNJ15CMq3gNODIiXpA0HJiYdun/Bzgt3fRMSQcAK0kG0Z6TLj8buBZ4XtIqYEa6zaUkg2SfT8v9MSL+kBPKP4BpQGeSwbVVD7Y9ERidPmctgOXAEGBhIX88s3Iye/bsotW1evVqRo0axfz58+nQoQOrV6/m5JNP5ogjjuCtt97itNNOo0OHDowZM4bzzjuPjz/+mAEDBqy7OeC8886jd+/PnsN16tSJv/71r5x77rmcc845rFq1im222Yb777+fnXbaiauvvppvf/vbm+UMzHfuMLOikl8h0nDpHU7XRcT9xapzq826xJzf+nm4Vj++fFAckhZFRKP1Pjl3WDlwPilMIXkj33dHmpmZmVkR+WmFRRAR+2Udg5mVH+cOs5bNjbAS1apdW3cBm1nBnDvMyocvR5qZmZllwI0wMzMzswy4EWZmZmaWAY8JK1EfrVzJ2CefyToMKzPH7emxQC2dc4cVg3NJ03BPmJmZmVkG3AgzMzMzy4AbYWZmZmYZKLsxYZIq049tgZ588j62lyLiuGyiMrNSV1FRAcDKlSt56aWX2HnnnQHo2bMnY8eOzTI0M2uhyq4RFhEVAJJ6AJVV801F0gYRsbop92lmDVdZmZy/LViwgIqKinXzTcW5w8yqa1aXIyVtLekRSTMlzZX0C0lK131P0t8k3SvpeUnPpA25qm0vk/SKpBmSLpf0Srp8e0lvS/q5pFnA9yV9RdKTkmZJekHSKTn1/E7STZImS5ov6VZJe0h6TNK/Jf2saf8qZlaXRYsWsf/++9O/f3969+7NWWedRUQAzh1m1njKriesDu8Ch0XEMkkbAH8GjgH+lK4fAPSNiFcl/RwYDpwh6QjgMKACWA7cWa3ezwOzIuJcAEmdgL0jYo2kzYBZkv4WEYvT8jsBB6af5wGdgIOAdsC/Jd0eEfOKfvTWbNxy4Y/rt10D9jl58uQGbF3eOnfuzJ///Gc23nhjVq9ezWGHHca4ceNyizh3WFkrNKfUN5e05DxSH82qJ4zkeK6W9BwwC9iFJDlWmRoRr6afnwS2Sz8fCPwhIpZFcvr7m2r1rgDuyZnfHPiTpBeASUBnoHfO+vsj4uOI+Bh4AZgYEasi4gOSxLp99cAlDZO0sGpa8eFHhR+9mdXL2rVrGT58OH379qVfv37Mnj27+uVK5w4zK7rm1ggbTnLmOCAi+gB/IDmDrLIi5/Maau4JjGrzy6Pq2kTiFuBRYOd0TNq/69hPnfuNiNER0a1qatehfQ2hmVmxXX311SxZsoSnn36aOXPm8I1vfIMVK3J/ts4dZlZ8ze1yZCdgcUSskNQV+Drw+zy2mwJcLOk64EPgu3nsZ0FEhKT9SS4hmBXN4MuuqNd2fsp1/SxZsoSuXbvSrl07Fi9ezJ/+9CdOOOGEfDZ17rCyUGhOcS5pGs2tEXYd8Ie0q/+/wMP5bBQR90vaHagElgKPA+/Vssl5wA2SLiG57DmjQVGbWaaGDh3KN77xDXbaaSe22morDj744Ly2c+4ws4bQp3vKWy5JHSPig/Ruyl+Q/G1+mFU8n+/SJX71wF+y2r2VKZ+9FpekRRHRrY4yzh3W7DiX1F8+eaNKc+sJa4i7JX2BZHzG88DpGcdjZuXBucPM6sWNsFREHJ51DGZWfpw7zKy+3AgrUe3btnV3sJkVzLnDrHw0t0dUmJmZmZUFN8LMzMzMMuBGmJmZmVkGPCasRH24/GN+80u/g8vs1DMOrLuQrePcYeXCv233hJmZmZllwo0wMzMzswy4EWZmZmaWgRbVCJN0tKSZkiolzZM0RVKT/A0kVUg6vin2ZWbF5dxhZo2hxQzMl9QVuAXoHxGvpsv6AUV5eaakDSJidS1FKoAjgXuLsT8zaxrOHWbWWFpST9gWwBrg3aoFETErIkLSFyX9VdIMSXMknVlVRlJI+lzO/NuSeqSfF0i6StIzwB2StpT0SHrGPFfSjZJaSeoCjAL2T8+kb2qiYzazhnPuMLNG0WJ6woA5wFTgVUmPAdOB3wOvA/cA34qIeZI6AE9JejoiZuRR7+eBAWlCbgccFhHLJLUGHgC+ERH3ShoBHBkRRzbGwZll7ffjf1pW9U6enPdjHJw7zHIU6zfZGL/tAn7XJaHF9IRFxNqIOAYYCEwE9gLmAr3T6V5JlSQJtiOwY55Vj4mIqssSrYCrJD0HzAZ2JbmUUCdJwyQtrJpWrPgo30Mzs0bk3GFmjaUl9YQBEBHzgHnAzZImAocB70ZETQlvDdA6Z75dtfXLcj4PA7qQnN2ukDR6PeVrims0MLpqvnOnzYsy3sTMisO5w8yKrcU0wiRtDfSIiGnpfCdgW+DXwPuSvhMRv03XbU+SXN8FXgEGABMkHQ1sVMtuOgGvp0l0S+BYYFy67n1g00Y4NLOScMLRP2mUerN+qrZzh9mnFeu3nvVvuxS0mMuRJA3OEZJeTi8dPAHcEREPAIcCR6cDa+cCvwHap9udDfxC0ixgF+CdWvbxC2BAWsddwKScdZOBDdN9eHCtWflw7jCzRtFiesLSW8u/WsO6f5FcWljfuoeAL+YsuihnXY9qZV8Ddq+hnqUkY0rMrIw4d5hZY2lJPWFmZmZmJcONMDMzM7MM6JM7pK2UdOvWLRYuXJh1GGYtmqRFEdEt6zgK4dxhlq1C8oZ7wszMzMwy4EaYmZmZWQbcCDMzMzPLQIt5REW5+WDF+4x66MdZh2ElbsTXrsg6BCsxzh3W3DTnPOeeMDMzM7MMuBFmZmZmlgE3wszMzMwyUDaNMElHS5opqVLSPElTJLWS9Kik+enylyRdlrPNppJulvTvdJsZkg5J1x2eblMp6XVJb+XMnyhpjKShadnTJQ3PI8b90nfLrW/d5ySdX6y/h5nlZ/z48fTv35+Kigp69erFAQccwNq1a9lvv/3YdtttqaiooGfPnlx44YXrtlm6dClDhgwB2NK5w8waS1kMzJfUFbgF6J++xw1J/YCqJ82eHRH3S+oEzJb0NPAXYAIwG9ghIlZLqgD+KumUiHgQeDCtayTwuYgYmrPPg6s+R0QxXpr7OeB84Moi1GVmeVi8eDGDBw9m5syZdO/eHYBZs2YhCYBrr72WI488kiVLlrDLLrswYMAADj30UA455BB22WUXgNcjopdzh5k1hnLpCdsCWAO8W7UgImZFtcf9R8QS4BmgJ3Ag0B0YFhGr0/WVwOXkvEg3H5JGSrou/dxG0q8kvSzpKUnXSHo0p/gG6frnJM2VtGu6/CagY3q2/Gwh+zez+nnjjTdo3bo1nTt3XresX79+6xphVTp16sTuu+/OSy+9xOTJk3n11VcZPXr0uvXOHWbWGMqiJwyYA0wFXpX0GDAd+H1ELMotJKkbsDfwa2A3YGZErKxW15PA1Q2IZTDwRaB3Oj+h2vpewKkR8QNJp5Mk7q8CpwOVEVHRgH1bM/PYz59p0PYH/vzAem87efLkBu27HPTp04e9996b7t27s++++zJw4EBOOOEEtt5660+VW7hwIVOnTuX73/8+M2bMoH///rRt27Z6dc4dZkVSSO6rT54rl/xWFj1hEbE2Io4BBgITgb2AuZK2T4tcm46nuA+4NCIeacRwDgR+FxGrImIVcEe19a9ExNPp5yeB7fKpVNIwSQurpo8/qt52NLNCtWrVinHjxjF9+nQGDRrEtGnT6N27N6+88goAZ599NhUVFRx11FFcdNFF7L///o0ZjnOHmX1KufSEARAR84B5wM2SJgKHp6vOjoj7qxWfBfyfpDZpwquyZ7quaGFVm1+R83kNef6NI2I0sO76x6abbeI3q5sVSa9evejVqxdDhgxh0KBBPPjgg8AnY8Jy9evXj+uvv55Vq1ZVr8a5w8yKqiwaYZK2BnpExLR0vhOwLfCvWjabAvyHpJdsaM7A/AuA7zYgnCnACZJ+n85/O8/t3gfaS2q7nkuk1kLte+7uDdq+OT9JuhgWLVrEggUL2GuvvQBYsmQJ8+fPZ7vtau5kOuCAA/jCF77A2WefvW6Zc4dZcRWS+5pzniuLy5EkjcUR6YDWSuAJ4I6IeKCmDSJiLfA1YEPgn5JeAm4DTo+IvzUglpuBBcCLwDSShuB7dW0UEe8CdwJzPLjWrGmsXr2aUaNGscMOO1BRUcE+++zDySefzBFHHFHjNq1ateKhhx7i448/huQRFc4dZtYoVO0GQ8uDpI4R8YGkLl+4rwAAC1xJREFUNsDdJDcAXFXMfWy62SZxzl1nFLNKa4aa8xliKZC0KCK6FbE+5w6zApVbniskb5TF5cgSNEnShkA7krs2r884HjMrD84dZraOG2H1EBEDso7BzMqPc4eZ5SqXMWFmZmZmzYrHhJWobt26xcKFC7MOw6xFK/aYsKbg3GGWrULyhnvCzMzMzDLgRpiZmZlZBjwwv0S9//HHXPTow1mHYSXo0v0OzjoEK2HOHWafVap50z1hZmZmZhlwI8zMzMwsA26EmZmZmWXAjTAzMzOzDHhgPiBpAfAxsALYCJgLXBUR0yV9DrgRqADWkjRcfwosA0alVWwJtAYWpfNXR8Tdkg4GLgK6Ae+m298WEbc0xXGZWeNx3jCzhnIj7BPHRUQlgKSjgQmSvgqcBLwF7BwRIakjsGVE/BN4MC0/EvhcRAytqkzSV4AxwNcjYnq6rBtwWtMdkpk1MucNM6s3N8LWIyLGS9odOBdoA0yP9NUCEfEB8EEe1YwARlUl0nTbhcDFjRCylaHpl15Zr+0OrOd2kydPrtd2lh/nDbPiq2+erK6+eXN9iplLPSasZk8DvYFfAOdJminpRkmH5rl9v7SOvEgaJmlh1bTyo4/qEbKZZaxJ8wY4d5iVMzfCaiaAiHgE2IZkjMZ7wM2SfllwZdLdkiolvS5pk+rrI2J0RHSrmtq2b9/Q+M2s6TVp3kj35dxhVqZ8ObJmuwEvAETEcmACyXiPvwB/B86oY/vZwO7pf4mIEwEkBW78GjDwovPrtV2pPvnZAOcNs6Kqb56srlTzpn/U6yHpCOD7wDWSviKpU87q/sC/8qjmUmCEpD1y6t2ouJGaWalw3jCzQrkn7BNjJVXdav4icEhEPC3pHJKkKpJbxRcD36qrsoiYKOlU4GpJW5HcKbUS+CH5DdA1s9LnvGFm9eZGGBARPWpZdw1wTR3bj6xh+URgYkNiM7PS5LxhZg3ly5FmZmZmGXAjzMzMzCwDSp8laCWmW7dusXDhwqzDMGvRJC2KiG5Zx1EI5w6zbBWSN9wTZmZmZpYB94SVKEmrgdezjqOJbEzyYuOWwMdaXjaPiA2zDqIQJZw7SvnfQ6nGVqpxQenGVgpx5Z03fHdk6Xq93C6D1JekhT7W5qclHWuJKcncUcr/Hko1tlKNC0o3tlKNqya+HGlmZmaWATfCzMzMzDLgRljpGp11AE3Ix9o8taRjLSWl+ncv1bigdGMr1bigdGMr1bjWywPzzczMzDLgnjAzMzOzDLgRZmZmZpYBN8KamKQvSpou6WVJMyT1rqHcqZL+Kelfkm6V1CafdaWkoccqaT9JH0mqzJnaN+1R1C2f45TUQ9KjkpZKqlzP+mbzndZ2rOXynZa6YuSRrOKq67eQcWwHSHpG0ouS5kr6maRG/f9knnHtmfN7mSvpZkmN+vy6fP+NpWUlaYqk9xozpkJiK5tcExGemnACpgCnpJ+/DsxYT5ltgf8CWwICHgTOqGtdqU1FONb9gMqsj6NIx9kZ2Bv43+rH1Ay/09qOtSy+01KfGvrbKtV/HyUQ2y7A/6Sf2wFTq7bJOK4OQJv0cyvgPuDsrOPKKTsMuBV4r4S+y7LINZkH0JImoAvwPrBBOi+SJ1tvX63ccOCmnPlDgKl1rSulqUjHWvI/onyPM6f8Z46puX2ndRxryX+npT4V47dVqv8+SiW2nO1uBEaWUlwkjcOJwNBSiAvoDTwObEcTNMIK+PdfFrnGlyOb1heAxRGxGiCSfymvAdtUK7cN8GrO/IKcMrWtKyXFOFaA7STNSrucf9CI8dZXvsdZm+b2ndal1L/TUles31ZWcWWh4NgkbUnSy/KXUogrvYz7HPA2sBT4VdZxpZe3bwWGAGsaMZ6CY0uVfK7xa4uslM0CukXEUkndgAmS3o6IP2QdmNWbv1MreZI2Af4M/Cwins06HoCIWAD0lbQx8DvgaODeTIOCi4HxEfEPST0yjqW6ssg17glrWv8BukraAJLBjCSt99eqlXsN6J4z3yOnTG3rSkmDjzUi3o+IpennhcA9wD6NG3bB8j3O2jS377RGZfKdlrpi5JEs48pC3rFJ6khyue+BiGjsB38W/DeLiGUkja8TSyCufYEfSlpAMn5uE0kLJG2edWzlkmvcCGtCEfEmSev8W+miY4CFEfFKtaLjgMMlbZn+AzudT854altXMopxrJK6Vt2ZlCbGQ4HZTRF/vgo4zto0t++0RuXwnZa6IuWRLONqcvnGlvYyTQQmRsRlJRTX9vrkrvG2wFHAnKzjioh9IqJ7RPQgudni/YjoERFvZR1b2eSarAeltbQJ6Ak8CbwMPAvsnC6/DTg8p9xpwL/S6Tekd8bUta6UpoYeK3AmMBd4Lv3vSNK3PJTSlM9xktzdtBB4C1iZfr6iOX6ntR1ruXynpT4VI4+U4r+PEojtAmAVUJkzXVACcQ0GXsj53VwPtMs6rmrle9B0d0fm8zcri1zj1xaZmZmZZcCXI83MzMwy4EaYmZmZWQbcCDMzMzPLgBthZmZmZhlwI8zMzMwsA26EmZmZmWXAjTBrFiR1lLRM0m+yjiUfktpIul7SXEnPSXpR0rCs4zJraZw7LEtuhFlzcRwwEzg6fep1UVS9GqMRnAVsBfSNiL5AP+BvxapcUuti1WXWzDl35HDuaFpuhFlzcSpwFfA4SVJF0suSdq0qIOkUSfeln7eU9AdJz0h6XtJlOeUWSLpK0jPAHWnZRyTNTM8+b8x5HUYbSb9K9/WUpGskPZpT10mSnpY0S9Ljkvqmq7oBb0bEaoCIWBERc3O2+46kyvRM99mql+Om9c1Jp79K2jrn2B6RNE7S88DutR2jma3j3OHckZ2sH9nvyVNDJ2BHkleftAYOB6any38C3JhT7jHgsPTz34B9088bkLwv7th0fgHJ6y+q3ijRDtg4/dwa+AtwfDp/BvAw0CadHgYeTdftBUwANkzn9wHmpp97k7yI9h/ArcDxQOt03X7AfKBrOt8hnXYCXge2TpdfADyUfj4F+BDomXO8NR6jJ0+enDvSz84dGU6N1V1q1pROBe6MiDWSJgA3S/oScCcwW9I5wNbADsBDkjYCDgS2kFRVx8Yk7yOrMibSDETSY3yVpL0BAV1I3uN2b1rP7yJiFYCkO4DvpdsdAfQFns7ZT2dJ7SNirqTtSF56OxC4BDgJ+N90uisiFgNExIdp3fuTvFh4UVrXr4AROZcPpkfES2nZfI7RrKVz7kg4d2TEjTAra5LakCSgVZJOSBd3AE6NiHMlPUuS0HqTJLzVktql5faIiBU1VL0s5/MwkuQ5ICJWSBpNcoa7PrkvYxVwR0T8ZL0FI1YCU4Apkm4DFkvqXOsB17yv6jFXZc/ajtGsxXLuqDFm544m5DFhVu4OB/4dEVtHRI+I6AHsAZyUJtnfAt8Fvg3cDhARy4BHgPOrKpG0laRuNeyjE/B6mkS3BI7NWTcFOCEd39Em3U+VB4FvSdom3UerqnEmkr4sqWtO2f7Au8B7wJ/T7bqmZTtI6pDGPEjSVuk2pwOTI2JN9YDrcYxmLY1zh3NH5twTZuXuVODu3AUR8Q9Ji4DDgAeAXwP/jIh/5BQ7ERgt6QWSs8LlwBCS8SHV/QL4k6S5wH+BSTnrbgZ2Bl4ElgDPkty5REQ8IelHwH1K7pRqC/w1LbMNcF16Zr2S5Ez0iIhYCzwu6RLgb5IiXf/1iHhB0nBgYnqZ4D/AabX8bQo5RrOWxrmjZs4dTaRq8KCZ1ZOkjhHxQXo2ezcwMyKuyjouMyttzh3mRphZA0l6GtiQZKzHVOCHEfFRtlGZWalz7jA3wszMzMwy4IH5ZmZmZhlwI8zMzMwsA26EmZmZmWXAjTAzMzOzDLgRZmZmZpYBN8LMzMzMMvD/XFcA4DZSUIsAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 640x560 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "PCC = pd.read_csv('FigureData/Figure4/32SimulationData/PCC.csv', sep = ',', header = 0, index_col = 0)\n",
    "RMSE = pd.read_csv('FigureData/Figure4/32SimulationData/RMSE.csv', sep = ',', header = 0, index_col = 0)\n",
    "SSIM = pd.read_csv('FigureData/Figure4/32SimulationData/SSIM.csv', sep = ',', header = 0, index_col = 0)\n",
    "JS = pd.read_csv('FigureData/Figure4/32SimulationData/JS.csv', sep = ',', header = 0, index_col = 0)\n",
    "\n",
    "Datasets = list(set(PCC['dataset']))\n",
    "\n",
    "RScore = None\n",
    "for Data in Datasets:\n",
    "    PCCUse = PCC[PCC['dataset'] == Data]\n",
    "    PCCUse = PCCUse.dropna(axis = 1, how = 'all')\n",
    "    PCCUse = PCCUse.fillna(0)\n",
    "    \n",
    "    RMSEUse = RMSE[RMSE['dataset'] == Data]\n",
    "    RMSEUse = RMSEUse.dropna(axis = 1, how = 'all')\n",
    "    RMSEUse = RMSEUse.fillna(1)\n",
    "    \n",
    "    JSUse = JS[JS['dataset'] == Data]\n",
    "    JSUse = JSUse.dropna(axis = 1, how = 'all')\n",
    "    JSUse = JSUse.fillna(1)\n",
    "    \n",
    "    SSIMUse = SSIM[SSIM['dataset'] == Data]\n",
    "    SSIMUse = SSIMUse.dropna(axis = 1, how = 'all')\n",
    "    SSIMUse = SSIMUse.fillna(0)\n",
    "    \n",
    "    Tools = PCCUse.columns.tolist()\n",
    "    for Tool in Tools[0:-1]:\n",
    "        Metric = pd.concat([PCCUse[Tool], SSIMUse[Tool], RMSEUse[Tool], JSUse[Tool]], axis = 1)\n",
    "        Metric.columns = ['PCC', 'SSIM', 'RMSE', 'JS']\n",
    "        Metric.to_csv('FigureData/Figure4/32SimulationData/Dataset' + Data + '_' + Tool + '_Metrics.txt', sep = '\\t')\n",
    "        Result = pd.DataFrame(Metric.mean())\n",
    "        Result.columns = ['AverageScore']\n",
    "        Result['Tool'] = Tool\n",
    "        Result['Data'] = Data\n",
    "        if RScore is None:\n",
    "            RScore = Result\n",
    "        else:\n",
    "            RScore = pd.concat([RScore, Result])\n",
    "\n",
    "RScore['Metrics'] = RScore.index\n",
    "\n",
    "palette = [\"#9de846\", '#F9EC31', \"#BBA8D1\",\"#D6DE23\", \"#7BD1F1\", \"#F5A8C7\",  \"#A2CBCF\", \"#988DC3\", \"#79c06e\", \"#71cac3\"]\n",
    "order = ['Cell2location','SpatialDWLS','RCTD','STRIDE','DestVI', 'Stereoscope','Tangram','Seurat', 'SPOTlight', 'DSTG']\n",
    "font = {'family':'DejaVu Sans','weight':'normal','size':15}\n",
    "plt.figure(figsize=(8,7), dpi= 80)\n",
    "n = 221\n",
    "for M in ['PCC', 'SSIM', 'RMSE', 'JS']:\n",
    "    DataMetric = RScore[RScore['Metrics'] == M]\n",
    "    ax1 = plt.subplot(n)\n",
    "    ax1 = sns.barplot(x= 'AverageScore',y = 'Tool', data = DataMetric, palette=palette, order = order, ci = 95)\n",
    "    n = n + 1\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "DataDir = 'FigureData/Figure4/32SimulationData/'\n",
    "PATH = 'FigureData/Figure4/32SimulationData/'\n",
    "path = 'FigureData/Figure4/32SimulationData/'\n",
    "os.popen('mkdir ' + path + 'Accuracy_Rank/')\n",
    "path_output = path + '/Accuracy_Rank/'\n",
    "order = ['Cell2location', 'SpatialDWLS', 'RCTD', 'STRIDE', 'DestVI', 'Stereoscope','Tangram','Seurat', 'SPOTlight', 'DSTG']\n",
    "Tools= order\n",
    "palette = [\"#9de846\", '#F9EC31', \"#BBA8D1\",\"#D6DE23\", \"#7BD1F1\", \"#F5A8C7\",  \"#A2CBCF\", \"#988DC3\", \"#79c06e\", \"#71cac3\"]\n",
    "\n",
    "###This script is used for rank get the rank score for each method\n",
    "\n",
    "def get_score(Result):\n",
    "    tools_num = Result.shape[0]\n",
    "    Tools_score=[]\n",
    "    methods = list(Result.index)\n",
    "    score_col = []\n",
    "    list_up = list(range(1,Result.shape[1]+1))\n",
    "    list_down  = list(range(Result.shape[1],0,-1))\n",
    "    \n",
    "    for method in methods:\n",
    "        if method == 'PCC' or method == 'SSIM':\n",
    "            Tools_score.append(pd.Series(list_down, index=Result.loc[method,:].sort_values(ascending=False).index))\n",
    "            \n",
    "        if method == 'JS' or method == 'RMSE':\n",
    "            Tools_score.append(pd.Series(list_up, index=Result.loc[method,:].sort_values(ascending=False).index))\n",
    "        score_col.append(method)\n",
    "        \n",
    "    score=pd.concat([m for m in Tools_score],axis=1)\n",
    "    score.columns = score_col\n",
    "    score = score/Result.shape[1]\n",
    "    return score\n",
    "\n",
    "def make_score(dataset_all, Tools, path_output):\n",
    "    for dataset in dataset_all:\n",
    "        prefix = '_'.join(dataset.split('_')[:-2])\n",
    "        Tools_data=[x for x in range(len(Tools))]\n",
    "        for i in range(len(Tools)):\n",
    "            File = PATH + prefix + '_' + Tools[i] + '_Metrics.txt'\n",
    "            if os.path.isfile(File): \n",
    "                Tools_data[i] = pd.read_table(File,sep='\\t',index_col=0, header=0)\n",
    "                Tools_data[i] = Tools_data[i].mean()\n",
    "                Tools_data[i]['Tool'] = Tools[i]\n",
    "            else:\n",
    "                Tools_data[i] = pd.DataFrame([-2, -2, 10, 10], columns = ['Genes'], index = ['PCC', 'SSIM', 'RMSE', 'JS']).T\n",
    "                Tools_data[i] = Tools_data[i].mean()\n",
    "                Tools_data[i]['Tool'] = Tools[i]\n",
    "        Result = pd.concat([m for m in Tools_data], axis = 1)\n",
    "        Result.columns = Result.loc[[\"Tool\"],:].values.flatten()\n",
    "        Result.drop('Tool', axis = 0, inplace = True)\n",
    "        \n",
    "        score = get_score(Result)\n",
    "        prefix = '_'.join(dataset.split('_')[:-2])\n",
    "        score.to_csv(path_output + prefix + '_score.txt', header = 1, index = 1)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "DataPATH = 'FigureData/Figure4/32SimulationData/'\n",
    "DirFiles = os.listdir(DataPATH)\n",
    "Dataset = [x for x in DirFiles if x[:4] == 'Data']\n",
    "make_score(Dataset, Tools, path_output)\n",
    "\n",
    "def make_all_score(dataset_all):\n",
    "    score_all = pd.DataFrame()\n",
    "    for dataset in dataset_all:\n",
    "        prefix = 'Dataset' + dataset\n",
    "        a = pd.read_csv(path + '/Accuracy_Rank/' + prefix + \"_score.txt\",header=0,index_col=0)\n",
    "        score_all=pd.concat([score_all,a],axis=0)\n",
    "    return score_all\n",
    "all_datasets = np.array(['1','2','3','4','5','6','7','8','9','10','11','12','13','14','15','16','1_r','2_r','3_r','4_r','5_r','6_r','7_r','8_r','9_r','10_r','11_r','12_r','13_r','14_r','15_r','16_r'])\n",
    "Score = make_all_score(all_datasets)\n",
    "Score.to_csv(path + \"/Accuracy_Rank/Score.txt\",header=1, index=1)\n",
    "\n",
    "order = ['Cell2location','SpatialDWLS','RCTD','STRIDE','DestVI', 'Stereoscope','Tangram','Seurat', 'SPOTlight', 'DSTG']\n",
    "\n",
    "def plot_all(df, name, order, palette):\n",
    "    df_all = pd.DataFrame(df.sum(axis=1).values,index = df.index.values,columns=['merge'])\n",
    "    df_all = df_all/4\n",
    "    \n",
    "    plt.figure(figsize=(8, 6))\n",
    "    axes =sns.boxplot(x= 'merge',y= df_all.index.values, data=df_all ,palette=palette,order=order,showmeans = True)\n",
    "    axes.set_xlabel(name, fontsize=10)\n",
    "    axes.set_ylabel('', fontsize=10)\n",
    "    axes.spines['top'].set_visible(False)\n",
    "    axes.spines['right'].set_visible(False)\n",
    "    plt.xticks(fontsize=8)\n",
    "    plt.yticks(fontsize=8)\n",
    "    plt.title('Accuracy Score')\n",
    "    plt.show()\n",
    "    return df_all\n",
    "    \n",
    "DataAS = plot_all(Score, 'Accuracy Score', order, palette)\n"
   ]
  },
  {
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}