MC8_HowToConnectToPACS.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "MC8_HowToConnectToPACS.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/RSNA/MagiciansCorner/blob/master/MC8_HowToConnectToPACS.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Lk1w_h_f8g47"
      },
      "source": [
        "# Magicians Corner 8 - How to connect an algorithm to a PACS"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RuUYgHzb6mQK"
      },
      "source": [
        "###by: Bradley J Erickson, MD, PhD and Felipe Kitamura, MD, MSc, PhD\n",
        "*Copyright 2020\n",
        "\n",
        "###See corresponding Radiology: AI article here: https://pubs.rsna.org/doi/10.1148/ryai.2021200105"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HPjX5Pqb7SXZ"
      },
      "source": [
        "In this tutorial we will:\n",
        "\n",
        "\n",
        "\n",
        "1.   Connect to a (cloud) PACS\n",
        "2.   Test if the connection is established\n",
        "3.   Query the PACS for a specific study\n",
        "4.   Retrieve this study\n",
        "5.   Perform an inference on this study (lung segmentation).\n",
        "6.   Send the result back to the PACS\n",
        "\n",
        "We will use an open PACS used for testing (https://www.dicomserver.co.uk/).\n",
        "\n",
        "\n",
        "Acknowledgements to:\n",
        "- pydicom and pynetdicom developers in keeping a complete documentation.\n",
        "- Johannes Hofmanninger (https://github.com/JoHof/lungmask#COVID-19-Web)\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-BpkffW56f_z"
      },
      "source": [
        "# Cell 1\n",
        "# First we will install the libraries we will use. It should take a few seconds.\n",
        "\n",
        "!pip install git+https://github.com/JoHof/lungmask\n",
        "\n",
        "!pip install pynetdicom #this is the DICOM DIMSE protocol library for Python\n",
        "\n",
        "!pip install numpy==1.20.0\n",
        "\n",
        "print('\\x1b[1;31m'+'Restart the Runtime in the Menu Runtime>Restart runtime (or press CTRL + M + .). Then go to the next cell.'+'\\x1b[0m')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lFKcqnCg9FVj"
      },
      "source": [
        "# Cell 2\n",
        "# Then we import some useful libraries, including the last one we installed\n",
        "\n",
        "from pynetdicom import (\n",
        "    AE, evt, build_role,\n",
        "    StoragePresentationContexts,\n",
        "    PYNETDICOM_IMPLEMENTATION_UID,\n",
        "    PYNETDICOM_IMPLEMENTATION_VERSION\n",
        ")\n",
        "from pynetdicom.sop_class import (\n",
        "    StudyRootQueryRetrieveInformationModelFind,\n",
        "    PatientRootQueryRetrieveInformationModelGet,\n",
        "    StudyRootQueryRetrieveInformationModelGet,\n",
        "    StudyRootQueryRetrieveInformationModelMove,\n",
        "    CTImageStorage\n",
        "\n",
        ")\n",
        "\n",
        "import pydicom\n",
        "from pydicom import dcmread\n",
        "from pydicom.dataset import Dataset\n",
        "import os\n",
        "from matplotlib import pyplot as plt\n",
        "from glob import glob\n",
        "\n",
        "\n",
        "import numpy as np\n",
        "import numpy.ma as ma\n",
        "import shutil\n",
        "import imageio\n",
        "import cv2\n",
        "from natsort import natsorted\n",
        "import random\n",
        "import datetime, time\n",
        "\n",
        "\n",
        "from lungmask import mask # This is the Deep Learning model we will use to segment the lungs\n",
        "import SimpleITK as sitk\n",
        "\n",
        "import warnings\n",
        "warnings.filterwarnings(\"ignore\")\n",
        "\n",
        "print('\\x1b[1;31m'+'Go to the next cell.'+'\\x1b[0m')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hyPb7bUE9ewc"
      },
      "source": [
        "# Cell 3\n",
        "# We must set up the information about PACS we will connect to\n",
        "# when you want to connect to your local PACS, change this address and port\n",
        "\n",
        "PACS_addr = \"www.dicomserver.co.uk\"\n",
        "port = 104\n",
        "\n",
        "print('\\x1b[1;31m'+'Go to the next cell.'+'\\x1b[0m')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "--bHkuNZBmjH"
      },
      "source": [
        "# Cell 4\n",
        "# Now we connect to the PACS and send a C-ECHO to test if we were able to establish connection\n",
        "\n",
        "ae = AE(ae_title=b'ANY-SCU')\n",
        "# Verification SOP Class has a UID of 1.2.840.10008.1.1\n",
        "#   we can use the UID str directly when adding the requested\n",
        "#   presentation context\n",
        "ae.add_requested_context('1.2.840.10008.1.1')\n",
        "ae.add_requested_context(StudyRootQueryRetrieveInformationModelFind)\n",
        "\n",
        "# Associate with a peer AE\n",
        "assoc = ae.associate(PACS_addr, port)\n",
        "\n",
        "if assoc.is_established:\n",
        "    print(\"Association established.\")\n",
        "    # Send a DIMSE C-ECHO request to the peer\n",
        "    status = assoc.send_c_echo()\n",
        "\n",
        "    # Print the response from the peer\n",
        "    if status:\n",
        "        print('C-ECHO Response: 0x{0:04x}'.format(status.Status))\n",
        "\n",
        "    # Release the association\n",
        "    assoc.release()\n",
        "    print(\"Association Released.\")\n",
        "else:\n",
        "    print(\"Association not established.\")\n",
        "    \n",
        "print('\\x1b[1;31m'+'Go to the next cell.'+'\\x1b[0m')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rAFHKhtmCzOK"
      },
      "source": [
        "A C-ECHO Response of 0x0000 means we were able to communicate with the PACS"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nss737zrBR2s"
      },
      "source": [
        "# Cell 5\n",
        "# Then we define the filters to query the specific study of interest\n",
        "\n",
        "ds = pydicom.Dataset()\n",
        "#ds.PatientName = ''\n",
        "#ds.Modality = 'CT'\n",
        "ds.StudyDescription = '*'\n",
        "ds.QueryRetrieveLevel = 'STUDY'\n",
        "ds.AccessionNumber = '1400059968'\n",
        "ds.PatientID = '*'\n",
        "ds.StudyInstanceUID = '*'\n",
        "# print the group and elements just to see what is there\n",
        "print(ds)\n",
        "\n",
        "print('\\x1b[1;31m'+'Go to the next cell.'+'\\x1b[0m')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JcaWRNxBdwVR"
      },
      "source": [
        "We will filter by AccessionNumber, a DICOM tag that should be unique for each study.\n",
        "The other tags with value '*' tell the PACS we want those information back."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6fbhlxyVQ1yp"
      },
      "source": [
        "# Cell 6\n",
        "\n",
        "# Here we establish a connection again, but now we will send a C-FIND to query the PACS using the filter we defined before.\n",
        "\n",
        "ae = AE(ae_title=b'ANY-SCU')\n",
        "# Verification SOP Class has a UID of 1.2.840.10008.1.1\n",
        "#   we can use the UID str directly when adding the requested\n",
        "#   presentation context\n",
        "ae.add_requested_context('1.2.840.10008.1.1')\n",
        "ae.add_requested_context(StudyRootQueryRetrieveInformationModelFind)\n",
        "\n",
        "# Associate with a peer AE\n",
        "assoc = ae.associate(PACS_addr, port)\n",
        "\n",
        "if assoc.is_established:\n",
        "    # Send a DIMSE C-ECHO request to the peer\n",
        "    status = assoc.send_c_echo()\n",
        "\n",
        "    # Print the response from the peer\n",
        "    if status:\n",
        "        print('C-ECHO Response: 0x{0:04x}'.format(status.Status))\n",
        "        responses = assoc.send_c_find(ds,StudyRootQueryRetrieveInformationModelFind)\n",
        "        for (status, identifier) in responses:\n",
        "            if status:\n",
        "                print('C-FIND query status: 0x{0:04x}'.format(status.Status))\n",
        "\n",
        "                # If the status is 'Pending' then identifier is the C-FIND response\n",
        "                if status.Status in (0xFF00, 0xFF01):\n",
        "                    print(identifier)\n",
        "                    StudyFound = identifier\n",
        "            else:\n",
        "                print('Connection timed out, was aborted or received invalid response')\n",
        "    # Release the association\n",
        "    assoc.release()\n",
        "    print(\"Association Released.\")\n",
        "    \n",
        "print('\\x1b[1;31m'+'Go to the next cell.'+'\\x1b[0m')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k9vgX2SveIPt"
      },
      "source": [
        "The output above shows the information of the study we found in the PACS. We will use the StudyInstanceUID as the identifier to download this study from the PACS to this Colab Notebook."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cs4Rso9zEE2b"
      },
      "source": [
        "# Cell 7\n",
        "# Having found a study of interest, we will send a C-GET to download it\n",
        "\n",
        "path = 'study/' # Folder to save the incoming DICOM files\n",
        "os.makedirs(path, exist_ok=True)\n",
        "\n",
        "# Implement the handler for evt.EVT_C_STORE\n",
        "def handle_store(event):\n",
        "    \"\"\"Handle a C-STORE request event.\"\"\"\n",
        "    ds = event.dataset\n",
        "    context = event.context\n",
        "\n",
        "    # Add the DICOM File Meta Information\n",
        "    meta = pydicom.Dataset()\n",
        "    meta.MediaStorageSOPClassUID = ds.SOPClassUID\n",
        "    meta.MediaStorageSOPInstanceUID = ds.SOPInstanceUID\n",
        "    meta.ImplementationClassUID = PYNETDICOM_IMPLEMENTATION_UID\n",
        "    meta.ImplementationVersionName = PYNETDICOM_IMPLEMENTATION_VERSION\n",
        "    meta.TransferSyntaxUID = context.transfer_syntax\n",
        "\n",
        "    # Add the file meta to the dataset\n",
        "    ds.file_meta = meta\n",
        "\n",
        "    # Set the transfer syntax attributes of the dataset\n",
        "    ds.is_little_endian = context.transfer_syntax.is_little_endian\n",
        "    ds.is_implicit_VR = context.transfer_syntax.is_implicit_VR\n",
        "\n",
        "    print(\"Saving file: \" + ds.SOPInstanceUID + \".dcm\")\n",
        "    # Save the dataset using the SOP Instance UID as the filename    \n",
        "    ds.save_as(path + ds.SOPInstanceUID + \".dcm\", write_like_original=False)\n",
        "\n",
        "    # Return a 'Success' status\n",
        "    return 0x0000\n",
        "\n",
        "handlers = [(evt.EVT_C_STORE, handle_store)]\n",
        "\n",
        "# Initialise the Application Entity\n",
        "ae = AE()\n",
        "\n",
        "# Add the requested presentation contexts (QR SCU)\n",
        "ae.add_requested_context(StudyRootQueryRetrieveInformationModelGet)\n",
        "# Add the requested presentation context (Storage SCP)\n",
        "ae.add_requested_context(CTImageStorage)\n",
        "\n",
        "# Create an SCP/SCU Role Selection Negotiation item for CT Image Storage\n",
        "role = build_role(CTImageStorage, scp_role=True)\n",
        "\n",
        "# Create our Identifier (query) dataset\n",
        "# We need to supply a Unique Key Attribute for each level above the\n",
        "#   Query/Retrieve level\n",
        "ds = pydicom.Dataset()\n",
        "ds.QueryRetrieveLevel = 'STUDY'\n",
        "ds.StudyInstanceUID = StudyFound.StudyInstanceUID # Use the StudyInstanceUID from the study we found before\n",
        "\n",
        "\n",
        "# Associate with peer AE at PACS_addr and port defined in the beginning \n",
        "assoc = ae.associate(PACS_addr, port, ext_neg=[role], evt_handlers=handlers)\n",
        "\n",
        "if assoc.is_established:\n",
        "    # Use the C-GET service to send the identifier\n",
        "    responses = assoc.send_c_get(ds, StudyRootQueryRetrieveInformationModelGet)\n",
        "\n",
        "    for (status, identifier) in responses:\n",
        "        if status:\n",
        "            print('C-GET query status: 0x{0:04x}'.format(status.Status))\n",
        "        else:\n",
        "            print('Connection timed out, was aborted or received invalid response')\n",
        "\n",
        "    # Release the association\n",
        "    assoc.release()\n",
        "else:\n",
        "    print('Association rejected, aborted or never connected')\n",
        "    \n",
        "print('\\x1b[1;31m'+'Go to the next cell.'+'\\x1b[0m')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MxpemmApflD_"
      },
      "source": [
        "A C-GET query status of 0xff00 means there are pending operations (files to be transfered). A C-GET status of 0x0000 means operation finished."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VOc-d022Z5im"
      },
      "source": [
        "# Cell 8\n",
        "\n",
        "# We can list the files in the study/ folder to see if the DICOM files were downloaded properly.\n",
        "\n",
        "#!rm -rf study/\n",
        "!ls study/\n",
        "!ls study/ | wc\n",
        "\n",
        "print('\\x1b[1;31m'+'Go to the next cell.'+'\\x1b[0m')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-GsWvkFFg_2-"
      },
      "source": [
        "# Cell 9\n",
        "\n",
        "# Let's take a look at the files we've just retrieved from the PACS\n",
        "\n",
        "# This is an anonymized study that we will use as example.\n",
        "\n",
        "# When plotting the images, we will also save them as JPG files to use the open-source lung segmentation model.\n",
        "\n",
        "WW = 400 # Window Width in Hounsfield Units\n",
        "WC = 40 # Window Center in Hounsfield Units\n",
        "LW = WC - WW/2\n",
        "UW = WC + WW/2\n",
        "\n",
        "files = glob(\"study/*.dcm\") # List all DICOM files\n",
        "\n",
        "DS = [pydicom.dcmread(_f) for _f in files] # Load them\n",
        "\n",
        "DS = sorted(DS, key= lambda x: float(x.SliceLocation)) # Orderm them by Slice Location\n",
        "\n",
        "plt.figure(figsize=(15,15)) # Create a plot\n",
        "\n",
        "for i, _ds in enumerate(DS): #For each DICOM\n",
        "    \n",
        "    img = _ds.pixel_array # Load the image \n",
        "    img = img * _ds.RescaleSlope + _ds.RescaleIntercept # Rescale values to Hounsfield Units\n",
        "    img[img < LW] = LW # Apply Lower Window Attenuation\n",
        "    img[img > UW] = UW # Apply Upper Window Attenuation\n",
        "    plt.subplot(10, 10, i+1)\n",
        "    plt.imshow(img, cmap = \"gray\") # Plot image as grayscale\n",
        "    plt.axis('off')\n",
        "\n",
        "\n",
        "plt.show()\n",
        "\n",
        "print('\\x1b[1;31m'+'Go to the next cell.'+'\\x1b[0m')\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZMfsf2HaBdOd"
      },
      "source": [
        "# Cell 10\n",
        "\n",
        "# Next step, we will create our AI tool. Since this AI is not the focus, we will\n",
        "# load the trained u-net from a prior article and will simply do the inference,\n",
        "# and no training. This should take no more than 2 minutes.\n",
        "\n",
        "files = glob(\"study/*.dcm\") # List all DICOM files\n",
        "\n",
        "os.makedirs(\"testimages_pred\", exist_ok=True)\n",
        "\n",
        "\n",
        "starting_time = time.time()\n",
        "\n",
        "for j in range(0, len(files)):\n",
        "    i = j \n",
        "    image = np.zeros((512,512,3))\n",
        "    pred = np.zeros((512,512,3))\n",
        "    ds = pydicom.dcmread(files[i])\n",
        "\n",
        "    image[...,0] = ds.pixel_array / (2 ** 11)\n",
        "    image[...,1] = ds.pixel_array / (2 ** 11)\n",
        "    image[...,2] = ds.pixel_array / (2 ** 11)\n",
        "\n",
        "    input_image = sitk.ReadImage(files[i])\n",
        "    pred[...,2] = mask.apply(input_image)\n",
        "    pred[...,2] = ma.masked_where(pred[...,2] == 0, pred[...,2])\n",
        "\n",
        "    InstanceNumber = ds.InstanceNumber\n",
        "\n",
        "    \n",
        "    img = cv2.addWeighted(image, 0.8, pred, 0.2, 0)\n",
        "    \n",
        "    cv2.imwrite(\"testimages_pred/\" + str(InstanceNumber).zfill(4) + \".jpg\", np.moveaxis(np.asarray([img[...,2], img[...,1], img[...,0]]),0,-1)*255,)\n",
        "\n",
        "print (\"Total execution time was \" + str(time.time() - starting_time) + \" seconds.\")\n",
        "\n",
        "im_list = natsorted(os.listdir('./testimages_pred'))\n",
        "\n",
        "fig=plt.figure(figsize=(250, 50))\n",
        "\n",
        "for i, f in enumerate(im_list):\n",
        "    pth = './testimages_pred/' + f \n",
        "    img = imageio.imread(pth)\n",
        "    fig.add_subplot(10, 10, i+1)\n",
        "    plt.imshow(img)\n",
        "    plt.title(i)\n",
        "    plt.axis('off')\n",
        "\n",
        "plt.subplots_adjust(bottom=0.1, left = 0.01, right=0.05, top=0.3)\n",
        "plt.show()\n",
        "\n",
        "print('\\x1b[1;31m'+'Go to the next cell.'+'\\x1b[0m')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OLPHSasJWuBN"
      },
      "source": [
        "# Cell 11\n",
        "\n",
        "# To send the results back to PACS we need to create new DICOM files\n",
        "\n",
        "# Look for the line: ds.PatientName = \"Putyournamehere\" and change it so you can\n",
        "# check the result later\n",
        "\n",
        "os.makedirs('dcm_pred', exist_ok=True)\n",
        "\n",
        "dt = datetime.datetime.now()\n",
        "\n",
        "series_unique = dt.strftime('%Y%m%d') + dt.strftime('%H%M%S.%f')\n",
        "series_unique = series_unique.replace(\".0\", \".1\")\n",
        "\n",
        "PID = str(np.random.randint(0,1000000))\n",
        "print (\"Patient ID generated is \" + str(PID))\n",
        "\n",
        "im_list = natsorted(os.listdir('./testimages_pred'))\n",
        "\n",
        "for i, f in enumerate(im_list):\n",
        "    pth = './testimages_pred/' + f \n",
        "    img = imageio.imread(pth)\n",
        "    ds = pydicom.Dataset()\n",
        "    # Create some temporary filenames\n",
        "    suffix = '.dcm'\n",
        "    filename_little_endian = f.replace(\".jpg\", \"\")\n",
        "\n",
        "    dt = datetime.datetime.now()\n",
        "\n",
        "    sop_unique = dt.strftime('%Y%m%d') + dt.strftime('%H%M%S.%f')\n",
        "    sop_unique = sop_unique.replace(\".0\", \".1\")\n",
        "\n",
        "    print(\"Setting file meta information...\")\n",
        "    # Populate required values for file meta information\n",
        "    file_meta = Dataset()\n",
        "    file_meta.MediaStorageSOPClassUID = '1.2.840.10008.5.1.4.1.1.7'\n",
        "    file_meta.MediaStorageSOPInstanceUID = \"1.2.3.1\" + sop_unique\n",
        "    file_meta.ImplementationClassUID = \"1.2.3.4\"\n",
        "    file_meta.TransferSyntaxUID = '1.2.840.10008.1.2'\n",
        "\n",
        "    print(\"Setting dataset values...\")\n",
        "    # Create the FileDataset instance (initially no data elements, but file_meta\n",
        "    # supplied)\n",
        "    ds = pydicom.FileDataset(filename_little_endian, {},\n",
        "                    file_meta=file_meta, preamble=b\"\\0\" * 128)\n",
        "\n",
        "    # Add the data elements -- not trying to set all required here. Check DICOM\n",
        "    # standard\n",
        "\n",
        "    \n",
        "    ###########################################################################\n",
        "    ###########################################################################\n",
        "    \n",
        "    # Change this string to check your result in the end of this notebook\n",
        "\n",
        "    ds.PatientName = \"Putyournamehere\" \n",
        "\n",
        "    ###########################################################################\n",
        "    ###########################################################################\n",
        "\n",
        "\n",
        "    ds.PatientID = PID\n",
        "    ds.AccessionNumber = PID + \"002\"\n",
        "    ds.PatientBirthDate = \"\"\n",
        "    ds.PatientSex = \"\"\n",
        "    ds.ReferringPhysicianName = \"\"\n",
        "    ds.StudyDescription = \"Lung Segmentation Inference Study\"\n",
        "    ds.SeriesDescription = \"Lung Segmentation Inference Series\"\n",
        "    \n",
        "\n",
        "    # Set the transfer syntax\n",
        "    ds.is_little_endian = True\n",
        "    ds.is_implicit_VR = True\n",
        "\n",
        "    ds.StudyInstanceUID = \"1.2.3.1\" + series_unique + \".1\"\n",
        "    ds.SeriesInstanceUID = \"1.2.3.1\" + series_unique + \".2\"\n",
        "    ds.SOPInstanceUID = ds.file_meta.MediaStorageSOPInstanceUID\n",
        "    ds.SOPClassUID = ds.file_meta.MediaStorageSOPClassUID\n",
        "\n",
        "    # Set creation date/time\n",
        "    \n",
        "    ds.ContentDate = dt.strftime('%Y%m%d')\n",
        "    timeStr = dt.strftime('%H%M%S.%f')  # long format with micro seconds\n",
        "    ds.ContentTime = timeStr\n",
        "\n",
        "    ds.StudyDate = ds.ContentDate\n",
        "    ds.StudyTime = ds.ContentTime\n",
        "\n",
        "    ds.InstanceNumber = i\n",
        "\n",
        "    ds.StudyID = PID + \"001\"\n",
        "\n",
        "    ds.Rows = img.shape[0]\n",
        "    ds.Columns = img.shape[1]\n",
        "    ds.SamplesPerPixel = 3\n",
        "    ds.PhotometricInterpretation = 'RGB'\n",
        "    ds.BitsStored = 8\n",
        "    ds.HighBit = 7\n",
        "    ds.BitsAllocated = 8\n",
        "    ds.Modality = 'CT'\n",
        "    ds.SeriesNumber = '201'\n",
        "\n",
        "    ds.PixelData = img.tobytes()\n",
        "\n",
        "    print(\"Writing test file\", filename_little_endian)\n",
        "    ds.save_as('dcm_pred/' + f.replace(\"jpg\", \"dcm\"))\n",
        "    print(\"File saved.\")\n",
        "\n",
        "print('\\x1b[1;31m'+'Go to the next cell.'+'\\x1b[0m')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mPScaggssMkI"
      },
      "source": [
        "# Cell 12\n",
        "\n",
        "# Here we implement a QR MOVE SCP to listen to C-MOVE requests\n",
        "\n",
        "# Implement the evt.EVT_C_MOVE handler\n",
        "def handle_move(event):\n",
        "    \"\"\"Handle a C-MOVE request event.\"\"\"\n",
        "    ds = event.identifier\n",
        "\n",
        "    if 'QueryRetrieveLevel' not in ds:\n",
        "        # Failure\n",
        "        yield 0xC000, None\n",
        "        return\n",
        "\n",
        "    # get_known_aet() is here to represent a user-implemented method of\n",
        "    #   getting known AEs, for this example it returns a dict with the\n",
        "    #   AE titles as keys\n",
        "    known_aet_dict = {b'KITAMURA' : (\"ec2-44-192-45-92.compute-1.amazonaws.com\", 104)}\n",
        "    try:\n",
        "        (addr, port) = known_aet_dict[event.move_destination]\n",
        "\n",
        "    except KeyError:\n",
        "        # Unknown destination AE\n",
        "        yield (None, None)\n",
        "        return\n",
        "\n",
        "    # Yield the IP address and listen port of the destination AE\n",
        "    yield (addr, port)\n",
        "\n",
        "    # Import stored SOP Instances\n",
        "    instances = []\n",
        "    matching = []\n",
        "    fdir = 'dcm_pred/'\n",
        "    for fpath in os.listdir(fdir):\n",
        "        instances.append(dcmread(os.path.join(fdir, fpath)))\n",
        "\n",
        "    if ds.QueryRetrieveLevel == 'STUDY':\n",
        "        if 'StudyInstanceUID' in ds:\n",
        "            matching = [\n",
        "                inst for inst in instances if inst.StudyInstanceUID == ds.StudyInstanceUID\n",
        "            ]\n",
        "\n",
        "        # Skip the other possible attributes...\n",
        "\n",
        "    # Skip the other QR levels...\n",
        "    # Yield the total number of C-STORE sub-operations required\n",
        "    yield len(matching)\n",
        "\n",
        "    # Yield the matching instances\n",
        "    for instance in matching:\n",
        "        # Check if C-CANCEL has been received\n",
        "        if event.is_cancelled:\n",
        "            yield (0xFE00, None)\n",
        "            return\n",
        "\n",
        "        # Pending\n",
        "        yield (0xFF00, instance)\n",
        "\n",
        "handlers = [(evt.EVT_C_MOVE, handle_move)]\n",
        "\n",
        "if ae is not None: # Check if we have already associated not to start duplicate servers\n",
        "  del(ae)\n",
        "\n",
        "# Create application entity\n",
        "ae = AE(\"MY-SCP\")\n",
        "\n",
        "# Add the requested presentation contexts (Storage SCU)\n",
        "ae.requested_contexts = StoragePresentationContexts\n",
        "# Add a supported presentation context (QR Move SCP)\n",
        "ae.add_supported_context(StudyRootQueryRetrieveInformationModelMove)\n",
        "\n",
        "# Start listening for incoming association requests\n",
        "try:\n",
        "  scp = ae.start_server(('127.0.0.1', 11112), evt_handlers=handlers, block=False)\n",
        "except:\n",
        "  print(\"It seems you run this cell twice without running the next one.\")\n",
        "\n",
        "\n",
        "print('\\x1b[1;31m'+'Go to the next cell.'+'\\x1b[0m')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-Fvvd8Zew2rn"
      },
      "source": [
        "# Cell 13\n",
        "\n",
        "# Now we set a SCU to send a C-MOVE to our SCP defined in the last cell\n",
        "# This C-MOVE will ask to move our inference results to an open PACS \n",
        "\n",
        "\n",
        "# Initialise the Application Entity\n",
        "ae2 = AE(\"MY-SCU\")\n",
        "\n",
        "# Add a requested presentation context\n",
        "ae2.add_requested_context(StudyRootQueryRetrieveInformationModelMove)\n",
        "\n",
        "# Create out identifier (query) dataset\n",
        "ds = pydicom.Dataset()\n",
        "ds.QueryRetrieveLevel = 'STUDY'\n",
        "ds.StudyInstanceUID = \"1.2.3.1\" + series_unique + \".1\" # \n",
        "\n",
        "\n",
        "# Associate with peer AE at IP 127.0.0.1 and port 11112\n",
        "assoc = ae2.associate('127.0.0.1', 11112)\n",
        "\n",
        "if assoc.is_established:\n",
        "    # Use the C-MOVE service to send the identifier\n",
        "    responses = assoc.send_c_move(ds, b'KITAMURA', StudyRootQueryRetrieveInformationModelMove)\n",
        "\n",
        "    for (status, identifier) in responses:\n",
        "        if status:\n",
        "            print('C-MOVE query status: 0x{0:04x}'.format(status.Status))\n",
        "\n",
        "            # If the status is 'Pending' then the identifier is the C-MOVE response\n",
        "            if status.Status in (0xFF00, 0xFF01):\n",
        "                print(identifier)\n",
        "        else:\n",
        "            print('Connection timed out, was aborted or received invalid response')\n",
        "\n",
        "    # Release the association\n",
        "    assoc.release()\n",
        "else:\n",
        "    print('Association rejected, aborted or never connected')\n",
        "\n",
        "\n",
        "# Stop our Storage SCP\n",
        "scp.shutdown()\n",
        "\n",
        "print('\\x1b[1;31m'+'Go to the next cell.'+'\\x1b[0m')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VWnMyZ5Y_S6O"
      },
      "source": [
        "A C-MOVE query status of 0xff00 means there are pending operations (files to be transfered). A C-MOVE status of 0x0000 means operation finished."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "STje_QGMAJrk"
      },
      "source": [
        "You can check if the result was transfered back to PACS by accessing the following link: [Research PACS](http://ec2-44-192-45-92.compute-1.amazonaws.com:8042/app/explorer.html#find-studies) and looking for a study with the PatientName you defined on cell #11.\n",
        "\n",
        "**Username:** orthanc\n",
        "\n",
        "**Password:** orthanc\n",
        "\n",
        "After clicking in the study, click the yellow button: Osimis Web Viewer.\n",
        "\n",
        "This is a link to the result sent to PACS during the creation of this notebook:\n",
        "[Test Result](http://ec2-44-192-45-92.compute-1.amazonaws.com:8042/osimis-viewer/app/index.html?series=53cc275e-f6389de2-e907724f-3b7e8b57-10cfbdb4)\n",
        "\n",
        "## Congratulations! You have finished this activity."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Urnj7uRL_Wzh"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}