analyzeContinuousNetwork_variarEnvironmentX3 Corregido.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Label and color"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "colors = { \"M0\":\"#c0c0c0\", \"M1\":\"#ff7f00\", \"M1a\":\"#fdbf6f\", \n",
    "         \"M2a\":\"#33a02c\", \"M2b\":\"#ffff99\", \"M2c+\":\"#b2df8a\", \n",
    "         \"M2c\":\"#e53d3f\", \"M2d\":\"#1f78b4\", \"IL10+\":\"#a6cee3\",\n",
    "         \"TGFB+\":\"#fb9a99\", \n",
    "        }\n",
    "for k, v in colors.items():\n",
    "    print( k, tuple(c for c in bytes.fromhex(v[1:])) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import os\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "from matplotlib.colors import BoundaryNorm\n",
    "from matplotlib.ticker import MaxNLocator\n",
    "import matplotlib.patches as mpatches\n",
    "from random import sample\n",
    "from matplotlib import cm\n",
    "import matplotlib\n",
    "from math import sqrt,ceil\n",
    "matplotlib.rcParams['svg.fonttype'] = 'none'\n",
    "from collections import OrderedDict\n",
    "from itertools import product\n",
    "\n",
    "#%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "colors = {\n",
    "\"M0\"\t:\t(170./255,170./255,170./255),\n",
    "\"M1\"\t:\t(0/255,255./255,255./255),\n",
    "\"M2a\"\t:\t(0/255,0/255,255./255),\n",
    "\"M2b\"\t:\t(138./255,43./255,226./255),\n",
    "\"M2c\"\t:\t(156./255,102./255,31./255),\n",
    "\"M2d\"\t:\t(139./255,35./255,35./255),\n",
    "\"M2aM2cM2d\"\t:\t(255./255,97./255,3./255),\n",
    "\"M1M2bM2cM2d\"\t:\t(69./255,139./255,0./255),\n",
    "\"M2cM2d\"\t:\t(220./255,20./255,60./255),\n",
    "\"M1M2bM2d\"\t:\t(255./255,185./255,15./255),\n",
    "\"M2aM2d\"\t:\t(255./255,215./255,0./255),\n",
    "\"M2aM2bM2d\"\t:\t(139./255,95./255,101./255),\n",
    "\"M2bM2d\"\t:\t(128./255,0./255,0./255),\n",
    "\"M1M2b\"\t:\t(60./255,179./255,113./255),\n",
    "\"M1M2d\"\t:\t(25./255,25./255,112./255),\n",
    "\"NoLabel\"\t:\t(255./255,225./255,255./255)\n",
    "\n",
    "            }\n",
    "\n",
    "colors = OrderedDict(sorted(colors.items(), key=lambda t: t[0]))\n",
    "\n",
    "\n",
    "plt.bar(range(len(colors)), [1]*len(colors), color=colors.values(), align=\"edge\" )\n",
    "plt.xticks(np.arange(0.5,len(colors)+.5,1), list(colors.keys()), rotation='vertical')\n",
    "#plt.savefig('ColorCode.svg')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def labelState(x):\n",
    "    #x = [STAT3,SMAD23,STAT6,SOCS1,TLR4,NFKB,STAT1,SOCS3,AP1,IL10,TNFA,TGFB,Fra1,HIF1A,ERK,IL4e,IL10e,TNFAe,TGFBe,IgG,A2a,IFNG,IFNB,IL1B,IL6e,MCSF,GMCSF,Hipoxia,GCGCR]\n",
    "    label = ''\n",
    "    feno = ''\n",
    "    fl = 0\n",
    "    if (x[0]<=0.25) and (x[2]<=0.25) and (x[5]<=0.25) and (x[6]<=0.25) and (x[8]<=0.25) and (x[12]<=0.25) and (x[13]<=0.25) and (x[14]<=0.25): \n",
    "        label = (\"M0\")\n",
    "        fl += 1\n",
    "        feno += label\n",
    "        feno += '-'\n",
    "########### \n",
    "    if (x[2]>=.75) and (((x[23]>=.75) and (x[8]>=0.75)) or (x[14]>=0.75)) and (((x[4]>=0.75) and (x[20]>=0.75)) or ((x[12]>=0.75) and (x[8]>=0.75)) or (x[13]>=0.75) or (x[12]>=0.75)):\n",
    "            label = (\"M2aM2bM2d\")\n",
    "            fl += 1\n",
    "            feno += label\n",
    "            feno += '-'\n",
    "    else:\n",
    "        if (x[2]>=.75) and (x[0]>=.75) and (((x[4]>=0.75) and (x[20]>=0.75)) or ((x[12]>=0.75) and (x[8]>=0.75)) or (x[13]>=0.75) or (x[12]>=0.75)):\n",
    "            label = (\"M2aM2cM2d\")\n",
    "            fl += 1\n",
    "            feno += label\n",
    "            feno += '-'\n",
    "        elif (x[0]>=.75) and (((x[4]>=0.75) and (x[20]>=0.75)) or ((x[12]>=0.75) and (x[8]>=0.75)) or (x[13]>=0.75) or (x[12]>=0.75)):\n",
    "            label = (\"M2cM2d\")\n",
    "            fl += 1\n",
    "            feno += label\n",
    "            feno += '-'\n",
    "        elif (x[2]>=.75) and (((x[4]>=0.75) and (x[20]>=0.75)) or ((x[12]>=0.75) and (x[8]>=0.75)) or (x[13]>=0.75) or (x[12]>=0.75)):\n",
    "            label = (\"M2aM2d\")\n",
    "            fl += 1\n",
    "            feno += label\n",
    "            feno += '-'\n",
    "        elif (x[2]>=.75):\n",
    "            label = (\"M2a\")\n",
    "            fl += 1\n",
    "            feno += label\n",
    "            feno += '-'\n",
    "        elif (x[0]>=.75):\n",
    "            label = (\"M2c\")\n",
    "            fl += 1\n",
    "            feno += label\n",
    "            feno += '-'\n",
    "        elif ((x[4]>=0.75) and (x[20]>=0.75)) or ((x[12]>=0.75) and (x[8]>=0.75)) or (x[13]>=0.75) or (x[12]>=0.75):\n",
    "            label = (\"M2d\")\n",
    "            fl += 1\n",
    "            feno += label\n",
    "            feno += '-'\n",
    "        else:\n",
    "            if ((x[5]>=0.75) or (x[6]>=0.75) or ((x[10]>=0.75) and (x[8]>=0.75)) or ((x[17]>=0.75) and (x[8]>=0.75))) and (((x[23]>=.75) and (x[8]>=0.75)) or (x[14]>=0.75)) and (x[0]>=.75) and (((x[4]>=0.75) and (x[20]>=0.75)) or ((x[12]>=0.75) and (x[8]>=0.75)) or (x[13]>=0.75) or (x[12]>=0.75)):\n",
    "                label = (\"M1M2bM2cM2d\")\n",
    "                fl += 1\n",
    "                feno += label\n",
    "                feno += '-'\n",
    "            elif ((x[5]>=0.75) or (x[6]>=0.75) or ((x[10]>=0.75) and (x[8]>=0.75)) or ((x[17]>=0.75) and (x[8]>=0.75))) and (((x[23]>=.75) and (x[8]>=0.75)) or (x[14]>=0.75)) and (((x[4]>=0.75) and (x[20]>=0.75)) or ((x[12]>=0.75) and (x[8]>=0.75)) or (x[13]>=0.75) or (x[12]>=0.75)):\n",
    "                label = (\"M1M2bM2d\")\n",
    "                fl += 1\n",
    "                feno += label\n",
    "                feno += '-'\n",
    "            elif ((x[5]>=0.75) or (x[6]>=0.75) or ((x[10]>=0.75) and (x[8]>=0.75)) or ((x[17]>=0.75) and (x[8]>=0.75))) and (((x[23]>=.75) and (x[8]>=0.75)) or (x[14]>=0.75)):\n",
    "                label = (\"M1M2b\")\n",
    "                fl += 1\n",
    "                feno += label\n",
    "                feno += '-'\n",
    "            elif ((x[5]>=0.75) or (x[6]>=0.75) or ((x[10]>=0.75) and (x[8]>=0.75)) or ((x[17]>=0.75) and (x[8]>=0.75))) and (((x[4]>=0.75) and (x[20]>=0.75)) or ((x[12]>=0.75) and (x[8]>=0.75)) or (x[13]>=0.75) or (x[12]>=0.75)):\n",
    "                label = (\"M1M2d\")\n",
    "                fl += 1\n",
    "                feno += label\n",
    "                feno += '-'\n",
    "            elif (((x[23]>=.75) and (x[8]>=0.75)) or (x[14]>=0.75)) and (((x[4]>=0.75) and (x[20]>=0.75)) or ((x[12]>=0.75) and (x[8]>=0.75)) or (x[13]>=0.75) or (x[12]>=0.75)):\n",
    "                label = (\"M2bM2d\")\n",
    "                fl += 1\n",
    "                feno += label\n",
    "                feno += '-'\n",
    "            elif ((x[23]>=.75) and (x[8]>=0.75)) or (x[14]>=0.75): \n",
    "                label = (\"M2b\")\n",
    "                fl += 1\n",
    "                feno += label\n",
    "                feno += '-'\n",
    "            elif (x[5]>=0.75) or (x[6]>=0.75) or ((x[10]>=0.5) and (x[8]>=0.75)) or ((x[17]>=0.75) and (x[8]>=0.75)): \n",
    "                label = (\"M1\")\n",
    "                fl += 1\n",
    "                feno += label\n",
    "                feno += '-'\n",
    "############\n",
    "    if (label == \"\"): label = \"NoLabel\"\n",
    " #   print(feno,fl)\n",
    "    return label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_missing_columns_linspace(data, missing):\n",
    "    from itertools import product\n",
    "    from numpy import linspace\n",
    "    \n",
    "    jump = ceil(data.shape[0] ** (1.0 / len(missing) ))\n",
    "    table = list(linspace(  start=0, stop=1, num=jump  ))\n",
    "    table = [ list(reversed(p)) for p in product(table, repeat=len(missing)) ]\n",
    "    table = table[(len(table)-data.shape[0]-1):-1]\n",
    "    table = pd.DataFrame(table, columns=missing, index = list(data.index))\n",
    "\n",
    "    return data.join(table)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_points_3D(path, Ini_Sta,data, nodeA, nodeB, nodeC, filename=False):\n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111, projection='3d')\n",
    "    \n",
    "    plt.title(\"Initial State: \"+Ini_Sta)\n",
    "    ax.set_xlabel(nodeA)\n",
    "    ax.set_ylabel(nodeB)\n",
    "    ax.set_zlabel(nodeC)\n",
    "\n",
    "    handles = []\n",
    "    for label in data[\"Label\"].unique():\n",
    "        data_filtered = data[data.Label != label]\n",
    "        ax.scatter( data_filtered[nodeA], data_filtered[nodeB], data_filtered[nodeC], \n",
    "                    c=data_filtered[\"Color\"].tolist(), label=label, lw = 0 )\n",
    "        handles.append( mpatches.Patch(color=colors[label], label=label) )\n",
    "    ax.view_init(azim=-135)\n",
    "    plt.legend(handles=handles, bbox_to_anchor=(1.04,1), loc=\"upper left\")\n",
    "    if filename: plt.savefig(path+\"/svg-color/\"+filename+'-points.svg')\n",
    "    else: plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def plot_points_2D(path, Ini_Sta,data, nodeA, nodeB, nodeC=\"TCR\", valueC=1, filename=False):\n",
    "    fig = plt.figure()\n",
    "    plt.title(\"Initial State: \"+Ini_Sta)\n",
    "    plt.xlabel(nodeA)\n",
    "    plt.ylabel(nodeB)\n",
    "\n",
    "    handles = []\n",
    "    for label in data[\"Label\"].unique():\n",
    "#        data_filtered = data[data[nodeC] == valueC ]\n",
    "        data_filtered = data\n",
    "        plt.scatter(data_filtered[nodeA], data_filtered[nodeB],\n",
    "                    c=data_filtered[\"Color\"].tolist(), label=label )\n",
    "        handles.append( mpatches.Patch(color=colors[label], label=label) )\n",
    "    plt.legend(handles=handles, bbox_to_anchor=(1.04,1), loc=\"upper left\")\n",
    "    if filename: plt.savefig(path+\"/svg-color/\"+filename+'-points.svg')\n",
    "    else: plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_mesh_3D(path, Ini_Sta,data, nodeA, nodeB, nodeC=\"TCR\", filename=False):\n",
    "    data_filtered = data[[nodeA, nodeB, nodeC, \"Color\"]]\n",
    " \n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111, projection='3d')\n",
    "\n",
    "    plt.title(\"Initial State: \"+Ini_Sta)\n",
    "    ax.set_xlabel(nodeA)\n",
    "    ax.set_ylabel(nodeB)\n",
    "    ax.set_zlabel(nodeC)\n",
    "    \n",
    "    X,Y = np.meshgrid(np.arange(0,1.1,.1), np.arange(0,1.1,.1))\n",
    "\n",
    "    data_filtered = data[data[nodeA] == 0 ]\n",
    "    c = data_filtered[[nodeB, nodeC, \"Color\"]].pivot(nodeB,nodeC).to_numpy()\n",
    "    ax.plot_surface(0, Y, X, rstride=1, cstride=1, facecolors=c)\n",
    "    labels = data_filtered[\"Label\"].unique()\n",
    "    handles = legend_custom(labels)\n",
    "    plot_mesh2D_1(path=path, Ini_Sta=Ini_Sta,c=c, X=nodeB, Y=nodeC, cte=0, handles=handles, filename=file)\n",
    "\n",
    "    data_filtered = data[data[nodeB] == 0 ]\n",
    "    c = data_filtered[[nodeA, nodeC, \"Color\"]].pivot(nodeA,nodeC).to_numpy()\n",
    "    ax.plot_surface(Y, 0, X, rstride=1, cstride=1, facecolors=c)\n",
    "    labels = data_filtered[\"Label\"].unique()\n",
    "    handles = legend_custom(labels)\n",
    "    plot_mesh2D_1(path=path, Ini_Sta=Ini_Sta,c=c, X=nodeA, Y=nodeC, cte=0, handles=handles, filename=file)\n",
    "\n",
    "    data_filtered = data[data[nodeC] == 0 ]\n",
    "#    print(data_filtered, X, Y) \n",
    "    #intentar substitutyendo el 0\n",
    "    Z = np.zeros(X.shape)\n",
    "    c = data_filtered[[nodeA, nodeB, \"Color\"]].pivot(nodeA,nodeB).to_numpy()\n",
    "    ax.plot_surface(Y, X, Z, rstride=1, cstride=1, facecolors=c)\n",
    "    labels = data_filtered[\"Label\"].unique()\n",
    "    handles = legend_custom(labels)\n",
    "    plot_mesh2D_1(path=path, Ini_Sta=Ini_Sta,c=c, X=nodeA, Y=nodeB, cte=0, handles=handles, filename=file)\n",
    "    \n",
    "    data_filtered = data[data[nodeA] == 1 ]\n",
    "    c = data_filtered[[nodeB, nodeC, \"Color\"]].pivot(nodeB,nodeC).to_numpy()\n",
    "    ax.plot_surface(1, Y, X, rstride=1, cstride=1, facecolors=c)\n",
    "    labels = data_filtered[\"Label\"].unique()\n",
    "    handles = legend_custom(labels)\n",
    "    plot_mesh2D_1(path=path, Ini_Sta=Ini_Sta,c=c, X=nodeB, Y=nodeC, cte=1, handles=handles, filename=file)\n",
    "\n",
    "    data_filtered = data[data[nodeB] == 1 ]\n",
    "    c = data_filtered[[nodeA, nodeC, \"Color\"]].pivot(nodeA,nodeC).to_numpy()\n",
    "    ax.plot_surface(Y, 1, X, rstride=1, cstride=1, facecolors=c)\n",
    "    labels = data_filtered[\"Label\"].unique()\n",
    "    handles = legend_custom(labels)\n",
    "    plot_mesh2D_1(path=path, Ini_Sta=Ini_Sta,c=c, X=nodeA, Y=nodeC, cte=1, handles=handles, filename=file)\n",
    "\n",
    "    data_filtered = data[data[nodeC] == 1 ]\n",
    "    Z = np.full((X.shape), 1, dtype = float)\n",
    "    c = data_filtered[[nodeA, nodeB, \"Color\"]].pivot(nodeA,nodeB).to_numpy()\n",
    "    ax.plot_surface(Y, X, Z, rstride=1, cstride=1, facecolors=c, linewidth=1, shade=False, edgecolors='k')\n",
    "    labels = data_filtered[\"Label\"].unique()\n",
    "    handles = legend_custom(labels)\n",
    "    plot_mesh2D_1(path=path, Ini_Sta=Ini_Sta,c=c, X=nodeA, Y=nodeB, cte=1, handles=handles, filename=file)\n",
    "\n",
    "    from itertools import product, combinations\n",
    "    #draw cube\n",
    "    r = [-0.001, 0.901]\n",
    "    for s, e in combinations(np.array(list(product(r,r,r))), 2):\n",
    "        if np.sum(np.abs(s-e)) == r[1]-r[0]:\n",
    "            ax.plot3D(*zip(s,e), color=\"k\", lw=3)\n",
    "    ax.view_init(azim=-135)\n",
    "\n",
    "    if filename: plt.savefig(path+\"/svg-color/\"+filename+'-mesh.svg')\n",
    "    else: plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def legend_custom(labels):\n",
    "    handles = []\n",
    "    for label in labels:\n",
    "        handles.append( mpatches.Patch(color=colors[label], label=label))        \n",
    "    return(handles)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_mesh2D_1(path, Ini_Sta, c, X, Y, cte, handles, filename=False):\n",
    "    from matplotlib.patches import Rectangle\n",
    "    #data_filtered = data[data[nodeC] == valueC ]\n",
    "    x = np.arange(0,1.1,.1)\n",
    "#    y = np.arange(0,1.1,.1)\n",
    "    XY= xy= product(x,repeat = 2)\n",
    "    h = x[-1]-x[0]\n",
    "  #  print(type(x),type(y),type(c))\n",
    " #   print(list(zip(XY, np.concatenate(c))))\n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111, aspect='equal')\n",
    "    plt.title(\"Initial State: \"+Ini_Sta)\n",
    "    plt.xlabel(X)\n",
    "    plt.ylabel(Y)\n",
    "    \n",
    "    dif = (x[2]-x[1])/2\n",
    "    plt.xlim([0-dif,1+dif])\n",
    "    plt.ylim([0-dif,1+dif])\n",
    "\n",
    "    for Z, cl in zip(XY, list(np.concatenate(c))):\n",
    "#        print(Z,cl)\n",
    "        ax.add_artist(Rectangle(xy=(Z[0]-dif, Z[1]-dif),\n",
    "                  color=cl,\n",
    "                  width=h, height=h))\n",
    "    \n",
    "    plt.legend(handles=handles, bbox_to_anchor=(1.04,1), loc=\"upper left\")\n",
    "    \n",
    "    if filename: plt.savefig(path+\"/svg-color/\"+filename+'/'+X+\"vs\"+Y+\"_\"+str(cte)+'-mesh.svg')\n",
    "    else: plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_mesh_2D(path, Ini_Sta, data, nodeA, nodeB, nodeC=\"TCR\",valueC=1, filename=False):\n",
    "    from matplotlib.patches import Rectangle\n",
    "#    data_filtered = data[data[nodeC] == valueC ]\n",
    "    data_filtered = data\n",
    "    x = data_filtered[nodeA]\n",
    "    y = data_filtered[nodeB]\n",
    "    c = data_filtered[\"Color\"].tolist()\n",
    "    labels = data_filtered[\"Label\"].unique()\n",
    "    handles = legend_custom(labels)\n",
    "#    print(x)\n",
    "    h = x.iloc[1]-x.iloc[0]\n",
    "    \n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111, aspect='equal')\n",
    "    plt.title(\"Initial State: \"+Ini_Sta)\n",
    "    plt.xlabel(nodeA)\n",
    "    plt.ylabel(nodeB)\n",
    "    \n",
    "    index = x.index\n",
    "    dif = (x[index[2]]-x[index[1]])/2\n",
    "    plt.xlim([0-dif,1+dif])\n",
    "    plt.ylim([0-dif,1+dif])\n",
    "\n",
    "    for x, y, c in zip(x, y, c):\n",
    "        ax.add_artist(Rectangle(xy=(x-dif, y-dif),\n",
    "                  color=c,\n",
    "                  width=h, height=h))\n",
    "    \n",
    "    plt.legend(handles=handles, bbox_to_anchor=(1.04,1), loc=\"upper left\")\n",
    "    if filename: plt.savefig(path+\"/svg-color/\"+filename+'-mesh.svg')\n",
    "    else: plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Lenovo\\Documents\\Python\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[' M2d_HIF1A_ERK.csv',\n",
       " ' M2d_HIF1A_STAT3.csv',\n",
       " ' M2d_HIF1A_STAT6.csv',\n",
       " 'M2d_HIF1A_NFKB.csv',\n",
       " 'M2d_HIF1A_STAT1.csv']"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "path = os.getcwd()\n",
    "print(path)\n",
    "#folder = \"Results-M1\"\n",
    "folder = \"Results-M2d\"\n",
    "path = path+\"/\"+folder\n",
    "#path = os.getcwd()\n",
    "os.listdir(path+\"/csv-clean/\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "M2d_HIF1A_STAT1.csv\n"
     ]
    }
   ],
   "source": [
    "a = os.listdir(path+\"/csv-clean/\")[4]\n",
    "for f in [a]: \n",
    "    print(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "M2d HIF1A STAT1 TCR\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Lenovo\\AppData\\Local\\Temp\\ipykernel_11840\\485436708.py:21: FutureWarning: In a future version of pandas all arguments of DataFrame.drop except for the argument 'labels' will be keyword-only.\n",
      "  data = data.drop([\"Sum\",\"Label\"], 1)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for file in [a]:\n",
    "\n",
    "    data = pd.read_csv(path+\"/csv-clean/\" + file, index_col=0)\n",
    "    \n",
    "    file = file.replace(\".csv\",\"\")\n",
    "    ## folder to save figures\n",
    "    if not os.path.exists(path+\"/svg-color/\"+file):\n",
    "        os.mkdir(path+\"/svg-color/\"+file)\n",
    "    \n",
    "    Ini_Sta = file.split(\"_\")[0]\n",
    "    nodeA = file.split(\"_\")[1]\n",
    "    nodeB = file.split(\"_\")[2]\n",
    "    try: nodeC = file.split(\"_\")[3]\n",
    "    except: nodeC = \"TCR\"\n",
    "    #Check if nodes in header exist in df\n",
    "    print(Ini_Sta,nodeA, nodeB, nodeC)\n",
    "    #missing = [n for n in [nodeA, nodeB, nodeC] if n not in data.columns]\n",
    "    missing = [n for n in [nodeA, nodeB, nodeC] if n not in data.columns]\n",
    "    if len(missing) > 0:\n",
    "        data = add_missing_columns_linspace(data, missing)\n",
    "    data = data.drop([\"Sum\",\"Label\"], 1)\n",
    "    data[\"Sum\"] = data.sum(axis=1)\n",
    "    data[\"Label\"] = data.apply(labelState, axis=1)\n",
    "    data[\"Color\"] = data[\"Label\"].map(colors)\n",
    "    if nodeC == \"TCR\": #2D graph\n",
    "        plot_points_2D(path, Ini_Sta, data, nodeA, nodeB, nodeC, filename=file)\n",
    "        plot_mesh_2D(path, Ini_Sta, data, nodeA, nodeB, nodeC, filename=file)\n",
    "    \n",
    "    else: #3D graph or die\n",
    "        plot_points_3D(path, Ini_Sta,data, nodeA, nodeB, nodeC, filename=file)\n",
    "        plot_mesh_3D(path, Ini_Sta,data, nodeA, nodeB, nodeC, filename=file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}