{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Tutorial 9: Lu177 Medium Energy Collimator Modeling" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", " - - - - - - - - - - - -\n", " P A R A L L E L | P R O J\n", " - - - - - - - - - - - -\n", "\n", " =================================================\n", "\n", " Please consider citing our publication\n", " ---------------------------------------------\n", " Georg Schramm and Kris Thielemans:\n", " \"PARALLELPROJ—an open-source framework for\n", " fast calculation of projections in\n", " tomography\"\n", " Front. Nucl. Med., 08 January 2024\n", " Sec. PET and SPECT, Vol 3\n", " https://doi.org/10.3389/fnume.2023.1324562\n", "\n", " =================================================\n", " \n", " parallelproj C lib: /data/anaconda/envs/pytomo_install_test/lib/libparallelproj_c.so.1.8.0\n", " parallelproj CUDA lib: /data/anaconda/envs/pytomo_install_test/lib/libparallelproj_cuda.so.1.8.0\n", " \n" ] } ], "source": [ "\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import torch\n", "import torch.optim as optim\n", "from spectpsftoolbox.simind_io import get_projections, get_source_detector_distances\n", "from spectpsftoolbox.operator2d import GaussianOperator, Kernel2DOperator\n", "from spectpsftoolbox.kernel2d import NGonKernel2D\n", "from spectpsftoolbox.simind_io import get_projections, get_source_detector_distances\n", "import pytomography\n", "from pytomography.io.SPECT import simind\n", "from pytomography.io.SPECT.shared import subsample_projections_and_modify_metadata, subsample_amap\n", "from pytomography.projectors.SPECT import SPECTSystemMatrix\n", "from pytomography.transforms.SPECT import SPECTAttenuationTransform, SPECTPSFTransform\n", "from pytomography.algorithms import OSEM\n", "from pytomography.likelihoods import PoissonLogLikelihood\n", "device = pytomography.device" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "headerpaths = np.array([f'/disk1/psf_data/208keV_ME_PSF/point_position{i}_tot_w1.h00' for i in range(538,1638)])\n", "respaths = np.array([f'/disk1/psf_data/208keV_ME_PSF/point_position{i}.res' for i in range(538,1638)])\n", "distances_all = get_source_detector_distances(respaths).to(device)\n", "projectionss_data = get_projections(headerpaths).to(device)[:,1:,1:]\n", "projectionss_data_norm = get_projections(headerpaths).to(device).sum(dim=(1,2)).mean()\n", "\n", "distances = torch.tensor([1,5,10,15,20,25,30,35,40,45,50,55.]).to(device)\n", "differences = torch.abs(distances[:, None] - distances_all)\n", "indices = list(torch.argmin(differences, dim=1).cpu())\n", "headerpaths = headerpaths[indices]\n", "respaths = respaths[indices]\n", "distances = get_source_detector_distances(respaths).to(device)\n", "projectionss_data = get_projections(headerpaths).to(device)[:,1:,1:] / projectionss_data_norm\n", "a_min = torch.min(distances).item()\n", "a_max = torch.max(distances).item()" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/tmp/ipykernel_5858/3805311267.py:4: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n", " xv, yv = torch.meshgrid(torch.tensor(x_eval).to(device).to(torch.float32), torch.tensor(y_eval).to(device).to(torch.float32), indexing='xy')\n" ] } ], "source": [ "Nx0 = 127\n", "dx0 = 0.48\n", "x_eval = y_eval = torch.arange(-(Nx0-1)/2, (Nx0+1)/2, 1).to(device) * dx0\n", "xv, yv = torch.meshgrid(torch.tensor(x_eval).to(device).to(torch.float32), torch.tensor(y_eval).to(device).to(torch.float32), indexing='xy')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Model the geometric component of the scintillator response (dominant for medium energy collimators):" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "Lb = 4.060 # cm length of collimator\n", "mu = 17.31149149658225\n", "sigma_fn = lambda a, bs: (bs[0]+a) / bs[0] \n", "amplitude_fn = lambda a, bs: torch.ones_like(a)\n", "sigma_params = torch.tensor([Lb-2/mu], requires_grad=True, dtype=torch.float32, device=device)\n", "amplitude_params = torch.tensor([1.], requires_grad=True, dtype=torch.float32, device=device)\n", "ngon_kernel = NGonKernel2D(\n", " N_sides = 6,\n", " Nx = 255,\n", " collimator_width=0.294,\n", " amplitude_fn=amplitude_fn,\n", " sigma_fn=sigma_fn,\n", " amplitude_params=amplitude_params,\n", " sigma_params=sigma_params,\n", " rot=90\n", ")\n", "\n", "ngon_operator = Kernel2DOperator(ngon_kernel, use_fft_conv=False)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/data/anaconda/envs/pytomo_install_test/lib/python3.11/site-packages/torch/functional.py:504: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at ../aten/src/ATen/native/TensorShape.cpp:3526.)\n", " return _VF.meshgrid(tensors, **kwargs) # type: ignore[attr-defined]\n", "/data/anaconda/envs/pytomo_install_test/lib/python3.11/site-packages/torchquad/integration/utils.py:255: UserWarning: DEPRECATION WARNING: In future versions of torchquad, an array-like object will be returned.\n", " warnings.warn(\n" ] } ], "source": [ "intrinsic_sigma = 0.3117568/(2*np.sqrt(2*np.log(2)))\n", "gauss_amplitude_fn = lambda a, bs: torch.ones_like(a)\n", "gauss_sigma_fn = lambda a, bs: bs[0]*torch.ones_like(a)\n", "gauss_amplitude_params = torch.tensor([1.], requires_grad=True, dtype=torch.float32, device=device)\n", "gauss_sigma_params = torch.tensor([intrinsic_sigma], requires_grad=True, device=device, dtype=torch.float32)\n", "gaussian_operator = GaussianOperator(\n", " gauss_amplitude_fn,\n", " gauss_sigma_fn,\n", " gauss_amplitude_params,\n", " gauss_sigma_params,\n", ")" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "psf_operator = gaussian_operator * ngon_operator" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Optimize the PSF operator, like was done in tutorial 3" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.0009568551904521883\r" ] } ], "source": [ "input = torch.zeros((12,127,127)).to(device)\n", "input[:,63,63] = 1\n", "\n", "def loss_fn(psf_pred, psf_data):\n", " return torch.sum((psf_pred - psf_data)**2) \n", "\n", "def train_w(operator, n_iters, lr=1e-3):\n", " optimizer = optim.Adam([*operator.params], lr=lr)\n", " for _ in range(n_iters):\n", " optimizer.zero_grad()\n", " error = loss_fn(operator(input,xv,yv,distances,normalize=True),projectionss_data)\n", " print(error.item(), end=\"\\r\")\n", " error.backward()\n", " optimizer.step()\n", " \n", "train_w(psf_operator, n_iters=400, lr=4e-3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Lets look at the results:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "output_tot = psf_operator(input, xv, yv, distances, normalize=True)\n", "IDX = 1\n", "plt.plot(projectionss_data[IDX,63].cpu())\n", "plt.plot(output_tot[IDX,63].detach().cpu(), ls='--')" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "psf_operator.save('/disk1/psf_data/operators/lu177_ME_GC.pkl')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Part 2: Reconstruction\n", "\n", "Now we'll compare standard Gaussian PSF modeling the PSF model obtained here" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* Open SIMIND data:" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "activity = 1000 # MBq\n", "dT = 15 # seconds per projection\n", "\n", "paths = [f'/disk1/psf_data/208keV_ME_jaszak/tot_w{i}.h00' for i in range(1,4)]\n", "object_meta, proj_meta = simind.get_metadata(paths[0])\n", "projections = simind.get_projections(paths)\n", "projections = torch.poisson(activity*dT*projections)\n", "\n", "object_meta, proj_meta, projections = subsample_projections_and_modify_metadata(object_meta, proj_meta, projections, N_pixel = 2, N_angle=1)\n", "photopeak = projections[1]\n", "ww_peak = simind.get_energy_window_width(paths[1])\n", "ww_lower = simind.get_energy_window_width(paths[0])\n", "ww_upper = simind.get_energy_window_width(paths[2])\n", "lower_scatter = projections[0]\n", "upper_scatter = projections[2]\n", "scatter = (lower_scatter/ww_lower+upper_scatter/ww_upper)*ww_peak/2\n", "attenuation_path = '/disk1/psf_data/208keV_ME_jaszak/amap.hct'\n", "attenuation_map = simind.get_attenuation_map(attenuation_path)\n", "attenuation_map = subsample_amap(attenuation_map, 2)\n", "att_transform = SPECTAttenuationTransform(attenuation_map)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* Reconstruct" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "def reconstruct(psf_operator = None):\n", " if psf_operator is None:\n", " psf_meta = simind.get_psfmeta_from_header(paths[0])\n", " psf_transform = SPECTPSFTransform(psf_meta)\n", " else:\n", " psf_transform = SPECTPSFTransform(psf_operator=psf_operator)\n", " system_matrix = SPECTSystemMatrix(\n", " obj2obj_transforms = [att_transform,psf_transform],\n", " proj2proj_transforms = [],\n", " object_meta = object_meta,\n", " proj_meta = proj_meta\n", " )\n", " likelihood = PoissonLogLikelihood(system_matrix, photopeak, additive_term=scatter)\n", " recon_algorithm = OSEM(likelihood)\n", " return recon_algorithm(n_iters = 4, n_subsets = 8)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "recon_gaussian_psf = reconstruct()\n", "recon_ngon_psf = reconstruct(psf_operator)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Lets look at the difference for using the ngon PSF:" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(34.0, 94.0, 34.0, 94.0)" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=(10,4))\n", "plt.subplot(121)\n", "plt.imshow(recon_gaussian_psf[:,:,64].cpu().T, cmap='magma', interpolation='gaussian', vmax=60)\n", "plt.xlim(64-30, 64+30)\n", "plt.ylim(64-30, 64+30)\n", "plt.colorbar()\n", "plt.axis('off')\n", "plt.subplot(122)\n", "plt.imshow(recon_ngon_psf[:,:,64].cpu().T, cmap='magma', interpolation='gaussian', vmax=60)\n", "plt.xlim(64-30, 64+30)\n", "plt.ylim(64-30, 64+30)\n", "plt.colorbar()\n", "plt.axis('off')" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0, 0.5, 'Counts')" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "IDX = 0\n", "plt.plot(recon_gaussian_psf[64,:,64].cpu())\n", "plt.plot(recon_ngon_psf[64,:,64].detach().cpu(), ls='--')\n", "plt.xlabel('Voxels')\n", "plt.ylabel('Counts')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that the peak value is slightly larger in the larger sphere. More comprehensive studies might seek to study the impact on recovery coefficients." ] } ], "metadata": { "kernelspec": { "display_name": "pytomo_install_test", "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.6" } }, "nbformat": 4, "nbformat_minor": 2 }