test_yolo_inf_wcrop.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os \n",
    "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"0\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dataset functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import pandas as pd\n",
    "import SimpleITK as sitk\n",
    "\n",
    "# this data loader is in a file now\n",
    "class Abus23DataLoader():\n",
    "    def __init__(self, dataset_path, labels_csv=None):\n",
    "        self.data = self.load_abus23(dataset_path, labels_csv)\n",
    "        self.dataset_path = dataset_path\n",
    "        self.used_data = self.data\n",
    "        self.cidx = 0\n",
    "        \n",
    "    def load_abus23(self, dataset_path, label_file=None):\n",
    "        if label_file is not None:\n",
    "            dataset = pd.read_csv(os.path.join(dataset_path, label_file))\n",
    "        else:\n",
    "            files = sorted([f for f in os.listdir(dataset_path) if f.endswith(\".nrrd\")])\n",
    "            files_id = [int(f.split(\".\")[0].split(\"_\")[-1]) for f in files]\n",
    "            files_path = [f for f in files] #os.path.join(dataset_path, f) \n",
    "            dataset_dict = [{\"case_id\": f_id, \"data_path\": f_path} for f_id, f_path in zip(files_id, files_path)]\n",
    "            dataset = pd.DataFrame.from_dict(dataset_dict)\n",
    "        print(\"Dataset columns:\", dataset.columns)\n",
    "        return dataset\n",
    "    \n",
    "    def set_subset_ids(self, list_id = [], id_label = 'case_id'):\n",
    "        if list_id:\n",
    "            self.used_data = self.data[self.data[id_label].isin(list_id)]\n",
    "        \n",
    "    def get_data_entry(self, idx):    \n",
    "        return self.used_data.iloc[idx]\n",
    "    \n",
    "    def get_item(self, idx):\n",
    "        entry = self.get_data_entry(idx).to_dict()\n",
    "        output = {}\n",
    "        output[\"id\"] = entry['case_id']\n",
    "        if 'label' in entry:\n",
    "            output[\"class\"] =entry['label']\n",
    "        image_full_path = os.path.join(self.dataset_path, entry['data_path'].replace('\\\\','/'))\n",
    "        output[\"image\"] = sitk.ReadImage(image_full_path)\n",
    "        output[\"image_path\"] = image_full_path\n",
    "        if 'mask_path' in entry:\n",
    "            mask_full_path = os.path.join(self.dataset_path, entry['mask_path'].replace('\\\\','/'))\n",
    "            output[\"mask\"] = sitk.ReadImage(mask_full_path)\n",
    "            output[\"mask_path\"] = mask_full_path\n",
    "            \n",
    "        return output\n",
    "\n",
    "    def get_keys(self):\n",
    "        return self.used_data.columns.tolist()\n",
    "        \n",
    "    def __getitem__(self, idx):\n",
    "       return self.get_item(idx)\n",
    "   \n",
    "    def __len__(self):\n",
    "        return len(self.used_data)\n",
    "   \n",
    "def get_validation_ids(val_file):\n",
    "    with open(val_file) as fp:\n",
    "        lines = fp.readlines()\n",
    "        #print([os.path.basename(i)for i in lines])\n",
    "        patients = set([int(os.path.basename(case).split('_')[0]) for case in lines])\n",
    "    return list(patients)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Data processing functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import SimpleITK as sitk\n",
    "import numpy as np\n",
    "import cv2\n",
    "\n",
    "def normalize_8bits(image: np.ndarray):\n",
    "    return (255.0 *(image - image.min()) / (image.max() - image.min())).astype(np.uint8)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# Create the volume from slices\n",
    "def volume_from_slice(slices):\n",
    "    mask_3d = np.stack(slices)\n",
    "    return mask_3d\n",
    "\n",
    "def sitk_from_volum(volum, format=None):\n",
    "    output_mask = sitk.GetImageFromArray(volum)\n",
    "    if format is not None:\n",
    "        #sitk.GetPixelIDValueAsString(format)\n",
    "        castImageFilter = sitk.CastImageFilter()\n",
    "        castImageFilter.SetOutputPixelType(format)\n",
    "        output_mask = castImageFilter.Execute(output_mask)\n",
    "        \n",
    "    return output_mask\n",
    "\n",
    "def sitk_volume_from_slice(slices, format=None):\n",
    "    mask_3d =  volume_from_slice(slices)\n",
    "    output_mask = sitk_from_volum(mask_3d, format)\n",
    "    caaa = sitk.GetArrayViewFromImage(output_mask)\n",
    "    print(\"After sitk volum:\",np.min(caaa ), np.max(caaa))\n",
    "    \n",
    "    return output_mask\n",
    "\n",
    "def get_bounding_box(mask_image):\n",
    "    # Convert SimpleITK image to NumPy array\n",
    "    mask_array = sitk.GetArrayFromImage(mask_image)\n",
    "    \n",
    "    if sum(mask_array.flatten()) == 0:\n",
    "        return np.zeros(3), np.zeros(3)\n",
    "    \n",
    "    # Get nonzero indices from the mask array\n",
    "    nonzero_indices = np.nonzero(mask_array)\n",
    "    \n",
    "    # Calculate bounding box coordinates and dimensions\n",
    "    min_coords = np.min(nonzero_indices, axis=1)\n",
    "    max_coords = np.max(nonzero_indices, axis=1)\n",
    "    center = (min_coords + max_coords)/2\n",
    "    dimensions = max_coords - min_coords + 1\n",
    "    \n",
    "    return center, dimensions\n",
    "\n",
    "\n",
    "def calculate_bb_score(image, bb):\n",
    "    # Convert the cropped region to a NumPy array\n",
    "    array = sitk.GetArrayViewFromImage(image)\n",
    "    cropped_array = array[bb[2]:bb[2]+bb[5], bb[1]:bb[1]+bb[4], bb[0]:bb[0]+bb[3]]\n",
    "    #cropped_array = array[bb[0]:bb[0]+bb[3], bb[1]:bb[1]+bb[4], bb[2]:bb[2]+bb[5]]\n",
    "    print(\"After crop volum:\",np.min(cropped_array), np.max(cropped_array))\n",
    "\n",
    "    # Calculate the BB score by averaging non-zero values\n",
    "    non_zero_values = cropped_array[cropped_array != 0]\n",
    "    if non_zero_values.size > 0:\n",
    "        bb_score = np.mean(non_zero_values)\n",
    "    else:\n",
    "        bb_score = 0.0\n",
    "\n",
    "    return bb_score\n",
    "\n",
    "def best_bb_bounding_boxes(mask_bn, mask_prob, th=0):\n",
    "    \n",
    "    caaa = sitk.GetArrayViewFromImage(mask_prob)\n",
    "    print(\"Prob\",np.min(caaa ), np.max(caaa))\n",
    "    \n",
    "    mradius=5\n",
    "    #mask_bn = sitk.BinaryMorphologicalClosing(mask_bn, kernelRadius=[mradius]*3 )\n",
    "    mask_bn = sitk.BinaryDilate(mask_bn, kernelRadius=[mradius]*3 )\n",
    "    mask_cc = sitk.ConnectedComponent(mask_bn)\n",
    "    \n",
    "    label_stats = sitk.LabelShapeStatisticsImageFilter()\n",
    "    label_stats.Execute(mask_cc)\n",
    "    num_labels = label_stats.GetNumberOfLabels()\n",
    "    print(num_labels)\n",
    "\n",
    "    best_score = 0\n",
    "    best_bb = [0,0,0], [0,0,0]\n",
    "    for label in range(1, num_labels + 1):\n",
    "        bbox = label_stats.GetBoundingBox(label)\n",
    "        print(\"BB\", bbox)\n",
    "        score = calculate_bb_score(mask_prob, bbox)\n",
    "        min_x, min_y, min_z, size_x, size_y, size_z = bbox\n",
    "        print([min_x+size_x/2, min_y+size_y/2, min_z+size_z/2], [size_x, size_y, size_z], score)\n",
    "        if score > th and score > best_score:\n",
    "            best_score = score\n",
    "            best_bb = [min_z+size_z/2, min_y+size_y/2, min_x+size_x/2], [size_z, size_y, size_x]\n",
    "            #best_bb = [min_x+mradius, min_y+mradius, min_z+mradius], [size_x-mradius, size_y-mradius, size_z-mradius]\n",
    "            \n",
    "    return best_bb[0], best_bb[1], best_score\n",
    "\n",
    "def binary_mask(image, output_format):\n",
    "    greater_mask = sitk.Greater(image, 0)\n",
    "    mask = sitk.Cast(greater_mask, output_format)\n",
    "    caaa = sitk.GetArrayViewFromImage(mask)\n",
    "    print(\"binary\",np.min(caaa ), np.max(caaa))\n",
    "    return mask\n",
    "\n",
    "\n",
    "\n",
    "# Cropping\n",
    "def get_slices(data, norm_fn = normalize_8bits):\n",
    "    if isinstance(data, sitk.Image):\n",
    "        data_array = sitk.GetArrayFromImage(data)\n",
    "    if isinstance(data, np.ndarray):\n",
    "        data_array = data\n",
    "    return [norm_fn(data_array[i, ...]) for i in range(len(data_array))]\n",
    "\n",
    "def crop_volume(data, crop=[0,0,0,0,0,0]):\n",
    "    data_array = sitk.GetArrayFromImage(data)\n",
    "    x1 = int(data_array.shape[2]*crop[0])\n",
    "    y1 = int(data_array.shape[1]*crop[1])\n",
    "    z1 = int(data_array.shape[0]*crop[2])\n",
    "    x2 = int(data_array.shape[2]*crop[3] if crop[3] > 0 else -data_array.shape[2])\n",
    "    y2 = int(data_array.shape[1]*crop[4] if crop[4] > 0 else -data_array.shape[1])\n",
    "    z2 = int(data_array.shape[0]*crop[5] if crop[5] > 0 else -data_array.shape[0])\n",
    "    print(data_array.shape)\n",
    "    print(z1,z2, y1,y2, x1,x2)\n",
    "    crop_array = data_array[z1:-z2, y1:-y2, x1:-x2]\n",
    "    crop_pad = [(z1,z2 if crop[5] > 0 else 0),\n",
    "                (y1,y2 if crop[4] > 0 else 0),\n",
    "                (x1,x2 if crop[3] > 0 else 0)]\n",
    "    return crop_array, crop_pad\n",
    "\n",
    "def volume_from_slice_wpad(slices, format=None, pad=None):\n",
    "    mask_3d = np.stack(slices)\n",
    "    \n",
    "    if pad is not None:\n",
    "        mask_3d = np.pad(mask_3d, pad)\n",
    "    \n",
    "    output_mask = sitk.GetImageFromArray(mask_3d)\n",
    "    \n",
    "    if format is not None:\n",
    "        #sitk.GetPixelIDValueAsString(format)\n",
    "        castImageFilter = sitk.CastImageFilter()\n",
    "        castImageFilter.SetOutputPixelType(format)\n",
    "        output_mask = castImageFilter.Execute(output_mask)\n",
    "        \n",
    "    return output_mask"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Prediction functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ultralytics import YOLO\n",
    "import numpy as np\n",
    "import json\n",
    "import cv2\n",
    "\n",
    "# Load a model\n",
    "class YOLOPredictor:\n",
    "    def __init__(self, model_file, conf_th = 0.5):\n",
    "        self.model = YOLO(model_file)  # pretrained YOLOv8n model\n",
    "        self.conf_th = conf_th\n",
    "        \n",
    "    def set_conf_th(self, conf_th = 0.5):\n",
    "        self.conf_th = conf_th\n",
    "        \n",
    "    def __call__(self, slice, conf_th=None):\n",
    "        return self.predict(slice, conf_th)\n",
    "        \n",
    "    def predict(self, slice, conf_th=None):\n",
    "        assert len(slice.shape) == 2\n",
    "        \n",
    "        if conf_th is None:\n",
    "            conf_th = self.conf_th\n",
    "        \n",
    "        #cv2.imwrite(\"temp.png\", slice)\n",
    "        #results = self.model(\"temp.png\", verbose=False)[0].cpu().numpy()\n",
    "        bgr_slice = cv2.cvtColor(slice, cv2.COLOR_GRAY2BGR)\n",
    "        results = self.model(bgr_slice, verbose=False)[0].cpu().numpy()\n",
    "        \n",
    "        \"\"\" best only\n",
    "        slice_mask = np.zeros(slice.shape)\n",
    "        avg_conf = None\n",
    "        if results.masks is not None:\n",
    "            total_conf = []\n",
    "            pred_mask_data = results.masks.data\n",
    "            pred_box_conf = [results.boxes[i].conf for i in range(len(pred_mask_data))]\n",
    "            best_pred = np.argmax(pred_box_conf)\n",
    "            best_pred_conf = pred_box_conf[best_pred]\n",
    "\n",
    "            if best_pred_conf >= conf_th:\n",
    "                slice_mask = cv2.resize(pred_mask_data[best_pred, ...], dsize=(slice.shape[1], slice.shape[0])) # interpolation=cv2.INTER_CUBIC)\n",
    "                avg_conf = pred_box_conf[best_pred]\n",
    "        \"\"\"\n",
    "        \n",
    "        \"\"\" All\n",
    "        slice_mask = np.zeros(slice.shape)\n",
    "        avg_conf = None\n",
    "        if results.masks is not None:\n",
    "            total_conf = []\n",
    "            pred_mask_data = results.masks.data\n",
    "            for i in range(len(pred_mask_data)):\n",
    "                \n",
    "                pred_box_conf = results.boxes[i].conf  # confidence score, (N, )\n",
    "                total_conf.append(pred_box_conf)\n",
    "                if pred_box_conf < conf_th:\n",
    "                    continue\n",
    "\n",
    "                m = cv2.resize(pred_mask_data[i, ...], dsize=(slice.shape[1], slice.shape[0])) # interpolation=cv2.INTER_CUBIC)\n",
    "                slice_mask = np.logical_or(slice_mask, m).astype(\"float32\")\n",
    "            avg_conf = np.mean(total_conf) \n",
    "        \"\"\"       \n",
    "        \n",
    "        # All w/prob_mask\n",
    "        slice_mask = np.zeros(slice.shape, dtype=np.float32)\n",
    "        if results.masks is not None:\n",
    "            pred_mask_data = results.masks.data\n",
    "            for i in range(len(pred_mask_data)):\n",
    "                pred_box_conf = results.boxes[i].conf  # confidence score, (N, )\n",
    "                if pred_box_conf < conf_th:\n",
    "                    continue\n",
    "                m = cv2.resize(pred_mask_data[i, ...], dsize=(slice.shape[1], slice.shape[0])) # interpolation=cv2.INTER_CUBIC)\n",
    "                slice_mask[m>0] = pred_box_conf           \n",
    "        \n",
    "        return slice_mask  #, avg_conf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Run inference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset columns: Index(['case_id', 'label', 'data_path', 'mask_path'], dtype='object')\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/20 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(353, 682, 865)\n",
      "0 10 20 20 25 86\n",
      "binary 0 1\n",
      "Prob 0.0 0.81861037\n",
      "8\n",
      "BB (490, 50, 0, 215, 215, 7)\n",
      "After crop volum: 0.0 0.65465575\n",
      "[597.5, 157.5, 3.5] [215, 215, 7] 0.65465575\n",
      "BB (151, 67, 149, 106, 162, 20)\n",
      "After crop volum: 0.0 0.71395844\n",
      "[204.0, 148.0, 159.0] [106, 162, 20] 0.6606274\n",
      "BB (20, 41, 166, 56, 179, 11)\n",
      "After crop volum: 0.0 0.61576873\n",
      "[48.0, 130.5, 171.5] [56, 179, 11] 0.61576873\n",
      "BB (226, 139, 194, 69, 72, 11)\n",
      "After crop volum: 0.0 0.6048045\n",
      "[260.5, 175.0, 199.5] [69, 72, 11] 0.6048045\n",
      "BB (236, 112, 217, 94, 86, 11)\n",
      "After crop volum: 0.0 0.6476124\n",
      "[283.0, 155.0, 222.5] [94, 86, 11] 0.64761245\n",
      "BB (396, 76, 258, 116, 111, 20)\n",
      "After crop volum: 0.0 0.81861037\n",
      "[454.0, 131.5, 268.0] [116, 111, 20] 0.73504937\n",
      "BB (236, 94, 268, 83, 104, 11)\n",
      "After crop volum: 0.0 0.7656488\n",
      "[277.5, 146.0, 273.5] [83, 104, 11] 0.7656488\n",
      "BB (311, 112, 290, 57, 48, 11)\n",
      "After crop volum: 0.0 0.66155297\n",
      "[339.5, 136.0, 295.5] [57, 48, 11] 0.66155297\n",
      "R: [273.5, 146.0, 277.5] [11, 104, 83] 0.7656488\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|▌         | 1/20 [00:25<08:07, 25.66s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(353, 682, 865)\n",
      "0 10 20 20 25 86\n",
      "binary 0 1\n",
      "Prob 0.0 0.8915669\n",
      "5\n",
      "BB (339, 121, 118, 88, 146, 22)\n",
      "After crop volum: 0.0 0.88244075\n",
      "[383.0, 194.0, 129.0] [88, 146, 22] 0.7912534\n",
      "BB (716, 32, 126, 68, 135, 12)\n",
      "After crop volum: 0.0 0.66344136\n",
      "[750.0, 99.5, 132.0] [68, 135, 12] 0.6403458\n",
      "BB (170, 67, 130, 156, 198, 27)\n",
      "After crop volum: 0.0 0.8915669\n",
      "[248.0, 166.0, 143.5] [156, 198, 27] 0.83090806\n",
      "BB (283, 157, 169, 76, 108, 26)\n",
      "After crop volum: 0.0 0.8483019\n",
      "[321.0, 211.0, 182.0] [76, 108, 26] 0.75971174\n",
      "BB (368, 183, 195, 35, 57, 11)\n",
      "After crop volum: 0.0 0.60040885\n",
      "[385.5, 211.5, 200.5] [35, 57, 11] 0.6004089\n",
      "R: [143.5, 166.0, 248.0] [27, 198, 156] 0.83090806\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 10%|█         | 2/20 [00:48<07:09, 23.84s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(353, 682, 865)\n",
      "0 10 20 20 25 86\n",
      "binary 0 1\n",
      "Prob 0.0 0.823443\n",
      "4\n",
      "BB (396, 148, 200, 36, 39, 11)\n",
      "After crop volum: 0.0 0.6087626\n",
      "[414.0, 167.5, 205.5] [36, 39, 11] 0.6087627\n",
      "BB (452, 103, 206, 116, 146, 23)\n",
      "After crop volum: 0.0 0.823443\n",
      "[510.0, 176.0, 217.5] [116, 146, 23] 0.7531341\n",
      "BB (396, 371, 271, 59, 56, 11)\n",
      "After crop volum: 0.0 0.6840498\n",
      "[425.5, 399.0, 276.5] [59, 56, 11] 0.6840497\n",
      "BB (424, 388, 293, 64, 48, 11)\n",
      "After crop volum: 0.0 0.66779494\n",
      "[456.0, 412.0, 298.5] [64, 48, 11] 0.66779506\n",
      "R: [217.5, 176.0, 510.0] [23, 146, 116] 0.7531341\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 15%|█▌        | 3/20 [01:06<06:05, 21.48s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(349, 682, 865)\n",
      "0 10 20 20 25 86\n",
      "binary 0 1\n",
      "Prob 0.0 0.81598014\n",
      "11\n",
      "BB (151, 121, 24, 59, 144, 11)\n",
      "After crop volum: 0.0 0.6233939\n",
      "[180.5, 193.0, 29.5] [59, 144, 11] 0.62339395\n",
      "BB (302, 134, 45, 52, 102, 11)\n",
      "After crop volum: 0.0 0.6629186\n",
      "[328.0, 185.0, 50.5] [52, 102, 11] 0.66291857\n",
      "BB (283, 121, 92, 78, 119, 21)\n",
      "After crop volum: 0.0 0.7497726\n",
      "[322.0, 180.5, 102.5] [78, 119, 21] 0.6953721\n",
      "BB (462, 219, 117, 47, 55, 12)\n",
      "After crop volum: 0.0 0.66017985\n",
      "[485.5, 246.5, 123.0] [47, 55, 12] 0.652094\n",
      "BB (264, 139, 131, 125, 90, 20)\n",
      "After crop volum: 0.0 0.6631774\n",
      "[326.5, 184.0, 141.0] [125, 90, 20] 0.652086\n",
      "BB (368, 139, 146, 52, 74, 13)\n",
      "After crop volum: 0.0 0.7096887\n",
      "[394.0, 176.0, 152.5] [52, 74, 13] 0.68210524\n",
      "BB (462, 112, 202, 88, 119, 22)\n",
      "After crop volum: 0.0 0.81598014\n",
      "[506.0, 171.5, 213.0] [88, 119, 22] 0.7124204\n",
      "BB (320, 174, 226, 65, 113, 11)\n",
      "After crop volum: 0.0 0.64353555\n",
      "[352.5, 230.5, 231.5] [65, 113, 11] 0.64353555\n",
      "BB (443, 157, 234, 59, 114, 11)\n",
      "After crop volum: 0.0 0.6247541\n",
      "[472.5, 214.0, 239.5] [59, 114, 11] 0.62475395\n",
      "BB (254, 192, 244, 41, 57, 11)\n",
      "After crop volum: 0.0 0.6427061\n",
      "[274.5, 220.5, 249.5] [41, 57, 11] 0.6427061\n",
      "BB (424, 219, 274, 69, 99, 13)\n",
      "After crop volum: 0.0 0.77609706\n",
      "[458.5, 268.5, 280.5] [69, 99, 13] 0.7229249\n",
      "R: [280.5, 268.5, 458.5] [13, 99, 69] 0.7229249\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|██        | 4/20 [01:31<06:01, 22.61s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(352, 682, 865)\n",
      "0 10 20 20 25 86\n",
      "binary 0 1\n",
      "Prob 0.0 0.85418236\n",
      "1\n",
      "BB (264, 103, 263, 151, 235, 50)\n",
      "After crop volum: 0.0 0.85418236\n",
      "[339.5, 220.5, 288.0] [151, 235, 50] 0.78078026\n",
      "R: [288.0, 220.5, 339.5] [50, 235, 151] 0.78078026\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 25%|██▌       | 5/20 [01:55<05:46, 23.09s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(330, 608, 865)\n",
      "0 9 18 18 25 86\n",
      "binary 0 1\n",
      "Prob 0.0 0.8361987\n",
      "3\n",
      "BB (273, 74, 149, 48, 64, 11)\n",
      "After crop volum: 0.0 0.63117963\n",
      "[297.0, 106.0, 154.5] [48, 64, 11] 0.6311797\n",
      "BB (330, 66, 164, 102, 155, 34)\n",
      "After crop volum: 0.0 0.8361987\n",
      "[381.0, 143.5, 181.0] [102, 155, 34] 0.73462725\n",
      "BB (471, 155, 191, 55, 72, 12)\n",
      "After crop volum: 0.0 0.64203745\n",
      "[498.5, 191.0, 197.0] [55, 72, 12] 0.63601726\n",
      "R: [181.0, 143.5, 381.0] [34, 155, 102] 0.73462725\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|███       | 6/20 [02:16<05:15, 22.54s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(349, 682, 865)\n",
      "0 10 20 20 25 86\n",
      "binary 0 1\n",
      "Prob 0.0 0.69212997\n",
      "1\n",
      "BB (565, 157, 259, 135, 250, 12)\n",
      "After crop volum: 0.0 0.69212997\n",
      "[632.5, 282.0, 265.0] [135, 250, 12] 0.66346693\n",
      "R: [265.0, 282.0, 632.5] [12, 250, 135] 0.66346693\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 35%|███▌      | 7/20 [02:40<04:58, 22.94s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(353, 682, 865)\n",
      "0 10 20 20 25 86\n",
      "binary 0 1\n",
      "Prob 0.0 0.8634786\n",
      "3\n",
      "BB (122, 103, 84, 81, 93, 13)\n",
      "After crop volum: 0.0 0.724496\n",
      "[162.5, 149.5, 90.5] [81, 93, 13] 0.69129694\n",
      "BB (254, 67, 162, 76, 126, 18)\n",
      "After crop volum: 0.0 0.7974901\n",
      "[292.0, 130.0, 171.0] [76, 126, 18] 0.7271201\n",
      "BB (236, 67, 193, 87, 166, 21)\n",
      "After crop volum: 0.0 0.8634786\n",
      "[279.5, 150.0, 203.5] [87, 166, 21] 0.81259155\n",
      "R: [203.5, 150.0, 279.5] [21, 166, 87] 0.81259155\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|████      | 8/20 [03:06<04:46, 23.85s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(354, 682, 865)\n",
      "0 10 20 20 25 86\n",
      "binary 0 1\n",
      "Prob 0.0 0.80934745\n",
      "6\n",
      "BB (481, 139, 115, 61, 54, 12)\n",
      "After crop volum: 0.0 0.7908889\n",
      "[511.5, 166.0, 121.0] [61, 54, 12] 0.7825813\n",
      "BB (358, 121, 129, 41, 54, 11)\n",
      "After crop volum: 0.0 0.6082947\n",
      "[378.5, 148.0, 134.5] [41, 54, 11] 0.6082948\n",
      "BB (302, 121, 143, 68, 99, 11)\n",
      "After crop volum: 0.0 0.6573498\n",
      "[336.0, 170.5, 148.5] [68, 99, 11] 0.6573497\n",
      "BB (490, 130, 152, 76, 92, 12)\n",
      "After crop volum: 0.0 0.68342566\n",
      "[528.0, 176.0, 158.0] [76, 92, 12] 0.68258536\n",
      "BB (547, 112, 196, 66, 104, 11)\n",
      "After crop volum: 0.0 0.7287362\n",
      "[580.0, 164.0, 201.5] [66, 104, 11] 0.7287363\n",
      "BB (377, 85, 225, 41, 84, 15)\n",
      "After crop volum: 0.0 0.80934745\n",
      "[397.5, 127.0, 232.5] [41, 84, 15] 0.7704311\n",
      "R: [121.0, 166.0, 511.5] [12, 54, 61] 0.7825813\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 45%|████▌     | 9/20 [03:31<04:26, 24.23s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(348, 682, 865)\n",
      "0 10 20 20 25 86\n",
      "binary 0 1\n",
      "Prob 0.0 0.88775545\n",
      "5\n",
      "BB (679, 121, 72, 105, 153, 11)\n",
      "After crop volum: 0.0 0.7640167\n",
      "[731.5, 197.5, 77.5] [105, 153, 11] 0.7640168\n",
      "BB (330, 174, 102, 31, 48, 11)\n",
      "After crop volum: 0.0 0.60230076\n",
      "[345.5, 198.0, 107.5] [31, 48, 11] 0.6023007\n",
      "BB (745, 103, 145, 39, 126, 19)\n",
      "After crop volum: 0.0 0.6827046\n",
      "[764.5, 166.0, 154.5] [39, 126, 19] 0.648765\n",
      "BB (386, 130, 157, 107, 137, 40)\n",
      "After crop volum: 0.0 0.88775545\n",
      "[439.5, 198.5, 177.0] [107, 137, 40] 0.7506521\n",
      "BB (396, 183, 272, 57, 93, 11)\n",
      "After crop volum: 0.0 0.7625322\n",
      "[424.5, 229.5, 277.5] [57, 93, 11] 0.7625322\n",
      "R: [77.5, 197.5, 731.5] [11, 153, 105] 0.7640168\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|█████     | 10/20 [03:56<04:05, 24.55s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(348, 682, 865)\n",
      "0 10 20 20 25 86\n",
      "binary 0 1\n",
      "Prob 0.0 0.87409234\n",
      "10\n",
      "BB (622, 165, 50, 88, 100, 11)\n",
      "After crop volum: 0.0 0.600124\n",
      "[666.0, 215.0, 55.5] [88, 100, 11] 0.60012394\n",
      "BB (622, 139, 63, 104, 114, 16)\n",
      "After crop volum: 0.0 0.7567152\n",
      "[674.0, 196.0, 71.0] [104, 114, 16] 0.7235173\n",
      "BB (537, 94, 106, 107, 146, 55)\n",
      "After crop volum: 0.0 0.87409234\n",
      "[590.5, 167.0, 133.5] [107, 146, 55] 0.7418399\n",
      "BB (613, 121, 169, 21, 54, 13)\n",
      "After crop volum: 0.0 0.736415\n",
      "[623.5, 148.0, 175.5] [21, 54, 13] 0.6670708\n",
      "BB (603, 94, 209, 147, 164, 32)\n",
      "After crop volum: 0.0 0.8641437\n",
      "[676.5, 176.0, 225.0] [147, 164, 32] 0.77996796\n",
      "BB (434, 112, 213, 40, 66, 11)\n",
      "After crop volum: 0.0 0.66933244\n",
      "[454.0, 145.0, 218.5] [40, 66, 11] 0.6693325\n",
      "BB (669, 165, 286, 31, 66, 13)\n",
      "After crop volum: 0.0 0.68675834\n",
      "[684.5, 198.0, 292.5] [31, 66, 13] 0.6577169\n",
      "BB (490, 157, 298, 41, 65, 11)\n",
      "After crop volum: 0.0 0.65325445\n",
      "[510.5, 189.5, 303.5] [41, 65, 11] 0.6532545\n",
      "BB (603, 219, 310, 31, 61, 11)\n",
      "After crop volum: 0.0 0.6140203\n",
      "[618.5, 249.5, 315.5] [31, 61, 11] 0.61402035\n",
      "BB (547, 219, 322, 43, 81, 11)\n",
      "After crop volum: 0.0 0.65502274\n",
      "[568.5, 259.5, 327.5] [43, 81, 11] 0.65502274\n",
      "R: [225.0, 176.0, 676.5] [32, 164, 147] 0.77996796\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 55%|█████▌    | 11/20 [04:23<03:46, 25.21s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(330, 608, 865)\n",
      "0 9 18 18 25 86\n",
      "binary 0 1\n",
      "Prob 0.0 0.86147785\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|██████    | 12/20 [04:44<03:12, 24.07s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "BB (349, 57, 210, 160, 177, 44)\n",
      "After crop volum: 0.0 0.86147785\n",
      "[429.0, 145.5, 232.0] [160, 177, 44] 0.78008825\n",
      "R: [232.0, 145.5, 429.0] [44, 177, 160] 0.78008825\n",
      "(330, 608, 865)\n",
      "0 9 18 18 25 86\n",
      "binary 0 1\n",
      "Prob 0.0 0.8494456\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 65%|██████▌   | 13/20 [05:05<02:40, 23.00s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "BB (311, 110, 197, 88, 117, 19)\n",
      "After crop volum: 0.0 0.8494456\n",
      "[355.0, 168.5, 206.5] [88, 117, 19] 0.74278325\n",
      "R: [206.5, 168.5, 355.0] [19, 117, 88] 0.74278325\n",
      "(353, 682, 865)\n",
      "0 10 20 20 25 86\n",
      "binary 0 1\n",
      "Prob 0.0 0.88564867\n",
      "5\n",
      "BB (188, 32, 82, 286, 300, 47)\n",
      "After crop volum: 0.0 0.88564867\n",
      "[331.0, 182.0, 105.5] [286, 300, 47] 0.8331987\n",
      "BB (188, 139, 148, 67, 97, 11)\n",
      "After crop volum: 0.0 0.62298095\n",
      "[221.5, 187.5, 153.5] [67, 97, 11] 0.62298095\n",
      "BB (358, 94, 151, 97, 126, 27)\n",
      "After crop volum: 0.0 0.8847688\n",
      "[406.5, 157.0, 164.5] [97, 126, 27] 0.80317867\n",
      "BB (726, 121, 171, 58, 119, 11)\n",
      "After crop volum: 0.0 0.6824741\n",
      "[755.0, 180.5, 176.5] [58, 119, 11] 0.6824741\n",
      "BB (443, 130, 214, 59, 101, 12)\n",
      "After crop volum: 0.0 0.7963882\n",
      "[472.5, 180.5, 220.0] [59, 101, 12] 0.7227142\n",
      "R: [105.5, 182.0, 331.0] [47, 300, 286] 0.8331987\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|███████   | 14/20 [05:30<02:22, 23.73s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(353, 682, 865)\n",
      "0 10 20 20 25 86\n",
      "binary 0 1\n",
      "Prob 0.0 0.90316254\n"
     ]
    }
   ],
   "source": [
    "from ultralytics import YOLO\n",
    "from tqdm import tqdm\n",
    "\n",
    "# ABUS 23 Test data\n",
    "dataset_path = \"/home/joel/abus23/datasets/DATA\" \n",
    "label_file = None #\"labels.csv\"\n",
    "validation_file = None #\"datasets/abus23_25_png/val_seg.txt\"\n",
    "\n",
    "# ABUS 23 Train data\n",
    "dataset_path = \"/home/joel/abus23/datasets/Train\" \n",
    "label_file = \"labels.csv\"\n",
    "bbx_labels = \"bbx_labels.csv\"\n",
    "validation_file = \"/home/joel/abus23/datasets/abus23_25_png/val_seg.txt\"\n",
    "\n",
    "# Yolo model\n",
    "yolo_weights = \"/home/joel/abus23/runs/segment/train10/weights/best.pt\"\n",
    "\n",
    "# Volume\n",
    "confidance_th = 0.6\n",
    "crop = [0,0,0,0,0,0]\n",
    "\n",
    "#crop = [0.03, 0.03, 0, 0.1, 0.03, 0.03]\n",
    "\n",
    "\n",
    "# Output folder\n",
    "output_folder = os.path.join( \"results_masks\", \"abus23_25\", \"raw_stack_train10_param1\")\n",
    "output_file_template = \"MASK_{:0>3}.nii.gz\"\n",
    "output_format = sitk.sitkUInt8\n",
    "\n",
    "# CSV files\n",
    "pred_csv = os.path.join(output_folder, \"prediction.csv\")\n",
    "if \"bbx_labels\" in locals() and bbx_labels is not None:\n",
    "        gt_csv = os.path.join(dataset_path, bbx_labels)\n",
    "\n",
    "\n",
    "# Create output folder\n",
    "os.makedirs(output_folder, exist_ok=False)\n",
    "\n",
    "detection_results = []\n",
    "\n",
    "# Load dataset\n",
    "dataset = Abus23DataLoader(dataset_path, label_file)\n",
    "\n",
    "# Get validation cases\n",
    "if validation_file is not None:\n",
    "        val_ids = get_validation_ids(validation_file)\n",
    "        dataset.set_subset_ids(val_ids)\n",
    "\n",
    "# Load yolo predictor\n",
    "yolo_predictor = YOLOPredictor(yolo_weights)\n",
    "# For each item in the dataset\n",
    "gt_files = []\n",
    "pred_files = []\n",
    "for item in tqdm(dataset):\n",
    "    \n",
    "        cropped_image, crop_pad = crop_volume(item['image'], crop)\n",
    "    \n",
    "        # Get image slice\n",
    "        image_slices = get_slices(cropped_image)\n",
    "\n",
    "        # Get predicted slices\n",
    "        yolo_masks_slices = [yolo_predictor(slice, conf_th=confidance_th) \n",
    "                             for slice in image_slices]\n",
    "\n",
    "        # Create 3D volum\n",
    "        prob_volum = volume_from_slice_wpad(yolo_masks_slices, sitk.sitkFloat32, pad=crop_pad)  \n",
    "        bn_volum = binary_mask(prob_volum, output_format)\n",
    "        \n",
    "        # Get Detection Box adn add result\n",
    "        det_pos, det_size, conf  = best_bb_bounding_boxes(bn_volum, prob_volum)  \n",
    "        print(\"R:\", det_pos, det_size, conf)\n",
    "        detection_results.append( \n",
    "                [item['id']] + det_pos + det_size + [conf])     \n",
    "        \n",
    "        # Copy metadata from predited image\n",
    "        \n",
    "        \n",
    "        bn_volum.CopyInformation(item['image'])\n",
    "        \n",
    "        # Save NRRD mask prediction\n",
    "        mask_file = os.path.join(output_folder, output_file_template.format(item['id']))\n",
    "        sitk.WriteImage(bn_volum, mask_file, useCompression=True )\n",
    "        \n",
    "        # Save file names for evaluation\n",
    "        pred_files.append(mask_file)\n",
    "        if 'mask_path' in item:\n",
    "                gt_files.append(item['mask_path'])\n",
    "                \n",
    "                \n",
    "# Save detection results\n",
    "det_df = pd.DataFrame(detection_results, \n",
    "                      columns=['public_id', 'coordX', \n",
    "                      'coordY', 'coordZ', 'x_length', \n",
    "                      'y_length','z_length', 'probability'])\n",
    "det_df.to_csv(pred_csv, index=False)\n",
    "\n",
    "                \n",
    "if len(gt_files) > 0:\n",
    "        with open(os.path.join(output_folder,\"cases.json\"), \"w\") as fp:\n",
    "                json.dump({\"gt_files\": gt_files,\n",
    "                        \"pred_files\": pred_files,\n",
    "                        \"confidance_th\": confidance_th},fp)\n",
    "                \n",
    "\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "det_df_sorted = det_df.sort_values(by = 'public_id')\n",
    "pred_sorted_csv = os.path.join(output_folder, \"prediction_sorted.csv\")\n",
    "det_df_sorted.to_csv(pred_sorted_csv, index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "with open(os.path.join(output_folder,\"cases.json\"), \"w\") as fp:\n",
    "        json.dump({\"gt_files\": gt_files,\n",
    "                \"pred_files\": pred_files,\n",
    "                \"confidance_th\": confidance_th},fp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from TDSCABUS2023.Metrics import segmentation\n",
    "from TDSCABUS2023.Metrics import detection\n",
    "\n",
    "\n",
    "def Validate(pred_list, gt_list, cvs_pred_file = None, csv_gt_file = None):\n",
    "    \n",
    "    print(\"Segmentation:\")\n",
    "    print(\"------------------------------------------\")\n",
    "    \n",
    "    scores = {'DiceCoefficient': [], 'HDCoefficient': [], 'score': []}\n",
    "    for pred, gt in zip(pred_list, gt_list):\n",
    "        try:\n",
    "            result = segmentation.score_case(gt, pred)\n",
    "        except Exception as e:\n",
    "           result = {'DiceCoefficient': 0, 'HDCoefficient': 0, 'score': 0} #HD coefficient if fail?\n",
    "        print(\"Case:\", os.path.basename(pred), \"  Results:\",  result)\n",
    "        \n",
    "        for k, v in result.items():\n",
    "            scores[k].append(v)\n",
    "        \n",
    "    for k, values in scores.items():\n",
    "        values = np.array(values)\n",
    "        print(f\"\\n{k}:\")\n",
    "        print(f\"   - Min: {values.min():0.4f}\")\n",
    "        print(f\"   - Max: {values.max():0.4f}\")\n",
    "        print(f\"   - Mean: {values.mean():0.4f}\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['results_masks/abus23_25_test/raw_stack_train10_default/MASK_107.nii.gz', 'results_masks/abus23_25_test/raw_stack_train10_default/MASK_109.nii.gz', 'results_masks/abus23_25_test/raw_stack_train10_default/MASK_105.nii.gz', 'results_masks/abus23_25_test/raw_stack_train10_default/MASK_127.nii.gz', 'results_masks/abus23_25_test/raw_stack_train10_default/MASK_116.nii.gz', 'results_masks/abus23_25_test/raw_stack_train10_default/MASK_118.nii.gz', 'results_masks/abus23_25_test/raw_stack_train10_default/MASK_119.nii.gz', 'results_masks/abus23_25_test/raw_stack_train10_default/MASK_115.nii.gz', 'results_masks/abus23_25_test/raw_stack_train10_default/MASK_101.nii.gz', 'results_masks/abus23_25_test/raw_stack_train10_default/MASK_124.nii.gz', 'results_masks/abus23_25_test/raw_stack_train10_default/MASK_128.nii.gz', 'results_masks/abus23_25_test/raw_stack_train10_default/MASK_126.nii.gz', 'results_masks/abus23_25_test/raw_stack_train10_default/MASK_104.nii.gz', 'results_masks/abus23_25_test/raw_stack_train10_default/MASK_108.nii.gz', 'results_masks/abus23_25_test/raw_stack_train10_default/MASK_117.nii.gz', 'results_masks/abus23_25_test/raw_stack_train10_default/MASK_106.nii.gz', 'results_masks/abus23_25_test/raw_stack_train10_default/MASK_129.nii.gz', 'results_masks/abus23_25_test/raw_stack_train10_default/MASK_111.nii.gz', 'results_masks/abus23_25_test/raw_stack_train10_default/MASK_102.nii.gz', 'results_masks/abus23_25_test/raw_stack_train10_default/MASK_100.nii.gz', 'results_masks/abus23_25_test/raw_stack_train10_default/MASK_122.nii.gz', 'results_masks/abus23_25_test/raw_stack_train10_default/MASK_110.nii.gz', 'results_masks/abus23_25_test/raw_stack_train10_default/MASK_123.nii.gz', 'results_masks/abus23_25_test/raw_stack_train10_default/MASK_112.nii.gz', 'results_masks/abus23_25_test/raw_stack_train10_default/MASK_103.nii.gz', 'results_masks/abus23_25_test/raw_stack_train10_default/MASK_114.nii.gz', 'results_masks/abus23_25_test/raw_stack_train10_default/MASK_120.nii.gz', 'results_masks/abus23_25_test/raw_stack_train10_default/MASK_125.nii.gz', 'results_masks/abus23_25_test/raw_stack_train10_default/MASK_113.nii.gz', 'results_masks/abus23_25_test/raw_stack_train10_default/MASK_121.nii.gz']\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "gt_files = [g.replace(\"DATA\", \"MASK\") for g in gt_files]\n",
    "print(pred_files)\n",
    "print(gt_files)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Detection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if \"bbx_labels\" in locals():\n",
    "    # Addapt the cases for the etst\n",
    "    temp_csv = \"./temp_test.csv\"\n",
    "\n",
    "    val_ids = get_validation_ids(validation_file)\n",
    "    gt_info = pd.read_csv(gt_csv)\n",
    "    test_info = gt_info[gt_info.public_id.isin(val_ids)]\n",
    "    print(\"Subset:\\n------------------------------\\n\", test_info, \"\\n---------------------------------\")\n",
    "    test_info.to_csv(temp_csv, index=False)\n",
    "\n",
    "    if os.path.exists(gt_csv):\n",
    "        detection.eval_withprint(temp_csv, pred_csv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Segmentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validating.. (Conf: 0.6)\n",
      "Segmentation:\n",
      "------------------------------------------\n",
      "\n",
      "DiceCoefficient:\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "zero-size array to reduction operation minimum which has no identity",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[15], line 11\u001b[0m\n\u001b[1;32m      8\u001b[0m         confidance_th \u001b[39m=\u001b[39m json_data[\u001b[39m\"\u001b[39m\u001b[39mconfidance_th\u001b[39m\u001b[39m\"\u001b[39m]\n\u001b[1;32m     10\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mValidating.. (Conf: \u001b[39m\u001b[39m{\u001b[39;00mconfidance_th\u001b[39m}\u001b[39;00m\u001b[39m)\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[0;32m---> 11\u001b[0m Validate(pred_files, gt_files)\n",
      "Cell \u001b[0;32mIn[12], line 24\u001b[0m, in \u001b[0;36mValidate\u001b[0;34m(pred_list, gt_list, cvs_pred_file, csv_gt_file)\u001b[0m\n\u001b[1;32m     22\u001b[0m values \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(values)\n\u001b[1;32m     23\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m\\n\u001b[39;00m\u001b[39m{\u001b[39;00mk\u001b[39m}\u001b[39;00m\u001b[39m:\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[0;32m---> 24\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m   - Min: \u001b[39m\u001b[39m{\u001b[39;00mvalues\u001b[39m.\u001b[39;49mmin()\u001b[39m:\u001b[39;00m\u001b[39m0.4f\u001b[39m\u001b[39m}\u001b[39;00m\u001b[39m\"\u001b[39m)\n\u001b[1;32m     25\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m   - Max: \u001b[39m\u001b[39m{\u001b[39;00mvalues\u001b[39m.\u001b[39mmax()\u001b[39m:\u001b[39;00m\u001b[39m0.4f\u001b[39m\u001b[39m}\u001b[39;00m\u001b[39m\"\u001b[39m)\n\u001b[1;32m     26\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m   - Mean: \u001b[39m\u001b[39m{\u001b[39;00mvalues\u001b[39m.\u001b[39mmean()\u001b[39m:\u001b[39;00m\u001b[39m0.4f\u001b[39m\u001b[39m}\u001b[39;00m\u001b[39m\"\u001b[39m)\n",
      "File \u001b[0;32m~/abus23/py_env/py310_1/lib/python3.10/site-packages/numpy/core/_methods.py:44\u001b[0m, in \u001b[0;36m_amin\u001b[0;34m(a, axis, out, keepdims, initial, where)\u001b[0m\n\u001b[1;32m     42\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_amin\u001b[39m(a, axis\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, out\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, keepdims\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m,\n\u001b[1;32m     43\u001b[0m           initial\u001b[39m=\u001b[39m_NoValue, where\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m):\n\u001b[0;32m---> 44\u001b[0m     \u001b[39mreturn\u001b[39;00m umr_minimum(a, axis, \u001b[39mNone\u001b[39;49;00m, out, keepdims, initial, where)\n",
      "\u001b[0;31mValueError\u001b[0m: zero-size array to reduction operation minimum which has no identity"
     ]
    }
   ],
   "source": [
    "if \"gt_files\" not in locals() or \"pred_files\" not in locals():\n",
    "    if not os.path.exists(os.path.join(output_folder,\"cases.json\")):\n",
    "        print(f\"Data not found in {output_folder}\")\n",
    "    print(f\"Loading data from {output_folder}..\")\n",
    "    with open(os.path.join(output_folder,\"cases.json\")) as fp:\n",
    "        json_data = json.load(fp)\n",
    "        gt_files, pred_files = json_data[\"gt_files\"], json_data[\"pred_files\"]\n",
    "        confidance_th = json_data[\"confidance_th\"]\n",
    "\n",
    "print(f\"Validating.. (Conf: {confidance_th})\")\n",
    "Validate(pred_files, gt_files)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "py310_1",
   "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.6"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}