rcm-metadata-investigation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# RCM Project: Coordinate Metadata Simplified\n",
    "The coordinate system of the RCM project is difficult to understand, this notebook simplifies this by making all coordinates relative to the macroscopic image space."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imports\n",
    "from dsa_helpers.girder_utils import login\n",
    "from girder_client import GirderClient\n",
    "import numpy as np\n",
    "import ipywidgets as widgets\n",
    "import pickle\n",
    "import matplotlib.pyplot as plt\n",
    "import cv2 as cv\n",
    "from IPython.display import display\n",
    "from tqdm.notebook import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Functions\n",
    "def convert_str_coords_to_float(coords: str) -> list[float]:\n",
    "    \"\"\"Convert a string of coordinates of form \"[####, ####]\" to a list of floats.\n",
    "    \n",
    "    Args:\n",
    "        coords (str): The string of coordinates to convert.\n",
    "        \n",
    "    Returns:\n",
    "        list[float]: The coordinates as floats.\n",
    "        \n",
    "    \"\"\"\n",
    "    return [float(coord) for coord in coords.strip(\"[]\").split(\",\")]\n",
    "\n",
    "\n",
    "def calculate_shape_of_image(metadata: dict) -> dict:\n",
    "    \"\"\"Calculate the shape of an image given the coordinates and the width and height.\n",
    "    \n",
    "    Args:\n",
    "        metadata (dict): The metadata of the image.\n",
    "        \n",
    "    Returns:\n",
    "        dict: The shape of the image\n",
    "        \n",
    "    \"\"\"    \n",
    "    # Get the size of the image by the pixels in metadata.\n",
    "    coords = np.array([\n",
    "        convert_str_coords_to_float(metadata[\"a\"]),\n",
    "        convert_str_coords_to_float(metadata[\"b\"]),\n",
    "        convert_str_coords_to_float(metadata[\"c\"]),\n",
    "        convert_str_coords_to_float(metadata[\"d\"])\n",
    "    ])\n",
    "    \n",
    "    min_x = min(coords[:, 0])\n",
    "    max_x = max(coords[:, 0])\n",
    "    min_y = min(coords[:, 1])\n",
    "    max_y = max(coords[:, 1])\n",
    "    \n",
    "    # Return the width and height.\n",
    "    return {\"min_x\": min_x, \"max_x\": max_x, \"min_y\": min_y, \"max_y\": max_y, \n",
    "            \"width\": max_x - min_x, \"height\": max_y - min_y}\n",
    "\n",
    "\n",
    "def add_simplified_coordinates(gc: GirderClient, project_fld: dict) -> list[dict]:\n",
    "    \"\"\"For a given project folder, simplify the coordinates of each image to be \n",
    "    relative to the macroscopic image.\n",
    "    \n",
    "    Args:\n",
    "        gc (girder_client.GirderClient): The Girder client to use.\n",
    "        project_fld (dict): The project folder to process.\n",
    "        \n",
    "    Returns:\n",
    "        list[dict]: The simplified coordinates of each image.\n",
    "        \n",
    "    \"\"\"\n",
    "    # Look for the registration metadata.\n",
    "    reg_metadata = project_fld.get('meta', {}).get('registrationData', [])\n",
    "    \n",
    "    # Separate the macroscopic image from list from all other images.\n",
    "    macroscopic_metadata = None\n",
    "    other_metadata = []\n",
    "    \n",
    "    for img_metadata in reg_metadata:\n",
    "        img_type = img_metadata.get(\"type\")\n",
    "        \n",
    "        if img_type == \"macroscopic image\":\n",
    "            macroscopic_metadata = img_metadata\n",
    "        elif img_type in (\"confocal image\", \"vivastack\"):\n",
    "            other_metadata.append(img_metadata)\n",
    "            \n",
    "    # If we don't have a macroscopic image, we can't do anything.\n",
    "    metadata_to_add = []\n",
    "    \n",
    "    if macroscopic_metadata is not None:\n",
    "        # Get the large image metadata for the macroscopic image.\n",
    "        macroscopic_large_image_metadata = gc.get(\n",
    "            f\"item/{macroscopic_metadata['yamlId']}/tiles\"\n",
    "        )\n",
    "        \n",
    "        # Get the image width and height.\n",
    "        macroscopic_width = macroscopic_large_image_metadata[\"sizeX\"]\n",
    "        macroscopic_height = macroscopic_large_image_metadata[\"sizeY\"]\n",
    "        \n",
    "        # Get the size of the macroscopic image by the pixels in metadata.\n",
    "        macroscopic_shape = calculate_shape_of_image(macroscopic_metadata)\n",
    "        \n",
    "        # Calculate ratio to go from scan pixel value to actual pixel value.\n",
    "        pixel_factor = macroscopic_width / macroscopic_shape[\"width\"]\n",
    "        \n",
    "        # Loop through each other image. \n",
    "        for img_metadata in other_metadata:\n",
    "            # Get the coordinates of this image.\n",
    "            coords = calculate_shape_of_image(img_metadata)\n",
    "            \n",
    "            # For each x value, sutract min_x of macroscopic image and scale.\n",
    "            x_min = int((coords['min_x'] - macroscopic_shape['min_x']) * pixel_factor)\n",
    "            x_max = int((coords['max_x'] - macroscopic_shape['min_x']) * pixel_factor)\n",
    "            \n",
    "            # Repeat fo ry values.\n",
    "            y_min = int((coords['min_y'] - macroscopic_shape['min_y']) * pixel_factor)\n",
    "            y_max = int((coords['max_y'] - macroscopic_shape['min_y']) * pixel_factor)\n",
    "            \n",
    "            metadata_to_add.append({\n",
    "                \"x_min\": x_min, \"x_max\": x_max, \"y_min\": y_min, \"y_max\": y_max,\n",
    "                # add additiona info\n",
    "                \"description\": img_metadata.get(\"description\", \"\"),\n",
    "                \"fov_mm_x\": img_metadata.get(\"fov_mm_x\", \"\"),\n",
    "                \"fov_mm_y\": img_metadata.get(\"fov_mm_y\", \"\"),\n",
    "                \"type\": img_metadata.get(\"type\", \"\"),\n",
    "                \"slices\": img_metadata.get(\"slices\", \"\"),\n",
    "                \"itemid\": img_metadata.get(\"itemid\", \"\"),\n",
    "                \"timestamp\": img_metadata.get(\"timestamp\", \"\"),\n",
    "                \"z_um_bottom\": img_metadata.get(\"z_um_bottom\", \"\"),\n",
    "                \"z_um_top\": img_metadata.get(\"z_um_top\", \"\"),\n",
    "                \"yamlId\": img_metadata.get(\"yamlId\", \"\")\n",
    "            })\n",
    "            \n",
    "            \n",
    "    if len(metadata_to_add):\n",
    "        # Add the metadata.\n",
    "        _ = gc.addMetadataToFolder(project_fld[\"_id\"], \n",
    "                                  {\"registrationDataSimplified\":metadata_to_add})\n",
    "            \n",
    "    return metadata_to_add"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Authenticate girder client.\n",
    "gc = login(\"https://wsi-deid.pathology.emory.edu/api/v1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Folder id with image folders.\n",
    "root_fld_id = \"66104727ee87269983c87412\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the folders for each project, or group of images.\n",
    "project_flds = list(gc.listFolder(root_fld_id))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run the function for each project folder.\n",
    "for project_fld in tqdm(project_flds, desc=\"Adding Simplified Coordinates\"):\n",
    "    if project_fld['_id'] not in ('666b3623fa042d3a8432a579', '666b3afafa042d3a8432a672'):\n",
    "        _ = add_simplified_coordinates(gc, project_fld)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the folders again.\n",
    "project_flds = list(gc.listFolder(root_fld_id))\n",
    "\n",
    "# Use interactive view to see each image on the macroscopic image.\n",
    "sample_project = project_flds[0]\n",
    "\n",
    "# Get the macroscopic image.\n",
    "reg_metadata = sample_project[\"meta\"][\"registrationData\"]\n",
    "\n",
    "macroscopic_img = None\n",
    "\n",
    "for img_metadata in reg_metadata:\n",
    "    if img_metadata.get(\"type\") == \"macroscopic image\":\n",
    "        # Get the image.\n",
    "        macroscopic_img = gc.get(\n",
    "            f\"item/{img_metadata['yamlId']}/tiles/region?units=base_pixels&exact=false\"\n",
    "            \"&encoding=pickle&jpegQuality=95&jpegSubsampling=0\",\n",
    "            jsonResp=False\n",
    "        )\n",
    "        \n",
    "        # Convert from pickle to numpy.\n",
    "        macroscopic_img = pickle.loads(macroscopic_img.content)\n",
    "        break\n",
    "\n",
    "# Get the simplified registration metadata.\n",
    "reg_metadata = sample_project[\"meta\"].get(\"registrationDataSimplified\", [])\n",
    "\n",
    "# To make this faster - preload the images.\n",
    "for img_metadata in reg_metadata:\n",
    "    img = gc.get(\n",
    "        f\"item/{img_metadata['yamlId']}/tiles/region?units=base_pixels&exact=false\"\n",
    "        \"&encoding=pickle&jpegQuality=95&jpegSubsampling=0\",\n",
    "        jsonResp=False\n",
    "    )\n",
    "    \n",
    "    # Convert from pickle to numpy.\n",
    "    img_metadata[\"img\"] = pickle.loads(img.content)[:, :, 0]\n",
    "\n",
    "\n",
    "def show_image_on_macroscopic_image(idx: int):\n",
    "    # Draw the box on the macroscopic image.\n",
    "    img_metadata = reg_metadata[idx]\n",
    "    \n",
    "    # Get this image.\n",
    "    small_img = img_metadata[\"img\"]\n",
    "    \n",
    "    # Get the coordinates.\n",
    "    x_min = img_metadata[\"x_min\"]\n",
    "    x_max = img_metadata[\"x_max\"]\n",
    "    y_min = img_metadata[\"y_min\"]\n",
    "    y_max = img_metadata[\"y_max\"]\n",
    "    \n",
    "    \n",
    "    # Draw the box.\n",
    "    img = cv.rectangle(macroscopic_img.copy(), (x_min, y_min), (x_max, y_max), \n",
    "                       (0, 255, 0), 2)\n",
    "    \n",
    "    # Plot both images side by side.\n",
    "    plt.figure(figsize=(10, 5))\n",
    "    plt.subplot(1, 2, 1)\n",
    "    plt.imshow(img)\n",
    "    plt.subplot(1, 2, 2)\n",
    "    plt.imshow(small_img, cmap=\"gray\")\n",
    "    plt.show()\n",
    "    \n",
    "    \n",
    "# Create the interactive view.\n",
    "img_slider = widgets.IntSlider(value=0, min=0, max=len(reg_metadata) - 1, continuous_update=False)\n",
    "out = widgets.interactive(show_image_on_macroscopic_image, idx=img_slider)\n",
    "\n",
    "# Create the layout.\n",
    "ui = widgets.VBox([img_slider, out.children[-1]])\n",
    "display(ui)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "env",
   "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.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}