Upload 2 files

demo.ipynb

@@ -0,0 +1,461 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# video 导入"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Usage of gradio.inputs is deprecated, and will not be supported in the future, please import your component from gradio.components\n",
+      "`optional` parameter is deprecated, and it has no effect\n",
+      "`keep_filename` parameter is deprecated, and it has no effect\n",
+      "The `allow_flagging` parameter in `Interface` nowtakes a string value ('auto', 'manual', or 'never'), not a boolean. Setting parameter to: 'never'.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running on local URL:  http://127.0.0.1:7865\n",
+      "\n",
+      "To create a public link, set `share=True` in `launch()`.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"http://127.0.0.1:7865/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "C:\\WINDOWS\\TEMP\\gradio\\6da74a6a81402070d14fdaec056ed2fd2ef5f186\\62691117.nii.gz\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Traceback (most recent call last):\n",
+      "  File \"d:\\anaconda3\\envs\\pytorch\\lib\\site-packages\\gradio\\routes.py\", line 439, in run_predict\n",
+      "    output = await app.get_blocks().process_api(\n",
+      "  File \"d:\\anaconda3\\envs\\pytorch\\lib\\site-packages\\gradio\\blocks.py\", line 1384, in process_api\n",
+      "    result = await self.call_function(\n",
+      "  File \"d:\\anaconda3\\envs\\pytorch\\lib\\site-packages\\gradio\\blocks.py\", line 1089, in call_function\n",
+      "    prediction = await anyio.to_thread.run_sync(\n",
+      "  File \"d:\\anaconda3\\envs\\pytorch\\lib\\site-packages\\anyio\\to_thread.py\", line 33, in run_sync\n",
+      "    return await get_asynclib().run_sync_in_worker_thread(\n",
+      "  File \"d:\\anaconda3\\envs\\pytorch\\lib\\site-packages\\anyio\\_backends\\_asyncio.py\", line 877, in run_sync_in_worker_thread\n",
+      "    return await future\n",
+      "  File \"d:\\anaconda3\\envs\\pytorch\\lib\\site-packages\\anyio\\_backends\\_asyncio.py\", line 807, in run\n",
+      "    result = context.run(func, *args)\n",
+      "  File \"d:\\anaconda3\\envs\\pytorch\\lib\\site-packages\\gradio\\utils.py\", line 700, in wrapper\n",
+      "    response = f(*args, **kwargs)\n",
+      "  File \"C:\\Windows\\Temp\\ipykernel_17604\\3933752410.py\", line 12, in process_nii_file\n",
+      "    model = UNETR(\n",
+      "  File \"d:\\anaconda3\\envs\\pytorch\\lib\\site-packages\\monai\\networks\\nets\\unetr.py\", line 93, in __init__\n",
+      "    self.vit = ViT(\n",
+      "  File \"d:\\anaconda3\\envs\\pytorch\\lib\\site-packages\\monai\\networks\\nets\\vit.py\", line 93, in __init__\n",
+      "    self.patch_embedding = PatchEmbeddingBlock(\n",
+      "  File \"d:\\anaconda3\\envs\\pytorch\\lib\\site-packages\\monai\\networks\\blocks\\patchembedding.py\", line 99, in __init__\n",
+      "    Rearrange(f\"{from_chars} -> {to_chars}\", **axes_len), nn.Linear(self.patch_dim, hidden_size)\n",
+      "  File \"d:\\anaconda3\\envs\\pytorch\\lib\\site-packages\\torch\\nn\\modules\\linear.py\", line 96, in __init__\n",
+      "    self.weight = Parameter(torch.empty((out_features, in_features), **factory_kwargs))\n",
+      "RuntimeError: [enforce fail at C:\\cb\\pytorch_1000000000000\\work\\c10\\core\\impl\\alloc_cpu.cpp:81] data. DefaultCPUAllocator: not enough memory: you tried to allocate 12582912 bytes.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import nibabel as nib\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import gradio as gr\n",
+    "from pathlib import Path\n",
+    "import torch\n",
+    "from monai.networks.nets import UNETR\n",
+    "import pytorch_lightning as pl\n",
+    "import tempfile\n",
+    "import base64\n",
+    "from celluloid import Camera\n",
+    "from IPython.display import HTML    \n",
+    "\n",
+    "def load_nifti(sample_path):\n",
+    "    print(sample_path)\n",
+    "    data = nib.load(sample_path).get_fdata()\n",
+    "    data = np.rot90(data, 3)\n",
+    "    return data\n",
+    "\n",
+    "def generate_animation(mri):\n",
+    "    fig = plt.figure()\n",
+    "    plt.axis('off')\n",
+    "    camera = Camera(fig)  # Create the camera object from celluloid\n",
+    "\n",
+    "    for i in range(mri.shape[2]):  # Sagital view\n",
+    "        plt.imshow(mri[:,:,i], cmap=\"bone\")\n",
+    "        camera.snap()  # Store the current slice\n",
+    "    \n",
+    "    animation = camera.animate(interval=200)\n",
+    "\n",
+    "    # Save the animation as a GIF file\n",
+    "    with tempfile.NamedTemporaryFile(suffix='.gif', delete=False) as temp_file:\n",
+    "        temp_filename = temp_file.name\n",
+    "        animation.save(temp_filename, writer='pillow', fps=3)\n",
+    "\n",
+    "    return temp_filename\n",
+    "\n",
+    "def predict_nifti(file):\n",
+    "    file_path = file.name\n",
+    "    # Load and process NIfTI file\n",
+    "    mri = load_nifti(file_path)\n",
+    "    \n",
+    "    # Generate animation and get the temporary file path\n",
+    "    animation_path = generate_animation(mri)\n",
+    "\n",
+    "    # Read the GIF file as bytes\n",
+    "    with open(animation_path, 'rb') as file:\n",
+    "        animation_bytes = file.read()\n",
+    "\n",
+    "    # Convert the bytes to base64 string\n",
+    "    animation_base64 = base64.b64encode(animation_bytes).decode('utf-8')\n",
+    "\n",
+    "    # Generate the HTML code to display the animation\n",
+    "    html_code = f'<img src=\"data:image/gif;base64,{animation_base64}\" alt=\"animation\">'\n",
+    "\n",
+    "    # Return the HTML code\n",
+    "    return html_code\n",
+    "\n",
+    "examples = [[r\"F:\\sth\\23Fall\\fcpro\\brain_image2\\imageTs\\60071979.nii.gz\"]]\n",
+    "# 创建 Gradio 用户界面\n",
+    "iface = gr.Interface(\n",
+    "    fn=predict_nifti,\n",
+    "    inputs=gr.inputs.File(label=\"上传MRI文件\", type=\"file\"),\n",
+    "    outputs=\"html\",\n",
+    "    title=\"NKU \",\n",
+    "    description=\"南开大学智齿辅助诊断系统\",\n",
+    "    allow_flagging=False,\n",
+    "    examples=examples\n",
+    ")\n",
+    "\n",
+    "iface.launch(share=False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 显示切片"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import shutil\n",
+    "import tempfile\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "from monai.losses import DiceCELoss\n",
+    "from monai.inferers import sliding_window_inference\n",
+    "from monai.transforms import (\n",
+    "    AsDiscrete,\n",
+    "    EnsureChannelFirstd,\n",
+    "    Compose,\n",
+    "    CropForegroundd,\n",
+    "    LoadImaged,\n",
+    "    Orientationd,\n",
+    "    RandFlipd,\n",
+    "    RandCropByPosNegLabeld,\n",
+    "    RandShiftIntensityd,\n",
+    "    ScaleIntensityRanged,\n",
+    "    Spacingd,\n",
+    "    SpatialPadd,\n",
+    "    RandRotate90d,\n",
+    "    CenterSpatialCropd,\n",
+    "    ResizeWithPadOrCropd,\n",
+    "    Flipd,\n",
+    "    Rotate90d,\n",
+    "    RandAffined,\n",
+    "    RandGaussianNoised,\n",
+    ")\n",
+    "\n",
+    "from monai.config import print_config\n",
+    "from monai.metrics import DiceMetric\n",
+    "from monai.networks.nets import UNETR\n",
+    "\n",
+    "from monai.data import (\n",
+    "    DataLoader,\n",
+    "    CacheDataset,\n",
+    "    load_decathlon_datalist,\n",
+    "    decollate_batch,\n",
+    "    pad_list_data_collate,\n",
+    "    SmartCacheDataset,\n",
+    "    ArrayDataset,\n",
+    "    Dataset\n",
+    ")\n",
+    "\n",
+    "import numpy as np\n",
+    "import torch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Usage of gradio.inputs is deprecated, and will not be supported in the future, please import your component from gradio.components\n",
+      "`optional` parameter is deprecated, and it has no effect\n",
+      "Expected 4 arguments for function <function process_nii_file at 0x000001E6090B2160>, received 3.\n",
+      "Expected at least 4 arguments for function <function process_nii_file at 0x000001E6090B2160>, received 3.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running on local URL:  http://127.0.0.1:7864\n",
+      "Running on public URL: https://69e978c9547c47c32b.gradio.live\n",
+      "\n",
+      "This share link expires in 72 hours. For free permanent hosting and GPU upgrades, run `gradio deploy` from Terminal to deploy to Spaces (https://huggingface.co/spaces)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"https://69e978c9547c47c32b.gradio.live\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import gradio as gr\n",
+    "import matplotlib.pyplot as plt\n",
+    "import torch\n",
+    "import nibabel as nib\n",
+    "import numpy as np\n",
+    "import SimpleITK as sitk\n",
+    "\n",
+    "def dcm2nii(dcms_path, nii_path):\n",
+    "\t# 1.构建dicom序列文件阅读器，并执行（即将dicom序列文件“打包整合”）\n",
+    "    reader = sitk.ImageSeriesReader()\n",
+    "    dicom_names = reader.GetGDCMSeriesFileNames(dcms_path)\n",
+    "    reader.SetFileNames(dicom_names)\n",
+    "    image2 = reader.Execute()\n",
+    "\t# 2.将整合后的数据转为array，并获取dicom文件基本信息\n",
+    "    image_array = sitk.GetArrayFromImage(image2)  # z, y, x\n",
+    "    origin = image2.GetOrigin()  # x, y, z\n",
+    "    print(origin)\n",
+    "    spacing = image2.GetSpacing()  # x, y, z\n",
+    "    print(spacing)\n",
+    "    direction = image2.GetDirection()  # x, y, z\n",
+    "    print(direction)\n",
+    "\n",
+    "    # 3.将array转为img，并保存为.nii.gz\n",
+    "    image3 = sitk.GetImageFromArray(image_array)\n",
+    "    image3.SetSpacing(spacing)\n",
+    "    image3.SetDirection(direction)\n",
+    "    image3.SetOrigin(origin)\n",
+    "    sitk.WriteImage(image3, nii_path)\n",
+    "\n",
+    "def calculate_volume(mask_image_path):\n",
+    "    # 读取分割结果的图像文件\n",
+    "    mask_image = sitk.ReadImage(mask_image_path)\n",
+    "\n",
+    "    # 获取图像的大小、原点和间距\n",
+    "    size = mask_image.GetSize()\n",
+    "    origin = mask_image.GetOrigin()\n",
+    "    spacing = mask_image.GetSpacing()\n",
+    "\n",
+    "    # 将 SimpleITK 图像转换为 NumPy 数组\n",
+    "    mask_array = sitk.GetArrayFromImage(mask_image)\n",
+    "\n",
+    "    # if len(np.unique(mask_array)) != 5:\n",
+    "    #     print(mask_image_path[-15:-12])\n",
+    "    #     print(np.unique(mask_array))\n",
+    "    \n",
+    "    # 计算非零像素的数量\n",
+    "    one_voxels = (mask_array == 1).sum()\n",
+    "    two_voxels = (mask_array == 2).sum()\n",
+    "    three_voxels = (mask_array == 3).sum()\n",
+    "    four_voxels = (mask_array == 4).sum()\n",
+    "    # print(one_voxels,two_voxels,three_voxels,four_voxels)\n",
+    "    # 计算像素的体积（以立方毫米为单位）\n",
+    "    voxel_volume_mm3 = spacing[0] * spacing[1] * spacing[2]\n",
+    "\n",
+    "    # 计算体积（以 mm³ 为单位）\n",
+    "    V_Right_ventricular_cistern = one_voxels * voxel_volume_mm3 / 1000.0\n",
+    "    V_Right_cerebral_sulcus = two_voxels * voxel_volume_mm3 / 1000.0\n",
+    "    V_Left_ventricular_cistern = three_voxels * voxel_volume_mm3 / 1000.0\n",
+    "    V_Left_cerebral_sulcus = four_voxels * voxel_volume_mm3 / 1000.0\n",
+    "    # 如果需要以其他单位（例如 cm³）显示，请进行适当的单位转换\n",
+    "    # volume_cm3 = volume_mm3 / 1000.0\n",
+    "\n",
+    "    return size,spacing,V_Right_ventricular_cistern, V_Right_cerebral_sulcus, V_Left_ventricular_cistern, V_Left_cerebral_sulcus\n",
+    "    \n",
+    "def process_nii_file(input_nii_file, dicom_file, slice, mode):\n",
+    "            \n",
+    "    if mode == \"Step1:Segment\":\n",
+    "        device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "        root_dir = \"./run\"\n",
+    "        model = UNETR(\n",
+    "            in_channels=1,\n",
+    "            out_channels=5,\n",
+    "            img_size=(96, 96, 16),\n",
+    "            feature_size=16,\n",
+    "            hidden_size=768,\n",
+    "            mlp_dim=3072,\n",
+    "            num_heads=12,\n",
+    "            pos_embed=\"perceptron\",\n",
+    "            norm_name=\"instance\",\n",
+    "            res_block=True,\n",
+    "            dropout_rate=0.0,\n",
+    "        ).to(device)\n",
+    "        model.load_state_dict(torch.load(os.path.join(root_dir, \"best_metric_model67v2.pth\")))\n",
+    "        \n",
+    "        test_transforms = Compose(\n",
+    "            [\n",
+    "            LoadImaged(keys=[\"image\"]),\n",
+    "            EnsureChannelFirstd(keys=[\"image\"]),\n",
+    "            Orientationd(keys=[\"image\"], axcodes=\"RAS\"),\n",
+    "            ScaleIntensityRanged(\n",
+    "                keys=[\"image\"],\n",
+    "                a_min=-50,\n",
+    "                a_max=100,\n",
+    "                b_min=0.0,\n",
+    "                b_max=1.0,\n",
+    "                clip=True,\n",
+    "            ),\n",
+    "            Rotate90d(keys=[\"image\"], k=1)\n",
+    "            # ResizeWithPadOrCropd(keys=[\"image\"], spatial_size=(512, 512, 16)),\n",
+    "            ]\n",
+    "        )\n",
+    "        test_file = [{'image':input_nii_file.name}]\n",
+    "        # test_file = [{'image':r'F:\\sth\\23Fall\\fcpro\\brain_image_copy\\image\\60020599.nii.gz'}]\n",
+    "        test_image = SmartCacheDataset(data=test_file, transform=test_transforms)[0]['image']\n",
+    "\n",
+    "        with torch.no_grad():\n",
+    "\n",
+    "            inputs = torch.unsqueeze(test_image, 1).cuda()\n",
+    "\n",
+    "            val_outputs = sliding_window_inference(inputs, (96, 96, 16), 8, model, overlap=0.8)\n",
+    "        \n",
+    "        # Process the output image\n",
+    "        output_image = torch.argmax(val_outputs, dim=1).detach().cpu().squeeze(0)\n",
+    "        \n",
+    "        # Display the images\n",
+    "        fig1 = plt.figure()\n",
+    "        plt.title(\"image\")\n",
+    "        plt.axis('off') # Remove axis\n",
+    "        plt.imshow(inputs.cpu().numpy()[0, 0, :, :, slice], cmap=\"gray\")\n",
+    "\n",
+    "        fig2 = plt.figure()\n",
+    "        plt.title(\"output\")\n",
+    "        plt.axis('off') # Remove axis\n",
+    "        plt.imshow(torch.argmax(val_outputs, dim=1).detach().cpu()[0, :, :, slice])\n",
+    "\n",
+    "        val_outputs = torch.argmax(val_outputs, dim=1).detach().cpu()[0, :, :, :]\n",
+    "        val_outputs = val_outputs.numpy().astype('int16')\n",
+    "        # val_outputs = np.transpose(val_outputs, (2, 1, 0))\n",
+    "        val_outputs = np.rot90(val_outputs, k=3)\n",
+    "        val_outputs = nib.Nifti1Image(val_outputs, np.eye(4))\n",
+    "        nib.save(val_outputs, f'D:/{input_nii_file.name[-15:-7]}_mask.nii.gz')\n",
+    "\n",
+    "        return [\"指定切片分割结果如下, mask文件已保存至D:/\", fig1, fig2]\n",
+    "    \n",
+    "    if mode == \"Step2:Volumn\":\n",
+    "        maskFilePath = input_nii_file.name\n",
+    "        size,spacing,V_Right_ventricular_cistern, V_Right_cerebral_sulcus, V_Left_ventricular_cistern, V_Left_cerebral_sulcus = calculate_volume(maskFilePath)\n",
+    "\n",
+    "        vol = f\"\"\"右侧脑室脑池的体积为{V_Right_ventricular_cistern}cm³\\n 右侧脑沟的体积为{V_Right_cerebral_sulcus}cm³\\n 左侧脑室脑池的体积为{V_Left_ventricular_cistern}cm³\\n 左侧脑沟的体积为{V_Left_cerebral_sulcus}cm³\"\"\"\n",
+    "        fig1 = plt.figure()\n",
+    "        fig2 = plt.figure()\n",
+    "        return [vol, fig1, fig2]\n",
+    "\n",
+    "# Define the Gradio interface\n",
+    "iface = gr.Interface(\n",
+    "    fn=process_nii_file,\n",
+    "    inputs=\n",
+    "    [gr.File(file_count='single', file_types=['.nii.gz']), \n",
+    "    gr.inputs.Slider(0, 24, default=8, label=\"Select Slice\", step=1),\n",
+    "    gr.Radio(\n",
+    "            [\"Step1:Segment\", \"Step2:Volumn\"], label=\"mode\"\n",
+    "        ),\n",
+    "    ],\n",
+    "    \n",
+    "    outputs=[gr.Text(label=\"Output\"), gr.Plot(label=\"image\"), gr.Plot(label=\"mask\")],  # Display both \"image\" and \"output\"\n",
+    ")\n",
+    "\n",
+    "iface.launch(share=True)\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "pytorch",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

demo.py

@@ -0,0 +1,178 @@
+import os
+
+import matplotlib.pyplot as plt
+
+from monai.losses import DiceCELoss
+from monai.inferers import sliding_window_inference
+from monai.transforms import (
+    EnsureChannelFirstd,
+    Compose,
+    LoadImaged,
+    Orientationd,
+    ScaleIntensityRanged,
+    Rotate90d,
+)
+from monai.networks.nets import UNETR
+
+from monai.data import (
+    SmartCacheDataset,
+)
+
+import numpy as np
+import torch
+
+import gradio as gr
+import matplotlib.pyplot as plt
+import torch
+import nibabel as nib
+import numpy as np
+import SimpleITK as sitk
+
+def dcm2nii(dcms_path, nii_path):
+	# 1.构建dicom序列文件阅读器，并执行（即将dicom序列文件“打包整合”）
+    reader = sitk.ImageSeriesReader()
+    dicom_names = reader.GetGDCMSeriesFileNames(dcms_path)
+    reader.SetFileNames(dicom_names)
+    image2 = reader.Execute()
+	# 2.将整合后的数据转为array，并获取dicom文件基本信息
+    image_array = sitk.GetArrayFromImage(image2)  # z, y, x
+    origin = image2.GetOrigin()  # x, y, z
+    print(origin)
+    spacing = image2.GetSpacing()  # x, y, z
+    print(spacing)
+    direction = image2.GetDirection()  # x, y, z
+    print(direction)
+
+    # 3.将array转为img，并保存为.nii.gz
+    image3 = sitk.GetImageFromArray(image_array)
+    image3.SetSpacing(spacing)
+    image3.SetDirection(direction)
+    image3.SetOrigin(origin)
+    sitk.WriteImage(image3, nii_path)
+
+def calculate_volume(mask_image_path):
+    # 读取分割结果的图像文件
+    mask_image = sitk.ReadImage(mask_image_path)
+
+    # 获取图像的大小、原点和间距
+    size = mask_image.GetSize()
+    origin = mask_image.GetOrigin()
+    spacing = mask_image.GetSpacing()
+
+    # 将 SimpleITK 图像转换为 NumPy 数组
+    mask_array = sitk.GetArrayFromImage(mask_image)
+
+    # if len(np.unique(mask_array)) != 5:
+    #     print(mask_image_path[-15:-12])
+    #     print(np.unique(mask_array))
+    
+    # 计算非零像素的数量
+    one_voxels = (mask_array == 1).sum()
+    two_voxels = (mask_array == 2).sum()
+    three_voxels = (mask_array == 3).sum()
+    four_voxels = (mask_array == 4).sum()
+    # print(one_voxels,two_voxels,three_voxels,four_voxels)
+    # 计算像素的体积（以立方毫米为单位）
+    voxel_volume_mm3 = spacing[0] * spacing[1] * spacing[2]
+
+    # 计算体积（以 mm³ 为单位）
+    V_Right_ventricular_cistern = one_voxels * voxel_volume_mm3 / 1000.0
+    V_Right_cerebral_sulcus = two_voxels * voxel_volume_mm3 / 1000.0
+    V_Left_ventricular_cistern = three_voxels * voxel_volume_mm3 / 1000.0
+    V_Left_cerebral_sulcus = four_voxels * voxel_volume_mm3 / 1000.0
+    # 如果需要以其他单位（例如 cm³）显示，请进行适当的单位转换
+    # volume_cm3 = volume_mm3 / 1000.0
+
+    return size,spacing,V_Right_ventricular_cistern, V_Right_cerebral_sulcus, V_Left_ventricular_cistern, V_Left_cerebral_sulcus
+    
+def process_nii_file(input_nii_file, dicom_file, slice, mode):
+            
+    if mode == "Step1:Segment":
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        root_dir = "./run"
+        model = UNETR(
+            in_channels=1,
+            out_channels=5,
+            img_size=(96, 96, 16),
+            feature_size=16,
+            hidden_size=768,
+            mlp_dim=3072,
+            num_heads=12,
+            pos_embed="perceptron",
+            norm_name="instance",
+            res_block=True,
+            dropout_rate=0.0,
+        ).to(device)
+        model.load_state_dict(torch.load(os.path.join(root_dir, "best_metric_model67v2.pth")))
+        
+        test_transforms = Compose(
+            [
+            LoadImaged(keys=["image"]),
+            EnsureChannelFirstd(keys=["image"]),
+            Orientationd(keys=["image"], axcodes="RAS"),
+            ScaleIntensityRanged(
+                keys=["image"],
+                a_min=-50,
+                a_max=100,
+                b_min=0.0,
+                b_max=1.0,
+                clip=True,
+            ),
+            Rotate90d(keys=["image"], k=1)
+            # ResizeWithPadOrCropd(keys=["image"], spatial_size=(512, 512, 16)),
+            ]
+        )
+        test_file = [{'image':input_nii_file.name}]
+        # test_file = [{'image':r'F:\sth\23Fall\fcpro\brain_image_copy\image\60020599.nii.gz'}]
+        test_image = SmartCacheDataset(data=test_file, transform=test_transforms)[0]['image']
+
+        with torch.no_grad():
+
+            inputs = torch.unsqueeze(test_image, 1).cuda()
+
+            val_outputs = sliding_window_inference(inputs, (96, 96, 16), 8, model, overlap=0.8)
+        
+        # Display the images
+        fig1 = plt.figure()
+        plt.title("image")
+        plt.axis('off') # Remove axis
+        plt.imshow(inputs.cpu().numpy()[0, 0, :, :, slice], cmap="gray")
+
+        fig2 = plt.figure()
+        plt.title("output")
+        plt.axis('off') # Remove axis
+        plt.imshow(torch.argmax(val_outputs, dim=1).detach().cpu()[0, :, :, slice])
+
+        val_outputs = torch.argmax(val_outputs, dim=1).detach().cpu()[0, :, :, :]
+        val_outputs = val_outputs.numpy().astype('int16')
+        # val_outputs = np.transpose(val_outputs, (2, 1, 0))
+        val_outputs = np.rot90(val_outputs, k=3)
+        val_outputs = nib.Nifti1Image(val_outputs, np.eye(4))
+        nib.save(val_outputs, f'D:/{input_nii_file.name[-15:-7]}_mask.nii.gz')
+
+        return ["指定切片分割结果如下, mask文件已保存至D:/", fig1, fig2]
+    
+    if mode == "Step2:Volumn":
+        maskFilePath = input_nii_file.name
+        size,spacing,V_Right_ventricular_cistern, V_Right_cerebral_sulcus, V_Left_ventricular_cistern, V_Left_cerebral_sulcus = calculate_volume(maskFilePath)
+
+        vol = f"""右侧脑室脑池的体积为{V_Right_ventricular_cistern}cm³\n 右侧脑沟的体积为{V_Right_cerebral_sulcus}cm³\n 左侧脑室脑池的体积为{V_Left_ventricular_cistern}cm³\n 左侧脑沟的体积为{V_Left_cerebral_sulcus}cm³"""
+        fig1 = plt.figure()
+        fig2 = plt.figure()
+        return [vol, fig1, fig2]
+
+# Define the Gradio interface
+iface = gr.Interface(
+    fn=process_nii_file,
+    inputs=
+    [gr.File(file_count='single', file_types=['.nii.gz']), 
+    gr.inputs.Slider(0, 24, default=8, label="Select Slice", step=1),
+    gr.Radio(
+            ["Step1:Segment", "Step2:Volumn"], label="mode"
+        ),
+    ],
+    
+    outputs=[gr.Text(label="Output"), gr.Plot(label="image"), gr.Plot(label="mask")],  # Display both "image" and "output"
+)
+
+iface.launch(share=True)