notebooks/multi_material-CT_scan-low_dose.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c81ec0d9-e184-4185-8e63-0b9ec47cf274",
   "metadata": {
    "id": "4DrP1n1sjg-e"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/TomographicImaging/gVXR-Tutorials/blob/main/notebooks/multi_material-lungman_phantom.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0fe41a6-8340-40b7-b4a5-a239daab3fb7",
   "metadata": {
    "id": "be4b4b61-7abb-440c-9605-486bce082901"
   },
   "outputs": [],
   "source": [
    "# -*- coding: utf-8 -*-\n",
    "#\n",
    "#  Copyright 2025 United Kingdom Research and Innovation\n",
    "#\n",
    "#  Licensed under the Apache License, Version 2.0 (the \"License\");\n",
    "#  you may not use this file except in compliance with the License.\n",
    "#  You may obtain a copy of the License at\n",
    "#\n",
    "#      http://www.apache.org/licenses/LICENSE-2.0\n",
    "#\n",
    "#  Unless required by applicable law or agreed to in writing, software\n",
    "#  distributed under the License is distributed on an \"AS IS\" BASIS,\n",
    "#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
    "#  See the License for the specific language governing permissions and\n",
    "#  limitations under the License.\n",
    "#\n",
    "#   Authored by:    Franck Vidal (UKRI-STFC)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ffcfed3-2145-4ba8-8715-17327e58b0d2",
   "metadata": {
    "id": "LitIbS2Yjg-g",
    "tags": []
   },
   "source": [
    "![gVXR](https://github.com/TomographicImaging/gVXR-Tutorials/blob/main/img/Logo-transparent-small.png?raw=1)\n",
    "\n",
    "# Low-dose CT scan with the Lungman phantom\n",
    "\n",
    "In this notebook you will use the knowledge learned in [Multi-material example: Lungman phantom](multi_material-CT_scan.ipynb). \n",
    "For the sake of realism, we will use an antrhopomorphic phantom this time, the [Lungman anthropomorphic chest phantom](https://doi.org/10.1117/1.JMI.5.1.013504) (Kyoto Kagaku, Tokyo, Japan). \n",
    "When it was originally scanned, there were nodules. \n",
    "It makes it a perfect example for illustrating low-dose CBCT in oncology. \n",
    "There are two ways to reduce the radiation dose in CT: lower the exposure, or reduce the number of projections taken. \n",
    "This notebook let you explore both strategies. \n",
    "\n",
    "![Change picture](change picture)\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\">\n",
    "    <b>Note:</b> Make sure the Python packages are already installed. See <a href=\"../README.md\">README.md</a> in the root directory of the repository. If you are running this notebook from Google Colab, please run the cell below to install the required packages.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e174bf3-e7a7-4df9-a0ad-75baccc01d4c",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "bSYJhBjCjg-h",
    "outputId": "443ab78d-3838-498c-dfe5-addd6f3cf186"
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = 'google.colab' in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !pip install gvxr SimpleITK k3d spekpy xpecgen"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1961536e-deac-495f-8459-433f36efe3cd",
   "metadata": {
    "id": "77W1AXNQjg-h"
   },
   "source": [
    "## Aims of this session\n",
    "\n",
    "\n",
    "1. Simulate a low-dose CBCT scan acquisition using gVXR, either\n",
    "    - adding quite a bit of noise to mimic a low exposure, and/or\n",
    "    - reducing the number of projections taken around the patient.\n",
    "2. Reconstruct the CT volume using the Core Imaging Library (CIL) with\n",
    "    - the filtered-back projection (FBP), and\n",
    "    - a gradient descent (iterative).\n",
    "\n",
    "![CT reconstructions](https://github.com/TomographicImaging/gVXR-Tutorials/blob/main/notebooks/output_data/multi_material-CT_scan-low_dose/reconstruction.png?raw=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea0ad5b2-dab2-4df9-9128-5d1292dc4bb7",
   "metadata": {
    "id": "rxBXwyIbjg-i"
   },
   "source": [
    "<!-- ## Summary of the simulation parameters\n",
    "\n",
    "| Parameters | Values | Units | Function call |\n",
    "|------------|--------|-------|---------------|\n",
    "| Source to patient distance | ??? | mm | `gvxr.setSourcePosition(...)` |\n",
    "| Source type (beam shape) | Point source (cone beam) | | `gvxr.usePointSource()` |\n",
    "| Beam spectrum | Polychromatic: 100 | kV | `gvxr.setMonoChromatic(...)` |\n",
    "| Source to detector distance | 100–182.5 | cm | `gvxr.setDetectorPosition(...)` |\n",
    "| Detector model | Varian a-Si | |  |\n",
    "| Detector orientation | [0, 0, -1] |  | `gvxr.setDetectorUpVector(...)` |\n",
    "| Detector resolution | 1190 &times; 1190 | pixels | `gvxr.setDetectorNumberOfPixels(...)` |\n",
    "| Pixel spacing | 0.33613445 &times; 0.33613445 | mm | `gvxr.setDetectorPixelSize(...)` |\n",
    "| Scintillator material | GOS phosphor |  | ??? |\n",
    "| Scintillator thickness | 0.290 | mm |   |\n",
    "| Detector \"cover\" | 1 | mm |  |\n",
    "\n",
    "\n",
    "kVp: 100\n",
    "Exposure time (in msec): 285\n",
    "Exposure time (in sec): 0.28500000000000003\n",
    "X-ray Tube Current (in mA): 175\n",
    "Exposure (in mAs): 83\n",
    "Distance Source to Detector (in mm): 1085.6\n",
    "Distance Source to Patient (in mm): 595.0\n",
    "Rows and columns: 512 512\n",
    "Pixel Spacing (in mm):  [0.625, 0.625]\n",
    "Slice Thickness (in mm):  1.0\n",
    "Volume size (in px):  512x512x426\n",
    "Corrected slice Thickness (in mm):  -86.1\n",
    " -->\n",
    "\n",
    "<!-- doi: 10.4172/2155-9619.1000354 -->\n",
    "<!-- DOI 10.1088/1361-6560/ab12aa -->\n",
    "\n",
    "<!-- a-Si 1200 -->\n",
    "<!-- 1190 × 1190 -->\n",
    "<!-- 0.34 0.33613445 -->\n",
    "<!-- GOS phosphor: A layer of phosphor that is 0.290 mm thick -->\n",
    "<!-- Copper build-up: A component that is the same thickness as the MLI (1 mm)  -->\n",
    "\n",
    "\n",
    "<!-- Tube voltage: 40–150 kV -->\n",
    "<!-- Source to image distance (SID): 100–182.5 cm -->\n",
    "<!-- Slice thickness: 1.0–5.0 mm -->\n",
    "<!-- Reconstructed volume resolution: Up to 512 × 512 -->\n",
    "<!-- Scan modes: Half-fan (HF) and full-fan (FF) -->\n",
    "<!-- Field of view (FOV): 24 cm for FF and 45 cm for HF -->\n",
    "<!-- X-ray source peak voltage: 100 kVp for head scans and 125 kVp for abdominal scans  -->"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4dea73c-4c57-4171-93d0-58f003b9b606",
   "metadata": {
    "id": "98anuGe-jg-i"
   },
   "source": [
    "## Import packages\n",
    "\n",
    "- `os` to create the output directory if needed\n",
    "- `matplotlib` to show 2D images\n",
    "- `SimpleITK` to load the DICOM file\n",
    "- `gvxr` to simulate X-ray images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "00443714-17d0-427f-9b11-e073415ae56a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os # Create the output directory if necessary\n",
    "import numpy as np # Who does not use Numpy?\n",
    "import datetime # Record the runtime to simulate the data\n",
    "\n",
    "import matplotlib # To plot images\n",
    "import matplotlib.pyplot as plt # Plotting\n",
    "from matplotlib.colors import LogNorm # Look up table\n",
    "from matplotlib.colors import PowerNorm # Look up table\n",
    "\n",
    "font = {'family' : 'serif',\n",
    "         'size'   : 15\n",
    "       }\n",
    "matplotlib.rc('font', **font)\n",
    "\n",
    "# Uncomment the line below to use LaTeX fonts\n",
    "# matplotlib.rc('text', usetex=True)\n",
    "\n",
    "import SimpleITK as sitk # To load the DICOM files\n",
    "\n",
    "import ipywidgets as widgets # To create widgets (user interface)\n",
    "\n",
    "# Simulation\n",
    "from gvxrPython3 import gvxr\n",
    "from gvxrPython3.utils import loadSpekpySpectrum\n",
    "from gvxrPython3.utils import plotScreenshot\n",
    "\n",
    "# Use temporary bug fix\n",
    "if os.path.exists(\"gvxr2json.py\"):\n",
    "    print(\"Use temporary bug fix\")\n",
    "    import gvxr2json\n",
    "#Use the file provided by gVXR's package\n",
    "else:\n",
    "    print(\"Use the file provided by gVXR's package\")\n",
    "    from gvxrPython3 import gvxr2json\n",
    "\n",
    "# Get the phantom data (will be integrated in gVXR's Python package in the next release, i.e. 2.0.9)\n",
    "from utils import downloadLungman, extractLungmanSTL, extractLungmanDX, extractLungmanCT, loadLungmanMeshes\n",
    "\n",
    "# CT reconstruction\n",
    "from gvxrPython3.gVXRDataReader import *\n",
    "from cil.framework.image_data import DataContainer\n",
    "from cil.processors import TransmissionAbsorptionConverter\n",
    "from cil.utilities.display import show_geometry, show2D\n",
    "from cil.utilities.jupyter import islicer, link_islicer\n",
    "from cil.recon import FBP, FDK\n",
    "from cil.plugins.astra.processors.FDK_Flexible import FDK_Flexible\n",
    "\n",
    "# GD_LS\n",
    "from cil.optimisation.algorithms import GD\n",
    "from cil.plugins.astra import ProjectionOperator\n",
    "from cil.optimisation.functions import LeastSquares\n",
    "from cil.processors import Slicer\n",
    "from cil.plugins.ccpi_regularisation.functions import FGP_TV"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35095b46-e3dd-4c8d-bc16-4bc442c49831",
   "metadata": {},
   "source": [
    "## Getting the data ready\n",
    "\n",
    "Where to save the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c5f1f8e-7b10-4f8a-a733-b1fb78d3a9f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "output_path = \"output_data/multi_material-CT_scan-low_dose\"\n",
    "if not os.path.exists(output_path):\n",
    "    os.makedirs(output_path);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10b6b99a-8e4f-430a-b55b-562806a87401",
   "metadata": {},
   "source": [
    "Download the data from [Zenodo](https://zenodo.org/records/10782644)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0094acd7-bd53-4c8d-9526-41f17a1c3a23",
   "metadata": {},
   "outputs": [],
   "source": [
    "zip_fname, lungman_path, mesh_path, CT_path = downloadLungman()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0607065-f6c8-4be2-a2a8-a25c754bdbcc",
   "metadata": {},
   "source": [
    "Extract the STL files from the ZIP file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "92a7f679-0ebf-43fd-86d8-ad85ac10e163",
   "metadata": {},
   "outputs": [],
   "source": [
    "stl_fname_set = extractLungmanSTL(zip_fname, lungman_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5913ad4d",
   "metadata": {},
   "source": [
    "Extract CT slices (DICOM files) from the ZIP file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "09a79e71",
   "metadata": {},
   "outputs": [],
   "source": [
    "CT_DICOM_fname_set = extractLungmanCT(zip_fname, \n",
    "                                      CT_path,\n",
    "                                      [\"CT000308\", \"CT000309\", \"CT000114\", \"CT000067\"]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da2cf8a6",
   "metadata": {},
   "source": [
    "Extract the Digital Radiograph (DX) (a DICOM file) from the ZIP file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "451afdf1",
   "metadata": {},
   "outputs": [],
   "source": [
    "DX_DICOM_fname_set = extractLungmanDX(zip_fname, lungman_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a005f1d2",
   "metadata": {},
   "source": [
    "## Read the ground truth Lungman data\n",
    "\n",
    "<!-- The data is store in DICOM files. The first slice is loaded manually to extract the metadata. The volume is loaded as a DICOM series. -->\n",
    "\n",
    "We will start with the first, second, middle and last CT slices, and we end with the digital radiograph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8065c84a",
   "metadata": {},
   "outputs": [],
   "source": [
    "reader = sitk.ImageFileReader();\n",
    "reader.SetImageIO(\"GDCMImageIO\");\n",
    "reader.LoadPrivateTagsOn();\n",
    "\n",
    "reader.SetFileName(CT_DICOM_fname_set[0]);\n",
    "reader.ReadImageInformation();    \n",
    "sitk_reference_first_CT_slice = reader.Execute();\n",
    "raw_reference_first_CT_slice = sitk.GetArrayFromImage(sitk_reference_first_CT_slice)[0];\n",
    "\n",
    "reader.SetFileName(CT_DICOM_fname_set[1]);\n",
    "reader.ReadImageInformation();    \n",
    "sitk_reference_second_CT_slice = reader.Execute();\n",
    "raw_reference_second_CT_slice = sitk.GetArrayFromImage(sitk_reference_second_CT_slice)[0];\n",
    "\n",
    "reader.SetFileName(CT_DICOM_fname_set[2]);\n",
    "reader.ReadImageInformation();    \n",
    "sitk_reference_middle_CT_slice = reader.Execute();\n",
    "raw_reference_middle_CT_slice = sitk.GetArrayFromImage(sitk_reference_middle_CT_slice)[0];\n",
    "\n",
    "reader.SetFileName(CT_DICOM_fname_set[-1]);\n",
    "reader.ReadImageInformation();    \n",
    "sitk_reference_last_CT_slice = reader.Execute();\n",
    "raw_reference_last_CT_slice = sitk.GetArrayFromImage(sitk_reference_last_CT_slice)[0];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fb073b7c",
   "metadata": {},
   "outputs": [],
   "source": [
    "reader.SetFileName(DX_DICOM_fname_set[0]);\n",
    "reader.ReadImageInformation();    \n",
    "sitk_reference_DX = reader.Execute();\n",
    "raw_reference_DX = sitk.GetArrayFromImage(sitk_reference_DX)[0];"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41fc716e",
   "metadata": {},
   "source": [
    "Extract information useful for the simulation from the DICOM files:\n",
    "\n",
    "- CT volume:\n",
    "    - The number of voxels, and\n",
    "    - The voxel size.\n",
    "- DX image:\n",
    "    - The image size and the physical pixel spacing (i.e. not taking into account the magnification),\n",
    "    - The number of pixels,\n",
    "    - The distance from the source to the detector, and\n",
    "    - The distance from the source to the patient."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1aae195",
   "metadata": {},
   "source": [
    "The \"slice thickness\" is calculated from the positions of two neighbouring slices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f476c4bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "number_of_voxels = [\n",
    "    int(sitk_reference_first_CT_slice.GetMetaData(\"0028|0010\")),\n",
    "    int(sitk_reference_first_CT_slice.GetMetaData(\"0028|0011\")),\n",
    "    426\n",
    "]\n",
    "\n",
    "voxel_spacing = np.array(sitk_reference_first_CT_slice.GetMetaData(\"0028|0030\").split(\"\\\\\")).astype(np.single).tolist()\n",
    "voxel_spacing.append(abs(float(sitk_reference_first_CT_slice.GetMetaData(\"0020|1041\")) - float(sitk_reference_second_CT_slice.GetMetaData(\"0020|1041\"))))\n",
    "\n",
    "print(\"Number of voxels:\", number_of_voxels)\n",
    "print(\"Voxel spacing:\", voxel_spacing, \"mm\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fbe924cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute vmin and vmax according to the DICOM file\n",
    "window_centre = int(sitk_reference_middle_CT_slice.GetMetaData(\"0028|1050\").split(\"\\\\\")[1]) \n",
    "window_width = int(sitk_reference_middle_CT_slice.GetMetaData(\"0028|1051\").split(\"\\\\\")[1]) \n",
    "\n",
    "vmin = window_centre - window_width / 2\n",
    "vmax = window_centre + window_width / 2\n",
    "\n",
    "fig = plt.figure();\n",
    "plt.imshow(raw_reference_middle_CT_slice, cmap=\"gray\", vmin=vmin, vmax=vmax,\n",
    "                             extent=[0,(raw_reference_middle_CT_slice.shape[1]-1)*voxel_spacing[0],0,(raw_reference_middle_CT_slice.shape[0]-1)*voxel_spacing[1]])\n",
    "plt.title(\"Middle slice of the Lungman phantom\")\n",
    "plt.xlabel(\"Pixel position\\n(in mm)\")\n",
    "plt.ylabel(\"Pixel position\\n(in mm)\")\n",
    "plt.colorbar()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "13ae7882",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extract the information from the DICOM header\n",
    "imager_pixel_spacing = np.array(sitk_reference_DX.GetMetaData(\"0018|1164\").split(\"\\\\\")).astype(np.single);\n",
    "detector_element_spacing = np.array(sitk_reference_DX.GetMetaData(\"0018|7022\").split(\"\\\\\")).astype(np.single);\n",
    "print(\"Imager Pixel Spacing (in mm): \", imager_pixel_spacing, \"(with magnification)\");\n",
    "print(\"Detector Element Spacing (in mm): \", detector_element_spacing, \"(without magnification)\");\n",
    "\n",
    "# Extract the number of pixels\n",
    "size = sitk_reference_DX.GetSize()[0:2]\n",
    "print(\"Image size (in pixels): \", str(size[0]) + \" x \" + str(size[1]))\n",
    "\n",
    "# Extract the information from the DICOM header\n",
    "distance_source_to_detector = float(sitk_reference_DX.GetMetaData(\"0018|1110\"))\n",
    "distance_source_to_patient = float(sitk_reference_DX.GetMetaData(\"0018|1111\"))\n",
    "\n",
    "print(\"Distance Source to Detector: \", distance_source_to_detector, \"mm\")\n",
    "print(\"Distance Source to Patient: \", distance_source_to_patient, \"mm\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47bdf9a4",
   "metadata": {},
   "source": [
    "We also extract the visualisation window to show the image using the 'harder' window."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dbdab54c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute vmin and vmax according to the DICOM file\n",
    "window_centre = int(sitk_reference_DX.GetMetaData(\"0028|1050\").split(\"\\\\\")[1]) # Use 0 for normal, 1 for harder, 2 for softer\n",
    "window_width = int(sitk_reference_DX.GetMetaData(\"0028|1051\").split(\"\\\\\")[1]) # Use 0 for normal, 1 for harder, 2 for softer\n",
    "\n",
    "vmin = window_centre - window_width / 2\n",
    "vmax = window_centre + window_width / 2\n",
    "\n",
    "\n",
    "fig = plt.figure();\n",
    "plt.imshow(raw_reference_DX, cmap=\"gray\", vmin=vmin, vmax=vmax,\n",
    "                             extent=[0,(raw_reference_DX.shape[1]-1)*imager_pixel_spacing[0],0,(raw_reference_DX.shape[0]-1)*imager_pixel_spacing[1]])\n",
    "plt.title(\"Digital radiograph of the Lungman phantom\")\n",
    "plt.xlabel(\"Pixel position\\n(in mm)\")\n",
    "plt.ylabel(\"Pixel position\\n(in mm)\")\n",
    "plt.colorbar()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "473a1a8f",
   "metadata": {},
   "source": [
    "\n",
    "## Extract experiment parameters from the DICOM metadata of the digital radiograph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e4f7b70d",
   "metadata": {},
   "outputs": [],
   "source": [
    "kvp = float(sitk_reference_DX.GetMetaData(\"0018|0060\"))\n",
    "exposure_time_in_ms = int(sitk_reference_DX.GetMetaData(\"0018|1150\"))\n",
    "exposure_time_in_sec = 0.001 * exposure_time_in_ms\n",
    "xray_tube_current_in_mA = int(sitk_reference_DX.GetMetaData(\"0018|1151\"))\n",
    "xray_tube_current_in_mA = int(sitk_reference_DX.GetMetaData(\"0018|1153\"))\n",
    "exposure_in_mAs = int(sitk_reference_DX.GetMetaData(\"0018|1152\"))\n",
    "exposure_in_uAs = int(sitk_reference_DX.GetMetaData(\"0018|1153\"))\n",
    "distance_source_to_detector = float(sitk_reference_DX.GetMetaData(\"0018|1110\"))\n",
    "distance_source_to_patient = float(sitk_reference_DX.GetMetaData(\"0018|1111\"))\n",
    "detector_element_spacing = np.array(sitk_reference_DX.GetMetaData(\"0018|7022\").split(\"\\\\\")).astype(np.single);\n",
    "\n",
    "rows = int(sitk_reference_DX.GetMetaData(\"0028|0010\"))\n",
    "columns = int(sitk_reference_DX.GetMetaData(\"0028|0011\"))\n",
    "\n",
    "ref_size = [rows, columns, 426] #ref_volume.GetSize()\n",
    "\n",
    "# slice_thickness = float(volume.GetMetaData(\"0018|0050\"))\n",
    "\n",
    "print(\"kVp:\", kvp)\n",
    "print(\"Exposure time (in msec):\", exposure_time_in_ms)\n",
    "print(\"Exposure time (in sec):\", exposure_time_in_sec)\n",
    "print(\"X-ray Tube Current (in mA):\", xray_tube_current_in_mA)\n",
    "print(\"Exposure (in mAs):\", exposure_in_mAs)\n",
    "print(\"Exposure (in uAs):\", exposure_in_uAs)\n",
    "print(\"Distance Source to Detector (in mm):\", distance_source_to_detector)\n",
    "print(\"Distance Source to Patient (in mm):\", distance_source_to_patient)\n",
    "print(\"Rows and columns:\", rows, columns)\n",
    "print(\"Detector Element Spacing (in mm): \", detector_element_spacing, \"(without magnification)\");"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b724fb07-e8d2-4cfa-aa55-accbe431c6cc",
   "metadata": {
    "id": "cvuPTNdejg-k"
   },
   "source": [
    "## 1. Create an OpenGL context\n",
    "\n",
    "The first step is to create the simulation environment, known here as \"OpenGL context\".\n",
    "`gvxr.createOpenGLContext` will try to find the most suitable environment possible regardless of the operating system. This is an alternative function to `gvxr.createNewContext` used in [test_installation.ipynb](test_installation.ipynb)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0f64449d-55fc-4132-a843-d4a1d0394c76",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "O3l2mW4Fjg-k",
    "outputId": "d420b660-1997-460e-ecc0-45677479141d"
   },
   "outputs": [],
   "source": [
    "# gvxr.createOpenGLContext();\n",
    "# or \n",
    "# backend = \"OPENGL\";\n",
    "backend = \"EGL\";\n",
    "gvxr.createNewContext(backend);\n",
    "#\n",
    "# with backend a string. Two backends are currently available:\n",
    "#\n",
    "#     \"OPENGL\": makes use of the windowing ability of your system. It can be used for realtime visualisations. \n",
    "#               It is available on Windows, GNU/Linux and MacOS computers.\n",
    "#     \"EGL\": is for offscreen rendering on GNU/Linux computers. That's the option for cloud instances and supercomputers."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1c7650d-a26e-431d-b16e-dba0e50f9487",
   "metadata": {},
   "source": [
    "We increase the size of the visualisation framebuffer to generate higher resolution screenshots. It does not affect the simulation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "739f08cc-5824-4d4c-b4a2-0c7263310e3f",
   "metadata": {},
   "outputs": [],
   "source": [
    "gvxr.setWindowSize(1000, 1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "067dd9f6",
   "metadata": {},
   "source": [
    "## 2. Set the Sample\n",
    "\n",
    "A sample is define by its geometry (surface) and material composition. Note that you can transform (translate, scale and rotate) a sample."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "af97a304",
   "metadata": {},
   "outputs": [],
   "source": [
    "loadLungmanMeshes(mesh_path)\n",
    "skin_bbox = gvxr.getNodeOnlyBoundingBox(\"skin\", \"mm\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b51ac480",
   "metadata": {},
   "source": [
    "## 3. Set the Detector\n",
    "\n",
    "A detector is defined by its position, orientation, pixel resolution and the space between the centre of two consecutive pixels along its two axes. Here we also set a scintillator. To speed-up everything, we downscale the simulation by a factor of 4."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f1d26da",
   "metadata": {},
   "outputs": [],
   "source": [
    "gvxr.setDetectorPosition(0, \n",
    "    -(skin_bbox[1] + distance_source_to_patient - distance_source_to_detector), \n",
    "    0, \n",
    "    \"mm\");\n",
    "gvxr.setDetectorUpVector(0, 0, 1);\n",
    "gvxr.setDetectorNumberOfPixels(columns // 4, rows // 4);\n",
    "gvxr.setDetectorPixelSize(*(detector_element_spacing * 4), \"mm\");\n",
    "gvxr.setScintillator(\"CsI\", 600, \"um\");\n",
    "\n",
    "print(\"Detector position:\", gvxr.getDetectorPosition(\"mm\"), \"mm\")\n",
    "print(\"Detector up vector:\", gvxr.getDetectorUpVector())\n",
    "print(\"Detector number of pixels:\", gvxr.getDetectorNumberOfPixels())\n",
    "print(\"Pixel spacing:\", gvxr.getDetectorPixelSpacing(\"mm\"), \"mm\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba530d5f",
   "metadata": {},
   "source": [
    "Plot the energy response of the detector."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4f8e0c2f",
   "metadata": {},
   "outputs": [],
   "source": [
    "detector_response = np.array(gvxr.getEnergyResponse(\"keV\"));\n",
    "\n",
    "plt.figure(figsize= (20,10))\n",
    "# plt.title(\"Detector response\")\n",
    "plt.plot(detector_response[:,0], detector_response[:,1])\n",
    "plt.xlabel('Incident energy: E (in keV)')\n",
    "plt.ylabel('Detector energy response: $\\\\delta$(E) (in keV)')\n",
    "\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.savefig(output_path + '/detector_response.pdf')\n",
    "plt.savefig(output_path + '/detector_response.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ffb6ed56",
   "metadata": {},
   "source": [
    "## 4. Set the X-ray source\n",
    "\n",
    "We must set it's position and beam shape. We will use the distance from the DICOM file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2ae7d25e-8acf-4065-ac5b-526e9f03193e",
   "metadata": {},
   "outputs": [],
   "source": [
    "gvxr.setSourcePosition(0, \n",
    "    -(distance_source_to_detector + skin_bbox[1] + distance_source_to_patient - distance_source_to_detector), \n",
    "    0, \n",
    "    \"mm\");    \n",
    "gvxr.useParallelSource();\n",
    "\n",
    "print(\"Source position:\", gvxr.getSourcePosition(\"mm\"), \"mm\")\n",
    "print(\"Source shape:\", gvxr.getSourceShape())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d9305d9-35f5-4f89-9656-c25e26c97971",
   "metadata": {
    "id": "faqHVUZDjg-l"
   },
   "source": [
    "## 5. Set the Spectrum\n",
    "\n",
    "We define here the number of photons and their kinetic energy.\n",
    "Again, we will use the \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2cfca6e8-f695-46ef-84ea-83ceb454b11c",
   "metadata": {
    "id": "tA4L8T8Njg-l"
   },
   "outputs": [],
   "source": [
    "filtration = None;\n",
    "\n",
    "source_detector_distance = np.linalg.norm(np.array(gvxr.getSourcePosition(\"cm\")) - np.array(gvxr.getDetectorPosition(\"cm\")))\n",
    "\n",
    "spectrum = loadSpekpySpectrum(kvp, \n",
    "    filters=filtration,\n",
    "    th_in_deg=12,\n",
    "    max_number_of_energy_bins=50,\n",
    "    mAs=exposure_in_mAs,\n",
    "    z=source_detector_distance\n",
    "    );"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1175000",
   "metadata": {},
   "source": [
    "\n",
    "Plot the beam spectrum computed with Spekpy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22562134-6a2e-452f-aabe-003bb3b21cbc",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize= (20,10))\n",
    "# plt.title(\"Beam spectrum\")\n",
    "plt.bar(spectrum[1], spectrum[2], width=1)\n",
    "plt.xlabel('Energy in keV')\n",
    "plt.ylabel('Probability distribution of photons per keV')\n",
    "plt.savefig(output_path + \"/spectrum.pdf\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "318ccf85-51b9-4df4-9b3c-384c362bf341",
   "metadata": {
    "id": "FWhKJqMBjg-n"
   },
   "source": [
    "## 6. Compute the corresponding X-ray image.\n",
    "\n",
    "It is possible to compute, retrieve and save an X-ray image as well as the path length of X-ray through an object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "02e8f49d-86d2-4e4e-9360-9f4f6274bce4",
   "metadata": {},
   "outputs": [],
   "source": [
    "x_ray_image = np.array(gvxr.computeXRayImage(), dtype=np.single) / gvxr.getTotalEnergyWithDetectorResponse();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a780a562-7f2e-4b8e-88a3-f5828907f7fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "plotScreenshot()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b29996ab",
   "metadata": {},
   "source": [
    "# Tweak the spectrum and photon flux\n",
    "\n",
    "---\n",
    "## Task:\n",
    "\n",
    "- Run the cell below,\n",
    "- Using the sliders, modify the spectrum. Lower the exposure to add noise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ccf32d47",
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "from scipy import *\n",
    "import matplotlib.pyplot as plt\n",
    "from ipywidgets import interact, FloatSlider\n",
    "from IPython.display import display\n",
    "import spekpy as sp\n",
    "\n",
    "number_of_white_images = 10\n",
    "new_exposure_time_in_msec = None\n",
    "\n",
    "def ms2mAs(ms):\n",
    "    original_mAs = (exposure_in_uAs / 1000.0)\n",
    "    original_current_in_mA = original_mAs / exposure_time_in_sec;\n",
    "    return original_current_in_mA * (ms / 1000.0)\n",
    "\n",
    "\n",
    "## Plot parameters\n",
    "xmin, xmax, nx = 0.0, 10.0, 50\n",
    "ymin, ymax = -1.2, 1.2\n",
    "pmin, pmax, pstep, pinit = -3.2, 3.2, 0.2, 0.0\n",
    "\n",
    "## Set up the plot data\n",
    "x     = np.linspace(xmin, xmax, nx)\n",
    "fig, axs = plt.subplots(nrows=1, ncols=3, figsize=(10,5))\n",
    "line, = axs[0].plot([], [], linewidth=2) # Initialize curve to empty data.\n",
    "\n",
    "## Set up the figure axes, etc.\n",
    "axs[0].set_title(\"Tube spectrum\")\n",
    "axs[0].set_xlim(xmin, xmax)\n",
    "# axs[0].set_ylim(ymin, ymax)\n",
    "axs[0].set_xlabel('Energy in keV')\n",
    "axs[0].set_ylabel('Number photons per keV per cm$^2$')\n",
    "\n",
    "axs[1].set_title(\"X-ray image\\nUsing a log LUT\")\n",
    "\n",
    "axs[2].set_title(\"Intensity profile\\nmiddle row\")\n",
    "# axs[2].set_xlim(xmin, xmax)\n",
    "# axs[2].set_ylim(ymin, ymax)\n",
    "axs[2].set_xlabel('Pixel position')\n",
    "axs[2].set_ylabel('Pixel intensity')\n",
    "line_profile, = axs[2].plot([], [], linewidth=2) # Initialize curve to empty data.\n",
    "\n",
    "hfig = display(fig, display_id=True)\n",
    "plt.close(fig)\n",
    "\n",
    "def on_apply_button_clicked(_):\n",
    "    plt.clf()\n",
    "\n",
    "    global number_of_white_images, x_ray_image\n",
    "    global new_exposure_time_in_msec\n",
    "\n",
    "    number_of_white_images = white_slider.value\n",
    "    kvp = kV_slider.value\n",
    "    new_exposure_time_in_msec = exposure_time_slider.value\n",
    "\n",
    "    source_detector_distance = np.linalg.norm(np.array(gvxr.getSourcePosition(\"cm\")) - np.array(gvxr.getDetectorPosition(\"cm\")))\n",
    "\n",
    "    # Generate and load the corresponding spectrum\n",
    "    spectrum = loadSpekpySpectrum(kvp, \n",
    "        filters=None,\n",
    "        th_in_deg=12,\n",
    "        max_number_of_energy_bins=50,\n",
    "        mAs=ms2mAs(new_exposure_time_in_msec),\n",
    "        z=source_detector_distance\n",
    "        );\n",
    "    \n",
    "    if len(spectrum[1]) == len(spectrum[2]) and len(spectrum[1]) > 0:\n",
    "        axs[0].set_xlim(0, kvp)\n",
    "        axs[0].set_ylim(0, np.max(spectrum[2]))\n",
    "        line.set_data(spectrum[1], spectrum[2])\n",
    "    else:\n",
    "        line.set_data([], [])\n",
    "    \n",
    "    gvxr.enablePoissonNoise()\n",
    "\n",
    "    x_ray_image = np.array(gvxr.computeXRayImage()) / gvxr.getUnitOfEnergy(\"MeV\")\n",
    "    \n",
    "    if number_of_white_images > 0:\n",
    "        white_image = np.array(gvxr.getWhiteImage()) / gvxr.getUnitOfEnergy(\"MeV\")\n",
    "        for i in range(number_of_white_images - 1):\n",
    "            white_image += np.array(gvxr.getWhiteImage()) / gvxr.getUnitOfEnergy(\"MeV\")\n",
    "        white_image /= number_of_white_images\n",
    "\n",
    "        x_ray_image /= white_image\n",
    "\n",
    "    x_ray_image[x_ray_image<0.0] = 1e-5\n",
    "    axs[1].imshow(np.log(x_ray_image), cmap=\"gray\")\n",
    "\n",
    "    \n",
    "    row = x_ray_image[x_ray_image.shape[0] // 2]\n",
    "    line_profile.set_data(np.arange(len(row)), row)\n",
    "    axs[2].set_xlim(0, len(row) - 1)\n",
    "    axs[2].set_ylim(0, np.max(row))\n",
    "\n",
    "    fig.canvas.draw()\n",
    "    hfig.update(fig)\n",
    "\n",
    "\n",
    "apply_button = widgets.Button(description=\"Apply\")\n",
    "apply_button.on_click(on_apply_button_clicked)\n",
    "\n",
    "# Select the voltage\n",
    "kV_slider = widgets.IntSlider(\n",
    "    value=100,\n",
    "    min=20,\n",
    "    max=200,\n",
    "    step=1,\n",
    "    description='kV:'\n",
    ")\n",
    "\n",
    "# Select the mAs\n",
    "exposure_time_slider = widgets.FloatSlider(\n",
    "    value=exposure_time_in_ms,\n",
    "    min=0.01,\n",
    "    max=15,\n",
    "    step=0.25,\n",
    "    description='Exposure time in ms:',\n",
    ")\n",
    "\n",
    "white_slider = widgets.IntSlider(\n",
    "    value=number_of_white_images,\n",
    "    min=0,\n",
    "    max=100,\n",
    "    step=1,\n",
    "    description='White images:',\n",
    ")\n",
    "\n",
    "on_apply_button_clicked(None)\n",
    "\n",
    "display(widgets.VBox([kV_slider, exposure_time_slider, white_slider, apply_button]))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df89a759",
   "metadata": {},
   "source": [
    "# Select the number of projections\n",
    "\n",
    "---\n",
    "## Task:\n",
    "\n",
    "- Run the cell below,\n",
    "- Using the slider, lower the number of projections (the lower, the faster the simulation and reconstruction)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c252b555",
   "metadata": {},
   "source": [
    "To speed-up computations, reduce the size of the detector so that it is almost linear."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2e14bba9",
   "metadata": {},
   "outputs": [],
   "source": [
    "gvxr.setDetectorNumberOfPixels(columns, 3);\n",
    "default_number_of_projections = gvxr.getOptimalNumberOfProjectionsCT()\n",
    "\n",
    "projection_slider = widgets.IntSlider(\n",
    "        value=default_number_of_projections,\n",
    "        min=50,\n",
    "        max=round(default_number_of_projections*1.5),\n",
    "        step=1,\n",
    "        description='Projections:',\n",
    "    )\n",
    "\n",
    "def on_reset_button_clicked(_):\n",
    "    projection_slider.value = default_number_of_projections\n",
    "    \n",
    "reset_button = widgets.Button(description=\"Reset\")\n",
    "reset_button.on_click(on_reset_button_clicked)\n",
    "\n",
    "display(widgets.VBox([projection_slider, reset_button]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "852c1076",
   "metadata": {},
   "source": [
    "# Perform the CT simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "63bf7eb3",
   "metadata": {},
   "outputs": [],
   "source": [
    "number_of_projections = projection_slider.value;\n",
    "\n",
    "number_of_white_images = white_slider.value\n",
    "\n",
    "translation_vector_in_mm = [\n",
    "    skin_bbox[0] + (skin_bbox[3] - skin_bbox[0]) / 2.0,\n",
    "    skin_bbox[1] + (skin_bbox[4] - skin_bbox[1]) / 2.0,\n",
    "    skin_bbox[2] + (skin_bbox[5] - skin_bbox[2]) / 2.0,\n",
    "]\n",
    "\n",
    "start_time = datetime.datetime.now()\n",
    "\n",
    "CT_output_path = os.path.join(output_path, \"projections-\" + str(number_of_projections)+\"-\" + str(new_exposure_time_in_msec) +\"mAs\")\n",
    "gvxr.computeCTAcquisition(CT_output_path, # the path where the X-ray projections will be saved.\n",
    "                                                                    # If the path is empty, the data will be stored in the main memory, but not saved on the disk.\n",
    "                                                                    # If the path is provided, the data will be saved on the disk, and the main memory released.\n",
    "                          os.path.join(output_path, \"screenshots-\" + str(number_of_projections)), # the path where the screenshots will be saved.\n",
    "                                                                    # If kept empty, not screenshot will be saved.\n",
    "                          projection_slider.value, # The total number of projections to simulate.\n",
    "                          0, # The rotation angle corresponding to the first projection.\n",
    "                          True, # A boolean flag to include or exclude the last angle. It is used to calculate the angular step between successive projections.\n",
    "                          360,\n",
    "                          number_of_white_images, # The number of white images used to perform the flat-field correction. If zero, then no correction will be performed.\n",
    "                          *translation_vector_in_mm, # The location of the rotation centre.\n",
    "                          \"mm\", # The corresponding unit of length.\n",
    "                          *gvxr.getDetectorUpVector(), # The rotation axis\n",
    "                          True # If true the energy fluence is returned, otherwise the number of photons is returned\n",
    "                               # (default value: true)\n",
    ");\n",
    "\n",
    "end_time = datetime.datetime.now()\n",
    "delta_time = end_time - start_time\n",
    "total_run_time_in_sec = delta_time.total_seconds()\n",
    "run_time_in_msec_per_frame = total_run_time_in_sec * 1000 / number_of_projections\n",
    "\n",
    "print(\"Total runtime for\", number_of_projections, \"projections:\", total_run_time_in_sec, \"[sec]\")\n",
    "print(\"Runtime per frame:\", run_time_in_msec_per_frame, \"[msec]\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db3b8134",
   "metadata": {},
   "source": [
    "# Perform the CT reconstruction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7a98815",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read the simulated data with CIL.\n",
    "reader = gVXRDataReader(CT_output_path, -np.array(gvxr.getAngleSetCT()));\n",
    "data = reader.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f328a226",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_corr = TransmissionAbsorptionConverter(min_intensity=1e-6, white_level=data.max())(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "00496036",
   "metadata": {},
   "outputs": [],
   "source": [
    "ag = data_corr.geometry #.get_slice(vertical='centre')\n",
    "ig = ag.get_ImageGeometry()\n",
    "\n",
    "ig.voxel_num_x = number_of_voxels[0]\n",
    "ig.voxel_num_y = number_of_voxels[1]\n",
    "\n",
    "# # A linear detector is used\n",
    "if gvxr.getDetectorNumberOfPixels()[1] == 3:\n",
    "    ig.voxel_num_z = 3\n",
    "else:\n",
    "    ig.voxel_num_z = number_of_voxels[2]\n",
    "\n",
    "ig.voxel_size_x = voxel_spacing[0]\n",
    "ig.voxel_size_y = voxel_spacing[1]\n",
    "ig.voxel_size_z = voxel_spacing[2]\n",
    "\n",
    "print(ig)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eadec9a4",
   "metadata": {},
   "source": [
    "## FBP (analytic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3fb973fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_corr.reorder(order='tigre')\n",
    "FBP_reconstruction = FBP(data_corr, ig).run()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "748c396f",
   "metadata": {},
   "outputs": [],
   "source": [
    "islicer(FBP_reconstruction, title=\"FBP or FDK\", cmap='gray', origin='upper-right')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0179ac0",
   "metadata": {},
   "source": [
    "## Gradient descent (iterative)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bed08555",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_corr.reorder(\"astra\")\n",
    "\n",
    "A = ProjectionOperator(ig, ag, device=\"gpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3e20bee7",
   "metadata": {},
   "outputs": [],
   "source": [
    "b = data_corr\n",
    "f1 = LeastSquares(A, b)\n",
    "x0 = ig.allocate(0.0)\n",
    "f1(x0);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4f2928b",
   "metadata": {},
   "outputs": [],
   "source": [
    "GD_LS = GD(initial=x0, \n",
    "    objective_function=f1, \n",
    "    step_size=None, \n",
    "    max_iteration=1000, \n",
    "    update_objective_interval=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a436c073",
   "metadata": {},
   "outputs": [],
   "source": [
    "GD_LS.run(1000, verbose=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da7f5469",
   "metadata": {},
   "outputs": [],
   "source": [
    "islicer(GD_LS.solution, title=\"Gradient Descent\", cmap='gray', origin='upper-right')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f28831e",
   "metadata": {},
   "source": [
    "## Comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4797463f",
   "metadata": {},
   "outputs": [],
   "source": [
    "middle_slice_FBP_reconstruction = FBP_reconstruction.get_slice(vertical='centre')\n",
    "middle_slice_GD_reconstruction = GD_LS.solution.get_slice(vertical='centre')\n",
    "mirrored_reference = np.fliplr(raw_reference_middle_CT_slice)\n",
    "\n",
    "mean_FBP = np.mean(middle_slice_FBP_reconstruction.as_array())\n",
    "std_FBP = np.std(middle_slice_FBP_reconstruction.as_array())\n",
    "\n",
    "mean_REF = np.mean(mirrored_reference)\n",
    "std_REF = np.std(mirrored_reference)\n",
    "\n",
    "mirrored_reference = (mirrored_reference - mean_REF) / std_REF\n",
    "mirrored_reference = (mirrored_reference + mean_FBP) * std_FBP\n",
    "\n",
    "reference = DataContainer(mirrored_reference)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87fe24cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "show2D([reference, middle_slice_FBP_reconstruction, middle_slice_GD_reconstruction], \n",
    "    title=[\"Ground truth\", \"FBP or FDK\", \"Gradient Descent\"],\n",
    "    axis_labels=[[\"\", \"\"], [\"\", \"\"], [\"\", \"\"]], \n",
    "    num_cols=3,\n",
    "    size=[15,5]).save(os.path.join(output_path, \"reconstruction.png\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "020b7394",
   "metadata": {},
   "source": [
    "# Happy?\n",
    "\n",
    "Depending on the parameters set previously, you may not be happy with the results.\n",
    "\n",
    "---\n",
    "## Task:\n",
    "\n",
    "- Go back to the sliders above,\n",
    "- Adjust the noise level and the number of projections, and\n",
    "- Re-run all the subsequent cells until the end of the notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ce68bc6-9fab-4818-b09f-5159873fae2c",
   "metadata": {
    "id": "1vrbJFWzjg-p"
   },
   "source": [
    "# Cleaning up\n",
    "\n",
    "Once we have finished, it is good practice to clean up the OpenGL contexts and windows with the following command. Note that due to the object-oriented programming nature of the core API of gVXR, this step is automatic anyway."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f8713a20-0639-4ebf-be91-34c76d362e1c",
   "metadata": {
    "id": "2ldO2muTjg-p"
   },
   "outputs": [],
   "source": [
    "# Works on Windows (gvxr >= 2.0.9)\n",
    "# Will work on Linux (gvxr >= 2.0.10)\n",
    "if os.name == 'nt':\n",
    "    gvxr.destroy(); \n",
    "# Does not work on Windows.\n",
    "# Deprecated, for backward compatibility on Linux.\n",
    "else:\n",
    "    gvxr.terminate(); "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}