![\"Open](\"https://colab.research.google.com/assets/colab-badge.svg\"){kind=icon}
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Hev7LYxba6Db"
+ },
+ "source": [
+ "\n",
+ "#Assignment 2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "ux1g-TwrEe5N",
+ "outputId": "7799d3db-6e18-400f-8fd0-acef45e44f20"
+ },
+ "source": [
+ "%pylab inline"
+ ],
+ "execution_count": 1,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Populating the interactive namespace from numpy and matplotlib\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "-MaZXclAEiGA",
+ "outputId": "8074fe73-b4b0-4268-dbce-c9889aa19b07"
+ },
+ "source": [
+ "# we will be using the EEG/MEG analysis library MNE\n",
+ "# documentation is available here: https://mne.tools/stable/index.html\n",
+ "!pip install -U mne"
+ ],
+ "execution_count": 2,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Collecting mne\n",
+ " Downloading mne-0.24.1-py3-none-any.whl (7.4 MB)\n",
+ "\u001b[K |████████████████████████████████| 7.4 MB 4.3 MB/s \n",
+ "\u001b[?25hRequirement already satisfied: scipy>=1.1.0 in /usr/local/lib/python3.7/dist-packages (from mne) (1.4.1)\n",
+ "Requirement already satisfied: numpy>=1.15.4 in /usr/local/lib/python3.7/dist-packages (from mne) (1.21.5)\n",
+ "Installing collected packages: mne\n",
+ "Successfully installed mne-0.24.1\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "5q6p7Vp2Ek06"
+ },
+ "source": [
+ "import mne # let's import MNE\n",
+ "\n",
+ "# .. and the sample dataset\n",
+ "from mne.datasets import sample\n",
+ "\n",
+ "# These data were acquired with the Neuromag Vectorview system at \n",
+ "# MGH/HMS/MIT Athinoula A. Martinos Center Biomedical Imaging. \n",
+ "# EEG data from an electrode cap was acquired simultaneously with the MEG. \n",
+ "\n",
+ "### EXPERIMENT DESCRIPTION ###\n",
+ "# In this experiment, checkerboard patterns were presented to the subject into\n",
+ "# the left and right visual field, interspersed by tones to the left or right ear.\n",
+ "# The interval between the stimuli was 750 ms. Occasionally a smiley face was \n",
+ "# presented at the center of the visual field. The subject was asked to press a \n",
+ "# key with the right index finger as soon as possible after the appearance of the face."
+ ],
+ "execution_count": 3,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "wPiwovpdImU4",
+ "outputId": "fbe7d2e1-14fe-48f3-df21-9de624b2a5aa"
+ },
+ "source": [
+ "# and let's load it!\n",
+ "data_path = sample.data_path()\n",
+ "raw = mne.io.read_raw_fif(data_path + '/MEG/sample/sample_audvis_raw.fif')"
+ ],
+ "execution_count": 4,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Using default location ~/mne_data for sample...\n",
+ "Creating ~/mne_data\n"
+ ]
+ },
+ {
+ "output_type": "stream",
+ "name": "stderr",
+ "text": [
+ "Downloading file 'MNE-sample-data-processed.tar.gz' from 'https://osf.io/86qa2/download?version=5' to '/root/mne_data'.\n",
+ "100%|██████████████████████████████████████| 1.65G/1.65G [00:00<00:00, 572GB/s]\n",
+ "Untarring contents of '/root/mne_data/MNE-sample-data-processed.tar.gz' to '/root/mne_data'\n"
+ ]
+ },
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Attempting to create new mne-python configuration file:\n",
+ "/root/.mne/mne-python.json\n",
+ "Opening raw data file /root/mne_data/MNE-sample-data/MEG/sample/sample_audvis_raw.fif...\n",
+ " Read a total of 3 projection items:\n",
+ " PCA-v1 (1 x 102) idle\n",
+ " PCA-v2 (1 x 102) idle\n",
+ " PCA-v3 (1 x 102) idle\n",
+ " Range : 25800 ... 192599 = 42.956 ... 320.670 secs\n",
+ "Ready.\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "cl4dZERpcBEh"
+ },
+ "source": [
+ "**Task 1:** How many EEG channels were used when acquiring the data? [15 Points]\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "37bn9S-dMn0p"
+ },
+ "source": [
+ "# Hint: You can use raw.info or raw.ch_names to figure this out!\n",
+ "# TODO: YOUR ANSWER"
+ ],
+ "execution_count": 5,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "1qPhiTKRglIE",
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 305
+ },
+ "outputId": "fec729f6-27cc-446e-8695-0d7092b683e0"
+ },
+ "source": [
+ "raw.info"
+ ],
+ "execution_count": 6,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/html": [
+ "\n",
+ "| Measurement date | \n", + "December 03, 2002 19:01:10 GMT | \n", + " \n", + "
|---|---|
| Experimenter | \n", + "MEG | \n", + " \n", + "Participant | \n", + "Unknown | \n", + " \n", + "
| Digitized points | \n", + "146 points | \n", + "
| Good channels | \n", + "204 Gradiometers, 102 Magnetometers, 9 Stimulus, 60 EEG, 1 EOG | \n", + "
| Bad channels | \n", + "MEG 2443, EEG 053 | \n", + "
| EOG channels | \n", + "EOG 061 | \n", + "
| ECG channels | \n", + "Not available | \n", + "
| Sampling frequency | \n", + "600.61 Hz | \n", + "
| Highpass | \n", + "0.10 Hz | \n", + "
| Lowpass | \n", + "172.18 Hz | \n", + "
| Projections | \n", + "PCA-v1: off PCA-v2: off PCA-v3: off | \n",
+ "
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Hev7LYxba6Db"
+ },
+ "source": [
+ "\n",
+ "#Assignment 3"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "ux1g-TwrEe5N",
+ "outputId": "8acb801d-0a9d-4596-ce36-1bd0e22e2c22"
+ },
+ "source": [
+ "%pylab inline"
+ ],
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Populating the interactive namespace from numpy and matplotlib\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "cl4dZERpcBEh"
+ },
+ "source": [
+ "**Task 1:** Download and install 3D Slicer [15 Points]\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "37bn9S-dMn0p"
+ },
+ "source": [
+ "# 3D Slicer is available for Windows, Linux, and Mac here: https://slicer.org\n",
+ "# Please use the stable version 4.11.2xxxxx !"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Downloaded"
+ ],
+ "metadata": {
+ "id": "wwaXja0cstPf"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "8pSy9pW5cKO_"
+ },
+ "source": [
+ "**Task 2:** Let's load some Ultrasound data! [15 Points]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "dpcL98RXOBZO"
+ },
+ "source": [
+ "# Please download this file: https://cs480.org/data/ultrasound.nrrd !\n",
+ "# Then, drag and drop the file into 3D Slicer and click OK."
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "99OwONlCchwX"
+ },
+ "source": [
+ "# TODO Is this a traditional ultrasound image?\n",
+ "# TODO: YOUR_ANSWER (YES or NO and WHY)"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ ""
+ ],
+ "metadata": {
+ "id": "6JFotFT-vOkS"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "This is a traditional image as it is a 2 dimensional black and white image after it is loaded into the slicer software\n"
+ ],
+ "metadata": {
+ "id": "jSXuF4fthsmy"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "eGFoOHsrcy2L"
+ },
+ "source": [
+ "**Task 3:** Visualize the ultrasound data! [30 Points]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "DoZQlOqmUkWg"
+ },
+ "source": [
+ "# Please use the Volume Rendering module in 3D slicer to render the data.\n",
+ "# Then, activate Cropping and adjust the bounding box to show the fetus.\n",
+ "# Hint: The MRI Default color map creates a nice visual."
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "_DnKFQyMdPDF"
+ },
+ "source": [
+ "# TODO Please post a screenshot of your rendering in the text box below by \n",
+ "# using the Upload image button after double-click."
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "XnQ0o-xabKuj"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "gfOWRBBBgoCG"
+ },
+ "source": [
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "rLSbojsodr9X"
+ },
+ "source": [
+ "**Task 4:** Segment the fetus! [40 Points]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "yPrMJuVcgsD4"
+ },
+ "source": [
+ "# Switch to the Legacy->Editor module and click OK to create the GenericAnatomyColors label map.\n",
+ "# Select the PAINT EFFECT and activate THRESHOLD PAINTING.\n",
+ "# Hint: Reduce the RADIUS for a smaller brush.\n",
+ "# Hint: Adjust the lower threshold to not include the black background.\n",
+ "# Hint: Switch to 'Red Slice only' view and use the arrow keys to navigate through the slices.\n",
+ "# \n",
+ "# TODO: Mark the Fetus by drawing on each slice!\n",
+ "# Hint: Start at Slice ~83mm to ~112mm\n",
+ "# TODO: Take a screenshot of one slice after painting and upload it below."
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "NN8fOim3y3kq"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "rWLWC3Nty-Iz"
+ },
+ "source": [
+ "# TODO: Use the MAKEMODELEFFECT and click APPLY.\n",
+ "# This will create a 3D mesh of your segmentation.\n",
+ "# TODO: Switch to '3D Only' view and take a screenshot of the segmented fetus in 3D!\n",
+ "# TODO: Upload the screenshot below."
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ ""
+ ],
+ "metadata": {
+ "id": "VJmy7CWsY2CM"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "4yr4Boxce011"
+ },
+ "source": [
+ "**Bonus Task:** Use Slicer Python to analyze the image data. [33 Points]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "UJU2Xel-e_-f",
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 122
+ },
+ "outputId": "e34b1fc4-5258-41fb-feb7-41d9a8446bc3"
+ },
+ "source": [
+ "\"\"\"# Activate the console with View -> Python Interactor.\n",
+ "# Now, you can run Python commands in 3D Slicer (don't run the commands here but in 3D Slicer!).\n",
+ "#\n",
+ "# 1) Let's install mahotas into the 3D Slicer environment.\n",
+ "pip_install('mahotas')\n",
+ "\n",
+ "# \n",
+ "# 2) Grab the image data as a numpy array.\n",
+ "# Hint: You need to replace $MRML_ID with the correct value.\n",
+ "# Hint: You can find that value in the DATA module, if you activate 'Show MRML IDs'\n",
+ "node = slicer.mrmlScene.GetNodeByID('$MRML_ID')\n",
+ "data_as_array = slicer.util.arrayFromVolume(node)\n",
+ "\n",
+ "#\n",
+ "# 3) Now, data_as_array is a numpy array containing the image data.\n",
+ "# We can print the shape and also the max value.\n",
+ "print(data_as_array.shape)\n",
+ "print(data_as_array.max())\n",
+ "\n",
+ "#\n",
+ "# 4) Please use mahotas to generate the histogram of the ultrasound data.\n",
+ "import mahotas as mh\n",
+ "pixelcounts = mh.fullhistogram(data_as_array)\n",
+ "\n",
+ "#\n",
+ "# TODO: Please answer the following questions.\n",
+ "# TODO: Max. Intensity Value in data_as_array:\n",
+ "# 254\n",
+ "# TODO: How many pixels with this max. intensity value?\n",
+ "# 52\n",
+ "#\n",
+ "\"\"\""
+ ],
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "\"# Activate the console with View -> Python Interactor.\\n# Now, you can run Python commands in 3D Slicer (don't run the commands here but in 3D Slicer!).\\n#\\n# 1) Let's install mahotas into the 3D Slicer environment.\\npip_install('mahotas')\\n\\n# \\n# 2) Grab the image data as a numpy array.\\n# Hint: You need to replace $MRML_ID with the correct value.\\n# Hint: You can find that value in the DATA module, if you activate 'Show MRML IDs'\\nnode = slicer.mrmlScene.GetNodeByID('$MRML_ID')\\ndata_as_array = slicer.util.arrayFromVolume(node)\\n\\n#\\n# 3) Now, data_as_array is a numpy array containing the image data.\\n# We can print the shape and also the max value.\\nprint(data_as_array.shape)\\nprint(data_as_array.max())\\n\\n#\\n# 4) Please use mahotas to generate the histogram of the ultrasound data.\\nimport mahotas as mh\\npixelcounts = mh.fullhistogram(data_as_array)\\n\\n#\\n# TODO: Please answer the following questions.\\n# TODO: Max. Intensity Value in data_as_array:\\n# 254\\n# TODO: How many pixels with this max. intensity value?\\n# 52\\n#\\n\""
+ ],
+ "application/vnd.google.colaboratory.intrinsic+json": {
+ "type": "string"
+ }
+ },
+ "metadata": {},
+ "execution_count": 2
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Max Intensity value in the data_as_array is 254"
+ ],
+ "metadata": {
+ "id": "EVrvjuApqilB"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ " Pixels with this max intensity value are 52."
+ ],
+ "metadata": {
+ "id": "oRi5KKsFqo1g"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "collaboration with Praveen Ganni"
+ ],
+ "metadata": {
+ "id": "ZW8O8bqOdXvM"
+ }
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "p7V4io1ngtUR"
+ },
+ "source": [
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "EHfGf23KfHb-"
+ },
+ "source": [
+ "# You did it!!\n",
+ "# ,------.\n",
+ "# `-____-' ,-----------.\n",
+ "# ,i--i. | |\n",
+ "# / @ @ \\ / HEE HEE! |\n",
+ "# | -.__.- | ___-' J\n",
+ "# \\. ,/ \"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"'\n",
+ "# ,\\\"\"\"\"/.\n",
+ "# ,' `--' `.\n",
+ "# (_,i' `i._)\n",
+ "# | |\n",
+ "# | ,. |\n",
+ "# | | | |\n",
+ "# `-' `-' -bodom-"
+ ],
+ "execution_count": null,
+ "outputs": []
+ }
+ ]
+}
\ No newline at end of file
diff --git a/CS480_Assignment_4.ipynb b/CS480_Assignment_4.ipynb
new file mode 100644
index 0000000..937e3e5
--- /dev/null
+++ b/CS480_Assignment_4.ipynb
@@ -0,0 +1,931 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "name": "CS480_Assignment_4_(2) (1).ipynb",
+ "provenance": [],
+ "collapsed_sections": [],
+ "include_colab_link": true
+ },
+ "kernelspec": {
+ "name": "python3",
+ "display_name": "Python 3"
+ },
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "view-in-github",
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "DMrBgGVKWEPJ"
+ },
+ "source": [
+ "\n",
+ "#Assignment 4"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ ""
+ ],
+ "metadata": {
+ "id": "Sio2BKI9Xp9u"
+ }
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "Ll5BVb2mZS2_"
+ },
+ "source": [
+ "# In this assignment, we will create a Random Forest classifier to detect pneumonia!"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "2lscACx4iuKi",
+ "outputId": "2f4b8c40-2d36-459f-9a0f-2296cabc4034"
+ },
+ "source": [
+ "# load numpy and matplotlib\n",
+ "%pylab inline"
+ ],
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Populating the interactive namespace from numpy and matplotlib\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "from google.colab import drive\n",
+ "drive.mount('/content/drive')"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "MmIbBmi8xq6C",
+ "outputId": "1f57ca36-b8be-4704-8043-784c6cf20f94"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "3yT4p3dDmJgI",
+ "outputId": "493ff88a-bece-4e54-c0a9-d4726b73e87c"
+ },
+ "source": [
+ "# we are using mahotas again, so lets install it!\n",
+ "!pip install mahotas"
+ ],
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Requirement already satisfied: mahotas in /usr/local/lib/python3.7/dist-packages (1.4.12)\n",
+ "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from mahotas) (1.21.5)\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "Lj9vr_3CmOYG"
+ },
+ "source": [
+ "# our imports include sklearn this time\n",
+ "import mahotas as mh\n",
+ "import os\n",
+ "from sklearn.ensemble import RandomForestClassifier"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "esXxAeAUWyB3"
+ },
+ "source": [
+ "**Task 1:** Download, extract, and load the data! [15 Points]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "yPO5ufNBmgwS"
+ },
+ "source": [
+ "# Please download this file: https://cs480.org/data/xray.zip\n",
+ "# This is a subset of the Kaggle Pneumonia Dataset!\n",
+ "#\n",
+ "# TODO: Upload xray.zip using the file panel on the left."
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "ynJMN1ugiyik"
+ },
+ "source": [
+ "# Run this code to extract the zip file and to create\n",
+ "# the folder structure of normal/ and pneumonia/ images.\n",
+ "# Each folder contains the first images of the Kaggle dataset.\n",
+ "import zipfile\n",
+ "with zipfile.ZipFile('/content/drive/MyDrive/US Assignments/xray.zip', 'r') as zip_ref:\n",
+ " zip_ref.extractall('.')\n",
+ "\n",
+ "NORMAL_DIR = 'normal/'\n",
+ "PNEUMONIA_DIR = 'pneumonia/'"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "u61SolZ7mQ2l"
+ },
+ "source": [
+ "# Here we load the first image from the normal dataset.\n",
+ "img = mh.imread(NORMAL_DIR + 'IM-0115-0001.jpeg')"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "4td0kmDkXlot",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "outputId": "3052a58d-7411-4773-edd6-5c85d33cc805"
+ },
+ "source": [
+ "# TODO: Please display this image and print the dimensions!\n",
+ "# This will display the width, height and how many color channels the image has \n",
+ "# Dimensions of the image\n",
+ "img.shape"
+ ],
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(1858, 2090)"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 9
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "ypOjAS1Dd4QG",
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 287
+ },
+ "outputId": "080dfc5a-1d34-4e4e-d618-d17564061917"
+ },
+ "source": [
+ "# TODO: YOUR CODE\n",
+ "# Displaying the image\n",
+ "pylab.imshow(img)"
+ ],
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "DMrBgGVKWEPJ"
+ },
+ "source": [
+ "\n",
+ "#Assignment 5"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "Ll5BVb2mZS2_"
+ },
+ "source": [
+ "# In this assignment, we will visualize and explore a CT scan!"
+ ],
+ "execution_count": 111,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "2lscACx4iuKi",
+ "outputId": "332f2961-ce5b-4692-a322-9b66c4f012bf"
+ },
+ "source": [
+ "# load numpy and matplotlib\n",
+ "%pylab inline"
+ ],
+ "execution_count": 112,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Populating the interactive namespace from numpy and matplotlib\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "from google.colab import drive\n",
+ "drive.mount('/content/drive')"
+ ],
+ "metadata": {
+ "id": "4bnD--b9gXSj",
+ "outputId": "d88eb9e4-ae27-48c7-b693-7926c874d170",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ }
+ },
+ "execution_count": 113,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "3yT4p3dDmJgI",
+ "outputId": "0af51fb4-df00-444f-c1bb-158d15c33c67"
+ },
+ "source": [
+ "# we are using pydicom, so lets install it!\n",
+ "!pip install pydicom"
+ ],
+ "execution_count": 114,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Requirement already satisfied: pydicom in /usr/local/lib/python3.7/dist-packages (2.3.0)\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "f_SOOwQf78z-"
+ },
+ "source": [
+ "**Task 1**: Download and visualize data with SliceDrop! [20 Points]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "vXxbYHfalVQt"
+ },
+ "source": [
+ "# Please download https://cs480.org/data/ct.zip and extract it on your computer!\n",
+ "# This is a CT scan of an arm in DICOM format."
+ ],
+ "execution_count": 115,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "wwtBQpTP8QbS"
+ },
+ "source": [
+ "# 1) Let's explore the data without loading it.\n",
+ "# TODO: Without loading the data, how many slices are there?"
+ ],
+ "execution_count": 116,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "There are 220 images in the zip file. Hence it has 220 slices"
+ ],
+ "metadata": {
+ "id": "QsJsb19IgxOg"
+ }
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "E1Xdz3xw8ZJ6"
+ },
+ "source": [
+ "# TODO: YOUR_ANSWER"
+ ],
+ "execution_count": 117,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "ZJHks55e8a8K"
+ },
+ "source": [
+ "# 2) Let's visualize the data with SliceDrop! \n",
+ "# Go to https://slicedrop.com and drag'n'drop all .dcm files into the browser.\n",
+ "# Please use the 2D sliders to show axial, sagittal, and coronal slices in 3D."
+ ],
+ "execution_count": 118,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "guioyU-e9Q2s"
+ },
+ "source": [
+ "# TODO Please post a screenshot of SliceDrop's 3D View in the text box below by \n",
+ "# using the Upload image button after double-click."
+ ],
+ "execution_count": 119,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Coronal View"
+ ],
+ "metadata": {
+ "id": "7I4zFXorhSkm"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "EL0cayyf9JPo"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Sagittal View"
+ ],
+ "metadata": {
+ "id": "6kjkYe30hYxD"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ ""
+ ],
+ "metadata": {
+ "id": "R9kIIEJOhV6m"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Axial View"
+ ],
+ "metadata": {
+ "id": "SoV1_Fdbhc2H"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ ""
+ ],
+ "metadata": {
+ "id": "Gjs1YkR7hcsy"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "KbpOUGY9fKLw"
+ },
+ "source": [
+ "**Task 2**: Load the data using pydicom as a 3D volume and then reslice it! [35 Points]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "kleZbthp9LcC"
+ },
+ "source": [
+ "# TODO: Please upload ct.zip using the file panel on the left.\n",
+ "# Then use the following snippet to extract the data."
+ ],
+ "execution_count": 120,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "JE2DknZUfSG8"
+ },
+ "source": [
+ "import zipfile\n",
+ "with zipfile.ZipFile('ct.zip', 'r') as zip_ref:\n",
+ " zip_ref.extractall('.')"
+ ],
+ "execution_count": 121,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "wOiAyhP2fSJm"
+ },
+ "source": [
+ "# 1) Now loop through all the DICOM files and store them in a 3D numpy array.\n",
+ "# Hint: You can either store them in a list first or read the dimensions of a\n",
+ "# single image slice to properly create the 3D numpy array.\n",
+ "# Hint 2: os.listdir(DIR) gives a list of filenames in a directory.\n",
+ "# Hint 2b: This list is not sorted - make sure you sort it.\n",
+ "# Hint 3: The dcmread function loads a single DICOM file.\n",
+ "# Hint 4: You can then use .pixel_array to access the image data."
+ ],
+ "execution_count": 122,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "pip install pydicom"
+ ],
+ "metadata": {
+ "id": "1RrHp84TkQv2",
+ "outputId": "f72a0c04-fe79-4113-9efd-853650fb8a16",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ }
+ },
+ "execution_count": 123,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Requirement already satisfied: pydicom in /usr/local/lib/python3.7/dist-packages (2.3.0)\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "qcnvddIGjVOO"
+ },
+ "source": [
+ "from pydicom import dcmread\n",
+ "import os"
+ ],
+ "execution_count": 124,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "KN6vNSJpiRf0"
+ },
+ "source": [
+ "# TODO: YOUR CODE FOR LOADING THE VOLUME AS A 3D NUMPY ARRAY"
+ ],
+ "execution_count": 125,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "files = sorted(os.listdir('ct'))"
+ ],
+ "metadata": {
+ "id": "jNu1LcN6kbkv"
+ },
+ "execution_count": 126,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "slice0 = dcmread('ct/'+files[0])\n",
+ "slice0_shape = [i for i in slice0.pixel_array.shape]\n",
+ "slice0_shape.append(len(files))"
+ ],
+ "metadata": {
+ "id": "oKiPz32Jkkl2"
+ },
+ "execution_count": 127,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "images = np.zeros(slice0_shape, dtype=float)"
+ ],
+ "metadata": {
+ "id": "jEGdgLg4k53j"
+ },
+ "execution_count": 128,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "for k in range(0, len(files)):\n",
+ " slice_array = dcmread('ct/'+files[k]).pixel_array\n",
+ " images[:,:,k] = slice_array"
+ ],
+ "metadata": {
+ "id": "PRCN_UZXlbHj"
+ },
+ "execution_count": 129,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "-ASKScaKii8S"
+ },
+ "source": [
+ "# 2) Now create and show axial, sagittal, and coronal slices from the 3D volume.\n",
+ "# Hint: Please use imshow(XX, cmap='gray') to show the image."
+ ],
+ "execution_count": 130,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "5pa-UOtUikTK",
+ "outputId": "f1aa56a9-fc32-412c-f2cc-614f384774cb",
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 395
+ }
+ },
+ "source": [
+ "# TODO: YOUR CODE FOR AXIAL\n",
+ "plt.figure(figsize = (8,6))\n",
+ "plt.imshow(images[:,:,slice0_shape[2]//2], cmap='gray')"
+ ],
+ "execution_count": 131,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "DMrBgGVKWEPJ"
+ },
+ "source": [
+ "\n",
+ "#Assignment 6"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "Ll5BVb2mZS2_"
+ },
+ "outputs": [],
+ "source": [
+ "# In this assignment, we will train a U-Net classifer to detect mitochondria\n",
+ "# in electron microscopy images!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "GhpX7CGfyuqw"
+ },
+ "outputs": [],
+ "source": [
+ "### IMPORTANT ###\n",
+ "#\n",
+ "# Activate GPU support: Runtime -> Change Runtime Type\n",
+ "# Hardware Accelerator: GPU\n",
+ "#\n",
+ "### IMPORTANT ###"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "2lscACx4iuKi",
+ "outputId": "3b3a517a-df01-4eba-f6d6-78329cfc9364"
+ },
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Populating the interactive namespace from numpy and matplotlib\n"
+ ]
+ }
+ ],
+ "source": [
+ "# load numpy and matplotlib\n",
+ "%pylab inline"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "ZmB60TxJyQ61",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "outputId": "3a7e32e5-30e9-4faa-a197-70321fb5a816"
+ },
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Collecting git+https://github.com/jakeret/unet.git\n",
+ " Cloning https://github.com/jakeret/unet.git to /tmp/pip-req-build-vgu11_mm\n",
+ " Running command git clone -q https://github.com/jakeret/unet.git /tmp/pip-req-build-vgu11_mm\n"
+ ]
+ }
+ ],
+ "source": [
+ "# load the unet tensorflow code\n",
+ "!pip install git+https://github.com/jakeret/unet.git"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "gn19r-d9yZVk"
+ },
+ "outputs": [],
+ "source": [
+ "# .. and use it!\n",
+ "# Note: There are a ton of U-Net implementations but this one is easier to use!\n",
+ "import unet"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "uMSdlwXfyRAv"
+ },
+ "outputs": [],
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "f_SOOwQf78z-"
+ },
+ "source": [
+ "**Task 1**: Study the unet circle example and learn about mitochondria! [15 Points]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "rfTKzDOLysUW"
+ },
+ "outputs": [],
+ "source": [
+ "# The unet package allows to train a U-Net classifier with little code.\n",
+ "# As discussed in class, the U-Net can be used to label/segment/annotate images."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "kI8AJjDmysXR"
+ },
+ "outputs": [],
+ "source": [
+ "# TODO: Please study the Circles example \n",
+ "# https://github.com/jakeret/unet/blob/master/notebooks/circles.ipynb"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "QM4GKfzTysZv"
+ },
+ "outputs": [],
+ "source": [
+ "# TODO: ... and look how the (artificial) dataset is generated\n",
+ "# https://github.com/jakeret/unet/blob/master/src/unet/datasets/circles.py"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "P2BsS24Cyscm"
+ },
+ "outputs": [],
+ "source": [
+ "# 1) Question\n",
+ "# TODO: Please describe what the U-Net is trained to do.\n",
+ "#\n",
+ "# TODO: "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ldyHGnxq7vfZ"
+ },
+ "source": [
+ "The unet has been trained to recognise circles in a noisy image that has not been filtered. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "vKAyYg6yzXnw"
+ },
+ "outputs": [],
+ "source": [
+ "# 2) Question\n",
+ "# TODO: In circles.py, what does the following mean:\n",
+ "# channels = 1\n",
+ "# classes = 2\n",
+ "#\n",
+ "# TODO: "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "xKuvTOir7vfa"
+ },
+ "source": [
+ "The channel parameter gives us the information about the layers of the data. Since it's value is 1, I assume the images we have are of grey scale.\n",
+ "\n",
+ "The classes parameter represents the class labels. The two class labels can be circles, not circles."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "iRDRxjS-9LYi"
+ },
+ "outputs": [],
+ "source": [
+ "# 3) Question\n",
+ "# TODO: What are mitochondria and what is their appearance in\n",
+ "# electron microscopy data?\n",
+ "# Hint: You can validate your answer in Task 4!\n",
+ "#\n",
+ "# TODO: YOUR ANSWER"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "XdcmkK1i1Yv8"
+ },
+ "source": [
+ "Mitochondria are organelles with two membranes that are found in all cells and are basically called as power house of the cells. Mitochondria appear as spherical or sausage-shaped structures under an electron microscope."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "KbpOUGY9fKLw"
+ },
+ "source": [
+ "**Task 2**: Setup a datagenerator for mitochondria images! [45 Points]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "kleZbthp9LcC"
+ },
+ "outputs": [],
+ "source": [
+ "# TODO: \n",
+ "# Download https://cs480.org/data/mito.npz to your computer.\n",
+ "# Then, please upload mito.npz using the file panel on the left."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "cJJB5etk0O3B"
+ },
+ "outputs": [],
+ "source": [
+ "# The code below is similar to the circles.py file from Task 1.\n",
+ "# We follow Tensorflow conventions to design a tf.data.Dataset for training\n",
+ "# the U-Net.\n",
+ "#\n",
+ "# TODO: Please add four different data augmentation methods in the code block\n",
+ "# below. (image normalization to 0..1, horizontal data flip, vertical data flip,\n",
+ "# rotation by 90 degrees)\n",
+ "#\n",
+ "# Hint: https://github.com/jakeret/unet/blob/master/src/unet/datasets/oxford_iiit_pet.py#L25"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "d-aohs2x0O5s"
+ },
+ "outputs": [],
+ "source": [
+ "import tensorflow as tf\n",
+ "import tensorflow_datasets as tfds\n",
+ "from tensorflow_datasets.core import DatasetInfo\n",
+ "from typing import Tuple, List\n",
+ "import numpy as np\n",
+ "\n",
+ "IMAGE_SIZE = (256, 256)\n",
+ "channels = 1\n",
+ "classes = 2\n",
+ "\n",
+ "def load_data(count:int, splits:Tuple[float]=(0.7, 0.2, 0.1), **kwargs) -> List[tf.data.Dataset]:\n",
+ " return [tf.data.Dataset.from_tensor_slices(_build_samples(int(split * count), **kwargs))\n",
+ " for split in splits]\n",
+ "\n",
+ "\n",
+ "def _build_samples(sample_count:int, **kwargs) -> Tuple[np.array, np.array]:\n",
+ "\n",
+ " # here we load the mitochondria data\n",
+ " loaded = np.load('/content/drive/MyDrive/US Assignments/mito.npz')\n",
+ " loadedimages = loaded['arr_0'][0].copy()\n",
+ " loadedmasks = loaded['arr_0'][1].copy()\n",
+ "\n",
+ " # now let's go to numpyland\n",
+ " images = np.empty((sample_count, IMAGE_SIZE[0], IMAGE_SIZE[1], 1))\n",
+ " labels = np.empty((sample_count, IMAGE_SIZE[0], IMAGE_SIZE[1], 2))\n",
+ " for i in range(sample_count):\n",
+ " image, mask = loadedimages[i], loadedmasks[i]\n",
+ "\n",
+ " image = image.reshape((IMAGE_SIZE[0], IMAGE_SIZE[1], 1)).astype(np.float)\n",
+ "\n",
+ " mask = mask.reshape((IMAGE_SIZE[0], IMAGE_SIZE[1], 1))\n",
+ "\n",
+ " #\n",
+ " # TODO: Normalize the image to 0..1\n",
+ " image = tf.cast(image, tf.float32) / 255.0 # Loading the image using tensorflow and dividing ih 255.0\n",
+ " \n",
+ " mask -= 1 # auto decrementing mask\n",
+ " # TODO: YOUR CODE\n",
+ "\n",
+ " #\n",
+ " # TODO: Use Tensorflow to flip the image horizontally\n",
+ " #\n",
+ " if tf.random.uniform(()) > 0.5:\n",
+ " image = tf.image.flip_left_right(image) # Flipping the image left to right \n",
+ "\n",
+ " mask = tf.image.flip_left_right(mask) # Flipping the mask left to right \n",
+ "\n",
+ " #\n",
+ " # TODO: YOUR CODE\n",
+ " #\n",
+ "\n",
+ " #\n",
+ " # TODO: Use Tensorflow to flip the image vertically\n",
+ " #\n",
+ " if tf.random.uniform(()) > 0.5:\n",
+ " image = tf.image.flip_up_down(image) # FLipping the image upside down\n",
+ " \n",
+ " mask = tf.image.flip_up_down(mask) # FLipping the mask upside down\n",
+ " #\n",
+ " # TODO: YOUR CODE\n",
+ " #\n",
+ "\n",
+ " #\n",
+ " # TODO: Use Tensorflow to rotate the image 90 degrees\n",
+ " #\n",
+ " if tf.random.uniform(()) > 0.5:\n",
+ " image = tf.image.rot90(image) # Rotating image 90 degrees\n",
+ " mask = tf.image.rot90(mask) # Rotating mask to 90 degrees \n",
+ " #\n",
+ " # TODO: YOUR CODE\n",
+ " #\n",
+ "\n",
+ "\n",
+ " # augmentation done, let's store the image\n",
+ " images[i] = image\n",
+ "\n",
+ " # here we split the mask to background and foreground\n",
+ " fg = np.zeros((IMAGE_SIZE[0], IMAGE_SIZE[1], 1), dtype=np.bool)\n",
+ " fg[mask == 255] = 1\n",
+ " bg = np.zeros((IMAGE_SIZE[0], IMAGE_SIZE[1], 1), dtype=np.bool)\n",
+ " bg[mask == 0] = 1\n",
+ " \n",
+ " labels[i, :, :, 0] = bg[:,:,0]\n",
+ " labels[i, :, :, 1] = fg[:,:,0]\n",
+ "\n",
+ " return images, labels"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "eqsEUwQKfXnu"
+ },
+ "source": [
+ "**Task 3**: Let's train the U-Net! [25 Points]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "pnF1RIg1nVv7",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "outputId": "bf1a0729-cee3-476a-cd6f-ac278d93c031"
+ },
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stderr",
+ "text": [
+ "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:29: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
+ "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
+ "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:78: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
+ "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
+ "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:80: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
+ "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n"
+ ]
+ }
+ ],
+ "source": [
+ "#\n",
+ "# We can now create our training, validation, and testing data by calling\n",
+ "# our methods from Task 2.\n",
+ "#\n",
+ "train,val,test = load_data(660,splits=(0.7, 0.2, 0.1))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "from google.colab import drive\n",
+ "drive.mount('/content/drive')"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "54aCxNAHEg9-",
+ "outputId": "a0db7123-bc92-492f-ed2b-c9b0b284c4ed"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "ODwQX4rN3VfX"
+ },
+ "outputs": [],
+ "source": [
+ "# 1) Question\n",
+ "# TODO: We have in total 660 images + 660 masks. Based on the code above,\n",
+ "# how many images are used for training alone?\n",
+ "#\n",
+ "# TODO: YOUR ANSWER"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "cCY5ao3X3uYF"
+ },
+ "outputs": [],
+ "source": [
+ "#\n",
+ "# Let's setup the U-Net!\n",
+ "#\n",
+ "LEARNING_RATE = 1e-3\n",
+ "\n",
+ "unet_model = unet.build_model(channels=channels,\n",
+ " num_classes=classes,\n",
+ " layer_depth=5,\n",
+ " filters_root=64,\n",
+ " padding=\"same\")\n",
+ "\n",
+ "unet.finalize_model(unet_model, learning_rate=LEARNING_RATE)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "MYezkNl-4Fu3"
+ },
+ "outputs": [],
+ "source": [
+ "#\n",
+ "# And, let's setup the trainer...\n",
+ "#\n",
+ "trainer = unet.Trainer(checkpoint_callback=False,\n",
+ " learning_rate_scheduler=unet.SchedulerType.WARMUP_LINEAR_DECAY,\n",
+ " warmup_proportion=0.1,\n",
+ " learning_rate=LEARNING_RATE)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "bPs0NxVy3ua3",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "outputId": "82fabdf9-f61c-400f-b908-ee8ccabe5cf1"
+ },
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Epoch 1/10\n",
+ "47/47 [==============================] - 99s 2s/step - loss: 0.2109 - categorical_crossentropy: 0.2109 - categorical_accuracy: 0.8272 - mean_iou: 0.3806 - dice_coefficient: 0.7829 - auc: 0.9562 - learning_rate: 4.9956e-04 - val_loss: 0.2689 - val_categorical_crossentropy: 0.2689 - val_categorical_accuracy: 0.9434 - val_mean_iou: 0.3614 - val_dice_coefficient: 0.7311 - val_auc: 0.9940\n",
+ "Epoch 2/10\n",
+ "47/47 [==============================] - 69s 1s/step - loss: 0.0679 - categorical_crossentropy: 0.0679 - categorical_accuracy: 0.9115 - mean_iou: 0.4362 - dice_coefficient: 0.8911 - auc: 0.9902 - learning_rate: 9.4449e-04 - val_loss: 0.5473 - val_categorical_crossentropy: 0.5473 - val_categorical_accuracy: 0.9434 - val_mean_iou: 0.2726 - val_dice_coefficient: 0.5453 - val_auc: 0.9906\n",
+ "Epoch 3/10\n",
+ "47/47 [==============================] - 69s 1s/step - loss: 0.0660 - categorical_crossentropy: 0.0660 - categorical_accuracy: 0.9115 - mean_iou: 0.4421 - dice_coefficient: 0.8960 - auc: 0.9935 - learning_rate: 8.3338e-04 - val_loss: 0.5052 - val_categorical_crossentropy: 0.5052 - val_categorical_accuracy: 0.9434 - val_mean_iou: 0.2883 - val_dice_coefficient: 0.5767 - val_auc: 0.9763\n",
+ "Epoch 4/10\n",
+ "47/47 [==============================] - 68s 1s/step - loss: 0.0591 - categorical_crossentropy: 0.0591 - categorical_accuracy: 0.9115 - mean_iou: 0.4452 - dice_coefficient: 0.9016 - auc: 0.9944 - learning_rate: 7.2227e-04 - val_loss: 0.5504 - val_categorical_crossentropy: 0.5504 - val_categorical_accuracy: 0.9434 - val_mean_iou: 0.2729 - val_dice_coefficient: 0.5459 - val_auc: 0.9520\n",
+ "Epoch 5/10\n",
+ "47/47 [==============================] - 68s 1s/step - loss: 0.0534 - categorical_crossentropy: 0.0534 - categorical_accuracy: 0.9149 - mean_iou: 0.4490 - dice_coefficient: 0.9073 - auc: 0.9956 - learning_rate: 6.1116e-04 - val_loss: 0.5476 - val_categorical_crossentropy: 0.5476 - val_categorical_accuracy: 0.7396 - val_mean_iou: 0.2739 - val_dice_coefficient: 0.5479 - val_auc: 0.9418\n",
+ "Epoch 6/10\n",
+ "47/47 [==============================] - 68s 1s/step - loss: 0.0583 - categorical_crossentropy: 0.0583 - categorical_accuracy: 0.9247 - mean_iou: 0.4476 - dice_coefficient: 0.9038 - auc: 0.9952 - learning_rate: 5.0005e-04 - val_loss: 0.5406 - val_categorical_crossentropy: 0.5406 - val_categorical_accuracy: 0.7257 - val_mean_iou: 0.2767 - val_dice_coefficient: 0.5535 - val_auc: 0.9370\n",
+ "Epoch 7/10\n",
+ "47/47 [==============================] - 68s 1s/step - loss: 0.0489 - categorical_crossentropy: 0.0489 - categorical_accuracy: 0.9280 - mean_iou: 0.4531 - dice_coefficient: 0.9123 - auc: 0.9965 - learning_rate: 3.8894e-04 - val_loss: 0.5477 - val_categorical_crossentropy: 0.5477 - val_categorical_accuracy: 0.7102 - val_mean_iou: 0.2740 - val_dice_coefficient: 0.5480 - val_auc: 0.9326\n",
+ "Epoch 8/10\n",
+ "47/47 [==============================] - 68s 1s/step - loss: 0.0493 - categorical_crossentropy: 0.0493 - categorical_accuracy: 0.9331 - mean_iou: 0.4532 - dice_coefficient: 0.9123 - auc: 0.9966 - learning_rate: 2.7783e-04 - val_loss: 0.4859 - val_categorical_crossentropy: 0.4859 - val_categorical_accuracy: 0.7775 - val_mean_iou: 0.2951 - val_dice_coefficient: 0.5902 - val_auc: 0.9573\n",
+ "Epoch 9/10\n",
+ "47/47 [==============================] - 68s 1s/step - loss: 0.0414 - categorical_crossentropy: 0.0414 - categorical_accuracy: 0.9374 - mean_iou: 0.4563 - dice_coefficient: 0.9184 - auc: 0.9972 - learning_rate: 1.6672e-04 - val_loss: 0.5218 - val_categorical_crossentropy: 0.5218 - val_categorical_accuracy: 0.7425 - val_mean_iou: 0.2822 - val_dice_coefficient: 0.5645 - val_auc: 0.9459\n",
+ "Epoch 10/10\n",
+ "47/47 [==============================] - 69s 1s/step - loss: 0.0385 - categorical_crossentropy: 0.0385 - categorical_accuracy: 0.9392 - mean_iou: 0.4577 - dice_coefficient: 0.9212 - auc: 0.9973 - learning_rate: 5.5605e-05 - val_loss: 0.5286 - val_categorical_crossentropy: 0.5286 - val_categorical_accuracy: 0.7311 - val_mean_iou: 0.2800 - val_dice_coefficient: 0.5601 - val_auc: 0.9419\n"
+ ]
+ },
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "DMrBgGVKWEPJ"
+ },
+ "source": [
+ "\n",
+ "#Assignment 7"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "Ll5BVb2mZS2_"
+ },
+ "source": [
+ "# In this assignment, we will explore the Imaging Data Commons,\n",
+ "# a new service from the National Cancer Institute.\n",
+ "#\n",
+ "# We will find and explore a PET dataset and then perform a MIP reconstruction."
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "W1m0WCBb6h5n"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "uMSdlwXfyRAv"
+ },
+ "source": [
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "f_SOOwQf78z-"
+ },
+ "source": [
+ "**Task 1**: Browse the IDC datasets and find a combined CT or MRI with PET! [15 Points]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "XdcmkK1i1Yv8"
+ },
+ "source": [
+ "#\n",
+ "# Visit https://portal.imaging.datacommons.cancer.gov/ and find a dataset\n",
+ "# that includes structural imaging such as CT or MRI combined with a PET scan.\n",
+ "#\n",
+ "# You can start by selecting the type of a cancer case such as Bladder, Brain etc.\n",
+ "# Hint: Head and Neck include many PET scans.\n",
+ "#"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "AHFYoKTkPppz"
+ },
+ "source": [
+ "# TODO: Open the integrated OHIF viewer to view the data.\n",
+ "#\n",
+ "# 1) Select a collection, then a case, then a study in the IDC interface.\n",
+ "# 2) To open the OHIF viewer, click on the view icon.\n",
+ "# 3) Paste a screenshot of the viewer after the data was loaded below.\n",
+ "#"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "rMhD_uQU7mAq"
+ },
+ "source": [
+ "TODO: Add screenshot"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ ""
+ ],
+ "metadata": {
+ "id": "vOJ89kEz2iQk"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "KbpOUGY9fKLw"
+ },
+ "source": [
+ "**Task 2**: Visualize structural and PET side-by-side! [30 Points]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "9UNuaugR0O8k"
+ },
+ "source": [
+ "# In the OHIF viewer, please change the layout to show the structural image\n",
+ "# next to the PET scan.\n",
+ "#\n",
+ "# TODO: Use the LAYOUT functionality in the toolbar to switch to a 2-column layout."
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "d2J1AD8M77Tx"
+ },
+ "source": [
+ "# TODO: Find the cancerous lesion.\n",
+ "#\n",
+ "# 1) Navigate through the PET image to find the cancerous lesion."
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "2xkdKCnm77W2"
+ },
+ "source": [
+ "# TODO: Sync the structural scan (CT or MR) to the PET scan with the lesion.\n",
+ "#\n",
+ "# Hint: The \"Loc\" label in the bottom left of both scans should roughly match.\n",
+ "# Hint 2: The Levels tool allows Window/Level adjustment to increase contrast.\n",
+ "#"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "4QQ39tAk77Z2"
+ },
+ "source": [
+ "# TODO: Paste a screenshot showing the 2-column layout below."
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ ""
+ ],
+ "metadata": {
+ "id": "rc6mBbje2mtk"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Q5dsPqcE875J"
+ },
+ "source": [
+ "TODO: Add screenshot"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "dbYv-XZjPFZa"
+ },
+ "source": [
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "eqsEUwQKfXnu"
+ },
+ "source": [
+ "**Task 3**: Use an MIP to reslice the PET scan! [35 Points]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "XGYzUOUK4__u"
+ },
+ "source": [
+ "# We will now use the 2D MPR functionality to look at the lesion from different\n",
+ "# orientations.\n",
+ "#\n",
+ "# Hint: This works best in Google Chrome."
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "KLHO0i2n9uTj"
+ },
+ "source": [
+ "# Question 1): What is MPR?\n",
+ "#"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "AHKBMrIi94tX"
+ },
+ "source": [
+ "# TODO: YOUR ANSWER"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "The process of transforming data from an imaging modality acquired in one plane, usually axial, into another plane is known as multiplanar reformation or reconstruction (MPR). It's most typically done with thin-slice data from volumetric CT in the axial plane, but it may be done with any plane and any modality that can provide cross-sectional imaging, including MRI, PET, and SPECT."
+ ],
+ "metadata": {
+ "id": "TtnM7fju22wH"
+ }
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "OHuclxry96Th"
+ },
+ "source": [
+ "# Question 2): What is the difference between MIP, MinIP, AvgIP?\n",
+ "#"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Maximum Intensity Projection (MIP)\n",
+ "\n",
+ "For a 2D image, MIP is a feature that highlights the voxel with the highest attenuation value at all viewings and full volume. MIP can be used to locate all hyperdensing structures in a volume within a certain range. This approach tends to reveal contrasting bone structures while also concealing lower attenuation structures.\n",
+ "\n",
+ "Minmimum Intensity Projection (MinIP)\n",
+ "\n",
+ "The MinIP works in a similar way to the MIP, but instead of displaying the voxels with the maximum attenuation, it displays the ones with the least. MinIP solely represents the volume's hypodense structures, making it an excellent tool for detecting, localising, and quantifying ground-glass and linear attenuation patterns in chest scans. MinIP is notably beneficial for analysing the biliary tree and pancreatic duct, which are hypodense in comparison to surrounding tissue, particularly in the pancreatic fase.\n",
+ "\n",
+ "AvgIP (Average Intensity Projection):\n",
+ "\n",
+ "AvgIP works similarly to the other intensity projection modes, except instead of displaying the highest/lowest attenuation, it displays the average attenuation. This technique can be used to identify the interior structures of solid organs as well as the walls of hollow structures like blood vessels and intestines.\n",
+ "\n"
+ ],
+ "metadata": {
+ "id": "8P-4c8c33JvT"
+ }
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "tDwbU5ckPHnA"
+ },
+ "source": [
+ "# TODO: YOUR ANSWER"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "6aMkM41v-AHW"
+ },
+ "source": [
+ "# Now, please navigate to the lesion in all 3 orientations.\n",
+ "#\n",
+ "# TODO: Paste a screenshot below.\n",
+ "#"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ ""
+ ],
+ "metadata": {
+ "id": "d5S4H2NK5ZGH"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "7_7qJ4Ng-O15"
+ },
+ "source": [
+ "TODO: Add screenshot"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "el0CRGhL-A2o"
+ },
+ "source": [
+ "# Question 3): What does the Slab Thickness slider do?\n",
+ "#"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "The Slab Thickness Slider adjusts the slice thickness."
+ ],
+ "metadata": {
+ "id": "yDZRFaoT6rNf"
+ }
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "OnF3VM8f-UZK"
+ },
+ "source": [
+ "# TODO: YOUR ANSWER"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "XYtx1zEx-Qh2"
+ },
+ "source": [
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "R68B9XFl5Rgw"
+ },
+ "source": [
+ "**Task 4**: Let's access the pixel data! [20 Points]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "nUY4a8v47wN6"
+ },
+ "source": [
+ "# Please EXIT THE 2D MPR.\n",
+ "#\n",
+ "# We will now grab the pixel data of the currently displayed slice\n",
+ "# using the Javascript console.\n",
+ "#"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "jNb5khgK-w0G"
+ },
+ "source": [
+ "# 1) Open the Developer Tools of your browser and access the JS console.\n",
+ "#"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "TkLwR8xAPI-e"
+ },
+ "source": [
+ "# 2) The following code allows to access the pixel data of the slice that\n",
+ "# is currently displayed.\n",
+ "#\n",
+ "# element = cornerstone.getEnabledElements()[0];\n",
+ "# pixels = element.image.getPixelData();\n",
+ "#"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "pQ_WuOSH_KXr"
+ },
+ "source": [
+ "# Question 4): What is the maximum pixel value of the current slice?\n",
+ "#\n",
+ "# Hint: There are multiple ways of doing this according to\n",
+ "# https://medium.com/coding-at-dawn/the-fastest-way-to-find-minimum-and-maximum-values-in-an-array-in-javascript-2511115f8621\n",
+ "#"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ ""
+ ],
+ "metadata": {
+ "id": "C0POV_SK5Ql0"
+ }
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "u_swNiBV_xNK"
+ },
+ "source": [
+ "# TODO: YOUR ANSWER\n"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Maximum pixel value is 3740"
+ ],
+ "metadata": {
+ "id": "C6rPnvNe6f6N"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "1f72yBFNgonn"
+ },
+ "source": [
+ "**Bonus**: Apply a filter mask to the current slice! [33 Points]\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "cEEzh8DcACOR"
+ },
+ "source": [
+ "# Here we will modify the pixel data!\n",
+ "#\n",
+ "# The following code allows you to set the pixels of the current slice.\n",
+ "#\n",
+ "# pixels.set(new_pixels);\n",
+ "#\n",
+ "# Write code to APPLY A FILTER MASK to the pixels.\n",
+ "#\n",
+ "# Hint: You can use the following code to get the dimensions of the current slice.\n",
+ "# w = element.image.width;\n",
+ "# h = element.image.height;\n",
+ "#\n",
+ "# You can decide which filter mask to apply (e.g., Gaussian blur, edge detection..).\n",
+ "#\n",
+ "# ** IMPORTANT **\n",
+ "# Hint 2: Triggering a REDRAW programmatically might be hard but you can use\n",
+ "# the LEVELS tool to manually trigger a redraw to see filtered pixels.\n",
+ "# ** IMPORTANT **"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "V3cGbWdB93om",
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 126
+ },
+ "outputId": "e32df20d-f35e-4696-beac-ee3ea9cbf7d5"
+ },
+ "source": [
+ "\"\"\"#\n",
+ "#\n",
+ "# TODO: YOUR CODE GOES HERE\n",
+ "#\n",
+ "#\n",
+ "element = cornerstone.getEnabledElements()[0];\n",
+ "pixels = element.image.getPixelData();\n",
+ "temp_pixels =Array.from(pixels);\n",
+ "\n",
+ "w = element.image.width;\n",
+ "h = element.image.height;\n",
+ "\n",
+ "var pixels_reshape = [];\n",
+ "while(temp_pixels.length) pixels_reshape.push(temp_pixels.splice(0,w));\n",
+ "\n",
+ "var temp_new_pixels = new Array(h);\n",
+ "for (i=0; i < temp_new_pixels.length; i++){\n",
+ " temp_new_pixels[i]=new Array(w);\n",
+ " temp_new_pixels[i].fill(0)\n",
+ "}\n",
+ "\n",
+ "for (var i = 1; i < h-1; i++) {\n",
+ " for (var j = 1; j < w-1; j++) {\n",
+ " var UpperLeft = pixels_reshape[i-1][j-1];\n",
+ " var UpperMiddle = pixels_reshape[i-1][j];\n",
+ " var UpperRight = pixels_reshape[i-1][j+1];\n",
+ " var CenterLeft = pixels_reshape[i][j-1];\n",
+ " var CenterMiddle = pixels_reshape[i][j];\n",
+ " var CenterRight = pixels_reshape[i][j+1];\n",
+ " var LowerLeft = pixels_reshape[i+1][j-1];\n",
+ " var LowerMiddle = pixels_reshape[i+1][j];\n",
+ " var LowerRight = pixels_reshape[i+1][j+1];\n",
+ " var valx = UpperLeft + CenterLeft*2 + LowerLeft - UpperRight - CenterRight*2 - LowerRight;\n",
+ " var valy = UpperLeft + UpperMiddle*2 + UpperRight - LowerLeft - LowerMiddle*2 - LowerRight;\n",
+ "\n",
+ " temp_new_pixels[i][j]=Math.abs(valx)+Math.abs(valy); \n",
+ " }\n",
+ "}\n",
+ "\n",
+ "var new_pixels = Array.prototype.concat.apply([], temp_new_pixels);\n",
+ "pixels.set(new_pixels);\n",
+ "cornerstone.renderGrayscaleImage(element, true)\"\"\""
+ ],
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "'#\\n#\\n# TODO: YOUR CODE GOES HERE\\n#\\n#\\nelement = cornerstone.getEnabledElements()[0];\\npixels = element.image.getPixelData();\\ntemp_pixels =Array.from(pixels);\\n\\nw = element.image.width;\\nh = element.image.height;\\n\\nvar pixels_reshape = [];\\nwhile(temp_pixels.length) pixels_reshape.push(temp_pixels.splice(0,w));\\n\\nvar temp_new_pixels = new Array(h);\\nfor (i=0; i < temp_new_pixels.length; i++){\\n temp_new_pixels[i]=new Array(w);\\n temp_new_pixels[i].fill(0)\\n}\\n\\nfor (var i = 1; i < h-1; i++) {\\n for (var j = 1; j < w-1; j++) {\\n var UpperLeft = pixels_reshape[i-1][j-1];\\n var UpperMiddle = pixels_reshape[i-1][j];\\n var UpperRight = pixels_reshape[i-1][j+1];\\n var CenterLeft = pixels_reshape[i][j-1];\\n var CenterMiddle = pixels_reshape[i][j];\\n var CenterRight = pixels_reshape[i][j+1];\\n var LowerLeft = pixels_reshape[i+1][j-1];\\n var LowerMiddle = pixels_reshape[i+1][j];\\n var LowerRight = pixels_reshape[i+1][j+1];\\n var valx = UpperLeft + CenterLeft*2 + LowerLeft - UpperRight - CenterRight*2 - LowerRight;\\n var valy = UpperLeft + UpperMiddle*2 + UpperRight - LowerLeft - LowerMiddle*2 - LowerRight;\\n\\n temp_new_pixels[i][j]=Math.abs(valx)+Math.abs(valy); \\n }\\n}\\n\\nvar new_pixels = Array.prototype.concat.apply([], temp_new_pixels);\\npixels.set(new_pixels);\\ncornerstone.renderGrayscaleImage(element, true)'"
+ ],
+ "application/vnd.google.colaboratory.intrinsic+json": {
+ "type": "string"
+ }
+ },
+ "metadata": {},
+ "execution_count": 22
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ ""
+ ],
+ "metadata": {
+ "id": "SZIclPgf6EbO"
+ }
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "u7ZiV_N5A9to"
+ },
+ "source": [
+ "# TODO: Please add a screenshot after filtering the current slice."
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ESU5G9cjBAmt"
+ },
+ "source": [
+ "TODO: ADD SCREENSHOT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "0ZtwkapEBVrx"
+ },
+ "source": [
+ "#\n",
+ "# SUPER BONUS (+33 extra): Can you trigger the redraw programmatically?\n",
+ "#"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "fjvuYHqdBdHU"
+ },
+ "source": [
+ "# TODO: YOUR CODE FOR REDRAW GOES HERE"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ ""
+ ],
+ "metadata": {
+ "id": "R8LamXkWS76R"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Codee : cornerstone.renderGrayscaleImage(element, true)"
+ ],
+ "metadata": {
+ "id": "QU9SuiOdTHD6"
+ }
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "0PjWeCJ2825h"
+ },
+ "source": [
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "kWb3h4MKm5t4"
+ },
+ "source": [
+ "#\n",
+ "# THANK YOU!!!\n",
+ "#\n",
+ "# .--..--..--..--..--..--.\n",
+ "# .' \\ (`._ (_) _ \\\n",
+ "# .' | '._) (_) |\n",
+ "# \\ _.')\\ .----..---. /\n",
+ "# |(_.' | / .-\\-. \\ |\n",
+ "# \\ 0| | ( O| O) | o|\n",
+ "# | _ | .--.____.'._.-. |\n",
+ "# \\ (_) | o -` .-` |\n",
+ "# | \\ |`-._ _ _ _ _\\ /\n",
+ "# \\ | | `. |_||_| |\n",
+ "# | o | \\_ \\ | -. .-.\n",
+ "# |.-. \\ `--..-' O | `.`-' .'\n",
+ "# _.' .' | `-.-' /-.__ ' .-'\n",
+ "# .' `-.` '.|='=.='=.='=.='=|._/_ `-'.'\n",
+ "# `-._ `. |________/\\_____| `-.'\n",
+ "# .' ).| '=' '='\\/ '=' |\n",
+ "# `._.` '---------------'\n",
+ "# //___\\ //___\\\n",
+ "# || ||\n",
+ "# LGB ||_.-. ||_.-.\n",
+ "# (_.--__) (_.--__)\n",
+ "#\n",
+ "#"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "collaborate with praveen ganni"
+ ],
+ "metadata": {
+ "id": "0SYvmA_3yUUP"
+ }
+ }
+ ]
+}
\ No newline at end of file
diff --git a/Copy_of_CS480_Assignment_1.ipynb b/Copy_of_CS480_Assignment_1.ipynb
new file mode 100644
index 0000000..a8adae9
--- /dev/null
+++ b/Copy_of_CS480_Assignment_1.ipynb
@@ -0,0 +1,871 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "name": "Copy of CS480 Assignment 1.ipynb",
+ "provenance": [],
+ "collapsed_sections": [],
+ "include_colab_link": true
+ },
+ "kernelspec": {
+ "name": "python3",
+ "display_name": "Python 3"
+ }
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "view-in-github",
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "asaW4NA0jK20"
+ },
+ "source": [
+ "\n",
+ "# Assignment 1\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "Xv1Wc4ECfZwV",
+ "outputId": "210644cc-0608-47fe-dce9-f9b0a43c9231"
+ },
+ "source": [
+ "%pylab inline"
+ ],
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Populating the interactive namespace from numpy and matplotlib\n"
+ ]
+ },
+ {
+ "output_type": "stream",
+ "name": "stderr",
+ "text": [
+ "/usr/local/lib/python3.7/dist-packages/IPython/core/magics/pylab.py:161: UserWarning: pylab import has clobbered these variables: ['plot']\n",
+ "`%matplotlib` prevents importing * from pylab and numpy\n",
+ " \"\\n`%matplotlib` prevents importing * from pylab and numpy\"\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "from scipy.misc import electrocardiogram # scipy is a python scientific computing library\n",
+ "ecg = electrocardiogram() # let's load the scipy ECG dataset\n",
+ "from matplotlib import pyplot as plt\n"
+ ],
+ "metadata": {
+ "id": "dcsn8dfffLeI"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "NFw0i1_4-ixY"
+ },
+ "source": [
+ "SAMPLING_RATE = 360 # this data was sampled with 360 Hz"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "arraay1 = [[-0.245 ,1, 2], -0.125]\n",
+ "ecg [0:13:2]"
+ ],
+ "metadata": {
+ "id": "6sJKeBfCfUA1",
+ "outputId": "b03a0970-89c7-4af0-9aa6-7f70a2456a87",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ }
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "array([-0.245, -0.185, -0.17 , -0.185, -0.16 , -0.17 , -0.22 ])"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 65
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "firstsecond = ecg[:SAMPLING_RATE]"
+ ],
+ "metadata": {
+ "id": "jLsdQ9ELfaPH"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "secondsecond = ecg[1*SAMPLING_RATE:2*SAMPLING_RATE]"
+ ],
+ "metadata": {
+ "id": "7hbYA8uefca2"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "ele = ecg[8*SAMPLING_RATE:11*SAMPLING_RATE]"
+ ],
+ "metadata": {
+ "id": "cucwNpbvfc8u"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "MXCidk9L_VG8"
+ },
+ "source": [
+ "**Task 1:** Plot the data in the range from 9 to 11 seconds! [30 Points]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "s2n86tUP_pMZ"
+ },
+ "source": [
+ "# TODO your plotting code goes here\n",
+ "# please take the sampling rate into account to only plot the range\n",
+ "# between 9 and 11 seconds"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "print (ecg)\n",
+ "plot (ele)"
+ ],
+ "metadata": {
+ "id": "KIkJN29Wfkgf",
+ "outputId": "d5702809-6a66-4585-85f2-b4bc52b262f4",
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 300
+ }
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "[-0.245 -0.215 -0.185 ... -0.405 -0.395 -0.385]\n"
+ ]
+ },
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "[