"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "from utils import visualize_data2\n",
+ "from pathlib import Path\n",
+ "\n",
+ "# paths to example files\n",
+ "t1c_path = Path(\n",
+ " f\"{BASE_PATH}/data/OtherEXampleFromTCIA/OtherEXampleFromTCIA_brainles/raw_bet/OtherEXampleFromTCIA_t1c_bet.nii.gz\"\n",
+ ")\n",
+ "t1_path = Path(\n",
+ " f\"{BASE_PATH}/data/OtherEXampleFromTCIA/OtherEXampleFromTCIA_brainles/raw_bet/OtherEXampleFromTCIA_t1_bet.nii.gz\"\n",
+ ")\n",
+ "t2_path = Path(\n",
+ " f\"{BASE_PATH}/data/OtherEXampleFromTCIA/OtherEXampleFromTCIA_brainles/raw_bet/OtherEXampleFromTCIA_t2_bet.nii.gz\"\n",
+ ")\n",
+ "flair_path = Path(\n",
+ " f\"{BASE_PATH}/data/OtherEXampleFromTCIA/OtherEXampleFromTCIA_brainles/raw_bet/OtherEXampleFromTCIA_fla_bet.nii.gz\"\n",
+ ")\n",
+ "# visualize example images\n",
+ "visualize_data2(t1c_path, t1_path, t2_path, flair_path, height_p=0.60)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "---"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 4. Segmentation with BraTS Toolkit\n",
+ "\n",
+ "Now that we have preprocessed the data, we can start segmenting the data with BraTS Toolkit.\n",
+ "\n",
+ "#### Therefore, we again define a function to segment our files:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from brats_toolkit.segmentor import Segmentor\n",
+ "import os\n",
+ "from auxiliary.turbopath import turbopath\n",
+ "from tqdm import tqdm\n",
+ "\n",
+ "\n",
+ "def segment_exam(\n",
+ " t1_file: str,\n",
+ " t1c_file: str,\n",
+ " t2_file: str,\n",
+ " fla_file: str,\n",
+ " segmentation_file: str,\n",
+ " cid: str,\n",
+ " cuda_device=\"0\",\n",
+ ") -> None:\n",
+ " \"\"\"\n",
+ " segment_exam - Segments MRI images using a specified algorithm from the BRATS toolkit.\n",
+ "\n",
+ " Parameters:\n",
+ " t1_file (str): Path to the T1-weighted MRI image file.\n",
+ " t1c_file (str): Path to the T1-weighted contrast-enhanced MRI image file.\n",
+ " t2_file (str): Path to the T2-weighted MRI image file.\n",
+ " fla_file (str): Path to the Fluid-attenuated inversion recovery (FLAIR) MRI image file.\n",
+ " segmentation_file (str): Path to the output file where the segmented image will be saved.\n",
+ " cid (str): Algorithm identifier for segmentation.\n",
+ " cuda_device (str, optional): CUDA device ID for GPU acceleration. Default is \"0\".\n",
+ "\n",
+ " Returns:\n",
+ " None\n",
+ "\n",
+ " Example:\n",
+ " segment_exam(\n",
+ " t1_file='/path/to/t1.nii.gz',\n",
+ " t1c_file='/path/to/t1c.nii.gz',\n",
+ " t2_file='/path/to/t2.nii.gz',\n",
+ " fla_file='/path/to/fla.nii.gz',\n",
+ " segmentation_file='/path/to/segmentation_result.nii.gz',\n",
+ " cid=\"mic-dkfz\"\n",
+ " )\n",
+ "\n",
+ " This function segments MRI images using the specified algorithm from the BRATS toolkit. It accepts paths to T1-weighted,\n",
+ " T1-weighted contrast-enhanced, T2-weighted, and FLAIR MRI images, and performs segmentation using the specified algorithm.\n",
+ " The segmented image is saved in the specified output file.\n",
+ "\n",
+ " Note:\n",
+ " - The function uses the BRATS toolkit's Segmentor for segmentation.\n",
+ " - The 'cid' parameter specifies the algorithm to use.\n",
+ " - Segmentation results are saved with a file name corresponding to the algorithm identifier (cid).\n",
+ " - Errors during segmentation are caught, and an error message is printed.\n",
+ " \"\"\"\n",
+ "\n",
+ " # instantiate\n",
+ " seg = Segmentor(\n",
+ " verbose=True,\n",
+ " gpu=cuda_device,\n",
+ " )\n",
+ "\n",
+ " # algorithms we want to select for segmentation\n",
+ "\n",
+ " # execute it\n",
+ " if not os.path.exists(segmentation_file):\n",
+ " seg.segment(\n",
+ " t1=t1_file,\n",
+ " t2=t2_file,\n",
+ " t1c=t1c_file,\n",
+ " fla=fla_file,\n",
+ " cid=cid,\n",
+ " outputPath=segmentation_file,\n",
+ " )\n",
+ " else:\n",
+ " print(segmentation_file, \"already exists\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Now we again loop through our exams:\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Exams: 0%| | 0/2 [00:00──────────────────────────────────────── Thank you for using BraTS Toolkit ──────────────────────────────────────── \n",
+ "\n"
+ ],
+ "text/plain": [
+ "\u001b[92m──────────────────────────────────────── \u001b[0mThank you for using \u001b[1mBraTS Toolkit\u001b[0m\u001b[92m ────────────────────────────────────────\u001b[0m\n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ " Please support our development by citing BraTS Toolkit and the papers of the segmentation algorithms you use: \n",
+ " \n"
+ ],
+ "text/plain": [
+ " Please support our development by citing BraTS Toolkit and the papers of the segmentation algorithms you use: \n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ " https://github.com/neuronflow/BraTS-Toolkit#citation -- Thank you! \n",
+ " \n"
+ ],
+ "text/plain": [
+ " \u001b[4;94mhttps://github.com/neuronflow/BraTS-Toolkit#citation\u001b[0m -- Thank you! \n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ "─────────────────────────────────────────────────────────────────────────────────────────────────────────────────── \n",
+ "\n",
+ " \n"
+ ],
+ "text/plain": [
+ "\n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "/home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/TCGA-DU-7294/TCGA-DU-7294_brainles/segmentation/isen-20.nii.gz already exists\n",
+ "segmenting: /home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/TCGA-DU-7294 with algorithm: hnfnetv1-20\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "──────────────────────────────────────── Thank you for using BraTS Toolkit ──────────────────────────────────────── \n",
+ " Please support our development by citing BraTS Toolkit and the papers of the segmentation algorithms you use: \n",
+ " \n"
+ ],
+ "text/plain": [
+ " Please support our development by citing BraTS Toolkit and the papers of the segmentation algorithms you use: \n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ " https://github.com/neuronflow/BraTS-Toolkit#citation -- Thank you! \n",
+ " \n"
+ ],
+ "text/plain": [
+ " \u001b[4;94mhttps://github.com/neuronflow/BraTS-Toolkit#citation\u001b[0m -- Thank you! \n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ "─────────────────────────────────────────────────────────────────────────────────────────────────────────────────── \n",
+ "\n",
+ " \n"
+ ],
+ "text/plain": [
+ "\n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "/home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/TCGA-DU-7294/TCGA-DU-7294_brainles/segmentation/hnfnetv1-20.nii.gz already exists\n",
+ "segmenting: /home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/TCGA-DU-7294 with algorithm: yixinmpl-20\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "──────────────────────────────────────── Thank you for using BraTS Toolkit ──────────────────────────────────────── \n",
+ " Please support our development by citing BraTS Toolkit and the papers of the segmentation algorithms you use: \n",
+ " \n"
+ ],
+ "text/plain": [
+ " Please support our development by citing BraTS Toolkit and the papers of the segmentation algorithms you use: \n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ " https://github.com/neuronflow/BraTS-Toolkit#citation -- Thank you! \n",
+ " \n"
+ ],
+ "text/plain": [
+ " \u001b[4;94mhttps://github.com/neuronflow/BraTS-Toolkit#citation\u001b[0m -- Thank you! \n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ "─────────────────────────────────────────────────────────────────────────────────────────────────────────────────── \n",
+ "\n",
+ " \n"
+ ],
+ "text/plain": [
+ "\n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "/home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/TCGA-DU-7294/TCGA-DU-7294_brainles/segmentation/yixinmpl-20.nii.gz already exists\n",
+ "segmenting: /home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/TCGA-DU-7294 with algorithm: sanet0-20\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "──────────────────────────────────────── Thank you for using BraTS Toolkit ──────────────────────────────────────── \n",
+ " Please support our development by citing BraTS Toolkit and the papers of the segmentation algorithms you use: \n",
+ " \n"
+ ],
+ "text/plain": [
+ " Please support our development by citing BraTS Toolkit and the papers of the segmentation algorithms you use: \n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ " https://github.com/neuronflow/BraTS-Toolkit#citation -- Thank you! \n",
+ " \n"
+ ],
+ "text/plain": [
+ " \u001b[4;94mhttps://github.com/neuronflow/BraTS-Toolkit#citation\u001b[0m -- Thank you! \n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ "─────────────────────────────────────────────────────────────────────────────────────────────────────────────────── \n",
+ "\n",
+ " \n"
+ ],
+ "text/plain": [
+ "\n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "/home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/TCGA-DU-7294/TCGA-DU-7294_brainles/segmentation/sanet0-20.nii.gz already exists\n",
+ "segmenting: /home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/TCGA-DU-7294 with algorithm: scan-20\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "──────────────────────────────────────── Thank you for using BraTS Toolkit ──────────────────────────────────────── \n",
+ " Please support our development by citing BraTS Toolkit and the papers of the segmentation algorithms you use: \n",
+ " \n"
+ ],
+ "text/plain": [
+ " Please support our development by citing BraTS Toolkit and the papers of the segmentation algorithms you use: \n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ " https://github.com/neuronflow/BraTS-Toolkit#citation -- Thank you! \n",
+ " \n"
+ ],
+ "text/plain": [
+ " \u001b[4;94mhttps://github.com/neuronflow/BraTS-Toolkit#citation\u001b[0m -- Thank you! \n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ "─────────────────────────────────────────────────────────────────────────────────────────────────────────────────── \n",
+ "\n",
+ " \n"
+ ],
+ "text/plain": [
+ "\n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ " \u001b[A"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "/home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/TCGA-DU-7294/TCGA-DU-7294_brainles/segmentation/scan-20.nii.gz already exists\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "Algorithms: 0%| | 0/5 [00:00──────────────────────────────────────── Thank you for using BraTS Toolkit ──────────────────────────────────────── \n",
+ "\n"
+ ],
+ "text/plain": [
+ "\u001b[92m──────────────────────────────────────── \u001b[0mThank you for using \u001b[1mBraTS Toolkit\u001b[0m\u001b[92m ────────────────────────────────────────\u001b[0m\n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ " Please support our development by citing BraTS Toolkit and the papers of the segmentation algorithms you use: \n",
+ " \n"
+ ],
+ "text/plain": [
+ " Please support our development by citing BraTS Toolkit and the papers of the segmentation algorithms you use: \n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ " https://github.com/neuronflow/BraTS-Toolkit#citation -- Thank you! \n",
+ " \n"
+ ],
+ "text/plain": [
+ " \u001b[4;94mhttps://github.com/neuronflow/BraTS-Toolkit#citation\u001b[0m -- Thank you! \n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ "─────────────────────────────────────────────────────────────────────────────────────────────────────────────────── \n",
+ "\n",
+ " \n"
+ ],
+ "text/plain": [
+ "\n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "/home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/OtherEXampleFromTCIA/OtherEXampleFromTCIA_brainles/segmentation/isen-20.nii.gz already exists\n",
+ "segmenting: /home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/OtherEXampleFromTCIA with algorithm: hnfnetv1-20\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "──────────────────────────────────────── Thank you for using BraTS Toolkit ──────────────────────────────────────── \n",
+ " Please support our development by citing BraTS Toolkit and the papers of the segmentation algorithms you use: \n",
+ " \n"
+ ],
+ "text/plain": [
+ " Please support our development by citing BraTS Toolkit and the papers of the segmentation algorithms you use: \n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ " https://github.com/neuronflow/BraTS-Toolkit#citation -- Thank you! \n",
+ " \n"
+ ],
+ "text/plain": [
+ " \u001b[4;94mhttps://github.com/neuronflow/BraTS-Toolkit#citation\u001b[0m -- Thank you! \n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ "─────────────────────────────────────────────────────────────────────────────────────────────────────────────────── \n",
+ "\n",
+ " \n"
+ ],
+ "text/plain": [
+ "\n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "/home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/OtherEXampleFromTCIA/OtherEXampleFromTCIA_brainles/segmentation/hnfnetv1-20.nii.gz already exists\n",
+ "segmenting: /home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/OtherEXampleFromTCIA with algorithm: yixinmpl-20\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "──────────────────────────────────────── Thank you for using BraTS Toolkit ──────────────────────────────────────── \n",
+ " Please support our development by citing BraTS Toolkit and the papers of the segmentation algorithms you use: \n",
+ " \n"
+ ],
+ "text/plain": [
+ " Please support our development by citing BraTS Toolkit and the papers of the segmentation algorithms you use: \n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ " https://github.com/neuronflow/BraTS-Toolkit#citation -- Thank you! \n",
+ " \n"
+ ],
+ "text/plain": [
+ " \u001b[4;94mhttps://github.com/neuronflow/BraTS-Toolkit#citation\u001b[0m -- Thank you! \n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ "─────────────────────────────────────────────────────────────────────────────────────────────────────────────────── \n",
+ "\n",
+ " \n"
+ ],
+ "text/plain": [
+ "\n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "/home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/OtherEXampleFromTCIA/OtherEXampleFromTCIA_brainles/segmentation/yixinmpl-20.nii.gz already exists\n",
+ "segmenting: /home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/OtherEXampleFromTCIA with algorithm: sanet0-20\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "──────────────────────────────────────── Thank you for using BraTS Toolkit ──────────────────────────────────────── \n",
+ " Please support our development by citing BraTS Toolkit and the papers of the segmentation algorithms you use: \n",
+ " \n"
+ ],
+ "text/plain": [
+ " Please support our development by citing BraTS Toolkit and the papers of the segmentation algorithms you use: \n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ " https://github.com/neuronflow/BraTS-Toolkit#citation -- Thank you! \n",
+ " \n"
+ ],
+ "text/plain": [
+ " \u001b[4;94mhttps://github.com/neuronflow/BraTS-Toolkit#citation\u001b[0m -- Thank you! \n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ "─────────────────────────────────────────────────────────────────────────────────────────────────────────────────── \n",
+ "\n",
+ " \n"
+ ],
+ "text/plain": [
+ "\n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "/home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/OtherEXampleFromTCIA/OtherEXampleFromTCIA_brainles/segmentation/sanet0-20.nii.gz already exists\n",
+ "segmenting: /home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/OtherEXampleFromTCIA with algorithm: scan-20\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "──────────────────────────────────────── Thank you for using BraTS Toolkit ──────────────────────────────────────── \n",
+ " Please support our development by citing BraTS Toolkit and the papers of the segmentation algorithms you use: \n",
+ " \n"
+ ],
+ "text/plain": [
+ " Please support our development by citing BraTS Toolkit and the papers of the segmentation algorithms you use: \n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ " https://github.com/neuronflow/BraTS-Toolkit#citation -- Thank you! \n",
+ " \n"
+ ],
+ "text/plain": [
+ " \u001b[4;94mhttps://github.com/neuronflow/BraTS-Toolkit#citation\u001b[0m -- Thank you! \n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ "─────────────────────────────────────────────────────────────────────────────────────────────────────────────────── \n",
+ "\n",
+ " \n"
+ ],
+ "text/plain": [
+ "\n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "Exams: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████| 2/2 [00:00<00:00, 29.71it/s]\u001b[A"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "/home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/OtherEXampleFromTCIA/OtherEXampleFromTCIA_brainles/segmentation/scan-20.nii.gz already exists\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "EXAMPLE_DATA_DIR = turbopath(f\"{BASE_PATH}/data\")\n",
+ "\n",
+ "exams = EXAMPLE_DATA_DIR.dirs()\n",
+ "# we use these five algorithms to segment the images\n",
+ "# 2019 algorithms\n",
+ "# cids = [\"mic-dkfz\", \"scan\", \"xfeng\", \"lfb_rwth\", \"zyx_2019\", \"scan_2019\"]\n",
+ "\n",
+ "# 2020 algorithms\n",
+ "cids = [\"isen-20\", \"hnfnetv1-20\", \"yixinmpl-20\", \"sanet0-20\", \"scan-20\"]\n",
+ "\n",
+ "\n",
+ "for exam in tqdm(exams, desc=\"Exams\"):\n",
+ " for cid in tqdm(cids, desc=\"Algorithms\", leave=False):\n",
+ " print(\"segmenting:\", exam, \"with algorithm:\", cid)\n",
+ " brainles_folder = exam / exam.name + \"_brainles\"\n",
+ " preprocessed_folder = brainles_folder / \"raw_bet\"\n",
+ " segmentation_folder = brainles_folder / \"segmentation\"\n",
+ "\n",
+ " segmentation_file = segmentation_folder / cid + \".nii.gz\"\n",
+ "\n",
+ " segment_exam(\n",
+ " t1_file=preprocessed_folder / exam.name + \"_t1_bet.nii.gz\",\n",
+ " t1c_file=preprocessed_folder / exam.name + \"_t1c_bet.nii.gz\",\n",
+ " t2_file=preprocessed_folder / exam.name + \"_t2_bet.nii.gz\",\n",
+ " fla_file=preprocessed_folder / exam.name + \"_fla_bet.nii.gz\",\n",
+ " segmentation_file=segmentation_file,\n",
+ " cid=cid,\n",
+ " cuda_device=\"0\",\n",
+ " ),"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### The segementations are stored in folder \"segmentation\" \n",
+ "```data//_brainles```\n",
+ "\n",
+ "Segmentation results are saved with a file name corresponding to the algorithm identifier (cid).\n",
+ "\n",
+ "Algorithms used in this notebook:\n",
+ "- yixinmpl-20\n",
+ "- isen-20\n",
+ "- hnfnetv1-20\n",
+ "- scan-20\n",
+ "- sanet0-20\n",
+ " \n",
+ "For more details on the algorithms (docker images) see the [publication table of the BraTS toolkit](https://github.com/neuronflow/BraTS-Toolkit/tree/main?tab=readme-ov-file#citation)\n",
+ "\n",
+ "---"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 5. Fusion\n",
+ "\n",
+ "#### Now we can fuse the generated segmentations together. Therefore we again define a function to process our exams:\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from brats_toolkit.fusionator import Fusionator\n",
+ "\n",
+ "\n",
+ "def fuse_segmentation_exam(\n",
+ " segmentation_folder: str,\n",
+ " fusion_folder: str,\n",
+ "):\n",
+ " \"\"\"\n",
+ " Fuse multiple segmentations using different methods and save the results.\n",
+ "\n",
+ " Parameters:\n",
+ " - segmentation_folder (str): Path to the folder containing segmentation files in NIfTI format (*.nii.gz).\n",
+ " - fusion_folder (str): Path to the folder where fused segmentation results will be saved.\n",
+ "\n",
+ " Returns:\n",
+ " None\n",
+ "\n",
+ " Example:\n",
+ " ```python\n",
+ " fuse_segmentation_exam(\"/path/to/segmentations\", \"/path/to/fusion_results\")\n",
+ " ```\n",
+ "\n",
+ " This function uses the Fusionator class from the brats_toolkit to fuse segmentations using two different methods:\n",
+ " 1. Multimodal Average (MAV) method.\n",
+ " 2. Simple fusion method.\n",
+ "\n",
+ " The fused segmentations are saved in the specified `fusion_folder` with file names \"mav.nii.gz\" and \"simple.nii.gz\".\n",
+ "\n",
+ " Note:\n",
+ " - The Fusionator class must be available and correctly imported from the brats_toolkit.\n",
+ " - The segmentation files in the `segmentation_folder` should be in NIfTI format (*.nii.gz).\n",
+ "\n",
+ " Args:\n",
+ " - segmentation_folder (str): Path to the folder containing segmentation files in NIfTI format (*.nii.gz).\n",
+ " - fusion_folder (str): Path to the folder where fused segmentation results will be saved.\n",
+ " \"\"\"\n",
+ " # instantiate\n",
+ " fus = Fusionator(verbose=True)\n",
+ "\n",
+ " # segmentation file paths\n",
+ " segmentations = segmentation_folder.files(\"*.nii.gz\")\n",
+ "\n",
+ " # execution\n",
+ " # mav\n",
+ " mavPath = fusion_folder / \"mav.nii.gz\"\n",
+ " fus.fuse(\n",
+ " segmentations=segmentations,\n",
+ " outputPath=mavPath,\n",
+ " method=\"mav\",\n",
+ " weights=None,\n",
+ " )\n",
+ "\n",
+ " # simple\n",
+ " simplePath = fusion_folder / \"simple.nii.gz\"\n",
+ " fus.fuse(\n",
+ " segmentations=segmentations,\n",
+ " outputPath=simplePath,\n",
+ " method=\"simple\",\n",
+ " weights=None,\n",
+ " )"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "####Now we can again loop through our exams:\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "\r\n",
+ " 0%| | 0/2 [00:00──────────────────────────────────────── Thank you for using BraTS Toolkit ──────────────────────────────────────── \n",
+ "\n"
+ ],
+ "text/plain": [
+ "\u001b[92m──────────────────────────────────────── \u001b[0mThank you for using \u001b[1mBraTS Toolkit\u001b[0m\u001b[92m ────────────────────────────────────────\u001b[0m\n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ " Please support our development by citing BraTS Toolkit and the papers of the segmentation algorithms you use: \n",
+ " \n"
+ ],
+ "text/plain": [
+ " Please support our development by citing BraTS Toolkit and the papers of the segmentation algorithms you use: \n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ " https://github.com/neuronflow/BraTS-Toolkit#citation -- Thank you! \n",
+ " \n"
+ ],
+ "text/plain": [
+ " \u001b[4;94mhttps://github.com/neuronflow/BraTS-Toolkit#citation\u001b[0m -- Thank you! \n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ "─────────────────────────────────────────────────────────────────────────────────────────────────────────────────── \n",
+ "\n",
+ " \n"
+ ],
+ "text/plain": [
+ "\n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Loaded: /home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/TCGA-DU-7294/TCGA-DU-7294_brainles/segmentation/yixinmpl-20.nii.gz\n",
+ "Loaded: /home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/TCGA-DU-7294/TCGA-DU-7294_brainles/segmentation/isen-20.nii.gz\n",
+ "Loaded: /home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/TCGA-DU-7294/TCGA-DU-7294_brainles/segmentation/hnfnetv1-20.nii.gz\n",
+ "Loaded: /home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/TCGA-DU-7294/TCGA-DU-7294_brainles/segmentation/scan-20.nii.gz\n",
+ "Loaded: /home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/TCGA-DU-7294/TCGA-DU-7294_brainles/segmentation/sanet0-20.nii.gz\n",
+ "Orchestra: Now fusing all passed .nii.gz files using MAJORITY VOTING. For more output, set the -v or --verbose flag or instantiate the fusionator class with verbose=true\n",
+ "Number of segmentations to be fused using compound majority vote is: 5\n",
+ "Labels of current candidate: [0 1 2], dtype: uint8\n",
+ "Labels of current candidate: [0 1 2], dtype: uint8\n",
+ "Labels of current candidate: [0 1 2 4], dtype: uint8\n",
+ "Labels of current candidate: [0 1 2], dtype: uint8\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "WARNING:root:No labels passed, choosing those labels automatically: [0 1 2 4]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Labels of current candidate: [0 1 2 4], dtype: uint8\n",
+ "Labels: [1 2 4]\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "5\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "5\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "5\n",
+ "Shape of result: (155, 240, 240)\n",
+ "Labels and datatype of result: 2.0 0.0 float64\n",
+ "Converting float64 to uint8 np.ndarray\n",
+ "Loaded: /home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/TCGA-DU-7294/TCGA-DU-7294_brainles/segmentation/yixinmpl-20.nii.gz\n",
+ "Loaded: /home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/TCGA-DU-7294/TCGA-DU-7294_brainles/segmentation/isen-20.nii.gz\n",
+ "Loaded: /home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/TCGA-DU-7294/TCGA-DU-7294_brainles/segmentation/hnfnetv1-20.nii.gz\n",
+ "Loaded: /home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/TCGA-DU-7294/TCGA-DU-7294_brainles/segmentation/scan-20.nii.gz\n",
+ "Loaded: /home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/TCGA-DU-7294/TCGA-DU-7294_brainles/segmentation/sanet0-20.nii.gz\n",
+ "Orchestra: Now fusing all passed .nii.gz files in using SIMPLE. For more output, set the -v or --verbose flag or instantiate the fusionator class with verbose=true\n",
+ "Number of segmentations to be fused using SIMPLE is: 5\n",
+ "Labels of current candidate: [0 1 2], dtype: uint8\n",
+ "Labels of current candidate: [0 1 2], dtype: uint8\n",
+ "Labels of current candidate: [0 1 2 4], dtype: uint8\n",
+ "Labels of current candidate: [0 1 2], dtype: uint8\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "WARNING:root:No labels passed, choosing those labels automatically: [0 1 2 4]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Labels of current candidate: [0 1 2 4], dtype: uint8\n",
+ "Currently fusing label 1\n",
+ "(155, 240, 240)\n",
+ "Number of segmentations to be fused using compound majority vote is: 5\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 9122\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 9180\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 10541\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 9115\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 9608\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "Shape of result: (155, 240, 240)\n",
+ "Shape of current input array: (155, 240, 240)\n",
+ "Labels and datatype of current output: 1.0 0.0 float64\n",
+ "Number of segmentations to be fused using compound majority vote is: 5\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 9122\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 9180\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 10541\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 9115\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 9608\n",
+ "weight is: 3.740271506862001\n",
+ "weight is: 3.8240892486370663\n",
+ "weight is: 3.637696953801965\n",
+ "weight is: 3.69218021577528\n",
+ "weight is: 3.8234751640007185\n",
+ "Shape of result: (155, 240, 240)\n",
+ "Shape of current input array: (155, 240, 240)\n",
+ "Labels and datatype of current output: 1.0 0.0 float64\n",
+ "Convergence for label 1 after 0 iterations reached.\n",
+ "Currently fusing label 2\n",
+ "(155, 240, 240)\n",
+ "Number of segmentations to be fused using compound majority vote is: 5\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 14547\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 14527\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 14450\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 15764\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 14593\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "Shape of result: (155, 240, 240)\n",
+ "Shape of current input array: (155, 240, 240)\n",
+ "Labels and datatype of current output: 1.0 0.0 float64\n",
+ "Number of segmentations to be fused using compound majority vote is: 5\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 14547\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 14527\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 14450\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 15764\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 14593\n",
+ "weight is: 3.752705851139802\n",
+ "weight is: 3.7886928242593774\n",
+ "weight is: 3.6542352407582173\n",
+ "weight is: 3.7032811775246737\n",
+ "weight is: 3.849843061189314\n",
+ "Shape of result: (155, 240, 240)\n",
+ "Shape of current input array: (155, 240, 240)\n",
+ "Labels and datatype of current output: 1.0 0.0 float64\n",
+ "Convergence for label 2 after 0 iterations reached.\n",
+ "Currently fusing label 4\n",
+ "(155, 240, 240)\n",
+ "Number of segmentations to be fused using compound majority vote is: 5\n",
+ "Candidate with shape (155, 240, 240) and values [0] and sum 0\n",
+ "Candidate with shape (155, 240, 240) and values [0] and sum 0\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 352\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "WARNING:root:The passed segmentation contains labels other than 1 and 0.\n",
+ "WARNING:root:The passed segmentation contains labels other than 1 and 0.\n",
+ "WARNING:root:The passed segmentation contains labels other than 1 and 0.\n",
+ "ERROR:root:Majority Voting in SIMPLE returned an empty array\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Candidate with shape (155, 240, 240) and values [0] and sum 0\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 279\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "Shape of result: (155, 240, 240)\n",
+ "Shape of current input array: (155, 240, 240)\n",
+ "Labels and datatype of current output: 0.0 0.0 float64\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/home/eva/.local/lib/python3.10/site-packages/brats_toolkit/fusionator.py:556: RuntimeWarning: invalid value encountered in scalar divide\n",
+ " FNR = FN / (FN + TP)\n",
+ "/home/eva/.local/lib/python3.10/site-packages/brats_toolkit/fusionator.py:557: RuntimeWarning: invalid value encountered in scalar divide\n",
+ " TPR = TP / (TP + FN)\n",
+ "/home/eva/.local/lib/python3.10/site-packages/brats_toolkit/fusionator.py:565: RuntimeWarning: invalid value encountered in scalar divide\n",
+ " score = 2 * TP / (2 * TP + FP + FN)\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Number of segmentations to be fused using compound majority vote is: 5\n",
+ "Candidate with shape (155, 240, 240) and values [0] and sum 0\n",
+ "Candidate with shape (155, 240, 240) and values [0] and sum 0\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "WARNING:root:The passed segmentation contains labels other than 1 and 0.\n",
+ "WARNING:root:The passed segmentation contains labels other than 1 and 0.\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 352\n",
+ "Candidate with shape (155, 240, 240) and values [0] and sum 0\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 279\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1.0\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "WARNING:root:The passed segmentation contains labels other than 1 and 0.\n",
+ " 50%|██████████████████████████████████████████████████████████ | 1/2 [00:06<00:06, 6.36s/it]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "weight is: 1\n",
+ "weight is: 1.0\n",
+ "Shape of result: (155, 240, 240)\n",
+ "Shape of current input array: (155, 240, 240)\n",
+ "Labels and datatype of current output: 0.0 0.0 float64\n",
+ "Convergence for label 4 after 0 iterations reached.\n",
+ "Shape of result: (155, 240, 240)\n",
+ "Shape of current input array: (155, 240, 240)\n",
+ "Labels and datatype of current output: 2.0 0.0 float64\n",
+ "Converting float64 to uint8 np.ndarray\n",
+ "segmenting: /home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/OtherEXampleFromTCIA\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "──────────────────────────────────────── Thank you for using BraTS Toolkit ──────────────────────────────────────── \n",
+ " Please support our development by citing BraTS Toolkit and the papers of the segmentation algorithms you use: \n",
+ " \n"
+ ],
+ "text/plain": [
+ " Please support our development by citing BraTS Toolkit and the papers of the segmentation algorithms you use: \n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ " https://github.com/neuronflow/BraTS-Toolkit#citation -- Thank you! \n",
+ " \n"
+ ],
+ "text/plain": [
+ " \u001b[4;94mhttps://github.com/neuronflow/BraTS-Toolkit#citation\u001b[0m -- Thank you! \n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ "─────────────────────────────────────────────────────────────────────────────────────────────────────────────────── \n",
+ "\n",
+ " \n"
+ ],
+ "text/plain": [
+ "\n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Loaded: /home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/OtherEXampleFromTCIA/OtherEXampleFromTCIA_brainles/segmentation/yixinmpl-20.nii.gz\n",
+ "Loaded: /home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/OtherEXampleFromTCIA/OtherEXampleFromTCIA_brainles/segmentation/isen-20.nii.gz\n",
+ "Loaded: /home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/OtherEXampleFromTCIA/OtherEXampleFromTCIA_brainles/segmentation/hnfnetv1-20.nii.gz\n",
+ "Loaded: /home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/OtherEXampleFromTCIA/OtherEXampleFromTCIA_brainles/segmentation/scan-20.nii.gz\n",
+ "Loaded: /home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/OtherEXampleFromTCIA/OtherEXampleFromTCIA_brainles/segmentation/sanet0-20.nii.gz\n",
+ "Orchestra: Now fusing all passed .nii.gz files using MAJORITY VOTING. For more output, set the -v or --verbose flag or instantiate the fusionator class with verbose=true\n",
+ "Number of segmentations to be fused using compound majority vote is: 5\n",
+ "Labels of current candidate: [0 1 2 4], dtype: uint8\n",
+ "Labels of current candidate: [0 1 2 4], dtype: uint8\n",
+ "Labels of current candidate: [0 1 2 4], dtype: uint8\n",
+ "Labels of current candidate: [0 1 2 4], dtype: uint8\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "WARNING:root:No labels passed, choosing those labels automatically: [0 1 2 4]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Labels of current candidate: [0 1 2 4], dtype: uint8\n",
+ "Labels: [1 2 4]\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "5\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "5\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "5\n",
+ "Shape of result: (155, 240, 240)\n",
+ "Labels and datatype of result: 4.0 0.0 float64\n",
+ "Converting float64 to uint8 np.ndarray\n",
+ "Loaded: /home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/OtherEXampleFromTCIA/OtherEXampleFromTCIA_brainles/segmentation/yixinmpl-20.nii.gz\n",
+ "Loaded: /home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/OtherEXampleFromTCIA/OtherEXampleFromTCIA_brainles/segmentation/isen-20.nii.gz\n",
+ "Loaded: /home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/OtherEXampleFromTCIA/OtherEXampleFromTCIA_brainles/segmentation/hnfnetv1-20.nii.gz\n",
+ "Loaded: /home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/OtherEXampleFromTCIA/OtherEXampleFromTCIA_brainles/segmentation/scan-20.nii.gz\n",
+ "Loaded: /home/eva/Schreibtisch/GitHub_repos/tutorials_branch/BraTS-Toolkit/data/OtherEXampleFromTCIA/OtherEXampleFromTCIA_brainles/segmentation/sanet0-20.nii.gz\n",
+ "Orchestra: Now fusing all passed .nii.gz files in using SIMPLE. For more output, set the -v or --verbose flag or instantiate the fusionator class with verbose=true\n",
+ "Number of segmentations to be fused using SIMPLE is: 5\n",
+ "Labels of current candidate: [0 1 2 4], dtype: uint8\n",
+ "Labels of current candidate: [0 1 2 4], dtype: uint8\n",
+ "Labels of current candidate: [0 1 2 4], dtype: uint8\n",
+ "Labels of current candidate: [0 1 2 4], dtype: uint8\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "WARNING:root:No labels passed, choosing those labels automatically: [0 1 2 4]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Labels of current candidate: [0 1 2 4], dtype: uint8\n",
+ "Currently fusing label 1\n",
+ "(155, 240, 240)\n",
+ "Number of segmentations to be fused using compound majority vote is: 5\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 1886\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 2155\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 3410\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 2867\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 3005\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "Shape of result: (155, 240, 240)\n",
+ "Shape of current input array: (155, 240, 240)\n",
+ "Labels and datatype of current output: 1.0 0.0 float64\n",
+ "Number of segmentations to be fused using compound majority vote is: 5\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 1886\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 2155\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 3410\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 2867\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 3005\n",
+ "weight is: 3.1511742446548916\n",
+ "weight is: 3.343718586032138\n",
+ "weight is: 3.258616779885049\n",
+ "weight is: 3.0533377014683207\n",
+ "weight is: 3.5990560996214467\n",
+ "Shape of result: (155, 240, 240)\n",
+ "Shape of current input array: (155, 240, 240)\n",
+ "Labels and datatype of current output: 1.0 0.0 float64\n",
+ "Convergence for label 1 after 0 iterations reached.\n",
+ "Currently fusing label 2\n",
+ "(155, 240, 240)\n",
+ "Number of segmentations to be fused using compound majority vote is: 5\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 24365\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 26045\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 19746\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 16958\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 19935\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "Shape of result: (155, 240, 240)\n",
+ "Shape of current input array: (155, 240, 240)\n",
+ "Labels and datatype of current output: 1.0 0.0 float64\n",
+ "Number of segmentations to be fused using compound majority vote is: 5\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 24365\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 26045\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 19746\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 16958\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 19935\n",
+ "weight is: 3.6451807045381535\n",
+ "weight is: 3.5102207691555116\n",
+ "weight is: 3.806188837471846\n",
+ "weight is: 3.4225978325341364\n",
+ "weight is: 3.861889228137042\n",
+ "Shape of result: (155, 240, 240)\n",
+ "Shape of current input array: (155, 240, 240)\n",
+ "Labels and datatype of current output: 1.0 0.0 float64\n",
+ "Convergence for label 2 after 0 iterations reached.\n",
+ "Currently fusing label 4\n",
+ "(155, 240, 240)\n",
+ "Number of segmentations to be fused using compound majority vote is: 5\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 7628\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 7605\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 6569\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 5909\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 6808\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "weight is: 1\n",
+ "Shape of result: (155, 240, 240)\n",
+ "Shape of current input array: (155, 240, 240)\n",
+ "Labels and datatype of current output: 1.0 0.0 float64\n",
+ "Number of segmentations to be fused using compound majority vote is: 5\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 7628\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 7605\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 6569\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 5909\n",
+ "Candidate with shape (155, 240, 240) and values [0 1] and sum 6808\n",
+ "weight is: 3.776505044184724\n",
+ "weight is: 3.7866546517920887\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 2/2 [00:12<00:00, 6.31s/it]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "weight is: 3.895390628501695\n",
+ "weight is: 3.7132313583169902\n",
+ "weight is: 3.9573242849181356\n",
+ "Shape of result: (155, 240, 240)\n",
+ "Shape of current input array: (155, 240, 240)\n",
+ "Labels and datatype of current output: 1.0 0.0 float64\n",
+ "Convergence for label 4 after 0 iterations reached.\n",
+ "Shape of result: (155, 240, 240)\n",
+ "Shape of current input array: (155, 240, 240)\n",
+ "Labels and datatype of current output: 4.0 0.0 float64\n",
+ "Converting float64 to uint8 np.ndarray\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "EXAMPLE_DATA_DIR = turbopath(\"data\")\n",
+ "\n",
+ "exams = EXAMPLE_DATA_DIR.dirs()\n",
+ "\n",
+ "for exam in tqdm(exams):\n",
+ " print(\"segmenting:\", exam)\n",
+ " brainles_folder = exam / exam.name + \"_brainles\"\n",
+ " segmentation_folder = brainles_folder / \"segmentation\"\n",
+ " fusion_folder = brainles_folder / \"fusion\"\n",
+ "\n",
+ " fuse_segmentation_exam(\n",
+ " segmentation_folder=segmentation_folder,\n",
+ " fusion_folder=fusion_folder,\n",
+ " )"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### The fused segementation is saved in the folder \"fusion\"\n",
+ "```BraTS-Toolkit/data//_brainles/fusion```\n",
+ "\n",
+ "Run the subsequent cell for visualizing one example sample (T1c with segementation).\n",
+ "\n",
+ "**The BraTS-Toolkit segementation comprise the GD-enhancing tumor (label 4), the peritumoral edematous tissue (label 2), and the necrotic tumor core (label 1).**\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "from utils import visualize_segmentation\n",
+ "\n",
+ "visualize_segmentation(\n",
+ " modality_file=\"data//OtherEXampleFromTCIA/OtherEXampleFromTCIA_brainles/raw_bet/OtherEXampleFromTCIA_t1c_bet.nii.gz\",\n",
+ " segmentation_file=\"data/OtherEXampleFromTCIA/OtherEXampleFromTCIA_brainles/fusion/simple.nii.gz\",\n",
+ " slice_p=0.63, # default is 0.5\n",
+ ")"
+ ]
+ },
+ {
+ "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.10.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/eReg/temporary_directory/.gitignore b/eReg/temporary_directory/.gitignore
new file mode 100644
index 0000000..d6b7ef3
--- /dev/null
+++ b/eReg/temporary_directory/.gitignore
@@ -0,0 +1,2 @@
+*
+!.gitignore
diff --git a/eReg/utils.py b/eReg/utils.py
new file mode 100644
index 0000000..cb78729
--- /dev/null
+++ b/eReg/utils.py
@@ -0,0 +1,72 @@
+import os
+import matplotlib.pyplot as plt
+import nibabel as nib
+from pathlib import Path
+
+
+def visualize_data2(t1c, t1, t2, flair, height_p=0.5): #
+ """Visualize the MRI modalities. This function is different from "visualize_data" in the following ways:
+ a) it expects the four file paths directly (no naming convention required)
+ b) it does not take a slice index but a percentage height (e.g. 0.5 = 50% = middle slice) as imputs may have different dimensions
+
+ Args:
+ height_p (float, optional): the percentage of slicing height. 0.5 means 50% means exactly in the middle of the cuboid
+ slice_index (int, optional): Slice to be visualized (first index in data of shape (155, 240, 240)). Defaults to 75.
+ """
+ _, axes = plt.subplots(1, 4, figsize=(12, 10))
+
+ for i, (mod, modality_file) in enumerate(
+ [("t1", t1), ("t1c", t1c), ("t2", t2), ("flair", flair)]
+ ):
+
+ data = nib.load(modality_file).get_fdata()
+ # Get the middle slice along the specified axis
+ slice_index = int(
+ data.shape[2] * height_p
+ ) # show slice that is exactly in the middle
+ slice_data = data[:, ::-1, slice_index].T
+
+ axes[i].set_title(mod)
+ axes[i].imshow(slice_data, cmap="gray")
+ axes[i].axis("off")
+
+
+DATA_FOLDER = "data"
+
+
+def visualize_data(data_folder: str = DATA_FOLDER, slice_index: int = 75):
+ """Visualize the MRI modalities for a given slice index
+
+ Args:
+ data_folder (str, optional): Path to the folder containing the t1, t1c, t2 & flair file. Defaults to DATA_FOLDER.
+ slice_index (int, optional): Slice to be visualized (first index in data of shape (155, 240, 240)). Defaults to 75.
+ """
+ _, axes = plt.subplots(1, 4, figsize=(12, 10))
+
+ modalities = ["t1", "t1c", "t2", "flair"]
+ for i, mod in enumerate(modalities):
+ modality_file = os.path.join(data_folder, f"{mod}.nii.gz")
+ modality_np = nib.load(modality_file).get_fdata().transpose(2, 1, 0)
+ axes[i].set_title(mod)
+ axes[i].imshow(modality_np[slice_index, :, :], cmap="gray")
+ axes[i].axis("off")
+
+
+def visualize_segmentation(modality_file: str, segmentation_file: str, slice_p=0.5):
+ """Visualize the MRI modality and the segmentation
+
+ Args:
+ modality_file (str): Path to the desired modality file
+ segmentation_file (str): Path to the segmentation file
+ """
+ modality_np = nib.load(modality_file).get_fdata().transpose(2, 1, 0)
+ seg_np = nib.load(segmentation_file).get_fdata().transpose(2, 1, 0)
+ _, ax = plt.subplots(1, 2, figsize=(8, 4))
+
+ slice_index = int(modality_np.shape[0] * slice_p) # You can choose any slice here
+ ax[0].imshow(modality_np[slice_index, :, :], cmap="gray")
+ ax[1].imshow(modality_np[slice_index, :, :], cmap="gray")
+ ax[1].imshow(seg_np[slice_index, :, :], cmap="plasma", alpha=0.5)
+ for ax in ax:
+ ax.axis("off")
+ plt.tight_layout()
![\"Open](\"https://colab.research.google.com/assets/colab-badge.svg\"){kind=icon}
\n",
+ "