PyRadiomics_Extraction_pLGG.ipynb

{
 "nbformat": 4,
 "nbformat_minor": 0,
 "metadata": {
  "colab": {
   "name": "PyRadiomics Extraction pLGG.ipynb",
   "provenance": [],
   "collapsed_sections": []
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3"
  },
  "language_info": {
   "name": "python"
  }
 },
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Ezs-nfCS0ulI",
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Loading the data\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "os.listdir(r\"K:\\Projects\\SickKids_Brain_Preprocessing\\preprocessed_all_seq_kk_july_2022\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "os.chdir(\n",
    "    r\"K:\\Projects\\SickKids_Brain_Preprocessing\\preprocessed_all_seq_kk_july_2022\")  # we could also use \"cd\" but that would not be a python command"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "os.getcwd()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "os.listdir()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "import glob\n",
    "\n",
    "\n",
    "def load_image_data(path, patients, limit=False):\n",
    "    data_images = {}\n",
    "    for root, dirs, files in os.walk(path):\n",
    "        dirs.sort(key=int)\n",
    "        dirs = list(map(int, dirs))\n",
    "        dirs = [patient for patient in dirs if patient in patients]\n",
    "        if limit:\n",
    "            dirs = dirs[:limit]\n",
    "        for d in dirs:\n",
    "            print(f\"Loading Patient {d}...\")\n",
    "            np_filenames = glob.glob(f\"{os.path.join(root, f'{d}')}/*/*.npy\")\n",
    "            FLAIR = None\n",
    "            segmentation = None\n",
    "\n",
    "            target_1 = \"preprocessed_FLAIR.npy\"\n",
    "            result_1 = [string for string in np_filenames if target_1 in string]\n",
    "\n",
    "            target_2 = \"preprocessed_segmentation.npy\"\n",
    "            result_2 = [string for string in np_filenames if target_2 in string]\n",
    "\n",
    "            if result_1:\n",
    "                FLAIR = np.load(result_1[0])\n",
    "            if result_2:\n",
    "                segmentation = np.load(result_2[0])\n",
    "            if FLAIR is not None and segmentation is not None:\n",
    "                data_images[d] = [FLAIR, segmentation]\n",
    "            else:\n",
    "                print('Data missing.')\n",
    "        break\n",
    "    return data_images, dirs"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "excluded_patients = [2, 3, 4, 6, 7, 9, 11, 12, 13, 16, 21, 23, 25, 28, 29, 30, 33, 35, 36, 37, 38, 44, 45, 49, 50,\n",
    "                         52, 53, 54, 55, 58, 59, 61, 63, 66, 73, 74, 75, 77, 78, 80, 84, 85, 86, 92, 95, 96, 98, 100,\n",
    "                         102, 103, 105, 107, 108, 110, 113, 117, 121, 122, 123, 125, 128, 130, 131, 132, 136, 137, 138,\n",
    "                         139, 140, 141, 142, 143, 147, 148, 150, 152, 156, 158, 159, 165, 166, 171, 173, 174, 176, 182,\n",
    "                         183, 184, 187, 190, 191, 192, 194, 196, 199, 203, 204, 209, 210, 213, 221, 222, 224, 226, 227,\n",
    "                         228, 232, 233, 234, 235, 237, 240, 242, 243, 245, 246, 250, 254, 255, 256, 258, 259, 260, 261,\n",
    "                         263, 264, 266, 270, 272, 274, 277, 278, 283, 284, 285, 288, 293, 298, 299, 303, 306, 309, 311,\n",
    "                         312, 317, 318, 321, 322, 324, 325, 327, 328, 330, 332, 333, 334, 336, 337, 341, 343, 347,\n",
    "                         349, 350, 351, 352, 354, 356, 359, 364, 367, 370, 371, 374, 376, 377, 378, 380, 383, 386, 387,\n",
    "                         388, 392, 396, 243, 255, 261, 264, 288, 299, 309, 327, 351, 387]"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "radiomics_patients_list = set(range(1, 398))\n",
    "final_inclusion_list = set([319])\n",
    "# final_inclusion_list = set([x for x in radiomics_patients_list if x not in excluded_patients])\n",
    "patients_with_FLAIR = []\n",
    "image_directory = r'K:\\Projects\\SickKids_Brain_Preprocessing\\preprocessed_all_seq_kk_july_2022'\n",
    "for each_patient in os.listdir(image_directory):\n",
    "    try:\n",
    "        patients_with_FLAIR.append(int(each_patient))\n",
    "    except:\n",
    "        print(\"Patient not found.\")\n",
    "patients_with_FLAIR.sort(key=int)\n",
    "patients_list = list(final_inclusion_list.intersection(patients_with_FLAIR))\n",
    "\n",
    "images, patients_used = load_image_data(image_directory, patients=patients_list)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "data_pre_norm = {}\n",
    "for each_patient in patients_used:\n",
    "    image = images[each_patient][0]\n",
    "    seg = images[each_patient][1]\n",
    "    data_pre_norm[each_patient] = (image, seg)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "data = {}\n",
    "for each_patient in data_pre_norm.keys():\n",
    "    image_pre_norm = data_pre_norm[each_patient][0]\n",
    "    seg = data_pre_norm[each_patient][1]\n",
    "    image_post_norm = (image_pre_norm - np.min(image_pre_norm)) / (np.max(image_pre_norm) - np.min(image_pre_norm))\n",
    "    data[each_patient] = (image_post_norm, seg)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "for each_patient in data.keys():\n",
    "    if np.max(data[each_patient][0]) != 1 or np.min(data[each_patient][0]) != 0:\n",
    "        print(each_patient)\n",
    "        print(np.max(data[each_patient][0]))\n",
    "        print(np.min(data[each_patient][0]))\n",
    "        continue\n",
    "    np.save(os.path.join(os.getcwd(), f\"{each_patient}\\FLAIR\\preprocessed_FLAIR_normalized.npy\"), data[each_patient][0])"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "flair_img = data[list(data.keys())[0]][0]\n",
    "segmentation = data[list(data.keys())[0]][1]"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "flair_img_pre_norm = data[list(data.keys())[0]][0]\n",
    "segmentation_pre_norm = data[list(data.keys())[0]][1]"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "flair_img.shape"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "segmentation.shape"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib\n",
    "\n",
    "\n",
    "def plot_segmentation(seg):\n",
    "    cmap = matplotlib.colors.ListedColormap([\"black\", \"dimgrey\", \"forestgreen\", \"darkorange\"])\n",
    "    plt.figure()\n",
    "    plt.imshow(seg, cmap=cmap, vmin=0, vmax=3)\n",
    "\n",
    "\n",
    "plt.figure()\n",
    "plt.imshow(flair_img[:, :, 45], cmap='gray')\n",
    "plot_segmentation(segmentation[:, :, 45])\n",
    "\n",
    "print(\"unique values in the segmentation are:\", np.unique(segmentation))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "plt.figure()\n",
    "plt.imshow(flair_img_pre_norm[:, :, 45], cmap='gray')\n",
    "plot_segmentation(segmentation_pre_norm[:, :, 45])"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Statistics of the image\n",
    "import numpy as np\n",
    "\n",
    "print(\"minimum intensity value in the FLAIR image is:\", np.min(flair_img[4, :, :]))\n",
    "print(\"maximum intensity value in the FLAIR image is:\", np.max(flair_img[4, :, :]))\n",
    "print(\"Average intensity value in the FLAIR image is:\", np.mean(flair_img[4, :, :]))\n",
    "plt.hist(flair_img[4, :, :])\n",
    "plt.title(\"Histogram of intensities in the FLAIR image\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "import copy\n",
    "\n",
    "\n",
    "def seg_to_binary(seg):\n",
    "    local_seg = copy.deepcopy(seg)\n",
    "    local_seg[local_seg > 0] = 1\n",
    "    return local_seg\n",
    "\n",
    "\n",
    "seg = seg_to_binary(segmentation[:, :, 45])\n",
    "plt.figure()\n",
    "plt.imshow(flair_img[:, :, 45], cmap='gray')\n",
    "plt.figure()\n",
    "plt.imshow(seg, cmap='gray')"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "loc = []\n",
    "tumor_area = []\n",
    "for i in range(segmentation.shape[2]):\n",
    "    loc.append(i)\n",
    "    seg = seg_to_binary(segmentation[:, :, i])\n",
    "    tumor_area.append(np.sum(seg))\n",
    "\n",
    "plt.plot(loc, tumor_area)\n",
    "plt.xlabel(\"Slice#\")\n",
    "plt.ylabel(\"Surface Area\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "ind = np.argmax(tumor_area)\n",
    "\n",
    "print(\"The index slice is located at loc#\", ind)\n",
    "\n",
    "\n",
    "def refine_seg(seg):\n",
    "    local_seg = copy.deepcopy(seg)\n",
    "    local_seg[local_seg == 4] = 3\n",
    "    return local_seg\n",
    "\n",
    "\n",
    "seg = refine_seg(segmentation[:, :, ind])\n",
    "\n",
    "plt.figure()\n",
    "plt.imshow(flair_img[:, :, ind], cmap='gray')\n",
    "plot_segmentation(seg)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "import SimpleITK as sitk\n",
    "from radiomics import featureextractor\n",
    "\n",
    "\n",
    "def radiomics_extractor(img, msk):\n",
    "    print(img.shape)\n",
    "    img = img.transpose(2, 0, 1)\n",
    "    print(img.shape)\n",
    "    msk = msk.transpose(2, 0, 1)\n",
    "    img_sitk = sitk.GetImageFromArray(img)\n",
    "    print(img_sitk.GetSize())\n",
    "    msk_sitk = sitk.GetImageFromArray(msk)\n",
    "    print(msk_sitk.GetSize())\n",
    "\n",
    "    extractor = featureextractor.RadiomicsFeatureExtractor()\n",
    "\n",
    "    featureVector = extractor.execute(img_sitk, msk_sitk)\n",
    "\n",
    "    return featureVector\n",
    "\n",
    "\n",
    "seg = seg_to_binary(segmentation)\n",
    "radiomics = radiomics_extractor(flair_img, seg)\n",
    "\n",
    "print(type(radiomics))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "print(len(radiomics.keys()))\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Extracting full set of radiomics\n",
    "def radiomics_extractor(img, msk):\n",
    "    img = img.transpose(2, 0, 1)\n",
    "    msk = msk.transpose(2, 0, 1)\n",
    "    img_sitk = sitk.GetImageFromArray(img)\n",
    "    msk_sitk = sitk.GetImageFromArray(msk)\n",
    "\n",
    "    extractor = featureextractor.RadiomicsFeatureExtractor()\n",
    "    extractor.enableAllImageTypes()\n",
    "    extractor.enableAllFeatures()\n",
    "\n",
    "    featureVector = extractor.execute(img_sitk, msk_sitk)\n",
    "\n",
    "    return featureVector\n",
    "\n",
    "\n",
    "seg = seg_to_binary(segmentation)\n",
    "radiomics = radiomics_extractor(flair_img, seg)\n",
    "\n",
    "print(type(radiomics))\n",
    "print(len(radiomics.keys()))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "from IPython.display import clear_output\n",
    "\n",
    "radiomics_results = []\n",
    "for each_patient in data.keys():\n",
    "    print(f\"Computing features for {each_patient}...\")\n",
    "    mri_data = data[each_patient]\n",
    "    flair_img = mri_data[0]\n",
    "    seg = seg_to_binary(mri_data[1])\n",
    "    radiomics = radiomics_extractor(flair_img, seg)\n",
    "    updict = {\"id\": each_patient}\n",
    "    updict.update(radiomics)\n",
    "    radiomics_results.append(updict)\n",
    "    clear_output(wait=True)\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Saving the results"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "import os\n",
    "import LTRI_Funcs as LTRIf\n",
    "\n",
    "LTRIf.list_of_dict_to_csv(radiomics_results, r\"C:\\Users\\Justin\\Documents\\Data\\radiomics_features_07-18-22.csv\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Computing features for 319...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "parameter force2D must be set to True to enable shape2D extraction\n",
      "GLCM is symmetrical, therefore Sum Average = 2 * Joint Average, only 1 needs to be calculated\n",
      "GLCM is symmetrical, therefore Sum Average = 2 * Joint Average, only 1 needs to be calculated\n",
      "GLCM is symmetrical, therefore Sum Average = 2 * Joint Average, only 1 needs to be calculated\n",
      "Could not load required package \"skimage\", cannot implement filter LBP 2D\n",
      "Could not load required package \"scipy\" or \"trimesh\", cannot implement filter LBP 3D\n",
      "GLCM is symmetrical, therefore Sum Average = 2 * Joint Average, only 1 needs to be calculated\n",
      "GLCM is symmetrical, therefore Sum Average = 2 * Joint Average, only 1 needs to be calculated\n",
      "GLCM is symmetrical, therefore Sum Average = 2 * Joint Average, only 1 needs to be calculated\n",
      "GLCM is symmetrical, therefore Sum Average = 2 * Joint Average, only 1 needs to be calculated\n",
      "GLCM is symmetrical, therefore Sum Average = 2 * Joint Average, only 1 needs to be calculated\n",
      "GLCM is symmetrical, therefore Sum Average = 2 * Joint Average, only 1 needs to be calculated\n",
      "GLCM is symmetrical, therefore Sum Average = 2 * Joint Average, only 1 needs to be calculated\n",
      "GLCM is symmetrical, therefore Sum Average = 2 * Joint Average, only 1 needs to be calculated\n",
      "GLCM is symmetrical, therefore Sum Average = 2 * Joint Average, only 1 needs to be calculated\n",
      "GLCM is symmetrical, therefore Sum Average = 2 * Joint Average, only 1 needs to be calculated\n",
      "GLCM is symmetrical, therefore Sum Average = 2 * Joint Average, only 1 needs to be calculated\n"
     ]
    }
   ],
   "source": [
    "from IPython.display import clear_output\n",
    "\n",
    "radiomics_results = []\n",
    "for each_patient in data.keys():\n",
    "    print(f\"Computing features for {each_patient}...\")\n",
    "    mri_data = data[each_patient]\n",
    "    flair_img = mri_data[0]\n",
    "    seg = seg_to_binary(mri_data[1])\n",
    "    radiomics = radiomics_extractor(flair_img, seg)\n",
    "    updict = {\"id\": each_patient}\n",
    "    updict.update(radiomics)\n",
    "    radiomics_results.append(updict)\n",
    "    clear_output(wait=True)\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Saving the results"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "outputs": [],
   "source": [
    "import os\n",
    "import LTRI_Funcs as LTRIf\n",
    "\n",
    "LTRIf.list_of_dict_to_csv(radiomics_results, r\"C:\\Users\\Justin\\Documents\\Data\\radiomics_features_07-18-22.csv\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Computing features for 319...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "parameter force2D must be set to True to enable shape2D extraction\n",
      "GLCM is symmetrical, therefore Sum Average = 2 * Joint Average, only 1 needs to be calculated\n",
      "GLCM is symmetrical, therefore Sum Average = 2 * Joint Average, only 1 needs to be calculated\n",
      "GLCM is symmetrical, therefore Sum Average = 2 * Joint Average, only 1 needs to be calculated\n",
      "Could not load required package \"skimage\", cannot implement filter LBP 2D\n",
      "Could not load required package \"scipy\" or \"trimesh\", cannot implement filter LBP 3D\n",
      "GLCM is symmetrical, therefore Sum Average = 2 * Joint Average, only 1 needs to be calculated\n",
      "GLCM is symmetrical, therefore Sum Average = 2 * Joint Average, only 1 needs to be calculated\n",
      "GLCM is symmetrical, therefore Sum Average = 2 * Joint Average, only 1 needs to be calculated\n",
      "GLCM is symmetrical, therefore Sum Average = 2 * Joint Average, only 1 needs to be calculated\n",
      "GLCM is symmetrical, therefore Sum Average = 2 * Joint Average, only 1 needs to be calculated\n",
      "GLCM is symmetrical, therefore Sum Average = 2 * Joint Average, only 1 needs to be calculated\n",
      "GLCM is symmetrical, therefore Sum Average = 2 * Joint Average, only 1 needs to be calculated\n",
      "GLCM is symmetrical, therefore Sum Average = 2 * Joint Average, only 1 needs to be calculated\n",
      "GLCM is symmetrical, therefore Sum Average = 2 * Joint Average, only 1 needs to be calculated\n",
      "GLCM is symmetrical, therefore Sum Average = 2 * Joint Average, only 1 needs to be calculated\n",
      "GLCM is symmetrical, therefore Sum Average = 2 * Joint Average, only 1 needs to be calculated\n"
     ]
    }
   ],
   "source": [
    "from IPython.display import clear_output\n",
    "\n",
    "radiomics_results = []\n",
    "for each_patient in data.keys():\n",
    "    print(f\"Computing features for {each_patient}...\")\n",
    "    mri_data = data[each_patient]\n",
    "    flair_img = mri_data[0]\n",
    "    seg = seg_to_binary(mri_data[1])\n",
    "    radiomics = radiomics_extractor(flair_img, seg)\n",
    "    updict = {\"id\": each_patient}\n",
    "    updict.update(radiomics)\n",
    "    radiomics_results.append(updict)\n",
    "    clear_output(wait=True)\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Saving the results"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "outputs": [],
   "source": [
    "import os\n",
    "import LTRI_Funcs as LTRIf\n",
    "\n",
    "LTRIf.list_of_dict_to_csv(radiomics_results, r\"C:\\Users\\Justin\\Documents\\Data\\radiomics_features_07-18-22.csv\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "outputs": [
    {
     "data": {
      "text/plain": "'K:\\\\Projects\\\\SickKids_Brain_Preprocessing\\\\preprocessed_all_seq_kk_july_2022'"
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import clear_output\n",
    "\n",
    "radiomics_results = []\n",
    "for each_patient in data.keys():\n",
    "    print(f\"Computing features for {each_patient}...\")\n",
    "    mri_data = data[each_patient]\n",
    "    flair_img = mri_data[0]\n",
    "    seg = seg_to_binary(mri_data[1])\n",
    "    radiomics = radiomics_extractor(flair_img, seg)\n",
    "    updict = {\"id\": each_patient}\n",
    "    updict.update(radiomics)\n",
    "    radiomics_results.append(updict)\n",
    "    clear_output(wait=True)\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "sxHLlgddM-Id",
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Saving the results"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Hh-MW7ghNWuG",
    "outputId": "57454412-28ca-4dbe-c528-9522c108d6af",
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "source": [
    "import os\n",
    "import LTRI_Funcs as LTRIf\n",
    "\n",
    "LTRIf.list_of_dict_to_csv(radiomics_results, r\"C:\\Users\\Justin\\Documents\\Data\\radiomics_features_07-18-22.csv\")"
   ],
   "execution_count": 209,
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "outputs": [
    {
     "data": {
      "text/plain": "'K:\\\\Projects\\\\SickKids_Brain_Preprocessing\\\\preprocessed_FLAIR_from_tumor_seg_dir'"
     },
     "execution_count": 210,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.getcwd()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  }
 ]
}