scattering_example.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2b288638",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pydicom\n",
    "from pydicom import dcmread\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import scipy as st\n",
    "from scipy.constants import e, h, hbar, alpha, c, m_e\n",
    "\n",
    "from numba import jit\n",
    "import cv2\n",
    "\n",
    "from scipy.signal import convolve2d\n",
    "\n",
    "import os\n",
    "\n",
    "import density_map_library as den\n",
    "import projection_library as pro"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9c01e099",
   "metadata": {},
   "outputs": [],
   "source": [
    "in_dir_path = \"./infile\"\n",
    "mat_dir_path = \"./material_info\"\n",
    "model = pro.import_dicom(in_dir_path)\n",
    "model_kVp = den.find_model_kVp(in_dir_path)\n",
    "\n",
    "interval = 5\n",
    "anode_atomic_number = 74\n",
    "filter_thickness = 0.5\n",
    "\n",
    "\n",
    "predicted_CT_numbers = den.predict_CT_numbers_poly(mat_dir_path, model_kVp, interval, anode_atomic_number, filter_thickness)\n",
    "tissue_ranges = den.find_tissue_ranges(predicted_CT_numbers)\n",
    "\n",
    "mass_densities = den.mass_density_dictionary(mat_dir_path)\n",
    "\n",
    "density_map = den.find_density_map(model, tissue_ranges, predicted_CT_numbers, mass_densities)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "580359f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def N_P_integral(lam, lamp):\n",
    "    from scipy.constants import hbar, alpha, c, m_e\n",
    "    con = -((hbar*alpha)**2) / (2*(m_e*c)**2)\n",
    "    return con/2*(6*np.log(np.abs(lamp)) + 2*lamp*lam + 2*lam/lamp + 1/lamp**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f824ab32",
   "metadata": {},
   "outputs": [],
   "source": [
    "def N_P_definite_integrate_proportion(start, end, KeV):\n",
    "        \n",
    "    if(180<start < 0 or 180<end < 0):\n",
    "        print(\"please give positive values for start and end between 0-180, in degrees\")\n",
    "    \n",
    "    start = start * np.pi/180\n",
    "    end = end * np.pi/180\n",
    "    \n",
    "    lam = h * c/(KeV * 1000 * e)\n",
    "    \n",
    "    max_lamp = lam + (h/(m_e *c)) * (1-np.cos(0))\n",
    "    min_lamp = lam + (h/(m_e *c)) * (1-np.cos(np.pi))\n",
    "    \n",
    "    lamp_range = max_lamp - min_lamp\n",
    "    \n",
    "    max_range_integral_start =  N_P_integral(lam, lam)\n",
    "    max_range_integral_end = N_P_integral(lam, min_lamp) \n",
    "    \n",
    "    max_range_integral = max_range_integral_end - max_range_integral_start\n",
    "    \n",
    "    lamp_start = lam + (h/(m_e *c)) * (1-np.cos(start))\n",
    "    lamp_end = lam + (h/(m_e *c)) * (1-np.cos(end))\n",
    "    \n",
    "    lamp_start_integral = N_P_integral(lam, lamp_start)\n",
    "    lamp_end_integral = N_P_integral(lam, lamp_end)\n",
    "    \n",
    "    lamp_range_integral = lamp_end_integral - lamp_start_integral\n",
    "    \n",
    "    lamp_range_integral_proportion = lamp_range_integral/max_range_integral\n",
    "    \n",
    "    return lamp_range_integral_proportion\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f1663903",
   "metadata": {},
   "outputs": [],
   "source": [
    "def angle_intensity(angle, KeV):\n",
    "    class_electron_radius = st.constants.physical_constants[\"classical electron radius\"][0]\n",
    "    angle = angle * np.pi/180\n",
    "    lam = h * c/(KeV * 1000 * e)\n",
    "    lamp = lam + (h/(m_e *c)) * (1-np.cos(angle))\n",
    "    con = 0.5 * class_electron_radius **2\n",
    "    multi_one = (lam/lamp)**2\n",
    "    multi_two = lam/lamp + lamp/lam - np.sin(angle)**2\n",
    "    #klein_nishina_differential split into con, multi_one, and multi_two for clarity and neatness\n",
    "    \n",
    "    #radiation scatters through a sphere. Angles close to 90 scatter over a wider radius. The next section acounts for this\n",
    "    scatter_circumference = 2*np.sin(angle) * np.pi\n",
    "    \n",
    "    return con*multi_one*multi_two / scatter_circumference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "aa1ddbdb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def voxel_convolution(vox_z, vox_y, vox_x, object_shape, source_object_distance,object_image_distance, kernel_size, KeV):\n",
    "    source_image_distance = source_object_distance + object_image_distance + object_shape[0]\n",
    "    max_mag = ((source_image_distance)/(source_object_distance))\n",
    "    image_shape = np.array((object_shape[1]*max_mag, object_shape[2]*max_mag))\n",
    "    \n",
    "    \n",
    "    source_z = - source_object_distance\n",
    "    # minus because down is accending in array structure\n",
    "    source_y = image_shape[0]/2\n",
    "    source_x = image_shape[1]/2\n",
    "    \n",
    "    source_coord = np.array((source_z, source_y,source_x))\n",
    "    \n",
    "    vox_zd = vox_z\n",
    "    vox_yd = vox_y + image_shape[0]/2 - object_shape[1]\n",
    "    vox_xd = vox_x + image_shape[1]/2 - object_shape[2]\n",
    "    \n",
    "    vox_coord = np.array((vox_zd,vox_yd,vox_xd))\n",
    "    source_vox_vector = vox_coord - source_coord\n",
    "\n",
    "    \n",
    "    \n",
    "    grad_z = vox_z - source_z\n",
    "    grad_y = vox_yd - source_y\n",
    "    grad_x = vox_xd - source_x\n",
    "    \n",
    "    #Z = grad_z*t + vox_z (z component of vector)\n",
    "    #Z = object_image_distance when vector intersects detector\n",
    "    t = (object_image_distance - vox_zd)/grad_z\n",
    "    \n",
    "    #Y = grad_y*t + vox_y (formula for y component of vector)\n",
    "    #X = grad_x*t + vox_x(formula for x component of vector)\n",
    "    \n",
    "    kernel_centre_y = grad_y*t + vox_y\n",
    "    kernel_centre_x = grad_x*t + vox_x\n",
    "    \n",
    " \n",
    "    kernel_y_min = round(kernel_centre_y - kernel_size/2)\n",
    "    kernel_x_min = round(kernel_centre_x - kernel_size/2)\n",
    "    \n",
    "    scatter_angles = np.zeros((kernel_size,kernel_size))\n",
    "    \n",
    "    \n",
    "    y = 0\n",
    "    x = 0\n",
    "    while y < kernel_size:\n",
    "        x = 0\n",
    "        while x < kernel_size:\n",
    "            pix_coord = np.array((object_image_distance,kernel_y_min + y, kernel_x_min + x))\n",
    "            vox_pix_vector = pix_coord - vox_coord\n",
    "            scatter_angles[y][x] = np.arccos(np.dot(source_vox_vector, vox_pix_vector) / (np.linalg.norm(source_vox_vector) * np.linalg.norm(vox_pix_vector)))\n",
    "            x = x + 1\n",
    "        y = y + 1\n",
    "        \n",
    "    \n",
    "    scatter_angles = 180 - scatter_angles*180/np.pi\n",
    "    #converts to degrees, also reorientates\n",
    "    \n",
    "    kernel =  angle_intensity(scatter_angles, KeV)\n",
    "    \n",
    "    #N_P_definite_integrate_proportion(start, end, KeV)\n",
    "    #find percentage of scatter included in kernel\n",
    "    \n",
    "    #angles left, right, up and down\n",
    "    to_leftmost = scatter_angles[round(len(scatter_angles/2)) -1][0]\n",
    "    to_rightmost = scatter_angles[round(len(scatter_angles/2)) -1][-1]\n",
    "    to_upmost = scatter_angles[0][round(len(scatter_angles/2)) -1]\n",
    "    to_downmost = scatter_angles[-1][round(len(scatter_angles/2))-1]\n",
    "    vox_angle = scatter_angles[round(len(scatter_angles/2))-1][round(len(scatter_angles/2))-1]\n",
    "    \n",
    "    #scattered to each boundary\n",
    "    \n",
    "    leftwards_proportion = N_P_definite_integrate_proportion(to_leftmost, vox_angle, KeV)\n",
    "    rightwards_proportion = N_P_definite_integrate_proportion(to_rightmost, vox_angle, KeV)\n",
    "    upwards_proportion = N_P_definite_integrate_proportion(to_upmost, vox_angle, KeV)\n",
    "    downwwards_proportion = N_P_definite_integrate_proportion(to_downmost, vox_angle, KeV)\n",
    "    \n",
    "    \n",
    "    left_or_right = leftwards_proportion + rightwards_proportion\n",
    "    up_or_down = upwards_proportion + downwwards_proportion\n",
    "    \n",
    "    in_bounds_proportion = left_or_right * up_or_down\n",
    "    \n",
    "    \n",
    "    #accounts for scatter outside of the kernel size\n",
    "    kernel = kernel * in_bounds_proportion\n",
    "    \n",
    "    kernel_sum = kernel.sum()\n",
    "    \n",
    "    #calculates the intensity of each pixel as a proportion of radiation scattered onto detector\n",
    "    kernel = kernel/kernel_sum\n",
    "    \n",
    "    \n",
    "    return kernel\n",
    "    \n",
    "\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f24db979",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e9eb6c4f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_section_convolutions(object_shape, sections_cubed_root, source_object_distance, object_image_distance, kernel_size, KeV):\n",
    "    \n",
    "    section_dimentions = object_shape/sections_cubed_root\n",
    "    section_centre = section_dimentions/2\n",
    "    section_origins_z = np.arange(0, object_shape[0], section_dimentions[0])\n",
    "    section_origins_y = np.arange(0, object_shape[1], section_dimentions[1])\n",
    "    section_origins_x = np.arange(0, object_shape[2], section_dimentions[2])\n",
    "    \n",
    "    \n",
    "    section_centres_z = section_origins_z + section_centre[0]\n",
    "    section_centres_y = section_origins_y + section_centre[1]\n",
    "    section_centres_x = section_origins_x + section_centre[2]\n",
    "    \n",
    "    section_centres = np.stack((section_centres_z,section_centres_y,section_centres_x),0)\n",
    "    \n",
    "    \n",
    "    section_convolutions = np.zeros((sections_cubed_root, sections_cubed_root, sections_cubed_root,kernel_size,kernel_size))\n",
    "    \n",
    "    vox_z_section_index = 0\n",
    "    vox_y_section_index = 0\n",
    "    vox_x_section_index = 0\n",
    "    \n",
    "    while vox_z_section_index < sections_cubed_root:\n",
    "        vox_y_section_index = 0\n",
    "        while vox_y_section_index < sections_cubed_root:\n",
    "            vox_x_section_index = 0\n",
    "            while vox_x_section_index < sections_cubed_root:\n",
    "                \n",
    "                vox_z = int(section_centres[0][vox_z_section_index])\n",
    "                vox_y = int(section_centres[1][vox_y_section_index])\n",
    "                vox_x = int(section_centres[2][vox_x_section_index])\n",
    "                section_convolution = voxel_convolution(vox_z, vox_y, vox_x, object_shape, source_object_distance,object_image_distance, kernel_size, KeV)\n",
    "                section_convolutions[vox_z_section_index][vox_y_section_index][vox_x_section_index] = section_convolution\n",
    "                \n",
    "                vox_x_section_index = vox_x_section_index + 1\n",
    "           \n",
    "            vox_y_section_index = vox_y_section_index + 1\n",
    "            \n",
    "        vox_z_section_index = vox_z_section_index + 1\n",
    "            \n",
    "    \n",
    "    return section_convolutions\n",
    "                 \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "5b5c0cb9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def section_model(model,sections_cubed_root):\n",
    "    \n",
    "        \n",
    "    z_mod = len(model) % sections_cubed_root\n",
    "    if z_mod == 0:\n",
    "        z_extra = 0\n",
    "    else:\n",
    "        z_extra = sections_cubed_root - z_mod\n",
    "    \n",
    "    y_mod = len(model[0]) % sections_cubed_root\n",
    "    if y_mod == 0:\n",
    "        y_extra = 0\n",
    "    else:\n",
    "        y_extra = sections_cubed_root - y_mod\n",
    "    \n",
    "    x_mod = len(model[0][0]) % sections_cubed_root\n",
    "    if x_mod == 0:\n",
    "        x_extra = 0\n",
    "    else:\n",
    "        x_extra = sections_cubed_root - x_mod\n",
    "        \n",
    "        \n",
    "    \n",
    "    stretched_model_size = np.array((len(model) + z_extra, len(model[0]) + y_extra, len(model[0][0]) + x_extra ))\n",
    "    \n",
    "    \n",
    "    stretched_model = np.resize(model, stretched_model_size)\n",
    "    \n",
    "    section_size = stretched_model_size/sections_cubed_root\n",
    "    \n",
    "    sections = np.zeros((int(sections_cubed_root),int(sections_cubed_root),int(sections_cubed_root),int(section_size[0]), int(section_size[1]),int(section_size[2])))\n",
    "    \n",
    "    \n",
    "    iz = 0\n",
    "    iy = 0\n",
    "    ix = 0 \n",
    "    \n",
    "    while iz < sections_cubed_root:\n",
    "        iy = 0\n",
    "        while iy < sections_cubed_root:\n",
    "            ix = 0\n",
    "            while ix < sections_cubed_root:\n",
    " \n",
    "                \n",
    "                z_segments = np.split(stretched_model,sections_cubed_root,0)\n",
    "                z_segment = z_segments[iz]\n",
    "            \n",
    "                y_segments = np.split(z_segment,sections_cubed_root, 1)\n",
    "                y_segment = y_segments[iy]\n",
    "                \n",
    "                x_segments = np.split(y_segment,sections_cubed_root, 2)\n",
    "                x_segment = x_segments[ix]\n",
    "                \n",
    "                \n",
    "                \n",
    "                sections[iz][iy][ix] = x_segment\n",
    "                \n",
    "                \n",
    "                ix = ix + 1\n",
    "            iy = iy + 1\n",
    "        iz = iz + 1\n",
    "        \n",
    "        \n",
    "    return sections\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "fb1077aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "def unsegment(sections):\n",
    "    sections_cubed_root = len(sections)\n",
    "    section_dimentions = np.array((len(sections[0][0][0]),len(sections[0][0][0][0]),len(sections[0][0][0][0][0])))\n",
    "    \n",
    "    object_size = section_dimentions * sections_cubed_root\n",
    "    \n",
    "    zy_lineup = sections[0][0][0]\n",
    "    \n",
    "    iz = 0\n",
    "    iy = 1\n",
    "    ix = 1\n",
    "    \n",
    "    \n",
    "    while iz < sections_cubed_root:\n",
    "        while iy < sections_cubed_root:\n",
    "            zy_lineup = np.append(zy_lineup, sections[iz][iy][0], 1)\n",
    "            iy = iy + 1\n",
    "        iy = 0\n",
    "        iz = iz + 1\n",
    "        \n",
    "    remodel = np.reshape(zy_lineup, (object_size[0],object_size[1],section_dimentions[2]))\n",
    "    \n",
    "    \n",
    "    while ix < sections_cubed_root:\n",
    "        \n",
    "        zy_lineup = sections[0][0][ix]\n",
    "        iz = 0\n",
    "        iy = 1\n",
    "        \n",
    "        while iz < sections_cubed_root:\n",
    "            while iy < sections_cubed_root:\n",
    "                zy_lineup = np.append(zy_lineup, sections[iz][iy][ix], 1)\n",
    "                iy = iy + 1\n",
    "            iy = 0\n",
    "            iz = iz + 1\n",
    "        \n",
    "        zy_slice = np.reshape(zy_lineup, (object_size[0],object_size[1],section_dimentions[2]))\n",
    "        remodel = np.append(remodel, zy_slice,2) \n",
    "        ix = ix + 1\n",
    "    \n",
    "        \n",
    "      \n",
    "    return remodel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7281eb0a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def convolve_sectioned_model(sectioned_model, section_convolutions):\n",
    "    sections_cubed_root = len(sectioned_model)\n",
    "    \n",
    "    convolved_extra1 = round((len(section_convolutions[0][0][0]) - 1)/2)\n",
    "    convolved_extra2 = len(section_convolutions[0][0][0]) - 1 - convolved_extra1\n",
    "\n",
    "    convolved_sectioned_model = np.zeros_like(sectioned_model)\n",
    "\n",
    "    iz = 0\n",
    "    iy = 0\n",
    "    ix = 0\n",
    "    \n",
    "    while iz < sections_cubed_root:\n",
    "        while iy < sections_cubed_root:\n",
    "            while ix < sections_cubed_root:\n",
    "                current_section = sectioned_model[iz][iy][ix]\n",
    "                convolved_section = np.zeros_like(sectioned_model[0][0][0])\n",
    "                section_convolution = section_convolutions[iz][iy][ix]\n",
    "                i = 0\n",
    "                while i < len(convolved_section):\n",
    "                    convolved_slice = np.asarray(convolve2d(current_section[i], section_convolution))\n",
    "                    pad1 = np.arange(0,(convolved_extra1),1)\n",
    "                    pad2 = np.arange(0,(convolved_extra2),1)\n",
    "                    convolved_slice = np.delete(convolved_slice, pad1,0)\n",
    "                    convolved_slice = np.delete(convolved_slice, -pad2,0)\n",
    "                    \n",
    "                    convolved_slice = np.delete(convolved_slice, pad1,1)\n",
    "                    convolved_slice = np.delete(convolved_slice, -pad2,1)\n",
    "                    \n",
    "                    convolved_section[i] = convolved_slice\n",
    "                    i = i + 1\n",
    "                convolved_sectioned_model[iz][iy][ix] = convolved_section\n",
    "                ix = ix + 1\n",
    "            ix = 0\n",
    "            iy = iy + 1\n",
    "        iy = 0\n",
    "        iz = iz + 1\n",
    "            \n",
    "\n",
    "    return convolved_sectioned_model\n",
    "    \n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f9bd5057",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = density_map\n",
    "object_shape = np.asarray(model.shape)\n",
    "sections_cubed_root = 2\n",
    "source_object_distance = 100\n",
    "object_image_distance = 10\n",
    "kernel_size = 5\n",
    "KeV = 100\n",
    "\n",
    "sectioned_model = section_model(model,sections_cubed_root)\n",
    "section_convolutions = find_section_convolutions(object_shape, sections_cubed_root, source_object_distance, object_image_distance, kernel_size, KeV)\n",
    "\n",
    "convolved_sectioned_model = convolve_sectioned_model(sectioned_model, section_convolutions)\n",
    "\n",
    "remodel = unsegment(convolved_sectioned_model)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "081b35f2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x2226985e6a0>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(sectioned_model[0][0][0][50], cmap=plt.cm.bone)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "c4ca65c5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x2226993ecd0>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(remodel[51], cmap=plt.cm.bone)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a789b815",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}