notebooks/PatchPositions.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the list of the names\n",
    "\n",
    "import glob\n",
    "\n",
    "The_list = []\n",
    "sls = glob.glob(\"Path/To/Thumbnails/*.png\")\n",
    "for i in sls:\n",
    "    The_list.append(str(i[11:-4]))\n",
    "\n",
    "\n",
    "len(The_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import os\n",
    "import fast\n",
    "import cv2\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Select GPU\n",
    "# os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\"\n",
    "\n",
    "## if two levels of patches are to be used, if only one is used lvl3_B_p_size can be ignored\n",
    "lvl3_B_p_size = 256 * 3\n",
    "lvl3_s_p_size = 256\n",
    "Th_B_p_size = 51\n",
    "\n",
    "\n",
    "# get the sizes:\n",
    "\n",
    "Slides_test = The_list[0:20]\n",
    "\n",
    "SlNames_train = The_list[20:76]\n",
    "\n",
    "SlNames_valid = The_list[76:97]\n",
    "\n",
    "\n",
    "def get_sizes_into_set(SlideNames, SlideDir, ThumbDir, EmptySet):\n",
    "    for filename in SlideNames:\n",
    "        if not isinstance(filename, str):\n",
    "            filename = filename.numpy().decode(\"utf-8\")\n",
    "\n",
    "        importer = fast.WholeSlideImageImporter.create(SlideDir + filename + \".vsi\")\n",
    "        wsi = importer.runAndGetOutputData()\n",
    "        plane_height5 = wsi.getLevelHeight(5)\n",
    "        plane_width5 = wsi.getLevelWidth(5)\n",
    "        plane_height3 = wsi.getLevelHeight(3)\n",
    "        plane_width3 = wsi.getLevelWidth(3)\n",
    "        thumbnail = cv2.imread(ThumbDir + filename + \".png\")\n",
    "        thumbnail_height = thumbnail.shape[0]\n",
    "        thumbnail_width = thumbnail.shape[1]\n",
    "        # print(filename+': ', [plane_height5, plane_width5, plane_height3, plane_width3, thumbnail_height, thumbnail_width])\n",
    "        EmptySet[filename] = [\n",
    "            plane_height5,\n",
    "            plane_width5,\n",
    "            plane_height3,\n",
    "            plane_width3,\n",
    "            thumbnail_height,\n",
    "            thumbnail_width,\n",
    "        ]\n",
    "\n",
    "\n",
    "def get_initial_starting_pos(Slides):\n",
    "\n",
    "    # finding the last posion on the thumbnail to stop forming patches\n",
    "    last_pos_X = []\n",
    "    last_pos_Y = []\n",
    "    for Nmbr, filename in enumerate(Slides):\n",
    "        last_pos_X.append(lvl3_B_p_size * (math.floor(Slides[filename][3] / lvl3_B_p_size)) - 256)\n",
    "        last_pos_Y.append(lvl3_B_p_size * (math.floor(Slides[filename][2] / lvl3_B_p_size)) - 256)\n",
    "\n",
    "    # finding the starting positions of X for lvl3_B_patches\n",
    "    Start_pos_X_small = []\n",
    "    Start_pos_Y_small = []\n",
    "\n",
    "    Start_pos_X_big = []\n",
    "    Start_pos_Y_big = []\n",
    "\n",
    "    for indx, filename in enumerate(Slides):\n",
    "        Start_pos_X_small.append(list(range((256) * 2, last_pos_X[indx], int(lvl3_B_p_size / 3))))\n",
    "        Start_pos_Y_small.append(list(range((256) * 2, last_pos_Y[indx], int(lvl3_B_p_size / 3))))\n",
    "\n",
    "    for i, _ in enumerate(Start_pos_X_small):\n",
    "        Start_pos_X_big.append([])\n",
    "        for j in Start_pos_X_small[i]:\n",
    "            Start_pos_X_big[i].append(round(j - 256 * 1.5))\n",
    "\n",
    "    for i, _ in enumerate(Start_pos_Y_small):\n",
    "        Start_pos_Y_big.append([])\n",
    "        for j in Start_pos_Y_small[i]:\n",
    "            Start_pos_Y_big[i].append(round(j - 256 * 1.5))\n",
    "\n",
    "    # getting the fifth level starting positions:\n",
    "\n",
    "    Start_pos_X_fifthLevel = []\n",
    "    Start_pos_Y_fifthLevel = []\n",
    "\n",
    "    for indx, filename in enumerate(Slides):\n",
    "        Start_pos_X_fifthLevel.append([])\n",
    "        for ind, _ in enumerate(Start_pos_X_big[indx]):\n",
    "            Start_pos_X_fifthLevel[indx].append(\n",
    "                round((Start_pos_X_big[indx][ind] / Slides[filename][3]) * Slides[filename][1])\n",
    "            )\n",
    "        Start_pos_Y_fifthLevel.append([])\n",
    "        for ind2, _ in enumerate(Start_pos_Y_big[indx]):\n",
    "            Start_pos_Y_fifthLevel[indx].append(\n",
    "                round((Start_pos_Y_big[indx][ind2] / Slides[filename][2]) * Slides[filename][0])\n",
    "            )\n",
    "\n",
    "    # # get the corresponding Th_B_patch starting positions from Start_pos_X and Start_pos_Y, so you can check the tissue and GT\n",
    "\n",
    "    Th_Start_pos_X_small = []\n",
    "    Th_Start_pos_Y_small = []\n",
    "\n",
    "    Th_Start_pos_X_big = []\n",
    "    Th_Start_pos_Y_big = []\n",
    "\n",
    "    for indx, filename in enumerate(Slides):\n",
    "        Th_Start_pos_X_small.append([])\n",
    "        for ind, _ in enumerate(Start_pos_X_small[indx]):\n",
    "            Th_Start_pos_X_small[indx].append(\n",
    "                round((Start_pos_X_small[indx][ind] / Slides[filename][3]) * Slides[filename][5])\n",
    "            )  # we add thr 20 to get the central small patch not the big one then the patch size should be 10px\n",
    "        Th_Start_pos_Y_small.append([])\n",
    "        for ind2, _ in enumerate(Start_pos_Y_small[indx]):\n",
    "            Th_Start_pos_Y_small[indx].append(\n",
    "                round((Start_pos_Y_small[indx][ind2] / Slides[filename][2]) * Slides[filename][4])\n",
    "            )  # we add thr 20 to get the central small patch not the big one then the patch size should be 10px\n",
    "\n",
    "        Th_Start_pos_X_big.append([])\n",
    "        for ind, _ in enumerate(Start_pos_X_fifthLevel[indx]):\n",
    "            Th_Start_pos_X_big[indx].append(\n",
    "                round((Start_pos_X_fifthLevel[indx][ind] / Slides[filename][1]) * Slides[filename][5])\n",
    "            )  # we add thr 20 to get the central small patch not the big one then the patch size should be 10px\n",
    "        Th_Start_pos_Y_big.append([])\n",
    "        for ind2, _ in enumerate(Start_pos_Y_fifthLevel[indx]):\n",
    "            Th_Start_pos_Y_big[indx].append(\n",
    "                round((Start_pos_Y_fifthLevel[indx][ind2] / Slides[filename][0]) * Slides[filename][4])\n",
    "            )  # we add thr 20 to get the central small patch not the big one then the patch size should be 10px\n",
    "\n",
    "    return (\n",
    "        Start_pos_X_small,\n",
    "        Start_pos_Y_small,\n",
    "        Start_pos_X_big,\n",
    "        Start_pos_Y_big,\n",
    "        Start_pos_X_fifthLevel,\n",
    "        Start_pos_Y_fifthLevel,\n",
    "        Th_Start_pos_X_small,\n",
    "        Th_Start_pos_Y_small,\n",
    "        Th_Start_pos_X_big,\n",
    "        Th_Start_pos_Y_big,\n",
    "    )\n",
    "\n",
    "\n",
    "Slides_train = {}\n",
    "\n",
    "get_sizes_into_set(SlNames_train, \"Path/To/WSIs/\", \"/Path/To/Thumbnails/\", Slides_train)\n",
    "\n",
    "\n",
    "Slides_valid = {}\n",
    "\n",
    "get_sizes_into_set(SlNames_valid, \"Path/To/WSIs/\", \"/Path/To/Thumbnails/\", Slides_valid)\n",
    "\n",
    "\n",
    "(\n",
    "    Start_pos_X_small_train,\n",
    "    Start_pos_Y_small_train,\n",
    "    Start_pos_X_big_train,\n",
    "    Start_pos_Y_big_train,\n",
    "    Start_pos_X_fifthLevel_train,\n",
    "    Start_pos_Y_fifthLevel_train,\n",
    "    Th_Start_pos_X_small_train,\n",
    "    Th_Start_pos_Y_small_train,\n",
    "    Th_Start_pos_X_big_train,\n",
    "    Th_Start_pos_Y_big_train,\n",
    ") = get_initial_starting_pos(Slides_train)\n",
    "(\n",
    "    Start_pos_X_small_valid,\n",
    "    Start_pos_Y_small_valid,\n",
    "    Start_pos_X_big_valid,\n",
    "    Start_pos_Y_big_valid,\n",
    "    Start_pos_X_fifthLevel_valid,\n",
    "    Start_pos_Y_fifthLevel_valid,\n",
    "    Th_Start_pos_X_small_valid,\n",
    "    Th_Start_pos_Y_small_valid,\n",
    "    Th_Start_pos_X_big_valid,\n",
    "    Th_Start_pos_Y_big_valid,\n",
    ") = get_initial_starting_pos(Slides_valid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Visualizing the patch results\n",
    "\n",
    "image = cv2.imread(\"/Path/To/Thumbnails/\" + SlNames_train[0] + \".png\")\n",
    "\n",
    "for start_y in Th_Start_pos_Y_small_train[0]:\n",
    "    for start_x in Th_Start_pos_X_small_train[0]:\n",
    "        end_x = start_x + 10\n",
    "        end_y = start_y + 10\n",
    "        cv2.rectangle(image, (start_x, start_y), (end_x, end_y), (0, 255, 0), 1)  # Draws a green rectangle\n",
    "\n",
    "for start_y in Th_Start_pos_Y_big_train[0][0:1]:\n",
    "    for start_x in Th_Start_pos_X_big_train[0]:\n",
    "        end_x = start_x + 40\n",
    "        end_y = start_y + 40\n",
    "        cv2.rectangle(image, (start_x, start_y), (end_x, end_y), (255, 0, 0), 1)  # Draws a green rectangle\n",
    "\n",
    "plt.imshow(image)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create tissue masks\n",
    "\n",
    "# Path to the folder containing the image thumbnails\n",
    "folder_path = \"/Path/To/Thumbnails/\"\n",
    "\n",
    "# Path to the folder where you want to save the masks\n",
    "save_path = \"/Path/To/TissueMask/Results/\"\n",
    "\n",
    "# Create the save folder if it doesn't exist\n",
    "if not os.path.exists(save_path):\n",
    "    os.makedirs(save_path)\n",
    "\n",
    "# Iterate over the images in the folder\n",
    "for filename in os.listdir(folder_path):\n",
    "    if filename.endswith(\".jpg\") or filename.endswith(\".png\"):\n",
    "        # Read the image\n",
    "        image_path = os.path.join(folder_path, filename)\n",
    "        image = cv2.imread(image_path)\n",
    "\n",
    "        # Apply Gaussian blur to the image\n",
    "        blurred = cv2.GaussianBlur(image, (15, 15), 0)\n",
    "\n",
    "        # Convert the blurred image to grayscale\n",
    "        gray = cv2.cvtColor(blurred, cv2.COLOR_BGR2GRAY)\n",
    "\n",
    "        # Threshold the image to obtain the mask\n",
    "        _, mask = cv2.threshold(gray, 210, 255, cv2.THRESH_BINARY_INV)\n",
    "\n",
    "        # Save the mask\n",
    "        mask_filename = os.path.splitext(filename)[0] + \".png\"\n",
    "        mask_path = os.path.join(save_path, mask_filename)\n",
    "        cv2.imwrite(mask_path, mask)\n",
    "\n",
    "print(\"Masks saved successfully!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "image = cv2.imread(\"/Path/To/Thumbnails/\" + SlNames_train[0] + \".png\")\n",
    "tissue = cv2.imread(\"/Path/To/TissueMask/Results/\" + SlNames_train[0] + \".png\")\n",
    "\n",
    "for indx1, start_y in enumerate(Th_Start_pos_Y_small_train[0]):\n",
    "    for indx2, start_x in enumerate(Th_Start_pos_X_small_train[0]):\n",
    "        end_x = start_x + 10\n",
    "        end_y = start_y + 10\n",
    "\n",
    "        tissue_patch = tissue[start_y:end_y, start_x:end_x, :]\n",
    "        if len(tissue_patch[tissue_patch > 40]) > 0.3 * len(tissue_patch[tissue_patch < 300]):\n",
    "            cv2.rectangle(image, (start_x, start_y), (end_x, end_y), (0, 0, 0), 4)  # Draws a green rectangle\n",
    "            # patches = load_patches([Start_pos_X[0][indx2]+512], [Start_pos_Y[0][indx1]+512], \"D:/WSIs/WSIs/\" + 'HUS_L_005_IC' + \".vsi\", 3, 256)\n",
    "            # img = np.array(patches[0])\n",
    "            # cv2.imwrite('./test/'+'HUS_L_005_IC'+'X'+str(indx2)+'Y'+str(indx1)+'.png', img)\n",
    "\n",
    "\n",
    "plt.imshow(image)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## getting the final positions\n",
    "\n",
    "\n",
    "def get_clusters_label(arr):\n",
    "\n",
    "    unique_values, counts = np.unique(arr, return_counts=True)\n",
    "\n",
    "    # Find the index of the most dominant value\n",
    "    dominant_index = np.argmax(counts)\n",
    "\n",
    "    # Check if the most dominant value is zero\n",
    "    if unique_values[dominant_index] == 0:\n",
    "        # Find the next most dominant value by excluding zero from consideration\n",
    "        non_zero_counts = counts[unique_values != 0]\n",
    "        non_zero_values = unique_values[unique_values != 0]\n",
    "        next_dominant_index = np.argmax(non_zero_counts)\n",
    "        dominant_value = non_zero_values[next_dominant_index]\n",
    "    else:\n",
    "        # If the most dominant value is not zero, return it\n",
    "        dominant_value = unique_values[dominant_index]\n",
    "\n",
    "    return dominant_value\n",
    "\n",
    "\n",
    "def get_final_starting_pos(\n",
    "    startingPositions,\n",
    "    gts,\n",
    "    Slides,\n",
    "    Th_Start_pos_Y_small,\n",
    "    Th_Start_pos_X_small,\n",
    "    Start_pos_X_fifthLevel,\n",
    "    Start_pos_Y_fifthLevel,\n",
    "    Start_pos_X_small,\n",
    "    Start_pos_Y_small,\n",
    "):\n",
    "\n",
    "    for indx, filename in enumerate(Slides):\n",
    "\n",
    "        # startingPositions.append([])\n",
    "        # gts.append([])\n",
    "        print(indx)\n",
    "\n",
    "        name = str(list(Slides.keys())[indx])\n",
    "\n",
    "        tissue = cv2.imread(\"/Path/To/TissueMask/Results/\" + name + \".png\")\n",
    "        gt = cv2.imread(\"/Path/To/GTs/\" + name + \".png\")\n",
    "        clusters = np.load(\"/Path/To/ClusterResults/\" + name + \".npy\")\n",
    "\n",
    "        for indx1, start_y in enumerate(Th_Start_pos_Y_small[indx]):\n",
    "            for indx2, start_x in enumerate(Th_Start_pos_X_small[indx]):\n",
    "                end_x = start_x + 10\n",
    "                end_y = start_y + 10\n",
    "\n",
    "                tissue_patch = tissue[start_y:end_y, start_x:end_x, :]\n",
    "                gt_patch = gt[start_y:end_y, start_x:end_x, :]\n",
    "\n",
    "                if len(tissue_patch[tissue_patch > 40]) > 0.6 * len(tissue_patch[tissue_patch < 300]):\n",
    "                    # patches = load_patches([Start_pos_X[indx][indx2]+512], [Start_pos_Y[indx][indx1]+512], \"D:/WSIs/WSIs/\" + name + \".vsi\", 3, 256)\n",
    "                    # img = np.array(patches[0])\n",
    "                    # starting positions = [name, lvl5, lvl3]\n",
    "                    label = get_clusters_label(clusters)\n",
    "                    startingPositions.append(\n",
    "                        [\n",
    "                            \"Path/To/WSIs/\" + name + \".vsi\",\n",
    "                            [Start_pos_X_fifthLevel[indx][indx2]],\n",
    "                            [Start_pos_Y_fifthLevel[indx][indx1]],\n",
    "                            [Start_pos_X_small[indx][indx2]],\n",
    "                            [Start_pos_Y_small[indx][indx1]],\n",
    "                            label,\n",
    "                        ]\n",
    "                    )\n",
    "\n",
    "                    if len(gt_patch[gt_patch > 25]) > 0.25 * len(gt_patch[gt_patch < 300]):\n",
    "                        # cv2.imwrite('./test/tumor/'+'HUS_L_005_IC'+'X'+str(indx2)+'Y'+str(indx1)+'.png', img)\n",
    "                        gts.append(1)\n",
    "                        # cv2.imwrite('./test/tumor/'+name+'X'+str(indx2)+'Y'+str(indx1)+'.png', gt_patch)\n",
    "\n",
    "                    elif len(gt_patch[gt_patch < 20]) > 0.90 * len(gt_patch[gt_patch < 300]):\n",
    "                        gts.append(0)\n",
    "                        # cv2.imwrite('./test/healthy/'+name+'X'+str(indx2)+'Y'+str(indx1)+'.png', gt_patch)\n",
    "\n",
    "                    else:\n",
    "                        startingPositions.pop()\n",
    "\n",
    "                    # if len(gt_patch[gt_patch < 10]) > 0.8 * len(gt_patch[gt_patch < 300]):\n",
    "                    # cv2.imwrite('./test/healthy/'+'HUS_L_005_IC'+'X'+str(indx2)+'Y'+str(indx1)+'.png', img)\n",
    "\n",
    "\n",
    "# starting positions = [[name, lvl5X, lvl5Y, lvl3X, lvl3Y]]\n",
    "startingPositions_train = []\n",
    "gts_train = []\n",
    "\n",
    "\n",
    "startingPositions_valid = []\n",
    "gts_valid = []\n",
    "\n",
    "\n",
    "get_final_starting_pos(\n",
    "    startingPositions_train,\n",
    "    gts_train,\n",
    "    Slides_train,\n",
    "    Th_Start_pos_Y_small_train,\n",
    "    Th_Start_pos_X_small_train,\n",
    "    Start_pos_X_fifthLevel_train,\n",
    "    Start_pos_Y_fifthLevel_train,\n",
    "    Start_pos_X_small_train,\n",
    "    Start_pos_Y_small_train,\n",
    ")\n",
    "get_final_starting_pos(\n",
    "    startingPositions_valid,\n",
    "    gts_valid,\n",
    "    Slides_valid,\n",
    "    Th_Start_pos_Y_small_valid,\n",
    "    Th_Start_pos_X_small_valid,\n",
    "    Start_pos_X_fifthLevel_valid,\n",
    "    Start_pos_Y_fifthLevel_valid,\n",
    "    Start_pos_X_small_valid,\n",
    "    Start_pos_Y_small_valid,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export starting positions\n",
    "\n",
    "import pickle\n",
    "\n",
    "# Saving the lists to a file\n",
    "with open(\"PositionsAndGts_train.pkl\", \"wb\") as file:\n",
    "    pickle.dump(startingPositions_train, file)\n",
    "    pickle.dump(gts_train, file)\n",
    "\n",
    "\n",
    "with open(\"PositionsAndGts_valid.pkl\", \"wb\") as file:\n",
    "    pickle.dump(startingPositions_valid, file)\n",
    "    pickle.dump(gts_valid, file)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}