diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md new file mode 100644 index 0000000..339757e --- /dev/null +++ b/CODE_OF_CONDUCT.md @@ -0,0 +1,76 @@ +# Contributor Covenant Code of Conduct + +## Our Pledge + +In the interest of fostering an open and welcoming environment, we as +contributors and maintainers pledge to making participation in our project and +our community a harassment-free experience for everyone, regardless of age, body +size, disability, ethnicity, sex characteristics, gender identity and expression, +level of experience, education, socio-economic status, nationality, personal +appearance, race, religion, or sexual identity and orientation. + +## Our Standards + +Examples of behavior that contributes to creating a positive environment +include: + +* Using welcoming and inclusive language +* Being respectful of differing viewpoints and experiences +* Gracefully accepting constructive criticism +* Focusing on what is best for the community +* Showing empathy towards other community members + +Examples of unacceptable behavior by participants include: + +* The use of sexualized language or imagery and unwelcome sexual attention or + advances +* Trolling, insulting/derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or electronic + address, without explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Our Responsibilities + +Project maintainers are responsible for clarifying the standards of acceptable +behavior and are expected to take appropriate and fair corrective action in +response to any instances of unacceptable behavior. + +Project maintainers have the right and responsibility to remove, edit, or +reject comments, commits, code, wiki edits, issues, and other contributions +that are not aligned to this Code of Conduct, or to ban temporarily or +permanently any contributor for other behaviors that they deem inappropriate, +threatening, offensive, or harmful. + +## Scope + +This Code of Conduct applies both within project spaces and in public spaces +when an individual is representing the project or its community. Examples of +representing a project or community include using an official project e-mail +address, posting via an official social media account, or acting as an appointed +representative at an online or offline event. Representation of a project may be +further defined and clarified by project maintainers. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported by contacting the project team at alexander.mathis@epfl.ch. All +complaints will be reviewed and investigated and will result in a response that +is deemed necessary and appropriate to the circumstances. The project team is +obligated to maintain confidentiality with regard to the reporter of an incident. +Further details of specific enforcement policies may be posted separately. + +Project maintainers who do not follow or enforce the Code of Conduct in good +faith may face temporary or permanent repercussions as determined by other +members of the project's leadership. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, +available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html + +[homepage]: https://www.contributor-covenant.org + +For answers to common questions about this code of conduct, see +https://www.contributor-covenant.org/faq diff --git a/DLC_2_MotionMapper/README.MD b/DLC_2_MotionMapper/README.MD new file mode 100644 index 0000000..cf2840a --- /dev/null +++ b/DLC_2_MotionMapper/README.MD @@ -0,0 +1,10 @@ +**DeepLabCut --> MotionMapper** + +(1) download the code from Gordon Berman; here is a lightly modified version that I forked +that I know works with the script I supply: https://github.com/MMathisLab/MotionMapper + +(2) Make sure the whole folder is on-path in MATLAB (see Gordon's instrustions too) + +(3) Place my two helper functions into the MotionMapper folder: https://github.com/AlexEMG/DLCutils/tree/master/DLC_2_MotionMapper + +(4) Open the .m file called deeplabcut_into_motionMapper.m and follow the instructions! diff --git a/DLC_2_MotionMapper/saved_colormaps.mat b/DLC_2_MotionMapper/saved_colormaps.mat new file mode 100644 index 0000000..a58b217 Binary files /dev/null and b/DLC_2_MotionMapper/saved_colormaps.mat differ diff --git a/Demo_loadandanalyzeDLCdata.ipynb b/Demo_loadandanalyzeDLCdata.ipynb new file mode 100644 index 0000000..955fc1d --- /dev/null +++ b/Demo_loadandanalyzeDLCdata.ipynb @@ -0,0 +1,625 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "N0gDJMy1ywm8" + }, + "source": [ + "# DeepLabCut Toolbox - demo for post processing\n", + "\n", + "https://github.com/AlexEMG/DeepLabCut" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "hTtJxcQ7ywnB" + }, + "outputs": [], + "source": [ + "# Importing the toolbox (takes several seconds)\n", + "import pandas as pd\n", + "from pathlib import Path\n", + "import numpy as np\n", + "import os\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "WOEHc0MeywnJ" + }, + "outputs": [], + "source": [ + "# this is example data from the public project: https://github.com/AlexEMG/DeepLabCut/tree/master/examples/openfield-Pranav-2018-10-30\n", + "video='m3v1mp4.mp4'\n", + "DLCscorer='DeepCut_resnet50_openfieldOct30shuffle1_15001'\n", + "\n", + "dataname = str(Path(video).stem) + DLCscorer + '.h5'\n", + "\n", + "#loading output of DLC\n", + "Dataframe = pd.read_hdf(os.path.join(dataname))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
scorerDeepCut_resnet50_openfieldOct30shuffle1_15001
bodypartssnoutleftearrighteartailbase
coordsxylikelihoodxylikelihoodxylikelihoodxylikelihood
075.86107288.5070020.99863572.025992102.7499170.99963885.85531390.1997040.999799142.480108180.3720460.999833
174.64714886.4391780.99941470.35006899.6213880.99983685.88981987.0618890.999841141.605256179.3654150.999991
273.19410384.0195960.99893270.25904197.2084030.99971184.49419584.3643510.999868144.028973175.5096240.999990
373.43876080.5111570.99791569.01925694.7772820.99972383.49111481.9676550.999787147.907935174.8481150.999971
472.88661878.1187250.99879368.07669591.4361650.99983981.37581378.2915110.999795150.296287170.7332740.999970
\n", + "
" + ], + "text/plain": [ + "scorer DeepCut_resnet50_openfieldOct30shuffle1_15001 \\\n", + "bodyparts snout \n", + "coords x y likelihood \n", + "0 75.861072 88.507002 0.998635 \n", + "1 74.647148 86.439178 0.999414 \n", + "2 73.194103 84.019596 0.998932 \n", + "3 73.438760 80.511157 0.997915 \n", + "4 72.886618 78.118725 0.998793 \n", + "\n", + "scorer \\\n", + "bodyparts leftear rightear \n", + "coords x y likelihood x y likelihood \n", + "0 72.025992 102.749917 0.999638 85.855313 90.199704 0.999799 \n", + "1 70.350068 99.621388 0.999836 85.889819 87.061889 0.999841 \n", + "2 70.259041 97.208403 0.999711 84.494195 84.364351 0.999868 \n", + "3 69.019256 94.777282 0.999723 83.491114 81.967655 0.999787 \n", + "4 68.076695 91.436165 0.999839 81.375813 78.291511 0.999795 \n", + "\n", + "scorer \n", + "bodyparts tailbase \n", + "coords x y likelihood \n", + "0 142.480108 180.372046 0.999833 \n", + "1 141.605256 179.365415 0.999991 \n", + "2 144.028973 175.509624 0.999990 \n", + "3 147.907935 174.848115 0.999971 \n", + "4 150.296287 170.733274 0.999970 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Let's have a look at the data:\n", + "\n", + "#these structures are awesome to manipulate, how -->> see pandas https://pandas.pydata.org/pandas-docs/stable/index.html\n", + "Dataframe.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "ROlflqQLywnP" + }, + "outputs": [], + "source": [ + "# The plotting functions below are put here for simplicity and so that the user can edit them. Note that they \n", + "# (or variants thereof) are in fact in standard DLC and accessible via:\n", + "\n", + "import deeplabcut\n", + "deeplabcut.utils.plotting.PlottingResults?" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def get_cmap(n, name='hsv'):\n", + " return plt.cm.get_cmap(name, n)\n", + "\n", + "def Histogram(vector,color,bins):\n", + " dvector=np.diff(vector)\n", + " dvector=dvector[np.isfinite(dvector)]\n", + " plt.hist(dvector,color=color,histtype='step',bins=bins)\n", + "\n", + "def PlottingResults(Dataframe,bodyparts2plot,alphavalue=.2,pcutoff=.5,colormap='jet',fs=(4,3)):\n", + " ''' Plots poses vs time; pose x vs pose y; histogram of differences and likelihoods.'''\n", + " plt.figure(figsize=fs)\n", + " colors = get_cmap(len(bodyparts2plot),name = colormap)\n", + " scorer=Dataframe.columns.get_level_values(0)[0] #you can read out the header to get the scorer name!\n", + "\n", + " for bpindex, bp in enumerate(bodyparts2plot):\n", + " Index=Dataframe[scorer][bp]['likelihood'].values > pcutoff\n", + " plt.plot(Dataframe[scorer][bp]['x'].values[Index],Dataframe[scorer][bp]['y'].values[Index],'.',color=colors(bpindex),alpha=alphavalue)\n", + "\n", + " plt.gca().invert_yaxis()\n", + "\n", + " sm = plt.cm.ScalarMappable(cmap=plt.get_cmap(colormap), norm=plt.Normalize(vmin=0, vmax=len(bodyparts2plot)-1))\n", + " sm._A = []\n", + " cbar = plt.colorbar(sm,ticks=range(len(bodyparts2plot)))\n", + " cbar.set_ticklabels(bodyparts2plot)\n", + " #plt.savefig(os.path.join(tmpfolder,\"trajectory\"+suffix))\n", + " plt.figure(figsize=fs)\n", + " Time=np.arange(np.size(Dataframe[scorer][bodyparts2plot[0]]['x'].values))\n", + "\n", + " for bpindex, bp in enumerate(bodyparts2plot):\n", + " Index=Dataframe[scorer][bp]['likelihood'].values > pcutoff\n", + " plt.plot(Time[Index],Dataframe[scorer][bp]['x'].values[Index],'--',color=colors(bpindex),alpha=alphavalue)\n", + " plt.plot(Time[Index],Dataframe[scorer][bp]['y'].values[Index],'-',color=colors(bpindex),alpha=alphavalue)\n", + "\n", + " sm = plt.cm.ScalarMappable(cmap=plt.get_cmap(colormap), norm=plt.Normalize(vmin=0, vmax=len(bodyparts2plot)-1))\n", + " sm._A = []\n", + " cbar = plt.colorbar(sm,ticks=range(len(bodyparts2plot)))\n", + " cbar.set_ticklabels(bodyparts2plot)\n", + " plt.xlabel('Frame index')\n", + " plt.ylabel('X and y-position in pixels')\n", + " #plt.savefig(os.path.join(tmpfolder,\"plot\"+suffix))\n", + "\n", + " plt.figure(figsize=fs)\n", + " for bpindex, bp in enumerate(bodyparts2plot):\n", + " Index=Dataframe[scorer][bp]['likelihood'].values > pcutoff\n", + " plt.plot(Time,Dataframe[scorer][bp]['likelihood'].values,'-',color=colors(bpindex),alpha=alphavalue)\n", + "\n", + " sm = plt.cm.ScalarMappable(cmap=plt.get_cmap(colormap), norm=plt.Normalize(vmin=0, vmax=len(bodyparts2plot)-1))\n", + " sm._A = []\n", + " cbar = plt.colorbar(sm,ticks=range(len(bodyparts2plot)))\n", + " cbar.set_ticklabels(bodyparts2plot)\n", + " plt.xlabel('Frame index')\n", + " plt.ylabel('likelihood')\n", + "\n", + " #plt.savefig(os.path.join(tmpfolder,\"plot-likelihood\"+suffix))\n", + "\n", + " plt.figure(figsize=fs)\n", + " bins=np.linspace(0,np.amax(Dataframe.max()),100)\n", + "\n", + " for bpindex, bp in enumerate(bodyparts2plot):\n", + " Index=Dataframe[scorer][bp]['likelihood'].values < pcutoff\n", + " X=Dataframe[scorer][bp]['x'].values\n", + " X[Index]=np.nan\n", + " Histogram(X,colors(bpindex),bins)\n", + " Y=Dataframe[scorer][bp]['x'].values\n", + " Y[Index]=np.nan\n", + " Histogram(Y,colors(bpindex),bins)\n", + "\n", + " sm = plt.cm.ScalarMappable(cmap=plt.get_cmap(colormap), norm=plt.Normalize(vmin=0, vmax=len(bodyparts2plot)-1))\n", + " sm._A = []\n", + " cbar = plt.colorbar(sm,ticks=range(len(bodyparts2plot)))\n", + " cbar.set_ticklabels(bodyparts2plot)\n", + " plt.ylabel('Count')\n", + " plt.xlabel('DeltaX and DeltaY')\n", + " \n", + " #plt.savefig(os.path.join(tmpfolder,\"hist\"+suffix))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "bodyparts=Dataframe.columns.get_level_values(1) #you can read out the header to get body part names!\n", + "\n", + "bodyparts2plot=bodyparts #you could also take a subset, i.e. =['snout']\n", + "\n", + "%matplotlib inline\n", + "PlottingResults(Dataframe,bodyparts2plot,alphavalue=.2,pcutoff=.5,fs=(8,4))\n", + "\n", + "# These plots can are interactive and can be customized (see https://matplotlib.org/) [in the code above]\n", + "# note that the snout and other bpts jitter in this example that was not trained for long." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "h9H7eqDLywnV" + }, + "source": [ + "## Great so let's use Federico's code for ROI analysis\n", + "\n", + "Functions to extract time spent by the mouse in each of a list of user defined ROIS!\n", + "\n", + "https://github.com/AlexEMG/DLCutils/blob/master/time_in_each_roi.py" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "jg96O2acywnW", + "scrolled": false + }, + "outputs": [], + "source": [ + "import time_in_each_roi #the function needs to be in the same folder as the notebook\n", + "\n", + "#let's calculate velocity of the snout\n", + "bpt='snout'\n", + "vel = time_in_each_roi.calc_distance_between_points_in_a_vector_2d(np.vstack([Dataframe[DLCscorer][bpt]['x'].values.flatten(), Dataframe[DLCscorer][bpt]['y'].values.flatten()]).T)\n", + "\n", + "fps=30 # frame rate of camera in those experiments\n", + "time=np.arange(len(vel))*1./fps\n", + "vel=vel #notice the units of vel are relative pixel distance [per time step]\n", + "\n", + "# store in other variables:\n", + "xsnout=Dataframe[DLCscorer][bpt]['x'].values\n", + "ysnout=Dataframe[DLCscorer][bpt]['y'].values\n", + "vsnout=vel" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "\n", + "plt.plot(time,vel*1./fps)\n", + "plt.xlabel('Time in seconds')\n", + "plt.ylabel('Speed in pixels per second')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'leftside': position(topleft=(0, 0), bottomright=(300, 480)), 'rightside': position(topleft=(300, 0), bottomright=(640, 480))}\n" + ] + } + ], + "source": [ + "#define bounding boxes (here for left and right side of treadmill, displayed below)\n", + "from collections import namedtuple\n", + "position = namedtuple('position', ['topleft', 'bottomright'])\n", + "bp_tracking = np.array((xsnout, ysnout, vsnout))\n", + "\n", + "#two points defining each roi: topleft(X,Y) and bottomright(X,Y).\n", + "rois = {'leftside': position((0, 0), (300, 480)),'rightside': position((300, 0), (640, 480))} \n", + "print(rois)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD8CAYAAAB5Pm/hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzsnXdcVGe6x7/vmQFERURQUBAUC9ZNIhbSq9lNbrLpMZqtd9Pu3ZZstuSm7abs3Za7SXY32cQkm81mY0liS0/sHZTBgohIkaEJUgZEkTJzzv3jzDnMmQJDVzzfzyeRaWfeMwy/877P+zy/RyiKgomJiYnJ4EUa6AGYmJiYmPQtptCbmJiYDHJMoTcxMTEZ5JhCb2JiYjLIMYXexMTEZJBjCr2JiYnJIMcUehMTE5NBjin0JiYmJoMcU+hNTExMBjnWgR4AQExMjDJhwoSBHoaJiYnJOYXNZqtRFGV0Z887K4R+woQJZGZmDvQwTExMTM4phBD2YJ5nhm5MTExMBjmm0JuYmJgMckyhNzExMRnknBUx+qBZNwFOBxWSMjHpEicdUbz4o58O9DBMTDolMimSh4sf7tJrzi2hP22HJaZ/vknvM2KZ4NfKrwd6GCYmnfKMeKbLrzFDNyYmJiaDHFPoTUwGGJvdwSubC7DZHQM9FJNByrkVujEZVNjsDtKLaokaGsqhigYEMHNcJDkVDRxvaMLpgvGjhnL7nARSk6J8Xvv7z3MprWvi1gvjeezG6QNzEj3EZndw1993IbtvP3RFMgtnxrE6qwwFuMPPuZuYdBVT6E36HZvdwaqsMlbuLcUld77nsmJPCf919WSmjBmOVZKw153mT1/kob3ytW1FAOek2D+x5qAu8qCei3Y+ACv3lPDcrbNZsiCx/wdnMmgwhd6k38gsruOVzflsyauhK1vqLgX+tqmgw+d8kVN5Tgp9YfXpDh93KfD0ukOkxEWYM3uTbmMKfQcsyyjhpQ15NDY7+frMOF6656KBHtI5SVOrk+c/zWVZRkm3j3HLBeP4yXVTcLoUDpbV88sPDxouFheOH9nzgXqghZXSkqP7VGCjhoZworHVcJ8kwHOhI8sK6UW1ptCbdJvzWug7+mNelm7n8bWH9Ntr91cAmGLfBVqdMsv3lPDXTQXUnGoJ+DyrRXB1yhgEsDG3Cpfi+/h3LpnApNHDAUiJi2D94Sq+OlwFgACmxEb02rj3HKtl8RsZuGSFISES792X1mci+/B1KTy+Jttw3+L5ibznvigKIDREIi05uk/e3+T84LwU+t2FNby8MZ+MojoUwCIJnrtlFksWJLIso4SVe0s4fPykz+s25Fb1/2DPMWx2Byv3llBS10Rh9SmqG1tZMHEUP1s4hd98lEOrh4pbBNwzP9Gw2Xr7qzvJKqkHVJH7WkIkT9880yC0NruDzXkn9NuSgKihoZxpdREeatGf050ZeYvTxeNrDul7B21OuU9n0zHDQ/UZvADCQiRuvmCsLvSPXj+ViyfFmLN5kx5x3gm9ze7g3jczDEtjl6zwxJps3t1dTG5lY8DXjo8a2vcD7AU8s1kcTa19Hn7Q2JBbxf3vZOohFQE8ddN0/vPSiWSV1HP51Bg25lYDqsh7bzJmFNVy5HgjAlW8Q6ySj8gDpBfVGjZxXQo8viabp9YdYsqY4YyLHMK2/BpkRSHUGvyMvKnVyYPv2ig4cQqLEIBCiDW42XR3LizLMkr02bxFwKL5idwxJ4H6pvZQzo+umRLUsUxMOuK8E/r0oloUPzuBCnQo8gJ4/rbZfTau7mCzO9h69AQToocRNTSU8vozZNkdrNtfgcvjJEMsgkcWTiU1MYqRQ0MprWsir+okacm9O1N8cf1Rn03W5jaZrJJ6Fr+RTqtTNjyWU9HAE2uyUYARYVaWbi9CVsAqCe6eN5475iQA8MrmAoOApiVHE2qVaHPKWCTBf8wey9S4CJpaXRwsa2B3UR1O94WguU3mR8uyuP2ieL4xaywKCooCRypPkl1+koghFsocZwgpeYTDr+7iSGUjl0+J4eszYvnycBWNZ9r47j8yGB81VP/9axfRnIoGqhtbaGxuI/1YHYp7Vn7xJHWsE2OG4XTJVJ9q8fmsbcV1POERsnEpUNPYQmpSFPe+md5rvxMTExhkQm+zO3htSwGZ9jpOtbiIDA/hZwtT9JDM54eOEz0sVP1rDCLtwyLBNdNiGRMR5jeXe6BYllEScPXhvZEH0OZS+OMXeT7PtUr5/N9dF5AwamiPNx6X7ykhp+IkEujpghaLoKTuNJ8crPAReRAszyjB+15QV1ildU2sz6nkzR3HcMoKVknwrDu8lpoUxXv3pfHq5nw2Halm7f4Kwtyx9EevT8FWXMfdS3fjch/8eEMzr2wp5JUthR2cwbWA+nlWN7bw648PG1YNuZWN3PH3XZ1+Dgpw+PhJMo7V6a9XQzIF+srCVlzHIyv3+3wFq0420+aS2VlQC8DCGbGdvp+JSTAMGqG32R3c/douw0ZezalWHl+Tze8+O0xjiyuo4whg0uhhJI8ezoNXTjprxF3Dc7mvIQl1A+8n106hpK6Jb7+VQWubjOx+LMQi8dvbZjEuMpwVe0v5+EAFCuCUFX66cj/CfZywbm48ZhbX6WOyWgRXpYwBYHPeCVbuLQN8r60uf8sqNwqwPb+G7fk1+n1OWTGkGVY3NrPxSLX+eKs7lg5qLrrLzxVkeJiF1KRRNJxpZX9pg9/3HjHEir32dFD5/f4ItQje+u48ZsdHsmjpbvaV1KPQHuvPq2zkybXZPhdjgEXzEvVzAPjGzLhujaE/0WoiBPTJZKivj3++MGiEPr2o1idbQyNYkQf47W1nd3HKij2+7p2hVonb5yQQO2IIsSOG8N59aQFj9GEhFr46XEmbU8ZqkZgdP4JMu7r52dwm8/ethfxt8UUMCTFuaqrVq/W0uRRuvyieUItE+rE60pKjeWlDvh4Oa3MpVJ1sprz+DG0ev5DesKKTFTXN8HSLk4dX7jc8JglB45k27n59d0CRPtXiYuvRar+PaZxsdvZojG2ywvqcSlbZSjlUrl5MBCCEILusgS9zKg2fxZiIUMZGhrNoXiJLFiTyP6vbL+JXpnTaIa5X8Pwdb847wbHqU4waFsrIoaE+z6073UJ9UxujhqmP7S126OezYm8J105TVyGjPVbB3d2/eHN7IUU1Tfp9K/aW6kkTJl1DKB3MrPqLuXPnKkG1ElwmArpX2uyOoJbWHbFwRixvfGduj47Rl9jsDu78+y6DUFw/I7bLKw/PPzyAe99U4+cKoChqbvfEmGEIAftK6v3OPjX8hYp6giqKvsfUMlJuvTCelZmlhFkkWtxjFkBK3HDyKk/1ygWlP3noimQiwkPUC2l5Pauyymlxh7munxHL6IgwZo6L9LlgqzPdUqpPtiCE0IU1r7JRD1HWnm5l5tgRRISH6K+12R28trWQY9WnCLFInGxuo6Kh2e++VU+RgIRR4ZQ6zqC4917uu2yifr6b805w4mQzQ6wS5Q3N3DR7LAtnxvHa1kLWH/af4WaVBCsfvPi8ntk/I57RnVaFEDZFUToVrUEj9D96z8Yn2ZVdfm+LW1RCLILlD5y9XyCb3cEvPzxgqKScPyGK9x+6pFeOnV5US1R4CF8ermTr0ZrOXzQARIRZurQ6GzHE2oUZunbJOHuRBFw6KYYQC2zK69rvSBIQNyKMiobA9QznApKAR69P4YdXTx7ooQwY3RH6QRO6+TLADKAjBGpKW/zI8H5LQewONruDxUvTafUKPE/upSIh7bz9vYc/gtzL7nW6IvKghmEEED9yCBZJwl7X1MGzfUVeSwEtqT3N0u1FKO4JwYXjR2IrqUdRFKwWiQsSItlb3PfOk7IC2wu6dxGWFc55kQe15sUsHus6g0boQy0Sba6uCYFFEme9O6DN7uCx1Qd9BDjUIvT0w94gvag2KJEPtQicstInS/2+QAHK6pu7/LoLvAq1PB0lZ42LZHJshGGDcFlGiZ4q2lUG6sIZiCFWiYghVibGDAOgvEH9/OIjhwBQd7rVJ4avhZgOVTRQUNVIpt0RMKTX1fO9YkoMOwpqkRUFcZavus5WBo3QL5wRq9sUBMuzt8w6q0V+WUaJIUNDEmqM8q6543s9A6HMa7Y7PS6C8aOGogBb86pxyjKSEIwaFkrlye7NDGeMjeDWi+LZV1LP54faw2wCNSPmVIuL8VHhjBwawsFy38rk/iS7vIGVe0t49uMcfZN7+Z4Sg3hJAnbk15ASF8F9l0/kuuljWJ97IvBBvRACpsVG0OZSqDvdQl1TWx+cSddpdso0n2ql9rRauKWdc4XjDAtnxPKrG6Z3+t3TsmVqGlsM+wxagoBnjF4A+8v8Z0HdeuE4Qq0Ssntm4ZL7tlJ5sDJohH5XYdeWtNPjIvTde832IMwqMTk24qyY5dvsDp7ySsObHe9rB9Bb5FQY/9DaZIWl7o3pZRklLN9jJ9ydidNdob8wMYoHrpikWxi0tskISTA81MKpFieSJChxnKHEcaZbx5cEpMRG0CYrFJ7o2casrMD7mWXuW/5FSFbAXteEva5J993pCorScZHeQOM9I1eArw5XseVoNcvv7zgNNzUpqtPvqWf2zLKMEp5ap1pPSAKumx7LVSljyC6vZ8WeUv15Zuime5zzQm+zO3jo3UyqT7V2/mQPQq1qcy3vvPQ9xQ5WZJRw3YxYZsaPAAUumzK634XfX7rozPjIPhtHbGQ4eMyiC06c4sJnvmRsZHividGHtjL9IvrefWl8erCCDzLLaNA2TLsRD5qbFMWU2OFIQnD7nATmJI7kx8v3UXDiFIChgKtjjJuxAx1O6ej9BargOXsz3ckPFnf/Oe+IXqtTZlVWWa9+F5csSCQlLsKYDfZGOs0ehXYCuGvu+AGfhJ2LnNNC391MG0CPP7653bdaUkaduWiztL9sKuj3/N205GgsAoPYzxoX2Wfv99CVk9hwuMogLvVnnNSfCU7kNfGRNXcuxVdgnU6ZlzYcZebYEXySfZxyx5lOxVSgFmG5ZMVnhvk/N0zjwSsn6bdPtziZ+D+f6bdvmBXH54cqSY4ZStXJFk63Gvdwrp022lB0deuF4xgaZkUAEWFWQwMQz3O877KJFNacNqQAWiQ1l78tUDGH13Ekof4QaFvk519P0Ttv1TSqKyjvEMizn+SoqyIB17pnwJ6dujbnnTCMcf4E1QLDM55e09jClqPVOJ3qcVKT2p9zu3sP6LWthWzMrTJ8/p4X7d7CcxXwyuYCPc1U+8zCQiR9TCZd45wV+t9/ltttkQf4+OBx5k+M5lhtR5kYKi6vqsz+IDUpiqlxEeQebxda7/BKb7/fdTNiA+Yvd4YQcOXUGOIiw/U/xj+vz9PL+UEVfu+K10BIQhXOZ2+ZRXObk2c/yTU8/t59C7h0cox+e1+Jg9teba+jeOCKZJZuK+LKqaOpbmzhdGv77/mOOQm8cNfXEELo1hg3NP2aJfd8YXiPxOhhrNxbQuyIIVyVMsYnl10L+cWOGMKDV07i/b2lrMws5ecLpyIktYDrYHk9uwrrANVTf0FytH4cgFVZZewsqMFe28StF47T95mCSR/0nAH7+156Wn/cMGtswIlKZwVNb3xnLja7gx++Z9PDdi5X38bK05Kj9QlDqFXiztSEsyKkeq5yzgr9FzndF3lQxft/Pz1siBYIYN6EKPaX1uP0mkH2d/MHm93BkePG2XRfhxKuThnTodAL4MErkmlscZJRVEuBR06/rMDGI9VYJcHMcZEsWZCIJLqXIXHvgkTGuVNePzlYwds7iw2Pb//l1Ywf1e4k+scvjvCq28fm2mljmDRmOEu3FXHrheM43tBssJx+7Vtz+MassfrtJQvUilSWfekzDv2xAHg+7pIVfrwsi8unxPCja9sdJ7UivsunxPDyYt9eBnMSR3LVC1u4YupoFs1LZO3+CmbFj+jo49EJNg7e2Uq0o+NoF4HIIVaqPPZm+jpWXtmgFlnNSRzJE/8xwxT4HnLOCv03Zsb5LK27yimPpbyE6k65ZEEiNruD1VllLMso0cXVGqRdbW+hpfLp4xP0ajqlPw6WBc4F9/TsB83uOZ02p4wQ7fFip6zw5Fp1z+OGWWODmr1reC7PZ8WPYM6z633CLYee+TrDw9SvbatTZs5z6znVosb4/7r4ItKLalm6rYhvpSWyMbeK4x65494XiN5k69ETVDQ089RNM/T78qsasdnVz/S1b6X6fd3h4yex1zbxX1dO4qvD6uTlBo8L0UCgibtFCF74Kk+3lPC0n+7LWPmyjBKecH+HcioGNvtqsHDOCv1jN06n8mRzl1MqAzE7IVIXsdSkKNXO2P2YAO5M7Z9lo83uYHdhjU8W0bXTY/v0/ZdllLBib5l+WxP2QOEBbUNV80h5et0hXexlBZ5cm83zt87m+5cm8fZOoz+PQF2OazFYAfziGykoirpkHxMRRsqTxjDKRYkjWfXQJUiSukoorjnNVS9s0R/f+dg1vPBlHmv2lfPglcn8e7fdcJH4waUT+kzkAZZllBIzPIzr3I6TiqKw8MVtADxx43SGhfn/U/s8uxJJqOnBL2/MB+CKKf3jceOP17cW8ocvjnRoaxFiEX0WK7fZHTy5NrvdO6mPG7+cL5yzQg9qW7/5E6N93By7w6J5xuVtlEcxiFYk09fY7A5DpoEW+AixCB7y2HTsi/fVZuEa104bY7jw+cN7ye+Z86+JfVK0r7gqoIv85DHDeeabM/V4+ycHK3w8i358zWQevT5Fv+2ZKZU8ehif/vhyHl65jy9zqvjptVN0wfTk0+zjPHXzzI4+hm5zvOEMm45U8dCVkwhxp6qsyirXH//BZRP9vk5RFD47dJy05Giih4dx3F2YNHH0sD4ZpyfecXmb3cGfvjhC+rE6w/O0Dfb+ms371CqY6ZS9wjkt9KDGIF/ZUkB5N3Ov40cO4YdXT/GJYzqajOmafbkRCuof3h+/OGIQ+cULxhM/cmif2zOkF9X6zOBiIsK6dAzt8/MW+2M1gTe7//uqSfz8+hQkSaAoCj9ZsZ+PDxhXaG9+Z64+S5ZlhVtf3clBd3HNk/8xnXsXJPHAu5lsz6/hwSuT/Yo80Kez+ff3liErcI97stDU6uTnHxwAYOUDafoqxJv8E6coqj7N9y+ZgKfn1PAAs//ewGZ38O7uYj4+WIFLVkOCYyLC/NZGaD0Acioa+CCzFJesdtzqq9n8mqxy1u5TL5Cem/HmbL7nnPNCD/DDqyZ3a1Y/cmgIf1k8x+8XKS05mlCLpNsCfJBZ2md+2x9klvChrVwPfWix6jvm9E/OcJSXHa1F6t5+gCb2nmGcQEjulEBJEpxqcTLr176boVt+fhUT3GmwNadamPv8Bv2xrx65grjIIXznHxnY7A5uuyie17cG3rN57IbpXT6fYHDJCiv3lnD5lBgS3auXJ91N5eNGDGFBB7PRt7YfA2BsZDgnGrtehBZMy0j1OTWMiRhCxrFaVtnKDXs/soIhjRHa00if9diTuX1OQo+b03R2Dk+4QzYhFrX628yy6T0GhdAvWZAYlLh4U9+k+pe/+d25XO1ulqGRmhTFnXMTWOZu0uzsg6wbm93h458ugMumxPDwdVP77UueXV5veP9F8xK7/d5LFiSSMDKcn32wn5qOitgUdSUxLMzCN17a7vNwzjNf1+PaG3Or+ME77e6mR577Bk2tLu59I4PDx08yIXoYa/aV+xxDO5/f3ja7zz5L703YYzWnWe0O23z4Xxf7fY3N7mDFnhI+sKl7Ig++a+OC8WpoUKvvCCTie4vrWJNVTqmjiR35NYaQSliIxNM3zcTR1EpkeAhb86rZeKSqQ8+ZsBCJX3x9Gs9+kqO2ZrT4T2UMJsOnq2QW17HkzQycLhmB0OPysqwQPzLcFPleJGihF0JYgEygXFGUm4QQE4EVQDRgA76tKEqrECIM+BeQCtQCixRFKe71kXsRNSyE6sauVceCOiN76F0bT940gyXzE7F4LLM94/Ky4jvz7SnLMuw+Ih8WIvWryNvsDt7f215iHmKVepTdU3Wymd9+lsvJM05GDQuh7nQA/xYBR6sa+dOXxhaHcSOGsPt/rkEINZzz8Mr9rHNvuH/vkgn85pszOXGymXvfzCDfXf1aVHPa5/AaklDzzfsKz01YRVG47dWdANw9N4EEP83k9xyrZckbGYZJiUtRyCpRL7ZDQiT+svEof91UYCi+skiC2eNGBPSEUVAbxwQyVhPA7anxfHrwuF9B7ywnvzfZc6yWd3bZ2VFQ7dFi0niuZly+d+nKjP6nQC6gJfn+AXhRUZQVQojXgB8Af3f/61AUZbIQ4h738xb14ph9sBXXdVnkJaFVXUpMGTOcp9YeYsWeEu5dkKTPoDzj9ALfuH1P2F1Yw5c5lXqVpKWPzMo6Y3VWmaH69qqp3bd7KK45zbf/kUHdqVYunRzN5rzA3ZxkBV3ANRbPH8/vbv8aoFa5zvQI5yy/P42LJ0VTWtfEt97KwB6g0G1sZBhVJ1v0WaxLUTNJlvZBQxnvTdivciqpdxuT/dq98es5Mz9SeZKPD1R0uPLMPd5oKJLTcMmKQeS1GLastNd7BLJN0CYQS+YnsWR+UsAsqu7+3v2tPgCf90kvquHPXx1lj9vSWQ0RGauDTZuDviEooRdCJAD/AfwW+JkQQgDXAEvcT3kH+A2q0N/i/hngQ+BvQgih9GGHk88Odb14akxEGJPHRHDj7LEsnj+eT7OP8/TaHD3WH2aV+P4lE/TnK0Djmd5xF9xzrJZvvbUHl7vp9aJ5/S/wGmUOo2B2dRNWI6eige/+Yy8tbS6mxEb4iPzk0cMMBVbevHDXBdyZqq4k9pfWc+srO/XHDvz6eiLDQyisPsW33szQs1M8uWrqaLYcrea2i+JJiBpm2BT+6nAVyzJKet3CwnMTtrnNxQPv2gD439tmc6Sykff3lvChrczHs0gTt466aWkb1J6PabFzRVE3RbUwjacj5LOf5NDqlJEVtTbE6qeqtDe+Z5q4K7LCSxvzDRcvIdptiwQwalgoTlmhwevvRxLtG9j9sdl7PhPsjP4l4JeAtgaOBuoVRdHa95QB8e6f44FSAEVRnEKIBvfz+6xtUXWj+oevzYyD8RupPNlC5ckW9hbXkRIXwU1fG0dB1Sle3pivp/99lWusEn1zxzEWzozr9h+K43Qry/eW8OrmwvYiFEVh3ADFI212h6GgydpNj/uMolrueyeTU61ORgwJYX9pveHxUKvEddNjKaj2v1n6yY8vY1a8Gib7v6/y+OumAgCuShnN29+bhxCCwxUnWbR0N41+OkbdNTdBj4v/Y0cxT988k/AQiyGP/vNDx3tV6L03YX/3ebtFw4FS1XnU39fQIuCm2eNYd6CCb1+cxC0XxvOhrZTlbodGi8Ag4o1n2nhzxzFkWSHUIwYfKMSihWA62qANhkC2CGqor4QPs8oC+vR4TukUYNzIIUhCcMBjRSJAF/XUpKg+2+w1UelU6IUQNwEnFEWxCSGu6q03FkI8ADwAkJjY/T9Am93BJwePq8dEcFUnZfwToody6eQYveq1xSnz4vqjvP39eVw+dTSvbSvU44ZFXjPQ7mzI2uwOPs2uoLTuDNvzq2luk/lafCS5lSeR3TOYgYpHeqZVCuDubiyZ1x+u4kfLsvTMDe9Zm1psFs+qfWV+Xq0+Nis+klanzPz/3aCHPl6+50JuuVCdO2SVOLj9VWNu/dTY4RytOsWdqQlMiB6qXzhbXbJhNq/R29WmnpuwpXVNesaPJGBlpvFctZCKhCpukUNDALj/8mTGjxrKiCFWXeh/dn2Kj9gtnBkXtAj2dNPUZnew2lbGSvcMW5IE35gZy+iIIZxobObLQ1W4PJTce/WhrSJQFH2G/ptvzgLQK6n9bfj2xWavSTvBzOgvBb4phLgRGIIao38ZGCmEsLpn9QmAlvZQDowHyoQQViASdVPWgKIoS4GloPaM7e4JrM4q84jHKuQe77hk+q6540lLjmZVVhlt7ubSOwpquPmvO/jTnRfo1Z5pE0fxbrrdp/K25lQzr2wuCOqPbsXeEh5f3S46104bwy++kcK0uBGdGkn1B55WNN0pCvvQVsYvPzzgI6pxEWFUutMFFdQNy0CEWi0+Va67HruG4w3q5zwszMJvPjpseM1DV07ije1FXD4lht/dPpuDZQ1YpXy985VnJkpS9FAeuGJSr4dtlmWU6Juw33hpm36/d6glxB06meXR4Pv5Tw8zK36Entt/xG0DHTM8zK+ZWTBeNP5m3sF8v7TnzZsQRXHNaR5fY8xec8kK63NPEGaVaHXKPiLvmenTWYxe/9syZ+39TqdCryjK/wD/A+Ce0f9cUZR7hRAfAHeiZt58F1jnfslH7tu73Y9v6sv4fLVX/nFZB4VTAjVzxrN8Py05mtpTLTy59hC3vLKDmy8YR3LMMPKqTjE0zIpFEobMmLd32tUvuFXivQDNF1ZnlfHqlkLdEx3UJfmcpCimxal72QM9g0kvquHVzQX6bYmubTa/ub2I5z/N9bl/4YxYZo4dwUsBCpe8aWpx6iKfFD2UjT+7khV7S3lq7SGfjcWIMCv/d/cFPLJyP1NjI3j13jmEWCRSk6K4Ny2Rd3bZ9ddIQg0Z/d/dF/b656xuwp7g1gvjWfJGuqFhOxgF3jtNsaL+DPtK6vnF19srfY9UqpOT66YbU3yhY8Felm7nqY9y1JWhReLOuQlcPyOWnPIG/rwhH1lW/H5P21wyq7PKWLOvnD3H6jpNv3zvvjS9erajWbk33vcP9Hf+fKYnefS/AlYIIZ4H9gFvue9/C3hXCFEA1AH39GyIHdOVzUMF+M3HObrdsOeXbkFyNI++v9+QCaIuS1XRkL3ijs1Omff3lhjLyIvreO6Tw3p2hEWARZJwyfKAhmi8sdkdfOvNPfrMTRPFYManKAp//DKPv2/x9fH/r6sm8YvrU9hXWs9fNuX7FRDvz1JbMWne8rbiOr8if8OsOB69PoXFb6QTGR7CP78/j4ghIfr5rPXKo+/LblzaJuya/eWGeLRF0KkAfnFIMy6L0+/TrJy900BtxXUsfiODNpeM1SL4TloSDc1thIdYKao5zU6PRuGtLpllGSV63YdMgnDfAAAgAElEQVRGs1PmmY9ymBUfiRBQ6jhDRlGt3yKpSyfHsLe4DqcrcHjFnJWfm3RJ6BVF2QJscf9cBMz385xm4K5eGFtQdDXc0OpUZzPeX9LI8BAuSoxi05ETuhApqNkRgTJG3s8sQ7hF8nsXT+D1bUU+AnXn3ATi3Za7Z8sfRnpRraEK99LJwRVouWSFJ9Zks2KvMRQTapH4/R2zuX1OApnFdTy+xjdGDnB1ymgWzojzyfX+/KeXM33sCPYcq+Uny/f5fIYCWDwvkYf+baO5zcV7/3UJsSPURtU2u4NFr+/2SVmc1UfduFyywivulZCnyN81N4EJ0cM6/T1/caiSaXERJI8ert+nbV5PiBmmz+ATR4XzwpdH9crsNpfCWx52zUNDLX6PL1BXVdvy1Rx1BThY3sDBcnXyMT4qnBnjRrC/pN6n2OqRhVMB35CLJ+as/NzknK+M7U5ue6By87TkaNVVsU02iE3y6OEU1zYZxGTU0BDqmtpQFGhpk31EXlu+n41l3DWn2tMTFdSNys7G2Nzm4kfLstjg1fw6ZngoP1uYosbUN+Xzp6+O+n39ZZNjePv781m6rdDwOd00O46NuVUs3VbImn2BnUgfX5vNiZMtvPOf85ka2z7z/b+v8nxEPrQPUvS0itSvDlfq4qsRYhHcE0Q18YbcKvYU13H33PaxNTa3b15nlzXw8sZ8PVQYZpWwSmquvBDt5mIWAbddFM+qrDJa3TbRAnV/IsQq8eCVk3jwykmkF9VSXn+GFW6jMIuAe+YnkpYc3enGqMng4pwX+rTkaMI8LG+DIVA7DG1puiqrjPf3luoCcttF8STHDDP439c1tWF19+30noFKAhbPTxyw3PhA2OwOVmWVsXxP+/I+mEKwUy1Ovvm3HXoWknbeo4eHkjYp2m+Wizezxo3gkZX7fawKPsmuDKpTWJnjDC/fcyEXT2oPL/3mo0PsKmzf5+/oc/eMdYPvrNV2ehrp7k32vMpGvStTSlwEr24uYOMR4wVOwyIJlt2fBqCvVMKtEvvLGkhLHsU108aQXdbAlrxqth5VawtWZ5UzYkgIbS6F+Kgh+rH+vN54kfzBZRO5dnqsni6p2RRoaYmeKYn+zkmLq692Jx5o4UMzBHP+IfpwnzRo5s6dq2RmZnb+xGUClviO9710O0+4jaSC4foZsZ1WStrsDr44dJz3MkoYFzmEuMgh7CgwJg9dkBDJwhmx/Hu3Xc8yAZgeF8HnD18R9Hj6A20jrbnNeEG0SoKVD14c8I+99lQLqR5mYl29qPYWU8YM5/d3fM3Qxs/byE4Av711Fo4zraQlx+hC9/ct+Wxy94bV9ggURQ1XPPkfM9iSd4ItuRXIwookCZweCfCdNQn/z0snkFVS71M70FP8/V66m6l1NmR4mfQez4hn+LXyawCEEDZFUTot+z7nZ/QAOZ2kVHqzJe8ENrujwy+9FouMGhrKH7/M8xujXzRPbdO2/nCVQejLHE28vOEol03pvp1Ab5NeVEuLl8hrDoWBxljmaOKyP2w23BesyKcmjWR/aYMhY6kn5J84xaLXd7PyQdUo7Ak/bqUK8MS6QygKhFoL+M3NM33M7jyH09Im8/S6Q+77rGpDc68qp85G/w+vNofexEaEUeUVKvT2ePdGEvj9vXQ3Pm7G1U0GhdB3tTNpq0thd2GN39nSkBAJx+k2xo0MJ6eigUPl/k2kJNqzJBbNS+RAWbvwNLa4eHFDPn/fWqinpg0kNruDci+rA9Wlcrzf/HJtuf+eVwZHsPzvbbMBqGlsxV7n35OmOysDp6zwqw8PUHe6NaBIagvUVqfMC18e6dBXRsG4odoXJEUPNQj9DbPiSBo1lNe92mBq1gaaB3tv5/2bnN8MCqG/fU5Cl0Vp85EqLp4Uw478ampOtbJsT0mXZp8y6Nk7nmlxnkv9ljaZVX4yfPoTf12rBBAa4t+l0mZ3cM/S3UHZSPjjre/OZWNuFcv2BC6SguBXBt505JejVWlqv8e6Jt8q3f4OVGoGXhpRQ0P89jq+77KJjAgPMcMrJn3CoBD61KQopsdFkFvp6/oXCFtJg0/Luq6yYk8Jt89JYHVWe8m7gkcc2P2cuUlRJEUPG5A46aYjVV5dqxI7TPd84au8bos8wAP/yvTr8dIZCSOHcEXKGAqqGn3EMVjUdNjAb37LheN6rcewPy5IiNT9XAJdVAJdAMeOHML3LvHfctDEpKcMCqEHeP622dz9+i69PVpKbNeEX0tjk5XgZ34uBV7bWugTOooeFkrNKTW8ICvws/cPIER7U+y+DOd4WsYW1Zxitbu5hVYUFSjd02Z38PCKfZR2UFmsWeN2FA6ZO2EUFySMZOl2/wZmF44fSXZ5vcEQK8QieNnd6WtZRkm3hR7gyqkxZBTV0eKUfX6HHYu8ghYEDOb3b7WooRbtPEKtEovmJZJX5W7gIQlciu+F587UeNbuK8d7QVPpx5HTxKS3GDRCn5oUxfsPXmKYNT/wr0y+6sDgTEPb/PK2fM2paKC6sYUteSdwyYo+S/dkY24V102PNdxXe7qVEIsaQrBIgpiIMCrqm1FoL9jybszcG7N9m93BkjfSfcIiD12RTESAsIDN7mBZhp01WeV0FExJGDmElxfPAWBVVhk1jS2U1jUZLqYhFsEvvzGN1KQoJsQM4/NDx5k5dgT/3F2sp/dpnZhe21rIsepTJI8ezoNXTtLH1VFvXsltfxtIhEOtEj+5dipcq24+ZxTVst2jC5MnApgYM5QiPz1tOxL54WEWLp4Uw+iIMGaNi+RQRYPa1MNPA4+8ykaDi2WoRWLx/CQWz0/i95/nstfjgub9HTIx6U0GjdCDMbvAZnewMbdzkQd19q/ZIvjD0NfSq6pTViD/hHHlICvqRq1AcKi8gYr6ZsNjWpm61SK4ZFI02/Nr3AUtgmunj+HBK5JJnTCqC2eujvGZj3N8RF4SEBEe4tcsa1lGCU+tPWQwqvJHqFXSZ9xgLKhZllHCyr0lxI4YYhDsJQsS9Q1Ff+6LbwRIb/UeSUxEKCPDQ5kYM4zREWEs97MXM3n0MBYkR+tFUulFtUSFh5BxrC7wpi34iPyQEElPP9VWL4qiGEJRKXERbDhchYL6+3v2m7MMdQie38HUpCjGjwrnu2/tYWpsBL+9vb2l4QcPXcK338pge34NSaOGMreLv28Tk64wqITek1VZvg0fApFb2ci9b6YHDKlof7w2u8PQVEHjmJ9ZYXZ54JRP7eVtLoWtR9v9SlyKwleHq1h/uIprpo/mv6+aEvDioygKa/aVY7M7aG51snp/hc+4OvKwsdkdPL3Ov8hrzZk9HRcDjcNT0APRlfQ+b0uLmsZW7rwogcdunI7N7mDl3lI9HCLcY/3DnRfoXkP3vJHus8egdfHy/j6o96uBmhBaefqmuYaipKdvmsm2/GrdnwbAZm/Pl3e6FD2X3yr5z5apO92KDDx/m2+65ImTajbOzPgRmJj0JYNW6LuactnmlDv1mvf0b+/umIJ5uQJszK1m05FqFk6PNcyUM4vr+He6HZvd4TeerjUXv2HW2A5F2tPvBtT0vmumjWFMRNiAVvT6q9J9bVsRxbVNRIRb0Qr8hIB5SVFMiY0gr7KRt3cWseVIdcCNZM/fm9UiUGRjl6a0gptJXZDr0zvVuygrEE5Z4cm16nM9xf7z7ErGRIQxJ9H4ebY6ZfKq1JWg1hDcxKSvGLRCf/ucBJZnlHQYd/ZECNFp8++05OgOxVrtQSsQqH/42sauRRLcd9lETrY4+dBW5tEQWcVqEVyTMoYteSdoc7UX0iiK2gZvfW4Vt18UT01jK1vzqw3v5z0WiySCMihzNBmLeO6/bCKP3Ti9w9f0B5rfkPdn9EWO0SZBUdTUxWA2bj0/I4uARXPHM8478+j4EcC4+vjbps6tlj1XeLICT607xLiRQ4gYEsIrm/PZfKSaBcmjkCTj1OOTg32X/WNi4s2gFfrUpCiumxEb1GYsqGGTZz/J6TBWf6bN1eGM/LIpqgskELCd2x1zEnhpw1F2eGwSzp8QxdLvzNULlT7ILPUR/FVZ5T7vp21OyrRfUDqqdAU1ZPOvXcWsO2C0Y44ID+ngzPqP1KQolt+fxh8+z+129s2MsSPIq2o0hHg8e60Gs2L51+5jvBDAoM2T66bHsjG3qr35jazwvbf3Gp6TXlRn6Flrszt49P0D+uNLtxVxzbRYM3/epM8YtEIP8OCVk1jv3jjrDEXpPHzT0QwvxGKcSXfUjOHh66ayt7hO73C1q7COH72XRcrYCN2sanVWGSv3lvik4XkiScHH0oGAMWyLJM4ar3yNC8dHcbzhDKWOrqUdhlolnrt1FnmVjaq9QZC9Vj2x2R0+Xa3AdwVllQQPXTmJq1PGuK0U1Gbvs+IjySoxet+s3Nsu9KuzygzHcbq63qLSxKQrDGqhT02KYmEXZvWezUG8Ux7V23UBX3tXF/qteroHzpsQxT93FfNJ9nE+yT7OKyEFvHdfGjfMGsvqrHKcsivgcZwuhdK6pk49+W12B59nH+eTAxUGkQ92FdCfLEu386TuP2PEvW8a8MI9Y2wEz906Ww+/eMfbg8XfXoxFEtx/2UT+ubuY1jYZyeNz834vgLte22U4huafD77jl87CC63J4GJQCz2os/otR6t9Yr6eaHFWbcPsnV3HePbjXGRFbY58zbQxjBgS+KOySsKvnUBHeMaC9xY7+Mxt1dvSJvPj5VlU1DcTHxVOdWMLLpdagHNVyhgUYGteNa0udTWwPb+G7flq5k6oVeLpm2bQcKbNcIG6+7VdesaJxR0qDqYVXH+zNe+EbkoGviGXp2+ayeeHjuvn681Ficbsnu6aeUUNDTU09L5uRvuGeKBG3d7v9fyts3X75hCL4MErJ+mP3TEngQ8zS2l1KVgEPHcWXWhNBieDXui1mK8WMz9U0UBNYwtFNaf1nq6asOwqrGX333cZZlwuWWF9JyuCns6IIz0uIgpQUd+MRRK8cOfXCLVafL3T7Q5eXH+UHQVGwWt1yjzptmu2SoKbLxjLp9mVhrTCGWNHEBEewk1fG6fPQmFgmk2oq6QaooaGklnsYN0BY4qottrwDLmkxEWwu6jWYCWs0Rs+Nlo9glYn+/xtsw1ZNMFePJYsSAy4okhNimL5Axeb1sEm/cagF3rw/8cZqAVdV8Vi/oSoHjsNeptvqQNRyCqp54dXT/ZrV/vIwqlk2utodcrIijrzxKMfq1NW/HZsyq5Q8/t3F9bqK5kQi8TDC6cgywqpSVFMjY0go6iOzw4dZ1iohbu9uif1tJJ3Q24V7+62syO/Wr8IhYdYWDg9ls15J2hzyR26OPrroWC1dH1V5Y/0olra3L4GQnSvg5lGRxcF0zrYpD85L4TeH6lJUTx7yyy1aKgDb/COsEjwqxt6npIYMzzMsNEnQafNxD3j/J62DVrBjz+7Bs/G3J4Wva0umT9+kRfwvT7ILOOn101RvXtkhb9vLcTpUgixSPzqhhSa2+QORd9md7CzoBpJCDYeOcE+r41KATx4RTIPL5za4UXEZnfwzEeH8OrkxwUJvdcIXEvv9OzIZGJyrnPeCj0Yl9eNZ9pYur3IsIE2b0IUNadaOVZjtMadPGY48yeO6pX4tmeoANR47oKJ0dw4u/M+rv5mhSlxEbyfWcLKvWWG+6+fEctVKWP0C4HFIoGi4JQVBEKvkBVA8uhhFHrYAcvAixt8M45aXTLPfZILqGGWx26YxsyxI9hXWk9acjQuWebtncV8mVOpf65DQyyGi5rWmPryqaMDnpP2OWmmdZ6EWqVeE3nt/c02eyaDjfNa6MEoLAlR4Ty5LgcAqwT7Sur9OjXOnzhKb67RU9KLag0bxW0uhR0FNew5VtthTr8/bHYHnx6s4MtDxuIiz9aJ3tkh/vqR/uCyZH7zcY4+LouHfYDm+a4oxguES1b47ae5HY5PEnDrRfGs3lcWsDF1oPP65YcH+nQm74kZVjEZbJz3Qu9J1LD2ylhV43w9U0J6KRasv+fQUL9ho1aX0qWmJd4NQywSoKghIM+MD28R03723jhMiYvQ871njYv08YDxDhWFWCQumRzN5iPVAd0iQ60Sd6QmcEdqQlAzZtXbpoQPbWU+6Y69PZM3MRnMmELvwScHjgd87PEbp9HmUnp9OR+oVSF0za9n/eHKdpEXcM+8RN8y/w7wdwHwvB0og8R7hbCrsNYQGnLJit+ZezBFS4uXptPqMY2XgNkJkcyKjxxQPx4Tk3MNU+jd2OwONgSwNb57bgIPXDHJ72M9JVBBVKi7VD9Y5k4YBVvVZh8WSfS6EAYKZ3jf7xnfBroc67bZHewqrOHz7EqDyGvtD81ZvIlJ1zGF3k16US1tAawpPzpQwSKvFMPeYtG8JFbZyg257uEhFp66aUaX3m9YqKX9huiqd2fvESg01Bk2u4NVWWW8v7dU3xeRRHvR1F1zx5uzeBOTbmIKParIbD16wnDftNjhHKlSC6qCsTDuLqlJUVw73WjTcKbN1anBmjdvbD+m/+xy9d14+4JADcmvmx7LBeNHmtkvJiY9RBroAQw0aix4N3uOqU1F5roFZfgQ1c1REp3ntPeUmIgwn/ta2mS9arUzth2tZkd+tTr77Yfx9jbL95T49ZGPiQjzWzBmYmLSNc57oV+3r5xWt8hIwKQxahOITLtqkZs4aihP39S3ceE75iToHjQaCnTqjw+qCdh3395Dq0vBahEsmp/Yp83He5uvcir5aH+Fmrbpvk8Aob2c3WRicj5zXoduSuuaWHegQm81F2KVsEjGa19xbVOXwyhdJTUpiudune3TzWhL3omA9go2u4N3dhXzkYevvMulED8y/KwXeZvdwfrDlZTUNfF5diUKatrq3XPHMzNIy2UTE5PgOW+FfmveCR55fz9tLpmX77mQUscZ0pKj2VXg64zYlzF6jZS4CJ/7qk76erHb7A7e3F7EF4cqz0m7W7XCdbfeFERDlhXGjQzvsW+QiYmJL+el0O8truP7/9yLrECoRSI+aijfvDAem93BS35K/S0WY8z737uL+fJwFTfMGttrwuQvHn+xl2j/e3cxT63L8RH4s9FX3h82u4Mn1mQH7Px0tl+kTEzOVc5Lof/bpgKP1m/ts/X0olq9pF9DAHemtqf1PbX2EO+m2wF0X/TeEPu05GhCLULfLwB4Y3sRidHDWLIgkYyiWp76yCjyAjXcdLb5yvvj37uLefqjHP1zl4Tmnx985ycTE5Pucd4J/ZHKk+wsqNFztD1nkmnJ0YRYhCEDRLMAAPjrxnxd5DU8W8T1hNSkKOZNGMXOwvaZvUuBJ9dmk3/iJGv3+3q1L5o3/qwXeNC6RuXotwVw6eSYoJqYm5iY9JxOhV4IMQTYBoS5n/+hoii/FkJMBFYA0YAN+LaiKK1CiDDgX0AqUAssUhSluI/G3yUyimr58fJ9DAuz8NKiCzl8vNEwk0xNimLZ/Wks8eirKlA9yT89WMH/rfdtFn2oogGb3eHXUvf1rYVUnWzmwsSRWCRBS5sLe+0ZbpztG/Kx2R1kHPNtVSgr8PZOO6OGhhBiEbhkpUOv9rMNW3EdT647ZLjPIglT5E1M+pFgZvQtwDWKopwSQoQAO4QQnwM/A15UFGWFEOI14AfA393/OhRFmSyEuAf4A7Coj8YfNDa7g3vfzMApK4RYBCPCQ/nh1ZN9npd3/KTPjL6hqZXHthT6Pa5Lhp8uz2LGuEhiIsJIiApnY24VNnu75/qBMqOfzY6CGjbnneAhd3s6UBtG+3PK1PjepRO4dPLoc8Y+VzMk++JQpcGQTBI978hlYmLSNToVekVt53PKfTPE/Z8CXAMscd//DvAbVKG/xf0zwIfA34QQQvHXFqgfWbOvXBdSWVb8ZtHYiut4yiPEoLHUo+pUuP/neTZl9c2U1ftmyHTE+sNVbM2r5s65CcwaF8nKvSUBn2uVBJdOHn3O2Of6q3T13DA+F1YiJiaDiaBi9EIIC2p4ZjLwClAI1CuK4nQ/pQyId/8cD5QCKIriFEI0oIZ3/Hd07gea21xsOqJaDHRUObrxyIkOO00J4LIpMdwwayxPrc3GTzFnl2h1ySzLKNFb+vl9z3NwBqy24zOe0GVTzJi8iclAEZTQK4riAi4UQowE1gDTevrGQogHgAcAEhP7dob36Pv7qahv5geXTmDU8LCAoQ+5g9AJqMuYISEWJo8ZxjXTxrA+90TA50pCrao9eaaN2BFDmJMUxekWJ+lFtZw42YJnD42O1joLp8eSEhfBK5sLiBoaSk5FAwqc1ZuwacnRhmYloVbJFHkTkwGkS1k3iqLUCyE2AxcDI4UQVvesPgEodz+tHBgPlAkhrEAk6qas97GWAksB5s6d22dhnbd2FPFpttpx6b09JQHtAWx2B2/tVEM0knuG7W9Q6w9Xsf6wfztjT2RFraoFtfn3kcrGbvWldckKi17fhdOru9LKPSU8d+tsYkeEcaC0nitTxgAYesgOVCw/NSmKR7+ewh+/yOOGmXHcd0WyKfImJgNIMFk3o4E2t8iHAwtRN1g3A3eiZt58F1jnfslH7tu73Y9vGqj4fGVDMy982Z4po1W4gq9PenpRLU73FDSQyHeEFoMO1GjcO/9dkgRyEE3JNx7xv2pwKRgsE/6yqcDQixX3eO6cE8/dfWSx3BGXTIoB8ggPs3T6XBMTk74lmBn9WOAdd5xeAt5XFOUTIcRhYIUQ4nlgH/CW+/lvAe8KIQqAOuCePhh3p+w5VssjK/fjlGXCrBJOl4xFkthdWMOf1+fhktX499dnxDFqWCgFJ9pn3B3FzAGsFoGE2t9Vob3B9dM3zSSnooEPMlVPdc9IkPYal6z4tOPTwjFNLU7W7q/w+57B4D1kl6ywMrOMNfsrWH5//xqdfZGtdutak1XOZ9nHzymjNROTwUYwWTcHgYv83F8EzPdzfzNwV6+MrpssyyjhibXZKIqasfKttES+yKmkvL6ZHQXtUSRFgS9yKn1e7x2qF8DCGbGMjgjT4+MQOExy+5wE/THPmLr2mkAhFZvdEVDoL0iIZNG8RLbknWBjbpV6blZjuz4UxecCA9DqlFndhf6zPWXPsVpe36Z2u1Lc738u+eObmAw2Bl1lrM3u4Em3yAM4ZYW3dhZ3+3jabP1Bj5x3jUDC1VEaZEdiFyjF0moRegu9JQsSsdkdftv1aT9HDQ3l5Y1HqTrZoh+jurHF77F7mx0FNfx4WZZhdSGJs99szcRkMDPohH51VpnPjNYTLT7u7Z7oj9B+9JGx2R2sySr3uV8Ad88d32Hjbu+fbcV1BpEH/81Nehub3cF33srQP/9zxWzNxGSwM+iEviP59vSHyats5PNDx5k5dgSNLU7yqxrZU6w2G7FKsGheYr/2KPU2VNM2ViVJ6F47wbLlaLXhtkXQL008Nh850W5aBlxq5s6bmJwVDDqhv2NOAu9nluoZNBoS8JxHVaYWBvHkome/wioJHlmY0u/Vm2nJ0VildvdKbUNYlpUuNz4J8WpXdenkGD3bqC9Fd+TQ9vaLZu68icnZw6AT+tSkKFY+cDGrs8rIr2qk7nQrE0cPN/jK+MNmd+BoakNAn3eUCjTuu+aO570MNU6vzYwVut74pLLBGLbZll/DtvwaQiyCFQ9c3Gfnle9upn5HagL3DEBKp4mJiX8GndBDx5uhgdBmvN0R1t7i9jkJfGAro9WrOsq78UmnCP93t7kUfrXqIH+442u9fm624jo+sJUC8PGBCu6ZZ/rZmJicLZz3zcE1PIXUMkAt+VKTonj6phk+9185dXSXhPmOOQlYvbuNuyk4cYpFr+/mu//I4PE12djcTdB7gs3u4JerDuqrEM/CNBMTk4HHFHo3ucdPtt8QAabEfYzN7uCZj33dM080NPPK5vygRVkLX927IJH5E3wvEE5ZYevRGpZllLB46e4eib3N7mDJG+kUVp8G2pusm+mUJiZnD4MydNNVbHYHT3s0x3AOUOjGn+sjwIHyBg6UNxBmLWBZkBWunuGrZRklrNxbQk5FAy7ZmJnU5vJv2dyVMWuhJrNzlInJ2Yk5owd2F9YYm2MMUOgmamio4fb1M2JZPH+8HnJvccr87rNc/rYp+Nk9qD1t1/3oMlY+eAlfSzCmakqCHp1rWnI0kqSOMMRiZtqYmJyNmEIPXDwpBotbrISA+y6bOCBi5Whq1X+WgAvGj+TO1PGEhUh6j9tMu4MXvjrKotd3sywjcLMSf6QmRTFp9DDDffdf3nNnyXbPugHtLWNiYhIAU+hRBfCJG1WLfUWBf+4u7pVNyq6Slhytz95DQyTdE+e9+9J49PoUlsxvz2RxygpPrc3miSA3VG12B4te38Xqfe1eOgKICA/p0Zg9V0Mud+eusxWb3cErmwv4/We5fPutjC5fKE1MzlXMGL2bM22yXo06UCZcs+MjEQLiR4bz31dNNjQtT02KUvuwup0xQbUqfi+jhFVZZR26Q/pr7Qe9k11Ue1rN2RecfZuwnp5ALW0uvvf2Xlpd7amr2/NrKKk9zWM3Th/AUZqY9D2m0LtJS44mxCLR6lIF3zte3h+s21+OrEC544zfoq3UpCievWUWT687ZGgk3twm89H+ioBC//rWQh+Rt/aCB43N7uCdXXZAvWg8fdPMsyY+vyzdzlMf5eCSFTWJKkCPgde2FZEYPUxvfmxiMhgxQzduUpOiePT6qYBalfrsJzn9Hr75565iwFi05c2SBYmsfPBilixIJNSqxu4B/p1ezC8+2M9fNho3avccq+Urr45YFyRE6sfoCdvzq9sreBXFsMcwkNjsDp5Ye0g3rlMUmD42glCL/6/742uysZ3ucXdME5OzFnNG74FTVpf1A1Edu+dYLTkV7bn8HVXDaqGcO9y+9zPHjeDtncf4wKa6X766pUAP5XyQWWZ4rUWgWx73lPAQtXvU2ZY7v/Woscm7VRI8d+tsQE0HfWnDUZ8VTvrp2U/3yu0AACAASURBVKT24xhNTPoTU+g9SEuOQXAUhf6vjn1pQ77+swDuTO3cOdMzVz6n4iTbjtb47DEMc7fyk1DTRnvTMthmd2CR4K7U8dzlZaU8kEjugjd/NsmpSVHkVzUaGrxIQNqwbD9HMjEZHJhCHwC586f0GrbiOnYVtodpQqxSl22F05KjCbNKNDtld2Py09jsDsodZwi1CO6aO75XbZdtdgfrD1ehAGv3l3PX3PG9ctyejim9qJaNh6sYYpW4fU4Cd/i5YL50z0XUnmple0ENiaPCeXHRRaTuPDJAozYx6XvMGL0HH9pK9SW/06WwKqusw+f3Fqv3tTccCXY2701qUhTv3Z/G12fGAfBBZhmLl+5mQ+4JWvvgXNKLavTP6mzwttlbXMc9S3fzpy/zyK44SbNTZvW+wOf8+H+omTYXjT87ViEmJn2JOaPvgP5yvKlpVDcxNR/37jYJSU2K4msJkXyVU6mGcDzi0L295zAnsf04XXbX7CVsdgdb805Qf6aNtfvKfeLuHZ1zcY3qzfPRgQq+PFzJe4nTzBi9yaDFFHoP7kwdz8q9pcgKWIRgZhc7O3UHm93B+ly1Qbkkep6iqKaJCoPIQ+/bOpxudek/y0r/V8RmFtexaGm6nlkzMWYoZ9pcuFwKMp1vEGsrHH3j3dyMNRnEmELvQWpSFN+9JIm3d9qRla53duoO6UU1vZqi6JJlRoSHUHPKeJwZY0f06nms9Qg3OV0Kq7PK+nUzdu2+cl3kJaFepNOSo/Xm6I6mVr2y2Bub3cGmIyf02xZJmJuxJoMaU+i9KKpuAvovxVJ4/NvTFEU1Tp3utzn6ol5uBOIdJunvOb32/haPmXuwDWde31poaGB+19zxpJ4xN2NNBi+m0HtRVqcKvUTf54bb7A5edKdVSj2sLLXZHfz8/QMGAdPE1yJBSlxEzwfswYKJUXyZU6leoCyiX5qPe1JQfYrJo4dx25yEgDN3f+wtrmPjkSrdJC7EnZ3Dzr4dr4nJQGIKvQc2u4NC9yZdT4U3GNKLaj2qN7sftrHZHSxemq77uEhCjfe7ZAUFcMmw4XBVr55LXGQ4AN+9ZAI3XzCuX8M2DWfa2F9az39fNYkfXj056NdV1J/hv/5tI3HUMJ65eSbZFQ3tFwlT6E0GMabQe+CZItgfJf1pydGEWiWa22QUpfv+OqttZbrIa80/bpg1lmc/yaHVnVf/YVYpFklw9bQxvSLKh8rr3ecwqldF3tOIzPu4NruDVVll5JQ14JIVYkcMCfq4Z1pdPPBuJs1tMiseSGXymAiuSBnda+M2MTmbMYXeA014tY5JFfVnsNkdfTZbVXvEzuSJNdko0K3NX5vdwfI97Xa7CnDDrLEsWZBISlwE6UW11J1u4a0dxfxtcwFv7ijq0Oky2Pd8fdsxAH743j6eu7VN983pSKgzi+vYkFtFYtRQHGfaDM9xyQovbzjKXzcVqJXJAq6dHst/XjaBVqfCir0lfJZdaTjesx8fZnoQm8yKovDY6oPkVJzkjW/PZfKY3g1jmZic7ZhC70FqUhTL70/jJ8uzKK9vZvmezi2Ae8q+EodP4VFn7+Uppn9ef9SnildbiWibk69sLtBj9r2xwbw6q0wPObkUhafWHdL3AJa8kU6bSybUKhk+t2151Xzvn3sMewhhIRLv/mABFfVneHlDPkXusJl6XPjqcJVuyKY1hvGkzRXcuSzdVsS6/RX84uspXDcjttvnbWJyrmIKvRepSVFMHzuC8vpmZKVvM29sdgerPSpWOys8UhSFZRklPL0uB1eA3PVQPxvIacnRWC1CzVQRoscWzBX1TYbbWsORNqdMi3s15Pm55Vc18pOV+wzZQArQ0ibzn//cS2Ozk2lxEfzy61P58/p8gwUzwO1z4rlzTgLfe3uPoT4gmM3yN7cX8bvPj3BJcjT/fdWkHp23icm5iin0fqg51Yqg710Z04tqcXnMcANZH+wqqOGfu4rJq2zEXtfk87jGBQmRfp0pU5OiuGdeIu+m25HlntUH2OwOtuTVGO4LtUosmDiKP37RnqJotUhEDQ3lkRX7+PxQJWEhFkKtEk6nrK9AFOBUs5NHF07lh1dPRpIEI4eG8dTabP1zCbVK3LsgSV1tPXAxq7LKqGlsYXREWKfePZuPVPH8p7kAZJU4yCqpP2uM10xM+hNT6L3YfKSKA2X1XD41hgUTo7uUutdVPC8ggYzMXt9ayO8+VwVUALdeOI4vDlXS5pLVcIYQuFwyIVapQ/tht6Fjj8M3W/OMFsDaxWXTkSr2FDtYMDGKjGMOliwYrzdIEQL+svgiooeHkV5Uy4HSej0kIwk1w0lrMK7tLazKKkOAQcyDzZPXeGP7Mf3nYMM8JiaDEVPoPbDZHTzwrg1FgfSiOn567dQ+FYbqxub2G35CMf/YUaSLPKhiPSU2gm9fPEGP0QMBNz89ueWCcfw73a6GT7oZvrHZHWQW16ljQY2xP33zTErqTvPK5kIWzx/Pj6+ZwiW/38S/d5foIRgJyD9xiutnxuktEbflV9PmlP2umLoq6P7YVVBDpt3RLyszE5OzHVPoPUgvqsXpjhm0OWVW9XFZ/6tbCvWftTi39n42u0MPO2hIQvitAA1mjKkTRvHYDdP438+O4JIVfv3RIXIqGoK2Ll6WUWIIqQgB37t4Aquzyli5t5S05FE8881ZHCxT0y7bPOwJvEVWa3gezAWqO9iK6/j2P/bgkhWskuDueeO5oxctmk1MzjVMofcgLTkai0XgdKmFRh/ayvpMID7PPk52WYOhQtNTDFfuLTFsXkqCHjcNaXMpSEJtldjmUngvo4QPMktZ/sDFgHFloGX2zJsQxZeHKnlrZ7HhWLICS7cXISvq+B+6chKhVomMY3X6e0ioOf0PX+e7MuqNWbs/bHYHP3v/gKEQLX5kuCnyJuc1ptB7kJoUxayxI9hf1gCAq4/iuu/uLubpdTkoqG3u7vZqCpJZXGdoAWiRBM/dMqvHPV49C7Q0Wl0KD6/YR0V9My5FwSIJbpgZy5eHq3z8bLyRPWb3ORUnuSpljP4eWljGn8j3FTa7g0Wv7zaEjMyQjYlJEI1HhBDjhRCbhRCHhRA5Qoifuu8fJYRYL4TId/8b5b5fCCH+IoQoEEIcFELM6euT6C32HKvVRR76pp2grbhOF3lQQzbjvGacL67P1x8XwKJ543ss8tAeMpkxdoTh/vL6M3q6pktW+CS7slOR1xAYUzq19/jZ9Sl9Wn/gjaIovLj+aLvIC7h0Sky/jsHE5GwlmA5TTuBRRVFmAGnAD4UQM4DHgI2KokwBNrpvA9wATHH/9wDw914fdR/h2c5PdzXsZZF4a8cxQ9aKFncHdUb6yMr97CyswSIEFqFuePamYVhqUhTP3TqLUIukirRF4vlbZzMkRMIiYEiIxBM3TiPMqt4OtUq6w6ZVEjx0RbL+3FCLYMmCRB8xTU2K4odXT+6/mbzbtXNHQfvnFtrPqwkTk7OZTkM3iqIcB467f24UQuQC8cAtwFXup70DbAF+5b7/X4qiKEC6EGKkEGKs+zhnNZdPGc1fNuYjKxCmuRr2IqV1TWzOq0Zyl6l6Nuu22R3cs3Q3bS41HfHpm6dzqsXVJ5uVak66cTNUs0vQbs9JGkV6US0jhlj5zUc5TBoznN/d/jVSk6JYODOuzzZSu4rN7uBudwMSiyR49pszqfeyVzAxOd/pUoxeCDEBuAjIAGI9xLsS0GrL44FSj5f9f3tnHh9VeS/87zMzSci+7xsEwpawSABRcS9WqTtWq97b3tZq7e217dv27bV1q1pbe9vb2r63VUF7u4mKgqgUFxAEERLIhC0hBELIJIEsJJksZJ3lef84MyezZiM75/v5oDPnnDnneSZnfuf3/NYaxzY3QS+EeAhF4ycjY2RrpQ+XvMxonrtjAT/ZdJQFaSPbXepAZTPff+MgAvjjfUuoaOxQNflffXic9w+fVc0lAjjfYxtSZcah4ityx1ckz73r8rFJOO1SnmC0HKnDYVdZQ5/j1S5p6bKM6vemoTEZGbSgF0KEARuB70sp24QzAweQUkohxJB6T0gp1wJrAZYuXTr2vej8MDshDAEcqDRz/yv5I2LjdZYRttolAXpBQsQ0EiKm8eKn5XxyvEENodfrBEg5YRyIm4pq1AJvdo/wz4mCs1wygJ3hVwDV0JjKDErQCyECUIT8a1LKTY7N9U6TjBAiGXD2ZjsDpLt8PM2xbVKQf7p5yEXGBmJDYV/ykN0u2VhUw9uF1W51W3RCcbqmRgVPCLOD0WTmzQN9C7PxagA+EK5JZzrBqJeW1tCYjAwm6kYArwKlUsrfuux6D/ia4/XXgHddtn/VEX2zAmidDPZ5JyuyYlXn40hE3WwrqWfzwbNKhqZj266yBu/m3ULp0jSWTkx/5Fc08r03DqoPp/7q8IwnxspmNh86CyhC3ldBNw0NjcFp9FcA/wocFUIccmz7KfA8sEEI8QBgAu527NsKrAbKgU7g6yM64rHExTw1HAorm3noH4WqaUY6/nOmpdvtOL2LU3a82Xm8nm/8pVBd1TgF6Fi3ChwIo8nMPQ5zmF4I7lmuZb9qaPhjMFE3e+jrYe3J9T6Ol8B3LnBc40Z+RVNfjPsFJkz9fZ/JVwkbN/xVnBwPOnut/OSd4j4hj//M1vHm8/JGl3LGWvarhkZ/aJmxHrgu/S/EdGOsbGb3yXMDHnfZBLDHA1htdh5Zf5D61m4C9AK7XY55ZutQiA8PArSCZRoag0ET9D5wdmMaqulGqQ/TSHuXVa0Do9fB7IRwSuvafX7m5d0VNHf2cs+yjHETqMbKZp7ecowjNa08e3su85MjJkycvD9Ka9sAuH1xKvevyJyw49TQmAhogt6DjUXVwzLdGCub+cq6fO/SARJuXpTC1bMtbD50huiQQE7Ut6tVICWwobCGt4013LE4leSo4BFr4D0YjJXNqq3boBPMd/RgnciC02gy81q+0id3a3Et96/IHOcRaWhMbDRB74LRZPYqJjaQScBoMrPjeD3vHDzjJuQNOoF0iYnPy4zm0dXzABztAIvdWubZJWw8qEShvrjr1IgUMRuI+rZufrzxiDoOKSdmrLwn+RVN2B3Ojx7L6JeT1tCY7GiC3oX8iiY3YT1QrRslEWqfGirpmvD05M05mDt7fZo/nF2UNhXV8FZhNTa7RAihClybXfLYO0fZW36Or6/MGpV67a/sOc2uE+ew2OxeD6WJTnRIIEL5qke9nLSGxlRAE/QueGZV5qT4L4PQ1m3hZ++VqEJ+qAlPTvPInUvSyK9oIjok0E3Ll8CWo3VsLa7je9dnY9DrRsRmvqe8ka++WqDUi3e0+EuODJ7wNnknRpOZp98vcavVP1rlpDU0pgqaoHfB3NmrOmIF/rMs95xs5MdvH6a2tdtNGx6OVulpD/dl0vnd9pOAsmJYsySFmNAgVs1PGpZg+9UHpX115AFTUyc3L0yZNEIyv6KJHmtfPX1fTVs0NDTc0QS9C86mGT1WO0J4a/gdPVZ+sbWU1wqqyIoPZdO/X45dDq5n62AYjElnQ6Fix391z2neeOiyIV1z+7F6jp5pm3SmGldWZMWqHawCDTruykvTzDYaGgOgCXoX8jKjefLm+Ty2uRi7hGe2lDAnKRyADYXV7DheT+P5Xh68cgY/vGEO0wL06udGcgyeJp1ntpRgsdoRQmCzK20OLTbJc/88xvXzEliRFTfgGHaWNfDdNw6SGRPCr+5agNHUMilMNZ7kZUazMC2S0tp2nrolZ9Qd1hoaUwFN0Hvgaq6xWO1sOFDF20VnFO0a+PntuWMSzudq0nHWincV+hIoqmqhqKoFve4k181N4OGrZ3oJbiWSqJoNhdXYJdS2dROg10/aUr5Gk5mjZ9qw2aX6IJ5sDysNjbFGE/QetHVZXd4J3jt8Vq13rhPQ0mUZ8zH5EvpnzJ2s369Ul7TZJduO1bOjtJ57lqWzJi/dq5mJk8nuuMyvaMJu10IrNTSGwmBaCV40rNt9inWfVajvbVLSZVHCD/UTJNXe2aZvTV46Bp175q5Nwvr91dzz8j4+Ka3n5V2n3IT8VHBcrsiKxaBX5u0MrTSazOM7KA2NCY6m0Tv4pLSe57Ye99quF3D3BKoT7yQvM5pnbsvliXeL1RWHE6td8s2/FYL7ZlKjpnHVnIQxHOXIk5cZzfLpMXzu6O872VcoGhpjgSboHfzziHfJfGfBrIka1eEapXOuvYdPHW31DHod0+NCKfOor1PT0s36gio2FdWMSOes8cBoMpN/ull9PxI9AzQ0pjqaoMfZwMK9Cdbti1PITgyfUFq8L1zt90pRtSZV8N2/Lp9ul5hzJ92WyasFu9roAa6ZM3Z1gTQ0JisXvaC32yXPbS11y7QUQHZi+KSLTPFMvnrtwRVsMtawfn+VpxWHXWUNE/4h5gunjd7pe/j0xDmMJvOkm4eGxlhyUTtjrTY7P3r7MEVVLbj6NQ36qWEOyMuM5rk7F/DcHQu89u2vVBqW//SdoxPOmWk0mfnjznKf48rLjObupX0tiXutdl7YfmLCzUFDYyJx0Wr0+RWNPLG5hJMN5/nhqtlcPjOWP+woZ9eJc1w3d3I7LD2579IM3jlYw4FKd2HYa7NPCJu90WRW/QygJHfZ7BKDTsddS70zX+9cksbGohq6LYpZas/JRg5UNk9av4OGxmhzUWr0bxVWc++6Ak42nMegE1w+Kw6EwGJTBMfHJfXc/0r+lNISH71pnt8/drfFzsu7To3peJysL6jirpf28lpBFR8fq+fjY/VYbBK7VB5ErxdUef0t8jKjee2bK1iRFQMowUXdFjsvbNM0ew0NX1w0gt5oMvPC9hN89/Uifvz2kb6G3VKyqaiG+9bls9cRsidRsmLzK5rGb8AjTF5mND+/Y4FX7L2Tj4/V8/zW0jEbj9Fk5qebjvLYO0f77avrFOKeD6K8zGj+7xfnEmTou4U/K2/kK2v38dgENEdpaIwnF4Xpxmgyc++6fHodESjLMqM5cqYVq81OgEGHhIuiIqIzHPPlXaf4+Fi91/6Xd1dgsdsJNOj5wrzEUTODeP49PDHoBdfNSeCT0nq1E9fHx+pZX1DlVtsmLzOa9Q+u4IXtJ9hzslGtAfRaQRUbJ3EIqYbGSHNRCPr8ikZVqAhgdlI4j66e5xaK+OYBpVrkVK+ImJcZzdqvLmV9QRV/3lNB+bkOdZ8EXt1TCcC63RXcvSx9xL8Ho8nMz94rdhPyAtDpBHkZUcxKDFevedv/7OFwTat63IuflpMeE8yRmlY1YigvM5rvf2E2Byqb6bHY1egirTyChkYfU1rQP7+1lA9L6twiaiTwxv4qwoMMtHdb2VhUQ25KJDNiQyg/18Fjq+fytctnjNuYx4r7Ls3gvksz+P4bB9l86KzXfqtdjrij1mgyc8/L+9zq7Rv0gruX+n6g3LMsg8M1R9X31eYu/vXV/QiUEsVP3dLXxeu1b65gY1ENbx6owmZ39uKtnrIPbA1vjCYzG4tqOFnXTq/Nzj3LMrTqpg6mrKD3J8BAqQnz0u4Kn/t+9t4xalu6CQ8OmJRx5kMlOzFcbbYCqLXenfRY7GwaIc34T5+edBPyAPcsTfcZ/gmoP9IPimu5KTeZ43Vt/G2fSTW1PfaO8hAIMuh47cEV/OKOBTS296hmKatNalr9FGZ9vol/Hq3l+nkJzIgL5Zt/K8TmYg10KgmasJ+Cgt5oMvu1QQ8GSd9DIFDvO7xvKrEiK5agAJ0aquiUwzrAjvJ9vFVYzZ0X+B0YTWZ2lJ5z2xaoF9y5JK3fzzlXHs5zbCisptdRptnpxO222nlkfRG3XZKKxe5u9//gaC25KZGT9sfumu08Ve/B4bC+oIqfbi4GUOse+eJ/957mK8vS0fkJQrhYmFKC3mgyc/dLe7H1E8Xh/HP3c4iKM7xvvOPMRxOl2UoOP33nqNt2V3FpsUle2H6Cm3KT/TY8H4j8iib1OxfAwrRInrwlZ0jncYZVutbm77Xa0QlB2DQD63ZXeK0YzJ0WdW6TTdgbTWbufyWfHosdg17w1C05BBl0VDd3cvVFXvrhg2Lv2lS+OFl/nnvW7uPZ23OZmxQxyqOauEwpQf/SrlP9CvkAveDpW3Mxd/YSHRLIq3sqOOXijPSFM7xvpMwXE5G95Y397pfAZycb+exkIwIICtAN+cHn2gIwQC+GLOSd+KrN73zwdPZaMZrMPP/BcUrOtrl97s0DVZNO0OdXNKmrF4tN8rhDgwX4n53lfPPKLJZPj6Gsvv2i0/hvyk3ms5O+71sBzEwI4+uXTydAr+OXH5TypT/s4YGVM/je9dmEBk0psTcoptSMT58773ffldlxfP8Ls90KgFU2dar7DTq4bm4iceFB5KZEsvlgDftdMknXF1SRM4lNAP4orGzmn0f9a0cpUdM429KtvpcodvsXtp3g+6tmD0m4CCFAykGtpgaDZ22fkEADV2bHExJo4Msv7XXzNSRGTBuhqw6P/kww/vY5exg7I5Rc52OXsHZ3BWtdfE1XzY5j7b8uVVtcTmXuuzSDqqYOL1/bDfMT+ZZHp7VV8xP51YfHWbu7gvcPn+WpW+bzxZwk5X68SJhSgj5A7zv/y6ATbkIelPrzzjruAiXCw9Up6Lk0lMDjmyenCaA/fvlBqV/BqxPwH9dm8/T7JVhsdlXQSJTkpAOVzbz24OA0e9eqkza7HNXqmXmZ0fz89gU8vvmouoL41tUzR+Vag2H/6SbuW1eghu+ud/nOjJXNfGVdPlab9z5XU5UzDPi+dflYbHYEAptHptnuE43MfeJDALITwvjbA8tJjgxWrjMFbf2Prp7HP4/WUt/WTUZMCN9YmeXztxkdGsjzaxby5aVpPPZOMQ//o4hr58Tz9K25ZMSGjMPIx54pJegDDd6CXifgmdtyvW7ugtOKA8dpivB0CvpaGtolPPbOUfafbiI0yIAEclMih223Hmtcf+zn2rv59UdlbqYrz4ibh67MUpOsnHbxD4pr1e+l2zp4zd5purFJ5cE72sloruMej7+NM9Svx2Ljs5PnVN9Bj9XOI68X8bXLppMSNY3fbjupVuLssdp58G+F3DA/kaXTY1iaGc2SjCi3sa9/0EXwS8l9rxSo5h1XTjac57Jf7lDfB+gEVrtUI5Qm+r06ENXNnTy++SjV5i4EUNPSxZyk8H4/k5cZw5ZHVvKXvZX8btsJVv1uF49cN4sHr8oiyDC1V0FTStB7xl3PTw7n2dsXeN3UH5fUYTS1AErjiidv9rYXOzWDP39+mvKGPpOQBJ9hm3ofCT+DwVnQa7QfGkaTmfsc2ai+NHgBfGV5BrkpkWo4o/M78LSLuyYnfVbeyAFT/wXFjCYzG401ff6TMVoye5p2xgqjycyaF/e6bTPoBHYp0QlBkEHHLz9w72YmUO6h6bEhbD1ayxsHlH7AcWFBLM2MZun0aJZOj2FhWqRfwZ+TEkHB6WZeL6jiw5I6t/NbHA+abqudNS/u5bvXzeKGnCTmJ0dMmogUo8nMJ6X1VDZ1sO1YPXaJGhrsLFky0N/boNfxzSuz+NLCZJ7dcozffHyCTQfP8OxtuVwxK25M5jEeTClB7xl37c/E8pfPK9XXUkrMnb1+z3ffpRmsL6hSarL0c22bXbK/0sz+SjMbDlRx97IMVeA7NenokEBKzrYigTWOFYRn8+7hOjsHYsfxercyD644r+kcb3+mKac54YXtJ/o0e4udp98r4albvR+YzgeM67Wnevs/XzWSkiKnsWx6DPcuT2f5jFh+ubWUl13syxIlSS0rPoxHrssmPjyIwzUtFFaaKTQ1q4I7OEDP4vQoVfBf4qHxXz07nqtnxwNQ19rNe4fP8AsfLTL/sKOcP+woB+CKWbHcvTSdK7PjiQkNHLSZx/M4z8Y3vl7nZUZTUNFEoclMdEigGhhh7uzFoBPUmLtYNj2aoAA9ZXXtxIUF0dDWzemmDt47fFYNqV01L5G7l6bzyBtFWKz2IZcsSY4M5k/35/FpWQNPvVfC/a8UcOuiFB6/eR4J4ePrzxkNhOyvotQYsXTpUllYWDjwgesF3Hdh412fb1Ljb0GJ5X79ocsGFDrPby31m2Tlj0C9jsXpkRSazHhE/aEXcElGFIWOlYUni9OjeOLm+SMiDLstNm774+eU1bWjE4p2iRDYbHb0OsGXl6YPOU7eNfTPNdnq5X9ZyqqcRPW4P+4s5zcflbk9JKeNwoPsghmBe8uJ0WTm3rX76HU8wHUCwoIMtHVbiQ0N5LbFqcxPCeexd5RSEMLDZOZk+YwY7r80g2vnJtDVa6Ow0syBymaMJjMlZ1sVjVbA3KQIN60/NSrY61wHKpvZaKxRVwr9odcJ7A5/wt8fWM7yGd4C1Ggyezm8Hb52N4Rju1P7DjTo/Cocg0Un4Ic3zOE7184aEd9Dt8XGnz49xUufniLIoONHX5zDv6zIRD9BVzpPi6d5Sj4FgBDCKKVcOtBnLipB7+vmvP/SDL+ZmV6XL6jig+JacpIjaO+xIoGIIAPr9pz2atA9EuiF4Mc3zqGquZNz7T3EhQcNOXlLSsn33jjEe4fP8qMbZiOE8KllDQdnRVBnQTFQHJ8/umEOi9OjVK3tZ+8Vq0JPrxM8e1vuxHNoj6Cghz4bvUCpn78wLZJdZefYWFTDJ6UN9NrsZMaEkBUfyr+syOSKWXHkVzTxwdE63iz0FsbRIQH8n1WzuWF+EkmR0+josXKoukUV/EUmMx29NgBSIqeRNz2GZdMV09XcpAgvodXS2cvD/zCSX9HsdS1frJwVx1Wz45ibFMHc5HDeKqzmNx+dGHIEVXLkNOpau/v9nGumti8MOsGb3xpYORsqpxs7ePLdYj472ciC1Eh+fnsui9KjRvQaI8GoCHohxJ+Bm4EGKWWuY1sM8CYwHagE7pZSmoUSr/R7YDXQCfyblLJooEGMlaD/485yfv1Rmfp+pG4Yz8YZn5Y1sEV5AwAAIABJREFUYLH1H0bo6vh0JhDdsyyDD4pr3QSnJ3oBNy1I5utXzBhw3EaTmd98XMa+U038+MY5/Ps1I98a0anZW6x2DHodC1KVFYxTkws06LgqO17NVB5ustSoM8KCvj9aOnt5//BZ3jbWcLimFb1OcPXseNYsSeP6eQkEGXSU1bezraSe/952wuc5vnPtTG5bnEp2QhhCCKw2O8fr2imsbOaAyUxhZTP1bcr9GBZk4JKMKJY5HLyLM6IICeyz2trtkv+3o5zfbfd9LV+EBOrpttiQDuf6jQuS+OBonVfCGjhcMo7op/+8aS6//qiMXosdO31C3fl/1xWn1ep9jF4neGYUFQUpJVuO1PLslmOcO9/D/Zdm8H9vmEtkSMCoXG84jJagvwo4D/zNRdD/F9AspXxeCPEoEC2l/E8hxGrgERRBfynweynlpQMNYjw0er2AZ29fMCo3jFPwv3mgWr3x9QIevDJLXQnkpkTyzJYS1b7oNGW4Ck6E8LtS0Al46V/yuCEnyef+l3ed4vkPjyOlsjLY8K0V5E2PGfG5Oufrujr44YZDbCzqa7Y+OyGMEw3uOQ56HTzxpfl09NomRsTSGAp6V8ob2nnbeIZ3DtZQ39ZDZHAAtyxKZs2SNBanRyGEoOl8DzvLzrFudwVl9e1e5/jSwmT+7fLpLMmIVjV3KSU15i6Mpj5zT1l9u3I/6AQ5KREszYxRzD2Z0SQ48gyklLzy2WmeG0ZvAgFEhwYwNzGCkCA9NeYuwoIMNHX0UNnUqZp10qKDiQkJJDsxjKiQQGbGhWLusqi2etcVp6cdf6zulfZuC7/ddoK/7q0kJjSQn66exx2XpE6I2PtRM90IIaYDW1wEfRlwjZSyVgiRDHwqpZwjhHjZ8fp1z+P6O/9YCvq7X96HzS4J0AveGIRt/kJwjajxZXLxZ190dd7+7P0S/3XbdYJ7lqWTGBHEFbPi1XP84ZOT/NZFE3S1aY4FRpOZ+9fl0z1IW6xBJ/j6FdMJDtCTFBk8PuGq4yTondjsks/LG9lYVMOHxXX0WO1kxYeyZkkady5JVePhe612DlQ2s35/Ff884v2zyk4I40dfnMPVs+O9EqdauywUVSnafmGlmUPVLaq9PCMmxCH0FZPPzPgwdDrBkZoWHvqbkbq2bq9rDZbwIANpMSH0Wm109Njo6LXS2WtTlZiokADyMqJZkhnNkoxoFqVHuq04xpPiM608vrmYQ9UtrMiK4ee35zIrof8wztFmLAV9i5QyyvFaAGYpZZQQYgvwvJRyj2PfJ8B/Sin7leLjYbrRAT/84tgJv+Hiyyxks0sMeh0z40M5VqtoeHqdYPWCJM53W9hZ5h7/P1o2zYHG/ZNNRzhR7z9buT8C9YK7lqaPXZ7COAt6V9q6LWw9UsvGIqXPrxCKjXzNkjS+mJNEcKAiwKWUVDR28O6hs/zhk5M+z/X0rTncuiiF6NBAr329VjslZ1vVyJ7CSjNNHUoEWmRwAEszo8mbHs2y6TEsSI2krrWbxzYf5fPy0e28ptcJ5idHkJepCP+8zGhSIqeNmzZtt0veOFDNrz48TmevlQevzOKR67LVv8NYMy6C3vHeLKWMHoqgF0I8BDwEkJGRkWcymQae4QX+GD0jbn5xx+iYbkYT11VAfkUT//1xmc+IDSc6AbcuSiE7MXzEnLADjc+5inm7sFp1wvaHZ6KWLwL0SnTQqFUSnUCC3hVTUwcbi86wqahGNYWsXpDEmiVpLJ8R4yb8WjstbC+t5xdbS1WB7cq/XT6dB1bOID3GdzaolJLKpk7F1FNp5oCpmQpHQl2gXseCtEhHdE8M02ND+H87ynnvsO9S4CNNUsQ08jKj1XDSnJRInwmSo0nj+R5+ufU4G4tqSI0K5ulbc/jC/MSBPzjCaKabAfj2P4x8UKzEI4+1OWM0GKglnyeK/VYipeIkHUqIo6s5yZeGbTSZeWHbCT4boEDaDfMTKa1to9rcBSh23S/MT+Szk+fotdoHFPgGneDuZWnkpkSNrKY/QQW9E7tdsr+ymbeNNXxwtJaOXhvpMcHceYlSRtszld9qs1NoMvP77SfZ5yOu/7KsWH6yei4LUiP71ZSbzvdgNJlVW//RM61q3sfM+FCWZsYwLzmc3Scb2XG84YLnGRKoJyzIgM0ufT6sXFmUFsmKmbGq2ScuLOiCrz8YCiqaeHxzMScbzvOFeYn87Nb5pEWPXSmFsRT0vwaaXJyxMVLKHwshvgT8B33O2D9IKZcPdP6xEPSeoZWDjZ8fKdYXVPHmgSoSIqbxsEfRpQvhG3/Zz47j57y26x3lBvpjQWokV8yKZdX8JLdib56JLp4hksr5Bd+8cgbnu63UtnWx8/i5QYXaJUUEUd/Wox7rdIq7llkoOdvKW4WKI3sgwT9iPQMc99ZAD7SJQGevlQ+L69hYVMPeU01IqcTc37UkjdULkwnzUZ3R1NTB/35eyV/2VnrtiwkN5Lnbc1k1PxGDn3pRTrotNo7UtKqmHqPJTGuXBYC4sEAWpUVxsLqF5gGEtC8C9EJ9iERMM5AZG0pYkIHQIANBATpMTR0Un2nr9xwrsmL40sIUlmZGMzsxfNRi4S02O6/uOc3vtysms+9en80DK2eMySpjtKJuXgeuAeKAeuApYDOwAcgATCjhlc0Oe/3/ADeihFd+fSD7PIyNoPdM3LlhfiJrvzrg9zMg20rqKa1rdXOGerK+oMqt3rtOwFsPX37BAmR9QRWPv3PUrXa8XgdfWZZBjiOqx6kl61DSvyUSm126Ne7Q6wR//cZyggP0aqs/vU4gpaL9+0voGSkMPkLmnGUTzp3vQTBwyKq/JKx+q0ZWNrPrxDkMekGd8feI7IfZUFjtlqnsa2wTiTMtXWw+eIaNxhoqGjuYFqDjxpwk1uSlcfnMOJ+C7nyPlc0Hz7iVPXblRzfM5utXzBhUOV+7XVJ+7rybuae6WVmtuQruwRIbGkioQ7j3Wm1qLSaDTpCTGskl6VHEhSnHNJ3v5XBNi99yxU6umh3PfcvTuXxWHBHTRjZMssbcyTPvH+PjY/VkJ4Tx7O25o17HSUuY6gfPfqWBBh2vX2Bxp7/vq+SJd0uA/rM9Fzz1Ie09NrdtF/qg8dV/VQDPufgdfGmnoGjpZ1q6eGN/lSrAw4L0xIYGYWru9LyUF854Zl8x08PFmUhV2diBxW6nsLKZow7tTa8TrM5NorKpg9K6dmx+BP7Vs+NZPkNx3s2IC2Pd7gpe3XMa6TjHylmxzIgLpaPHhtFkpqKx/14E6tiE4J7lo+gfGAGklBysbuFtYw3vHz5Le7eV5Mhp3HFJKmvy0pgZH+bzc3ZHJdGfvV/i03F+y6IUfrp6rhr1Mxjq27oprDTz588r1JpSwyEqJIAFqZFETAsgJFCPqbmTw34iheYkhWGzQ1ldGx8fqx9Q+H9hXgL3X5rJVbPjR0Tr/6S0nqfeK6HG3MWdS1L56ep5o2ZK0gT9APz47cNsKKwBLjzqxmgyc9eLe/vS//s538yf/NPLjDIrPpTtP7xmWNcG7+QvUATwj/qZk9NRWtfWRVN7L0fPtCFRInhiQwOobe0Z8Lo60Vf8zDX006AXXDcngYLTTbR2WYc9LycR05SSAaNBZHAA0SEBmJo63R4YAtA5VjK+nmETsnSDD7otNraX1rPRWMOuE+ewS6Wkxpq8NG5dmNJv8k91cye/+vA4W3yEbs5JDOcXd+aSlzm4fAzXnJAAD5/Q+gITv/6oDHOnZdDzykmJ4PKZscSGBWGXksPVLRhNZhrP90UKLcmIUit/LkyLovF8D4WmZt7YX03B6f6zgL+0IJm7lqZxSXoUUSGDr/njpKvXxv/sPMna3RWEBBr48Y1zuHdZxogXjdMEfT8YTWZ+t+0Ee1ychRcSdfOjtw7xtrEvKUgvYIMfc8w1v97p1uQEYPn0aDY8fPmwrg3e5iDoP4xyfb6Jx98t9llz59nbF9Dc0cN/f3zCp+ATKIJPJ9zNGJ55AoDbw8/1PCuz48hJjvBbL8i1TopOwL3LM9hYVIPFalcyP0do9SBQitXduSSN+1/JV01bAhs6nYHZCWFY7JIAneBEw3mvhLVZCWH8as3Cfit19pcbMdY2/4b2bt49qGThltW3E6jXsWp+ImvyUrkqO75fm3xnr5VXPjvtlpPhyvN3LmBWQhgFp5v9zmsw837jQBWPbjzqc58/woIMXDErlqtmxzM9NpSzLUpyWKHJrFabDdALclIi1TpAeZkxxIcH0dlrZevROtYXmCiqGnjFMVTzXXlDO49vLia/oplF6VE8d3suuamRQ5pff2iC3g9Kkal8el1axF9o1M2df9pDUVWr+r4/we2rbO2q+YmsuwDTjadGrxPwcz+Zvr5q/LiyyFF+wbUH6zdXziA8OMDLKVtY2UxQgI678tK9BNmjm45w0mX5r9cp0ttVm/vanwvYdcJ9We0aeeOq/ble15lFrNfrQCp+BufrgcpN+GLVvATq2rpJjgzmfLeFvRWNKOuyPnRAbFgg5867OxYF8J83zcWgE5ysb2dBahR6vWD7sXo+PdGA3a6scB5YOYOm87109Vr5oKQeu12i08HlWXGkxwazZkl6v1UfR/KBIKWk5GwbbxtreO/wWZo7eokLC+L2xSmsyUtjXnL//VSllHxUUs9PNh3xqYUPZ7VjNJlZu/sUO443DNmW70nENAMLUiNJiQomOjSQ47XtWGw2qpq7ONPSpR43PTbEIfAD6bXamRkfRkuXhfnJ4dS29rB+v8mnw3eouShSSjYfOsNz/yyluaOXr142nR/cMHtEfATDEfQTI/1slMmvaHIT8qDY6IfrNFlfUMVBFyEPkJ3oP1uurNb7xtlVdg6jyTzsH/OKrFg3Z9eti1L8ahx/21vZrzP1cE0rpbXF/MzRT9efkHFtvP7G/mpmxofyjZVZAGo3J1AEZGCAjidvznE7358+LVeFvKsGH2DQ8fDVM3n46pleQs5Xf1hwL4G7qaiGt5xOVAGL0yM5XN3a75y3lSqhgEfVH7W3ZmsHLyEPSt2V513qyb/pMAe6YrFJXtrlvXqx2ZUa/pTD+oJqwgL1dPTa1FouzvMDzEsK5+d3ePdTGA5CCHJTI8lNjeSm3CTe2F/F2dYu/rqvklf2nGZ+cgRr8tK4bXGKT9uyEIIbc5O4MVcpuXGyvp1v/OWAGiY72HrwRpOZPSfPUdvazZuF1V7VLvtDLwSRwQaafTxo2rqtfH5q4EQuc1cvHxTX0tnr7jNzPqi2PHIloHQFu9fRFQzALofWFU0IwR2XpHHd3ER+81EZf91XydajtTx+83xuWZg85slfF4WgX5EViw7U6BSdgKuy49X9Q1lWG01mntjsXpterxNeHapceW1/lde2XpudNw9UDVt7y8uMZvWCZN51NEFxNkNxJka5hku+65LUohOwNDOa5o5eyl26S1lsSl1+fyucjUU1bn4GCZSf6/AyHwHEhAWSGhVMVVMH4cEBWGw2nthczN/zTW4ncBarslrtvLTrFNfOSeh3vm61/YMD1O/u57fnIqVk/f5qkHCwqpXxrjDrq2SvL867CBzPw0vr2lnz4t4RS+wzmsy8lm/i3UNnsEtl1XHLwhR6rTYOmMw8u+UYv9xayjVzErgrL5XokEClBjzeJTyyE8N54SuXuNngPRUnz2CAQL3g+Q/LfNZvcha7Kz7T6jcs2CalTyE/FFo7fft9PB9Uy2fE8uxtuTz5bjF2KYetGEYGB/Ds7bnclZfG45uL+e7rB9lwoJpnbsshy4+DfDS4KAQ94Fb71C7h42P17Chr4NrZ8ap2B0qN+Ky4UPIyY9h5vJ6G9h4uy4pVzRieAg/gloXJ/Qrqzl7fN9dbhTVqhcfhOPnOuixJoU/YB+gF185JoKGt26uY2NJMxcRkNJndmp5IoK6lmz/uLPdpQmhsH9hR66TxfC+N53s5XNPq9xjXkE07sO1YPdscFS6VHr/ZpEaFcLKhnZnxYcSEBXLgdBNrd592s9cbdIKokADVIQcOh/GyDDYdVGz8ep3gmjkJfHK8Hpvf3DJFp54eG0JVUyeDS0HzMS/HmUbSIvrYOxfWq9hoMvP3fZW8e+is28PEYpNsOtjnZ9IJCA3Ss720nu2l9W7neLuw2ivvxLOnracpb6COZjrR1/c2QC948pYcyuraeeLd4lEp++0PAT4fVCPZjnJRehSbv3MFrxWY+PWHZdz4wmfctjgZnU6g1+lGPaLrohD0vjr+AFht0k3IAxysauFgVYtb9UWnwNIBEcHeX9m7h86SFDFNfRg4Nc+XPi3nWF07Z8zuAnlRWiQWm51jtUo1wcEuez2545I0DlSavbZbbFItC+yJMzQtLzOaLy9NZ31B32rj7wWKxq0Xjhh6+rpdjSQCpR/tK3tO+3SyWu2S33w8uJK5Vruk8Xwvep1QksTsik9gTV4aa/LSvDogOZ3HEUEGSmrbuCk3GYAPtv2Fm1b9G/ddmuGmiX5a1kBFYwcxIQE+G8h4ciHiyV8ddgk8sfkoc5LCh2wDf+NAFZuM3sqJL+wSvxFTvTbJM++X8PDVM4kKCaCoqoVl06Np77b6VGT+9/PTPhuMuPptnrw5x63jmnPVNicpXK3vFBcexLn2HlUJcD3P9XMT2FHWgNVjcnodXD83ke3H6rGj/G4l/v82QsDC1Eg2FikmOM+H2UgJYL1O8NXLppMSFcwP3jzEWy7BHL4epCPJRSHoV2TFYtCJQdVd6Q870OLjhyBBjSbR62BBSiSH/GizAggy6Djisl8C7V0WVZse7B/7vkszqGrqYO1nFYNOaLpnWZ9WuGZJGpsckS2uJZFtLupot8XOpiJvG3Ra1DSsdkld2+A1fSdCQEZsKM/clssTm4vdrqdDWeFcOzeBD4vr1Brl9y7PYOWsOP7Pm4fotfkolSAlX16WQUpUsE8bv/O1v+/2vlNPwaVPeh3nqkWvL6hSlvJ2iV4vsA7DCdwfK7PjuCk3mX/kV6rF6pzYpGI+G+y98fd9lTz1XonX9+TUXq+ZHc+nZQ1q9rHTr7JqfiJbjtT6XJEcrmnl26/5bi/xp09PceuiFAL1Ok43dlBocldABIrS4Om38YXn38loMrPrxDk1lFcvUJvX9Nem85PSBmVp5axxL2Fucjhlde1uDny7RG0D+lZhNT+7JYeWLsuQfosDmX+d+9u7LLz8WYXX92uxDc0HMFQuCkHv1F5fK3C3let1/uu9DxebHb9CHhShvt9DC7dL1wfF0DowPbp6Hqtyktxu9jcLq720nFkOx6nreV2X3s7IFtfWgE5cE6uc/Pu12cxJCldDFEHJavTlvAR3bdUuFeft1bPjuH5egvq9CFC7aAHsLGtQ7b/OVocJEdO8SiU4tfihtkMcCGeXqLrWLgIc1UJvyEmk22IjKTKYiCAD7x85y5mWwZfwTYuaxryUSPadauS8RxLdNbPjuWJWLAYd7D55jj3lTbS42KT3n27ycuA7u545eyTvO9XIrz4s41C1e9igU8DflaeUi1iSEcXa3RVsL60nNSqYpo5ebspNZk5SONuO1SsPfxTTSkZ0CNXmzn4falKi+os8r7tqfiKL0qOGbf7Iy4zm9QdX+Cz57e/h/ced5aoCYZdgt0levH8JNy1IVld2Tge+pznrMUfGsLNbmtUu/fbBjQ4JpPhMKxuM1dhskgC9jkeum0WnxUZCWBB2YG95IzvKGvo15wXoxbCDQwbDRRFeCe49ToVQTAercpL4wZuH3LJBY0MCuHFBMjkpkewsa6ChrZsZcaG8f/isuvx1Jge1dPZirGoZFXtialQwOSkRfOvqmQC8lm+ivdtCQsQ0clIiKT7bqrapK6trV1schgcHqCaHY2dbmRag5xsrs/q1NXpqRb5+AK64JmZ5ajJOrdfTJBMXFoi50+Lzu9IBwtGnVCfg+nmJ6rwHso96CjrPObV3WVQTjVeJhaIaGtt7iA8P4s7Gu8l7sNTxuUaaz/fy588rB62xC5QHXVNHr9/P6IRy3IUsLPUCrp2bQHZiGDtLGzg+hDLQ18yOI3RaAJWNHVSc66DL4v6g0QnIig+j22KjuaNXjUwJ1Iu+HsM+wlttdolwrAidKzCdw/znmSg1VnhmjvsKp1YbBLkoRv7MZ8Jln9PRPtg/Y0iAnk6P79rJrPhQlmfFDslGr8XRD4C/5dVXXy1gf2Uzy6fH8LcHfDfE8uwB6hrVsqmohtcLqobtwBtp9MoqVemkpRNcMTOWPeWNSKloDtfMTiAkSM+C1EhOnTvPhsIaR30bxYkZHmRge2k9p851+LyZdShx7yuzY2nvtnLG3EVlUwcLU6MIDw6gvcvC+0dr3XwTy6cr39dg7NzQ11Ql3MWWPicpXBXO5o5eqs2d1LUptXCcZYzDgwy8d+QsZ31o2bcvTuFAZTPmTotXeF2AsHDl7GR2lPWfOj+azEkKo6GtG7OfyJCRYHpsCNPjQmnrsvhMFpoRF8rcpHCqmjspOesoQSHgnuUZpDrMYuBbs3XtmDYYE81oo5raHFEz/h44rr4b185v/XV484Wng1kn4NvXzOS6uYluyXlODDp481tDr3mlCfpxZH1BlVsseX+kRgeTkxwxQBSIxsWEP01yuOcKMOjIiA52C6G9d3k6v7xzIeC7VpJrUlB/5Qv8MV7Zv/0xnDG5rnD7S9Rz9W8YHGax/lqE+vIlDOd70hKmxhGnWeCJzUfdTDxRwe6hfwBxoYGs/epSt1VCeJCBtbsrJsyqQGNsGQkhrxeg1/fZ4QHuXdcnrO/KS1ePzcuM5hlHnLjNUa30mdty3Wzf/kIn/TGSESojxXDG5PqZ/hL1/JWz9mUmHe/vRtPoRxhPEw/Al1/c6ybA/SXAOD970GSmtM67CbQTvQ7mJ0VQUtvmDCogOFBPt8V2QfZfGFnNUmPsePiqLLfwXieDjQaZSFq4Rv9oGv0EwNeT+61vX85Lu07R0NbNPcsy/EbUuH7WaV901bY8NQXPH6nFZqfkbBubD9aw5Uit10rCHwJYPiOa5MhgGs/3kpsSQVuPVXVUhgUZ+OzkOVKjgpkZH8a+iiYSI6ZxzZwEzJ29tHdZ2FfRRKBBx+zEcNVZXF7fTo/VzmVZsbT1WBHg5kh2OrxPN3YQHaI4kX3FRfc79n4yUK/KjiMoQM+O4w1IKdHpBGGBejp7bcxKCGN2YrhLEpHyPUeHBtJjsTMvKZwlGdFsL62norFDrcufHh1MR68Ni9VOq0d1TSEgJSKIMz6qgC6bHs0dl6Sp30tzRy8Beh0nGs4jpcTgSOpq6eyluaOXrPgwsuJC2VfRxNEzvss5xIcFEhkc4BVN5cpAmuR4a5oaY4Om0U9gLkTb8rSxPvGl+Ty75Ri9NiVTNCc5kkM1viv36QTccUkqzR291LZ2c9zH6kKvg5tyk7krL42a5k6eev8YdrvE4HD2mjt7Kaoy9zmAHeUN4sODyHE0/M7LjKLiXAdPvluihkg+euMc8iuaqXdEO51u7CAhYhqhgXq3zM5Z8aFcMSuO5s5e/nmk1qcg1Au4bl4isaGBVDV30t5lofhsm3oO19VLuO48oaGx1Lf39NWd6echEmTQ+UwI8tX/Vi/gB34K6A3mb2w0mXlp1yn1gTg7MXzEQ0k1Jg+aM1bDDU8h4lkl0fVB8MX5SWpdk6lKVEiAW1y6KzMDq9FFzeNkg+9wxfToYGrMXUoTE0cUyqaiGre8A6X0QjqbDp6h12JXsjIvoMSFhoYvNNONhhuey3LP967ONoCPjtWp9d/VmGj6mnHodUo8tcVP/ZKhIoArs+MoON2MZYCVxhUzYyk0mbHalAfTX7++nPkpERRWNvPwP4qwWBXBqsY6g5sA/t712azMjlcfbs652Bzn+6/038MNe/3u//Y1s9yiKdYsURyeG4tqeNtYox63Ji+dNXnpE77vrMbFhSboL2L8Cf7+YqIBN+HmFIhWq5KIhsAtZNSx2yuM1Knpfu8LswG8VhqeGvEPbpjjdpxz3NfOTWT9gyvcBGt0SCDFZ1vdBPDK7HivSBK3831+HPrb76jB4iuaYs2SNJ/bNTQmCprpRsMnQ4nWAHdB7ZZx6og8ct3mtNEPdO4L1YiH5OPQ7i2NSYJmutEYMYYareHvdX/bhnvtsT6PhsZkx3/DSA0NDQ2NKYEm6DU0NDSmOJqg19DQ0JjiaIJeQ0NDY4qjCXoNDQ2NKY4m6DU0NDSmOJqg19DQ0JjiaIJeQ0NDY4qjCXoNDQ2NKY4m6DU0NDSmOJqg19DQ0JjiaIJeQ0NDY4qjCXoNDQ2NKc6oCHohxI1CiDIhRLkQ4tHRuIaGhoaGxuAYcUEvhNADfwRuAuYD9woh5o/0dTQ0NDQ0BsdoaPTLgXIpZYWUshd4A7htFK6joaGhoTEIRkPQpwLVLu9rHNs0NDQ0NMaBceswJYR4CHgIICMjY3AfCs1UWr5paIwwbeZofieeHu9haGgMSGRm5JA/MxqC/gyQ7vI+zbHNDSnlWmAtKD1jB3Xm2yovfHQaGj6IAJ76zniPQkNjdBgN080BIFsIMUMIEQh8BXhvFK6joaGhoTEIRlyjl1JahRD/AXwE6IE/SylLRvo6GhoaGhqDY1Rs9FLKrcDW0Ti3hoaGhsbQEFIOzjw+qoMQ4hxgGsShcUDjKA9nLNDmMfGYKnOZKvOAqTOX0ZxHppQyfqCDJoSgHyxCiEIp5dLxHseFos1j4jFV5jJV5gFTZy4TYR5arRsNDQ2NKY4m6DU0NDSmOJNN0K8d7wGMENo8Jh5TZS5TZR4wdeYy7vOYVDZ6DQ0NDY2hM9k0eg0NDQ2NITIpBP1kq28vhPizEKJBCFHssi1GCLFNCHHS8f9ox3YhhPiDY25HhBBLxm/k7ggh0oUQO4UQx4QQJUKI7zm2T6q5CCGmCSH2CyEOO+bxtGP7DCFEgWO8bzoyuRFCBDnelzv2Tx/P8XsihNALIQ4KIbY43k/WeVSklgG/AAADiklEQVQKIY4KIQ4JIQod2ybVvQUghIgSQrwthDguhCgVQlw20eYx4QX9JK1v/xfgRo9tjwKfSCmzgU8c70GZV7bj30PAi2M0xsFgBX4opZwPrAC+4/juJ9tceoDrpJSLgMXAjUKIFcCvgN9JKWcBZuABx/EPAGbH9t85jptIfA8odXk/WecBcK2UcrFL+OFku7cAfg98KKWcCyxC+dtMrHlIKSf0P+Ay4COX9z8BfjLe4xrEuKcDxS7vy4Bkx+tkoMzx+mXgXl/HTbR/wLvAqsk8FyAEKAIuRUliMXjeZyjlOy5zvDY4jhPjPXbHeNJQBMd1wBZATMZ5OMZUCcR5bJtU9xYQCZz2/F4n2jwmvEbP1KlvnyilrHW8rgMSHa8nxfwcy/5LgAIm4Vwc5o5DQAOwDTgFtEgprY5DXMeqzsOxvxWIHdsR++UF4MeA3fE+lsk5DwAJfCyEMDrKlsPku7dmAOeA/3WY014RQoQyweYxGQT9lEMqj/JJE+4khAgDNgLfl1K2ue6bLHORUtqklItRNOLlwNxxHtKQEULcDDRIKY3jPZYRYqWUcgmKOeM7QoirXHdOknvLACwBXpRSXgJ00GemASbGPCaDoB9UfftJQL0QIhnA8f8Gx/YJPT8hRACKkH9NSrnJsXlSzgVAStkC7EQxcUQJIZyF/VzHqs7DsT8SaBrjofriCuBWIUQlSovO61Dsw5NtHgBIKc84/t8AvIPyAJ5s91YNUCOlLHC8fxtF8E+oeUwGQT9V6tu/B3zN8fprKPZu5/avOrzxK4BWlyXfuCKEEMCrQKmU8rcuuybVXIQQ8UKIKMfrYBQ/QymKwL/LcZjnPJzzuwvY4dDKxhUp5U+klGlSyukov4MdUsr7mWTzABBChAohwp2vgRuAYibZvSWlrAOqhRBzHJuuB44x0eYx3s6MQTo8VgMnUOyqj433eAYx3teBWsCC8sR/AMU2+glwEtgOxDiOFShRRaeAo8DS8R6/yzxWoiw5jwCHHP9WT7a5AAuBg455FANPOrZnAfuBcuAtIMixfZrjfbljf9Z4z8HHnK4BtkzWeTjGfNjxr8T5u55s95ZjbIuBQsf9tRmInmjz0DJjNTQ0NKY4k8F0o6GhoaFxAWiCXkNDQ2OKowl6DQ0NjSmOJug1NDQ0pjiaoNfQ0NCY4miCXkNDQ2OKowl6DQ0NjSmOJug1NDQ0pjj/Hxc/j/2+JJFsAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.patches as patches\n", + "fig,ax = plt.subplots(1)\n", + "\n", + "#plot snout + bounding boxes for rois\n", + "plt.plot(xsnout,ysnout,'.-')\n", + "\n", + "rect = patches.Rectangle(rois['rightside'].topleft,rois['rightside'].bottomright[0]-rois['rightside'].topleft[0],rois['rightside'].bottomright[1]-rois['rightside'].topleft[1],linewidth=1,edgecolor='purple',facecolor='none')\n", + "ax.add_patch(rect)\n", + "rect = patches.Rectangle(rois['leftside'].topleft,rois['leftside'].bottomright[0]-rois['leftside'].topleft[0],rois['leftside'].bottomright[1]-rois['leftside'].topleft[1],linewidth=1,edgecolor='orange',facecolor='none')\n", + "ax.add_patch(rect)\n", + "plt.ylim(-11,491)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning: you've set check_inroi=False, so data reflect which ROI is closest even if tracked point is not in any given ROI.\n" + ] + }, + { + "data": { + "text/plain": [ + "{'transitions_per_roi': {'leftside': 10, 'rightside': 10, 'tot': 20},\n", + " 'cumulative_time_in_roi': {'leftside': 1768, 'rightside': 562, 'tot': 2330},\n", + " 'cumulative_time_in_roi_sec': {'leftside': 58.93333333333333,\n", + " 'rightside': 18.733333333333334,\n", + " 'tot': 77.66666666666666},\n", + " 'avg_time_in_roi': {'leftside': 176.8, 'rightside': 56.2, 'tot': 233.0},\n", + " 'avg_time_in_roi_sec': {'leftside': 5.8933333333333335,\n", + " 'rightside': 1.8733333333333335,\n", + " 'tot': 7.7666666666666675},\n", + " 'avg_vel_in_roi': {'leftside': 4.798367612314975,\n", + " 'rightside': 7.978920763420923,\n", + " 'tot': 12.7772883757359}}" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import time_in_each_roi #the function needs to be in the same folder as the notebook\n", + "\n", + "res = time_in_each_roi.get_timeinrois_stats(bp_tracking.T, rois, fps=30)\n", + "\n", + "#print results:\n", + "res" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "name": "Demo-labeledexample-MouseReaching.ipynb", + "provenance": [], + "version": "0.3.2" + }, + "kernelspec": { + "display_name": "Python [conda env:DLC-CPU] *", + "language": "python", + "name": "conda-env-DLC-CPU-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.6" + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/README.md b/README.md index cc91c4d..246783a 100644 --- a/README.md +++ b/README.md @@ -1,59 +1,162 @@ -[![Image.sc forum](https://img.shields.io/badge/dynamic/json.svg?label=forum&url=https%3A%2F%2Fforum.image.sc%2Ftags%2Fdeeplabcut.json&query=%24.topic_list.tags.0.topic_count&colorB=brightgreen&&suffix=%20topics&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAABPklEQVR42m3SyyqFURTA8Y2BER0TDyExZ+aSPIKUlPIITFzKeQWXwhBlQrmFgUzMMFLKZeguBu5y+//17dP3nc5vuPdee6299gohUYYaDGOyyACq4JmQVoFujOMR77hNfOAGM+hBOQqB9TjHD36xhAa04RCuuXeKOvwHVWIKL9jCK2bRiV284QgL8MwEjAneeo9VNOEaBhzALGtoRy02cIcWhE34jj5YxgW+E5Z4iTPkMYpPLCNY3hdOYEfNbKYdmNngZ1jyEzw7h7AIb3fRTQ95OAZ6yQpGYHMMtOTgouktYwxuXsHgWLLl+4x++Kx1FJrjLTagA77bTPvYgw1rRqY56e+w7GNYsqX6JfPwi7aR+Y5SA+BXtKIRfkfJAYgj14tpOF6+I46c4/cAM3UhM3JxyKsxiOIhH0IO6SH/A1Kb1WBeUjbkAAAAAElFTkSuQmCC)](https://forum.image.sc/tags/deeplabcut) -# DLCutils -Various scripts to support [DeepLabCut](https://github.com/AlexEMG/DeepLabCut). Feel free to contribute your own analysis methods, and perhaps some short notebook of how to use it. Thanks! +[![Image.sc forum](https://img.shields.io/badge/dynamic/json.svg?label=forum&url=https%3A%2F%2Fforum.image.sc%2Ftags%2Fdeeplabcut.json&query=%24.topic_list.tags.0.topic_count&colorB=brightgreen&&suffix=%20topics&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAABPklEQVR42m3SyyqFURTA8Y2BER0TDyExZ+aSPIKUlPIITFzKeQWXwhBlQrmFgUzMMFLKZeguBu5y+//17dP3nc5vuPdee6299gohUYYaDGOyyACq4JmQVoFujOMR77hNfOAGM+hBOQqB9TjHD36xhAa04RCuuXeKOvwHVWIKL9jCK2bRiV284QgL8MwEjAneeo9VNOEaBhzALGtoRy02cIcWhE34jj5YxgW+E5Z4iTPkMYpPLCNY3hdOYEfNbKYdmNngZ1jyEzw7h7AIb3fRTQ95OAZ6yQpGYHMMtOTgouktYwxuXsHgWLLl+4x++Kx1FJrjLTagA77bTPvYgw1rRqY56e+w7GNYsqX6JfPwi7aR+Y5SA+BXtKIRfkfJAYgj14tpOF6+I46c4/cAM3UhM3JxyKsxiOIhH0IO6SH/A1Kb1WBeUjbkAAAAAElFTkSuQmCC)](https://forum.image.sc/tags/deeplabcut) +[![PyPI version](https://badge.fury.io/py/deeplabcut.svg)](https://badge.fury.io/py/deeplabcut) +[![PyPI - Downloads](https://img.shields.io/pypi/dm/deeplabcut.svg?color=purple&label=PyPi)](https://pypistats.org/packages/deeplabcut) +[![GitHub stars](https://img.shields.io/github/stars/AlexEMG/DeepLabCut.svg?style=social&label=Star)](https://github.com/AlexEMG/DeepLabCut) -## DLC1 to DLC 2 conversion code +# DeepLabCut-Utils DLC Utils -This code allows you to import the labeled data from DLC 1 to DLC 2 projects. Note, it is not streamlined and should be used with care. +This repository contains various scripts as well as links to other packages related to [DeepLabCut](https://github.com/AlexEMG/DeepLabCut). Feel free to contribute your own analysis methods, and perhaps some short notebook of how to use it. Thanks! + + +# Example scripts for scaling up your DLC analysis & training: + +These two scripts illustrate how to train, test, and analyze videos for multiple projects automatically (scale_raining_and_evaluation.py) and how to analyze videos that are organized in subfolders automatically (scale_analysis_oversubfolders.py). Feel free to adjust them for your needs! -https://github.com/AlexEMG/DLCutils/blob/master/convertDLC1TO2.py +code: https://github.com/DeepLabCut/DLCutils/tree/master/SCALE_YOUR_ANALYSIS/scale_analysis_oversubfolders.py + +code: https://github.com/DeepLabCut/DLCutils/blob/master/SCALE_YOUR_ANALYSIS/scale_training_and_evaluation.py Contributed by [Alexander Mathis](https://github.com/AlexEMG) -## Running project created on Windows on Colaboratory -This solves a path problem when creating a project and annotating data on Windows (see https://github.com/AlexEMG/DeepLabCut/issues/172). This functionality will be included in -a later version of DLC 2. +# Using your DLC outputs, loading, simple ROI analysis, visualization examples: -https://github.com/AlexEMG/DLCutils/blob/master/convertWin2Unix.py +## Time spent of a body part in a particular region of interest (ROI) -*Usage:* change in lines 70 and 71 of https://github.com/AlexEMG/DLCutils/blob/master/convertWin2Unix.py +You can compute time spent in particular ROIs in frames. This demo Jupyer Notebook shows you how to load the outputs of DLC and perform the analysis (plus other plotting functions): -```basepath='/content/drive/My Drive/DeepLabCut/examples/'``` +code: https://github.com/DeepLabCut/DLCutils/blob/master/Demo_loadandanalyzeDLCdata.ipynb -```projectname='Reaching-Mackenzie-2018-08-30'``` +code: https://github.com/DeepLabCut/DLCutils/blob/master/time_in_each_roi.py -then run this script on colaboratory after uploading your labeled data to the drive. Thereby it will be converted -to unix format, then create a training set (with deeplabcut) and proceed as usual... +Contributed by [Federico Claudi](https://github.com/FedeClaudi) and Jupyter Notebok from [Alexander Mathis](https://github.com/AlexEMG) -Contributed by [Alexander Mathis](https://github.com/AlexEMG) +## DeepLabCut-Display GUI -## Time spent of a body part in a particular region of interest (ROI) +Open and view data to understand pose estimation errors and trends. Filter data by likelihood threshold. + +code: https://github.com/jakeshirey/DeepLabCut-Display + +Contributed by [Jacob Shirey](https://github.com/jakeshirey) + +## A GUI based ROI tool for time spent of a body part in a defined region of interest + +code: https://github.com/PolarBean/DLC_ROI_tool + +Contributed by [Harry Carey](https://github.com/PolarBean) + +## Linear Transformation and Scaling of DLC output data (transform_and_scale) -https://github.com/AlexEMG/DLCutils/blob/master/time_in_each_roi.py +This package is designed for anyone who wants to know where a tracked marker is within a reference frame (i.e. behavioral context). DeepLabCut outputs coordinates in relation to the field of view of the recorded video. With this tool, these coordinates can be linearly transformed and scaled to the reference frame of the behavioral context, meaning that the output coordinates are distances [cm] to a corner of the behavioral context, instead of distances [px] to a corner of the video field of view. -Contributed by [Federico Claudi](https://github.com/FedeClaudi) +code: https://github.com/DeepLabCut/DLCutils/tree/master/transform_and_scale/ -## Behavior clustering with MotionMapper +tutorial: https://github.com/DeepLabCut/DLCutils/tree/master/transform_and_scale/transform_and_scale_tutorial.ipynb + +Contributed by [Michael Schellenberger](https://github.com/MSchellenberger) + +# Clustering tools (using the output of DLC): + +## Identifying Behavioral Structure from Deep Variational Embeddings of Animal Motion + +paper: https://www.biorxiv.org/content/10.1101/2020.05.14.095430 + +code: https://github.com/LINCellularNeuroscience/VAME + +## Behavior clustering with MotionMapper - (adpated from https://github.com/gordonberman/MotionMapper) -https://github.com/AlexEMG/DLCutils/tree/master/DLC_2_MotionMapper +code: https://github.com/DeepLabCut/DLCutils/tree/master/DLC_2_MotionMapper Contributed by [Mackenzie Mathis](https://github.com/MMathisLab) +## Behavior clustering with B-SOiD + +B-SOiD: An Open Source Unsupervised Algorithm for Discovery of Spontaneous Behaviors <-- you can use the outputs of DLC to feed directly into B-SOiD (in MATLAB). + +paper: https://www.biorxiv.org/content/10.1101/770271v1.abstract + +code: https://github.com/YttriLab/B-SOiD + +# Machine-learning helper packages (using the output of DLC): + +## Behavior analysis with machine-learning in R (ETH-DLCAnalyzer) + +Deep learning based behavioral analysis enables high precision rodent tracking and is capable of outperforming commercial solutions. Oliver Sturman, Lukas von Ziegler, Christa Schläppi, Furkan Akyol, Benjamin Grewe, Johannes Bohacek + +paper: https://www.biorxiv.org/content/10.1101/2020.01.21.913624v1 + +code: https://github.com/ETHZ-INS/DLCAnalyzer + +## Behavior Analysis with machine learning classifiers (SIMBA) + +A pipeline for using pose estimation (i.e. DeepLabCut) then behavioral annotatation and generatation of supervised machine-learning-based classifiers. <-- you can use the outputs of DLC to feed directly into SIMBA (in Python). + +Code written by: [Simon Nilsson](https://github.com/sronilsson) (please direct use questions to Simon). + +paper: https://www.biorxiv.org/content/10.1101/2020.04.19.049452v2 + +code: https://github.com/sgoldenlab/simba + + +# 3D DeepLabCut helper packages: + +## A wrapper package for DeepLabCut2.0 for 3D videos (anipose) +code: https://github.com/lambdaloop/anipose + +maintainer: [Pierre Karashchuk](https://github.com/lambdaloop) + +## 3D reconstruction with EasyWand/Argus DLT system with DeepLabCut data: + +Written by [Brandon Jackson](https://github.com/haliaetus13), post our DLC workshop in Jan 2020: + +A small set of utilities that allow conversion between the data storage formats of DeepLabCut (DLC) and one of the DLT-based 3D tracking systems: either Ty Hedrick's DigitizingTools in MATLAB, or the Python-based Argus. These functions should allow you to use data previously digitized in a DLT system to create the files needed to train a DLC model, and to import DLC-tracked points back into a DLT 3D calibration to reconstruct 3D points. + +code: https://github.com/haliaetus13/DLCconverterDLT + +## Pupil Tracking +- From Tom Vaissie - tvaissie@scripps.edu +- Please see the README.txt file https://github.com/DeepLabCut/DLCutils/tree/master/pupilTracking for details; this code makes the video in case study 7 http://www.mousemotorlab.org/deeplabcut/. + +## Using DeepLabCut for USB-CGPIO feedback -## Using DeepLabCut for USB-CGPIO feedback paper: https://www.biorxiv.org/content/early/2018/11/28/482349 + code: https://github.com/bf777/DeepCutRealTime maintainer: [Brandon Forys](https://github.com/bf777) -## Pupil Tracking -- From Tom Vaissie - tvaissie@scripps.edu -- Please see the README.txt file https://github.com/AlexEMG/DLCutils/tree/master/pupilTracking for details; this code makes the video in case study 7 http://www.mousemotorlab.org/deeplabcut/. +## LEGACY utility functions (no longer required in DLC 2+): -Please direct inquires to the **contributors/code-maintainers of that code**. Note that the software(s) are provided "as is", without warranty of any kind, express or implied. +## DLC1 to DLC 2 conversion code + +This code allows you to import the labeled data from DLC 1 to DLC 2 projects. Note, it is not streamlined and should be used with care. +https://github.com/DeepLabCut/DLCutils/tree/master/conversion_scripts_LEGACY + +Contributed by [Alexander Mathis](https://github.com/AlexEMG) + +## Running project created on Windows on Colaboratory +#UPDATE: as of Deeplabcut 2.0.4 onwards you no longer need to use this code! You can simply create the training set on the cloud and it will automatically convert your project for you. + + - This solves a path problem when creating a project and annotating data on Windows (see https://github.com/AlexEMG/DeepLabCut/issues/172). This functionality will be included in +a later version of DLC 2 (DONE!) +https://github.com/DeepLabCut/DLCutils/tree/master/conversion_scripts_LEGACY + +*Usage:* change in lines 70 and 71 of https://github.com/DeepLabCut/DLCutils/tree/master/conversion_scripts_LEGACY/convertWin2Unix.py + +```basepath='/content/drive/My Drive/DeepLabCut/examples/'``` + +```projectname='Reaching-Mackenzie-2018-08-30'``` + +then run this script on colaboratory after uploading your labeled data to the drive. Thereby it will be converted +to unix format, then create a training set (with deeplabcut) and proceed as usual... + +Contributed by [Alexander Mathis](https://github.com/AlexEMG) + + + +Please direct inquires to the **contributors/code-maintainers of that code**. Note that the software(s) are provided "as is", without warranty of any kind, express or implied. diff --git a/SCALE_YOUR_ANALYSIS/scale_analysis_oversubfolders.py b/SCALE_YOUR_ANALYSIS/scale_analysis_oversubfolders.py new file mode 100644 index 0000000..0c8d753 --- /dev/null +++ b/SCALE_YOUR_ANALYSIS/scale_analysis_oversubfolders.py @@ -0,0 +1,48 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Sun Feb 10 16:04:37 2019 + +@author: alex +""" + +import os + +import deeplabcut + +def getsubfolders(folder): + ''' returns list of subfolders ''' + return [os.path.join(folder,p) for p in os.listdir(folder) if os.path.isdir(os.path.join(folder,p))] + +project='ComplexWheelD3-12-Fumi-2019-01-28' + +shuffle=1 + +prefix='/home/alex/DLC-workshopRowland' + +projectpath=os.path.join(prefix,project) +config=os.path.join(projectpath,'config.yaml') + +basepath='/home/alex/BenchmarkingExperimentsJan2019' #data' + +''' + +Imagine that the data (here: videos of 3 different types) are in subfolders: + /January/January29 .. + /February/February1 + /February/February2 + + etc. + +''' + +subfolders=getsubfolders(basepath) +for subfolder in subfolders: #this would be January, February etc. in the upper example + print("Starting analyze data in:", subfolder) + subsubfolders=getsubfolders(subfolder) + for subsubfolder in subsubfolders: #this would be Febuary1, etc. in the upper example... + print("Starting analyze data in:", subsubfolder) + for vtype in ['.mp4','.m4v','.mpg']: + deeplabcut.analyze_videos(config,[subsubfolder],shuffle=shuffle,videotype=vtype,save_as_csv=True) + + \ No newline at end of file diff --git a/SCALE_YOUR_ANALYSIS/scale_training_and_evaluation.py b/SCALE_YOUR_ANALYSIS/scale_training_and_evaluation.py new file mode 100644 index 0000000..aa3ca64 --- /dev/null +++ b/SCALE_YOUR_ANALYSIS/scale_training_and_evaluation.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Sat Nov 17 14:12:43 2018 + +An example script to automate analysis on 3 different GPUs for different projects. Feel free to adapt this to your needs! + +@author: alex + +First start container: +python3 scale_training_and_evaluation.py 1 (2 or 3) + +""" + +import subprocess, sys +import numpy as np +import itertools +import os + +import deeplabcut + +Maxiter=int(1.5*10**5) + +model=int(sys.argv[1]) + +Projects=[['project1-phoenix-2019-01-28'],['ComplexWheelD3-12-Fumi-2019-01-28', 'maze-ariel-2019-01-28'], ['TBI-BvA-2019-01-28','group-eli-2019-01-28']] + +shuffle=1 + +prefix='/home/alex/DLC-workshopRowland' + +for project in Projects[model]: + projectpath=os.path.join(prefix,project) + config=os.path.join(projectpath,'config.yaml') + + cfg=deeplabcut.auxiliaryfunctions.read_config(config) + previous_path=cfg['project_path'] + + cfg['project_path']=projectpath + deeplabcut.auxiliaryfunctions.write_config(config,cfg) + + print("This is the name of the script: ", sys.argv[0]) + print("Shuffle: ", shuffle) + print("config: ", config) + + deeplabcut.create_training_dataset(config, Shuffles=[shuffle],windows2linux=True) + + deeplabcut.train_network(config, shuffle=shuffle, max_snapshots_to_keep=5, maxiters=Maxiter) + print("Evaluating...") + deeplabcut.evaluate_network(config, Shuffles=[shuffle],plotting=True) + + print("Analyzing videos..., switching to last snapshot...") + #cfg=deeplabcut.auxiliaryfunctions.read_config(config) + #cfg['snapshotindex']=-1 + #deeplabcut.auxiliaryfunctions.write_config(config,cfg) + + for vtype in ['.mp4','.m4v','.mpg']: + try: + deeplabcut.analyze_videos(config,[str(os.path.join(projectpath,'videos'))],shuffle=shuffle,videotype=vtype,save_as_csv=True) + except: + pass + + print("DONE WITH ", project," resetting to original path") + cfg['project_path']=previous_path + deeplabcut.auxiliaryfunctions.write_config(config,cfg) diff --git a/conda-environment-cheatsheet b/conda-environment-cheatsheet index 9778550..53efc0e 100644 --- a/conda-environment-cheatsheet +++ b/conda-environment-cheatsheet @@ -2,6 +2,16 @@ conda create -n dlctest python=3.6 conda env export > environment.yml +to create: +conda env create -f environment.yml ##Remove: conda remove --name dlctest --all + + +## A nice environment for CPU on Ubuntu 16.04 +conda create -n DLC2 python=3.6 +pip install deeplabcut +pip install https://extras.wxpython.org/wxPython4/extras/linux/gtk3/ubuntu-16.04/wxPython-4.0.3-cp36-cp36m-linux_x86_64.whl +pip install tensorflow +pip install ipython spyder diff --git a/contribute.md b/contribute.md new file mode 100644 index 0000000..85809ad --- /dev/null +++ b/contribute.md @@ -0,0 +1,9 @@ +# How to Contribute to DeepLabCut utils? + +DeepLabCut utils is library to collect useful scripts, software and other packages that are related to https://github.com/AlexEMG/DeepLabCut. + +We welcome community involvement and are happy to receive code extensions, bug fixes, documentation updates etc. + +If you want to contribute to the code, please make a [pull request](https://github.com/AlexEMG/DLCutils/pull/new/) that includes what new functionality you added or what you edited. + + diff --git a/convertDLC1TO2.py b/conversion_scripts_LEGACY/convertDLC1TO2.py similarity index 100% rename from convertDLC1TO2.py rename to conversion_scripts_LEGACY/convertDLC1TO2.py diff --git a/convertWin2Unix.py b/conversion_scripts_LEGACY/convertWin2Unix.py similarity index 100% rename from convertWin2Unix.py rename to conversion_scripts_LEGACY/convertWin2Unix.py diff --git a/m3v1mp4DeepCut_resnet50_openfieldOct30shuffle1_15001.h5 b/m3v1mp4DeepCut_resnet50_openfieldOct30shuffle1_15001.h5 new file mode 100755 index 0000000..ad4a247 Binary files /dev/null and b/m3v1mp4DeepCut_resnet50_openfieldOct30shuffle1_15001.h5 differ diff --git a/pupilTracking/pupilDLC.py b/pupilTracking/pupilDLC.py new file mode 100644 index 0000000..20ad2fb --- /dev/null +++ b/pupilTracking/pupilDLC.py @@ -0,0 +1,33 @@ +# libraries +import matplotlib.pyplot as plt +import pandas as pd +import numpy as np +import os + +# data selection +path = input('path to csv files (eg. C:\\Users\\) :') #C:\Users\Windows\Desktop +path = os.path.normpath(path) +os.chdir(path) +files = [os.path.join(path, file) for file in os.listdir(path) + if file.endswith('.csv')] +print(files) +i = input('which file to selecet (eg: 0 or 1) ?') +i = int(i) + +# dataset +df = pd.read_csv(files[i]) # store the csv file in dataframe df +df = df.iloc[2:len(df.index), np.r_[0,1,2,4,5,7,8,10,11]] # subselect dataframe +df.columns = ['frame','x1x','x1y','x2x','x2y','y1x','y1y','y2x','y2y'] +df = df.convert_objects(convert_numeric=True) +df = df.assign(diamH = ((df.x2x-df.x1x)**2 + (df.x2y-df.x1y)**2)**0.5, diamV = ((df.y2x-df.y1x)**2 + (df.y2y-df.y1y)**2)**0.5) #obtain horizontal and vertucak pupil diameters respectively diamH and diamV + +# plot +figure = plt.figure() +plt.plot('frame','diamH', data=df, linestyle='none', marker='o', markersize=1, alpha=0.1) +plt.plot('frame','diamV', data=df, linestyle='none', marker='o', markersize=1, alpha=0.1) +plt.xlim(0,len(df.index)) +plt.axis('off') +plt.box(False) +#plt.show() + +figure.savefig(files[i]+'.png', bbox_inches='tight', transparent=True, dpi=300) \ No newline at end of file diff --git a/time_in_each_roi.py b/time_in_each_roi.py index e1ab240..04b6043 100644 --- a/time_in_each_roi.py +++ b/time_in_each_roi.py @@ -1,6 +1,8 @@ import numpy as np from collections import namedtuple from scipy.spatial import distance +import pandas as pd +import warnings """ Functions to extract time spent by the mouse in each of a list of user defined ROIS @@ -77,17 +79,22 @@ def calc_distance_between_points_in_a_vector_2d(v1): return np.array(dist) -def get_roi_at_each_frame(bp_data, rois): +def get_roi_at_each_frame(bp_data, rois, check_inroi): """ Given position data for a bodypart and the position of a list of rois, this function calculates which roi is the closest to the bodypart at each frame - :param bp_data: numpy array: [nframes, 2] -> X,Y position of bodypart at each frame - [as extracted by DeepLabCut] --> df.bodypart.values + :param bp_data: numpy array: [nframes, 3] -> X,Y,Speed position of bodypart at each frame + [as extracted by DeepLabCut] --> df.bodypart.values. :param rois: dictionary with the position of each roi. The position is stored in a named tuple with the location of two points defyining the roi: topleft(X,Y) and bottomright(X,Y). + :param check_inroi: boolean, default True. If true only counts frames in which the tracked point is inside of a ROI. + Otherwise at each frame it counts the closest ROI. :return: tuple, closest roi to the bodypart at each frame """ + def sort_roi_points(roi): + return np.sort([roi.topleft[0], roi.bottomright[0]]), np.sort([roi.topleft[1], roi.bottomright[1]]) + if not isinstance(rois, dict): raise ValueError('rois locations should be passed as a dictionary') if not isinstance(bp_data, np.ndarray): @@ -107,35 +114,51 @@ def get_roi_at_each_frame(bp_data, rois): roi_names = list(rois.keys()) - # Calc distance toe ach roi for each frame + # Calc distance to each roi for each frame data_length = bp_data.shape[0] distances = np.zeros((data_length, len(centers))) for idx, center in enumerate(centers): cnt = np.tile(center, data_length).reshape((data_length, 2)) dist = np.hypot(np.subtract(cnt[:, 0], bp_data[:, 0]), np.subtract(cnt[:, 1], bp_data[:, 1])) - - - distances[:, idx] = dist - # Get which roi the mouse is in at each frame + # Get which roi is closest at each frame sel_rois = np.argmin(distances, 1) roi_at_each_frame = tuple([roi_names[x] for x in sel_rois]) - return roi_at_each_frame + + # Check if the tracked point is actually in the closest ROI + if not check_inroi: + cleaned_rois = [] + for i, roi in enumerate(roi_at_each_frame): + x,y = bp_data[i, 0], bp_data[i, 1] + X, Y = sort_roi_points(rois[roi]) # get x,y coordinates of roi points + if not X[0] <= x <= X[1] or not Y[0] <= y <= Y[1]: + cleaned_rois.append('none') + else: + cleaned_rois.append(roi) + return cleaned_rois + else: + warnings.warn("Warning: you've set check_inroi=False, so data reflect which ROI is closest even if tracked point is not in any given ROI.") + return roi_at_each_frame -def get_timeinrois_stats(data, rois, fps=None): +def get_timeinrois_stats(data, rois, fps=None, returndf=False, check_inroi=True): """ - Quantify number of times the animal enters a roi, comulative number of frames spend there, comulative time in seconds + Quantify number of times the animal enters a roi, cumulative number of frames spend there, cumulative time in seconds spent in the roi and average velocity while in the roi. In which roi the mouse is at a given frame is determined with --> get_roi_at_each_frame() Quantify the ammount of time in each roi and the avg stay in each roi - :param data: trackind data is a numpy array with shape (n_frames, 3) with data for X,Y position and Velocity + :param data: trackind data is a numpy array with shape (n_frames, 3) with data for X,Y position and Speed. If [n_frames, 2] + array is passed, speed is calculated automatically. :param rois: dictionary with the position of each roi. The position is stored in a named tuple with the location of two points defyining the roi: topleft(X,Y) and bottomright(X,Y). :param fps: framerate at which video was acquired - :return: dictionary + :param returndf: boolean, default False. If true data are returned as a DataFrame instead of dict. + :param check_inroi: boolean, default True. If true only counts frames in which the tracked point is inside of a ROI. + Otherwise at each frame it counts the closest ROI. + + :return: dictionary or dataframe # Testing >>> position = namedtuple('position', ['topleft', 'bottomright']) @@ -149,8 +172,23 @@ def get_timeinrois_stats(data, rois, fps=None): def get_indexes(lst, match): return np.asarray([i for i, x in enumerate(lst) if x == match]) + # Check arguments + if data.shape[1] == 2: # only X and Y tracking data passed, calculate speed + speed = calc_distance_between_points_in_a_vector_2d(data) + data = np.hstack((data, speed.reshape((len(speed), 1)))) + + elif data.shape[1] != 3: + raise ValueError("Tracking data should be passed as either an Nx2 or Nx3 array. Tracking data shape was: {}. Maybe you forgot to transpose the data?".format(data.shape)) + + roi_names = [k.lower() for k in list(rois.keys())] + if "none" in roi_names: + raise ValueError("No roi can have name 'none', that's reserved for the code to use, please use a different name for your rois.") + + if "tot" in roi_names: + raise ValueError("No roi can have name 'tot', that's reserved for the code to use, please use a different name for your rois.") + # get roi at each frame of data - data_rois = get_roi_at_each_frame(data, rois) + data_rois = get_roi_at_each_frame(data, rois, check_inroi) data_time_inrois = {name: data_rois.count(name) for name in set(data_rois)} # total time (frames) in each roi # number of enters in each roi @@ -175,12 +213,32 @@ def get_indexes(lst, match): vels = data[indexes, 2] avg_vel_per_roi[name] = np.average(np.asarray(vels)) - results = dict(transitions_per_roi=transitions_count, - comulative_time_in_roi=data_time_inrois, - comulative_time_in_roi_sec=data_time_inrois_sec, - avg_time_in_roi=avg_time_in_roi, - avg_time_in_roi_sec=avg_time_in_roi_sec, - avg_vel_in_roi=avg_vel_per_roi) + # get comulative + transitions_count['tot'] = np.sum(list(transitions_count.values())) + data_time_inrois['tot'] = np.sum(list(data_time_inrois.values())) + data_time_inrois_sec['tot'] = np.sum(list(data_time_inrois_sec.values())) + avg_time_in_roi['tot'] = np.sum(list(avg_time_in_roi.values())) + avg_time_in_roi_sec['tot'] = np.sum(list(avg_time_in_roi_sec.values())) + avg_vel_per_roi['tot'] = np.sum(list(avg_vel_per_roi.values())) + + if returndf: + roinames = sorted(list(data_time_inrois.keys())) + results = pd.DataFrame.from_dict({ + "ROI_name": roinames, + "transitions_per_roi": [transitions_count[r] for r in roinames], + "cumulative_time_in_roi": [data_time_inrois[r] for r in roinames], + "cumulative_time_in_roi_sec": [data_time_inrois_sec[r] for r in roinames], + "avg_time_in_roi": [avg_time_in_roi[r] for r in roinames], + "avg_time_in_roi_sec": [avg_time_in_roi_sec[r] for r in roinames], + "avg_vel_in_roi": [avg_vel_per_roi[r] for r in roinames], + }) + else: + results = dict(transitions_per_roi=transitions_count, + cumulative_time_in_roi=data_time_inrois, + cumulative_time_in_roi_sec=data_time_inrois_sec, + avg_time_in_roi=avg_time_in_roi, + avg_time_in_roi_sec=avg_time_in_roi_sec, + avg_vel_in_roi=avg_vel_per_roi) return results diff --git a/transform_and_scale/DLCTransformer.py b/transform_and_scale/DLCTransformer.py new file mode 100644 index 0000000..b53226a --- /dev/null +++ b/transform_and_scale/DLCTransformer.py @@ -0,0 +1,208 @@ +import pandas as pd +import numpy as np +from read_config import read_config +from typing import Optional + +class DLCTransformer: + def __init__(self, config_filepath: str, dlc_filepath: Optional[str] = None, dlc_df: Optional[pd.DataFrame] = None): + self.config = read_config(config_filepath) + self.dlc_filepath = dlc_filepath + if self.dlc_filepath is not None: + if self.dlc_filepath.endswith("h5"): + self.dlc_df = pd.read_hdf(dlc_filepath, header=[0, 1, 2], index_col=0) + elif self.dlc_filepath.endswith("csv"): + self.dlc_df = pd.read_csv(dlc_filepath, header=[0, 1, 2], index_col=0) + else: + raise ValueError("DeepLabCut file must be .h5 or .csv") + else: + if dlc_df is not None: + self.dlc_df = dlc_df + else: + raise ValueError("One of the arguments dlc_filepath or dlc_df must be specified") + + # read metadata + self.origin_marker = self.config["origin_marker"] + self.basis_vector_h_marker = self.config["basis_vector_h_marker"] + self.basis_vector_v_marker = self.config["basis_vector_v_marker"] + self.scale_factor_h = self.config["scale_factor_h"] + self.scale_factor_v = self.config["scale_factor_v"] + self.dlc_immobile_marker_threshold = self.config[ + "dlc_immobile_marker_threshold" + ] + self.show_angle = self.config["show_angle"] + self.scorer = self.dlc_df.columns.get_level_values(0).unique()[0] + + def run(self) -> pd.DataFrame: + """ + Translate and scale DLC data. + First get median coordinate of origin marker and basis vectors, then transform and scale the data. + + :return: pd.DataFrame with transformed and scaled DLC data + """ + # get basis vectors and origin + origin, basis_vector_h, basis_vector_v = self.get_basis_vectors( + df=self.dlc_df, + origin_marker=self.origin_marker, + basis_vector_h_marker=self.basis_vector_h_marker, + basis_vector_v_marker=self.basis_vector_v_marker, + dlc_immobile_marker_threshold=self.dlc_immobile_marker_threshold, + ) + + if self.show_angle: + print( + "Angle between basis vectors :", + self._calculate_angle(basis_vector_v, (0, 0), basis_vector_h), + ) + + # transform df + df_transformed = self.transform( + self.dlc_df, origin, basis_vector_h, basis_vector_v + ) + df_scaled = self.scale_df( + df_transformed, self.scale_factor_h, self.scale_factor_v + ) + return df_scaled + + def get_basis_vectors( + self, + df: pd.DataFrame, + origin_marker: str, + basis_vector_h_marker: str, + basis_vector_v_marker: str, + dlc_immobile_marker_threshold: float, + ) -> (tuple, tuple, tuple): + """ + Returns the origin and basis vectors of the coordinate system + + :param df: pd.DataFrame with tracking data + :param origin_marker: name of origin marker + :param basis_vector_h_marker: name of horizontal basis vector marker + :param basis_vector_v_marker: name of vertical basis vector marker + :param dlc_immobile_marker_threshold: minimum likelihood of a constant marker to be included into the median coordinate calculation + :return: coordinates of origin, basis_vector_h, basis_vector_v + """ + origin = self.get_median_coordinate( + df, origin_marker, dlc_immobile_marker_threshold + ) + + # bring coordinates into origin system + basis_vector_h_coord = self.get_median_coordinate( + df=df, + marker=basis_vector_h_marker, + dlc_immobile_marker_threshold=dlc_immobile_marker_threshold, + ) + basis_vector_v_coord = self.get_median_coordinate( + df=df, + marker=basis_vector_v_marker, + dlc_immobile_marker_threshold=dlc_immobile_marker_threshold, + ) + + # calculate basis vector transformation + basis_vector_h = ( + basis_vector_h_coord[0] - origin[0], + basis_vector_h_coord[1] - origin[1], + ) + basis_vector_v = ( + basis_vector_v_coord[0] - origin[0], + basis_vector_v_coord[1] - origin[1], + ) + + return origin, basis_vector_h, basis_vector_v + + def get_median_coordinate(self, df, marker, dlc_immobile_marker_threshold) -> tuple: + """ + Returns the most likely coordinate of a vector + + :param df: pd.DataFrame with tracking data + :param marker: name of marker of which the median coordinate should be calculated + :param dlc_immobile_marker_threshold: minimum likelihood of a constant marker to be included into the median coordinate calculation + :return: median coordinate of marker + """ + # filter df + df = df.droplevel(0, axis=1) + marker_df = df.loc[ + df[marker, "likelihood"] > dlc_immobile_marker_threshold, marker + ].copy() + x_coord = np.nanmedian(marker_df["x"]) + y_coord = np.nanmedian(marker_df["y"]) + coords = (x_coord, y_coord) + return coords + + def _calculate_angle(self, a, b, c) -> float: + """ + Calculates the angle between three points a-b-c + + :param a: tuple of coordinates + :param b: tuple of coordinates + :param c: tuple of coordinates + :return: angle between a-b-c in degrees + """ + + # Calculate the vectors AB and BC + vector_AB = (b[0] - a[0], b[1] - a[1]) + vector_BC = (c[0] - b[0], c[1] - b[1]) + + # Calculate the magnitudes of AB and BC + magnitude_AB = np.linalg.norm(vector_AB) + magnitude_BC = np.linalg.norm(vector_BC) + # + # Calculate the dot product of AB and BC + dot_product = np.dot(vector_AB, vector_BC) + + # Calculate the angle in radians using the dot product and magnitudes + angle_radians = np.arccos(dot_product / (magnitude_AB * magnitude_BC)) + + # Convert the angle to degrees + angle_degrees = np.degrees(angle_radians) + return angle_degrees + + def transform(self, df, origin, basis_vector_h, basis_vector_v) -> pd.DataFrame: + """ + Transform the coordinates of the df into the new coordinate system + + :param df: pd.DataFrame with tracking data + :param origin: coordinate of origin + :param basis_vector_h: coordinate of horizontal basis vector + :param basis_vector_v: coordinate of vertical basis vector + :return: transformed pd.DataFrame + """ + transformed_df = df.copy() + final_transformed_df = df.copy() + + # 2d rotation matrix + a = basis_vector_h[0] + b = basis_vector_h[1] + c = basis_vector_v[0] + d = basis_vector_v[1] + + for marker in df.columns.get_level_values(1).unique(): + + # shift coordinates into origin system + transformed_df.loc[:, (self.scorer, marker, "x")] -= origin[0] + transformed_df.loc[:, (self.scorer, marker, "y")] -= origin[1] + + # linear algebra 2D transformation + final_transformed_df.loc[:, (self.scorer, marker, "y")] = ( + (transformed_df.loc[:, (self.scorer, marker, "y")] / b) + - (transformed_df.loc[:, (self.scorer, marker, "x")] / a) + ) / ((-c / a) + (d / b)) + + final_transformed_df.loc[:, (self.scorer, marker, "x")] = ( + transformed_df.loc[:, (self.scorer, marker, "x")] + - c * final_transformed_df.loc[:, (self.scorer, marker, "y")] + ) / a + + return final_transformed_df + + def scale_df(self, df, scale_factor_h, scale_factor_v) -> pd.DataFrame: + """ + :param df: pd.DataFrame with tracking data + :param scale_factor_h: horizontal scale factor + :param scale_factor_v: vertical scale factor + :return: scaled pd.DataFrame + """ + scaled_df = df.copy() + for marker in df.columns.get_level_values(1).unique(): + scaled_df.loc[:, (self.scorer, marker, "x")] *= scale_factor_h + scaled_df.loc[:, (self.scorer, marker, "y")] *= scale_factor_v + return scaled_df diff --git a/transform_and_scale/README.md b/transform_and_scale/README.md new file mode 100644 index 0000000..fae5edc --- /dev/null +++ b/transform_and_scale/README.md @@ -0,0 +1,28 @@ +# Easy transformation and scaling of DeepLabCut Data + +#### Background +DeepLabCut is a widely used markerless pose estimation toolbox in behavioral science. The output of DeepLabCut is coordinates in pixels for each frame for each marker. However, in most cases the coordinates first need to be translated (i.e. adapted to the coordinate-space of the behavioral maze) and scaled (e.g. to cm) to enable meaningful behavioral quantification. + +#### Functionality +The Transform_DLC repository takes care of a specific task: It takes DeepLabCut dataframes as the input and outputs transformed and scaled DeepLabCut dataframes. Requirements for this transformation and scaling are that the behavioral maze or a reference has to be rectangular and its corners have to be tracked with DeepLabCut. + +#### Usage +For an example usecase check out the tutorial notebook! + +1) Set hyperparameter in config file: Specify the name of the horizontal and vertical basis vector markers (in a rectangular maze these are two opposing corners) and the origin (the corner that connects the two basis vector corners). Additionally, set the DeepLabCut-likelihood threshold for those markers, and the scale factors (optional, if you don´t need scaling set them to 1). For quality control set show_angle to True. + +2) Instantiate the DLCTransformer class with the filepath to your DeepLabCut tracked data and the config-filepath. + +3) Use .run on your instantiated class object and save the output in a variable of your choice. + + +#### Contribution +This is a [Defense Circuits Lab](https://www.defense-circuits-lab.com/) project written by [Michael Schellenberger](https://github.com/MSchellenberger) for [DLCutils](https://github.com/DeepLabCut/DLCutils). + + + +
+ + DefenseCircuitsLab + +
\ No newline at end of file diff --git a/transform_and_scale/__pycache__/DLCTransformer.cpython-39.pyc b/transform_and_scale/__pycache__/DLCTransformer.cpython-39.pyc new file mode 100644 index 0000000..8f81d28 Binary files /dev/null and b/transform_and_scale/__pycache__/DLCTransformer.cpython-39.pyc differ diff --git a/transform_and_scale/__pycache__/read_config.cpython-39.pyc b/transform_and_scale/__pycache__/read_config.cpython-39.pyc new file mode 100644 index 0000000..8f303f8 Binary files /dev/null and b/transform_and_scale/__pycache__/read_config.cpython-39.pyc differ diff --git a/transform_and_scale/config.yaml b/transform_and_scale/config.yaml new file mode 100644 index 0000000..763d295 --- /dev/null +++ b/transform_and_scale/config.yaml @@ -0,0 +1,7 @@ +origin_marker: 'RodLowerLeft' +basis_vector_h_marker: 'RodLowerRight' +basis_vector_v_marker: 'RodUpperLeft' +scale_factor_h: 5.8 +scale_factor_v: 3 +dlc_immobile_marker_threshold: 0.9 +show_angle: True \ No newline at end of file diff --git a/transform_and_scale/read_config.py b/transform_and_scale/read_config.py new file mode 100644 index 0000000..94b43e6 --- /dev/null +++ b/transform_and_scale/read_config.py @@ -0,0 +1,21 @@ +import yaml + + +def read_config(config_path: str) -> dict: + """ + Reads structured config file defining a project. + + :param config_path: path to config file + """ + + try: + with open(config_path, "r") as ymlfile: + config_file = yaml.load(ymlfile, Loader=yaml.SafeLoader) + except FileNotFoundError: + raise ( + "Could not find the config file at " + + config_path + + " \n Please make sure the path is correct and the file exists" + ) + + return config_file diff --git a/transform_and_scale/test_data/DefenseCircuitsLab2023_Rotarod_testfile.h5 b/transform_and_scale/test_data/DefenseCircuitsLab2023_Rotarod_testfile.h5 new file mode 100644 index 0000000..f4c6184 Binary files /dev/null and b/transform_and_scale/test_data/DefenseCircuitsLab2023_Rotarod_testfile.h5 differ diff --git a/transform_and_scale/transform_and_scale_tutorial.ipynb b/transform_and_scale/transform_and_scale_tutorial.ipynb new file mode 100644 index 0000000..a2b9ed3 --- /dev/null +++ b/transform_and_scale/transform_and_scale_tutorial.ipynb @@ -0,0 +1,63 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from DLCTransformer import DLCTransformer" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dlc_filepath = r\"test_data/DefenseCircuitsLab2023_Rotarod_testfile.h5\"\n", + "config_filepath = r\"config.yaml\"\n", + "transformer = DLCTransformer(dlc_filepath=dlc_filepath, config_filepath=config_filepath)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "scaled = transformer.run()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "scaled.head()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/ubuntu_install_helper_files/dlc_ubuntu18.yml b/ubuntu_install_helper_files/dlc_ubuntu18.yml new file mode 100644 index 0000000..8c33461 --- /dev/null +++ b/ubuntu_install_helper_files/dlc_ubuntu18.yml @@ -0,0 +1,106 @@ +name: dlc +channels: + - conda-forge + - defaults +dependencies: + - _tflow_select=2.1.0=gpu + - blas=1.0=openblas + - c-ares=1.15.0=h14c3975_1001 + - ca-certificates=2019.5.15=0 + - certifi=2019.3.9=py36_0 + - cudatoolkit=10.0.130=0 + - cudnn=7.6.0=cuda10.0_0 + - cupti=10.0.130=0 + - gast=0.2.2=py_0 + - hdf5=1.10.4=nompi_h3c11f04_1106 + - libblas=3.8.0=7_openblas + - libcblas=3.8.0=7_openblas + - libedit=3.1.20181209=hc058e9b_0 + - libffi=3.2.1=hd88cf55_4 + - libgcc-ng=9.1.0=hdf63c60_0 + - libgfortran-ng=7.3.0=hdf63c60_0 + - liblapack=3.8.0=7_openblas + - libopenblas=0.3.6=h5a2b251_0 + - libprotobuf=3.8.0=h8b12597_0 + - libstdcxx-ng=9.1.0=hdf63c60_0 + - mock=3.0.5=py36_0 + - ncurses=6.1=he6710b0_1 + - numpy-base=1.14.6=py36h2f8d375_4 + - openblas=0.3.5=h9ac9557_1001 + - openssl=1.1.1c=h7b6447c_1 + - pip=19.1.1=py36_0 + - python=3.6.8=h0371630_0 + - readline=7.0=h7b6447c_5 + - setuptools=41.0.1=py36_0 + - sqlite=3.28.0=h7b6447c_0 + - tensorflow=1.13.1=gpu_py36h3991807_0 + - tensorflow-base=1.13.1=gpu_py36h8d69cac_0 + - tensorflow-estimator=1.13.0=py_0 + - tk=8.6.8=hbc83047_0 + - werkzeug=0.15.4=py_0 + - xz=5.2.4=h14c3975_4 + - zlib=1.2.11=h7b6447c_3 + - pip: + - absl-py==0.7.1 + - astor==0.8.0 + - chardet==3.0.4 + - click==7.0 + - cloudpickle==1.2.1 + - cycler==0.10.0 + - decorator==4.4.0 + - deeplabcut==2.0.6.3 + - easydict==1.9 + - grpcio==1.21.1 + - h5py==2.9.0 + - idna==2.8 + - imageio==2.3.0 + - intel-openmp==2019.0 + - ipython==6.0.0 + - ipython-genutils==0.2.0 + - jedi==0.13.3 + - keras-applications==1.0.8 + - keras-preprocessing==1.1.0 + - kiwisolver==1.1.0 + - markdown==3.1.1 + - matplotlib==3.0.3 + - moviepy==0.2.3.5 + - networkx==2.3 + - numexpr==2.6.9 + - numpy==1.14.6 + - opencv-python==3.4.5.20 + - pandas==0.21.0 + - parso==0.4.0 + - patsy==0.5.1 + - pexpect==4.7.0 + - pickleshare==0.7.5 + - pillow==6.0.0 + - prompt-toolkit==1.0.16 + - protobuf==3.8.0 + - ptyprocess==0.6.0 + - pygments==2.4.2 + - pyparsing==2.4.0 + - pypubsub==4.0.3 + - python-dateutil==2.7.3 + - pytz==2019.1 + - pywavelets==1.0.3 + - pyyaml==5.1.1 + - requests==2.22.0 + - ruamel-yaml==0.15.0 + - scikit-image==0.14.3 + - scikit-learn==0.19.2 + - scipy==1.1.0 + - simplegeneric==0.8.1 + - six==1.11.0 + - statsmodels==0.9.0 + - tables==3.5.2 + - tensorboard==1.12.2 + - tensorflow-gpu==1.12.0 + - termcolor==1.1.0 + - tqdm==4.32.1 + - traitlets==4.3.2 + - urllib3==1.25.3 + - wcwidth==0.1.7 + - wheel==0.31.1 + - wxpython==4.0.3 +prefix: /home/fairhalllab/Downloads/yes/envs/dlc + diff --git a/ubuntu_install_helper_files/installDLCandAnaconda.sh b/ubuntu_install_helper_files/installDLCandAnaconda.sh new file mode 100644 index 0000000..62fab03 --- /dev/null +++ b/ubuntu_install_helper_files/installDLCandAnaconda.sh @@ -0,0 +1,21 @@ +sudo apt install curl +sudo apt-get install git + +#download anaconda: +curl https://repo.anaconda.com/archive/Anaconda3-2019.03-Linux-x86_64.sh --output anaconda.sh +sudo chmod 777 anaconda.sh + +./anaconda.sh + + +cd Desktop +git clone https://github.com/AlexEMG/DeepLabCut + +# YOU NEED TO RESTART TERMINAL... +## An environment for CPU on Ubuntu 18.04 +conda create -n DLC python=3.6 +conda activate DLC +pip install deeplabcut +pip install https://extras.wxpython.org/wxPython4/extras/linux/gtk3/ubuntu-18.04/wxPython-4.0.3-cp36-cp36m-linux_x86_64.whl +pip install tensorflow +pip install ipython spyder diff --git a/ubuntu_install_helper_files/testDLC.py b/ubuntu_install_helper_files/testDLC.py new file mode 100644 index 0000000..162e825 --- /dev/null +++ b/ubuntu_install_helper_files/testDLC.py @@ -0,0 +1,13 @@ +import deeplabcut +import os + + +configpath=os.path.join('/home/neudata/Desktop/DeepLabCut/examples/openfield-Pranav-2018-10-30/config.yaml') + +deeplabcut.load_demo_data(configpath) + +deeplabcut.train_network(configpath,maxiters=5) #trains for 5 iterations + + +#manually test GUI... +deeplabcut.label_frames(configpath)