B1_interactive_filtering.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "kernel": "Python3"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       "    .main-title{\n",
       "        text-align:center;\n",
       "        padding: 30px;\n",
       "        border-top: 12px double darkblue;\n",
       "        border-bottom: 4px solid darkblue;\n",
       "        font-size: 2.7em;\n",
       "        font-family: georgia,garamond,serif;\n",
       "        text-transform: uppercase;\n",
       "        background-color: #e6faff;\n",
       "    }\n",
       "    .notebook-description{\n",
       "        text-align:justify;\n",
       "        margin-left: 100px;\n",
       "        margin-right: 100px;\n",
       "        line-height: 1.25;\n",
       "    }\n",
       "    .project-scope{\n",
       "        text-align: justify;\n",
       "        line-height: 1.5;\n",
       "    }\n",
       "    .features-used-description > dt::before, .filtering-types-description > dt::before {\n",
       "        content: \"•\";\n",
       "        font-size: 17px;\n",
       "        color: darkblue;\n",
       "        display: inline-block; \n",
       "        width: 0.7em;\n",
       "    }\n",
       "    .features-used-description > dt, .filtering-types-description > dt{\n",
       "        font-size: 1.2em;\n",
       "    }\n",
       "    .features-used-description > dd, .filtering-types-description > dd{\n",
       "        margin-left: 30px;\n",
       "    }\n",
       "    .note::before{\n",
       "        content: \"** \";\n",
       "        font-size: 0.9em;\n",
       "        margin-top:30px;\n",
       "    }\n",
       "    .note{\n",
       "        font-size: 0.9em;\n",
       "        font-style: italic;\n",
       "        margin-top:30px;\n",
       "    }\n",
       "    var {\n",
       "        font-family: monospace;\n",
       "        font-size: larger;\n",
       "    }\n",
       "    .project-structure{\n",
       "        text-align: justify;\n",
       "        line-height: 1.5;\n",
       "    }\n",
       "    .section-heading{\n",
       "        font-size: 2em;\n",
       "        padding-left: 10px;\n",
       "        text-align: left;\n",
       "        border-left: 3px solid darkblue;\n",
       "        height: 50px;\n",
       "        font-family: cursive;\n",
       "    }\n",
       "    .section-content{\n",
       "        margin-top: 10px;\n",
       "        text-align: justify;\n",
       "        line-height: 1.5;\n",
       "    }\n",
       "    .output_subarea iframe{\n",
       "        width: 98% !important;\n",
       "    }\n",
       "    .equation{\n",
       "        margin-top: 25px;\n",
       "        margin-bottom:25px;\n",
       "    }\n",
       "    .image{\n",
       "        width: 400px;\n",
       "        margin-top: 25px;\n",
       "    }\n",
       "    .image-description{\n",
       "        text-align: center;\n",
       "        font-size: larger;\n",
       "    }\n",
       "    \n",
       "    .acknowledgement {\n",
       "        text-transform: uppercase;\n",
       "    }\n",
       "    .acknowledgement > .section-heading{\n",
       "        text-transform: uppercase;\n",
       "        font-size: 1.3em;\n",
       "        text-align: center;\n",
       "        border-left: none;\n",
       "    }\n",
       "    .acknowledgement > .section-content{\n",
       "        text-align: center;\n",
       "        font-size:smaller;\n",
       "#         margin-top: 25px;\n",
       "        margin-left: 40px;\n",
       "        margin-right: 40px;\n",
       "    }\n",
       "    .signature{\n",
       "        margin-top:30px;\n",
       "    }\n",
       "    .signature > .date {\n",
       "        width: 50%;\n",
       "        display: inline-block;\n",
       "        float: left;\n",
       "        text-align: left;\n",
       "    }\n",
       "    .signature > .sign {\n",
       "        width: 50%;\n",
       "        display: inline-block;\n",
       "        float: right;\n",
       "        text-align: right;\n",
       "    }\n",
       "    .references{\n",
       "        background-color: #e6faff;\n",
       "        border: 1.2px solid grey;\n",
       "        padding: 0px 7px 1px 7px;\n",
       "    }\n",
       "    .references > h3{\n",
       "        margin-top: 5px !important;\n",
       "    }\n",
       "    .references > ol{\n",
       "        margin-top: 4px;\n",
       "        margin-bottom: 4px;\n",
       "    }\n",
       "\n",
       "    \n",
       "</style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<style>\n",
    "    .main-title{\n",
    "        text-align:center;\n",
    "        padding: 30px;\n",
    "        border-top: 12px double darkblue;\n",
    "        border-bottom: 4px solid darkblue;\n",
    "        font-size: 2.7em;\n",
    "        font-family: georgia,garamond,serif;\n",
    "        text-transform: uppercase;\n",
    "        background-color: #e6faff;\n",
    "    }\n",
    "    .notebook-description{\n",
    "        text-align:justify;\n",
    "        margin-left: 100px;\n",
    "        margin-right: 100px;\n",
    "        line-height: 1.25;\n",
    "    }\n",
    "    .project-scope{\n",
    "        text-align: justify;\n",
    "        line-height: 1.5;\n",
    "    }\n",
    "    .features-used-description > dt::before, .filtering-types-description > dt::before {\n",
    "        content: \"•\";\n",
    "        font-size: 17px;\n",
    "        color: darkblue;\n",
    "        display: inline-block; \n",
    "        width: 0.7em;\n",
    "    }\n",
    "    .features-used-description > dt, .filtering-types-description > dt{\n",
    "        font-size: 1.2em;\n",
    "    }\n",
    "    .features-used-description > dd, .filtering-types-description > dd{\n",
    "        margin-left: 30px;\n",
    "    }\n",
    "    .note::before{\n",
    "        content: \"** \";\n",
    "        font-size: 0.9em;\n",
    "        margin-top:30px;\n",
    "    }\n",
    "    .note{\n",
    "        font-size: 0.9em;\n",
    "        font-style: italic;\n",
    "        margin-top:30px;\n",
    "    }\n",
    "    var {\n",
    "        font-family: monospace;\n",
    "        font-size: larger;\n",
    "    }\n",
    "    .project-structure{\n",
    "        text-align: justify;\n",
    "        line-height: 1.5;\n",
    "    }\n",
    "    .section-heading{\n",
    "        font-size: 2em;\n",
    "        padding-left: 10px;\n",
    "        text-align: left;\n",
    "        border-left: 3px solid darkblue;\n",
    "        height: 50px;\n",
    "        font-family: cursive;\n",
    "    }\n",
    "    .section-content{\n",
    "        margin-top: 10px;\n",
    "        text-align: justify;\n",
    "        line-height: 1.5;\n",
    "    }\n",
    "    .output_subarea iframe{\n",
    "        width: 98% !important;\n",
    "    }\n",
    "    .equation{\n",
    "        margin-top: 25px;\n",
    "        margin-bottom:25px;\n",
    "    }\n",
    "    .image{\n",
    "        width: 400px;\n",
    "        margin-top: 25px;\n",
    "    }\n",
    "    .image-description{\n",
    "        text-align: center;\n",
    "        font-size: larger;\n",
    "    }\n",
    "    \n",
    "    .acknowledgement {\n",
    "        text-transform: uppercase;\n",
    "    }\n",
    "    .acknowledgement > .section-heading{\n",
    "        text-transform: uppercase;\n",
    "        font-size: 1.3em;\n",
    "        text-align: center;\n",
    "        border-left: none;\n",
    "    }\n",
    "    .acknowledgement > .section-content{\n",
    "        text-align: center;\n",
    "        font-size:smaller;\n",
    "#         margin-top: 25px;\n",
    "        margin-left: 40px;\n",
    "        margin-right: 40px;\n",
    "    }\n",
    "    .signature{\n",
    "        margin-top:30px;\n",
    "    }\n",
    "    .signature > .date {\n",
    "        width: 50%;\n",
    "        display: inline-block;\n",
    "        float: left;\n",
    "        text-align: left;\n",
    "    }\n",
    "    .signature > .sign {\n",
    "        width: 50%;\n",
    "        display: inline-block;\n",
    "        float: right;\n",
    "        text-align: right;\n",
    "    }\n",
    "    .references{\n",
    "        background-color: #e6faff;\n",
    "        border: 1.2px solid grey;\n",
    "        padding: 0px 7px 1px 7px;\n",
    "    }\n",
    "    .references > h3{\n",
    "        margin-top: 5px !important;\n",
    "    }\n",
    "    .references > ol{\n",
    "        margin-top: 4px;\n",
    "        margin-bottom: 4px;\n",
    "    }\n",
    "\n",
    "    \n",
    "</style>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "kernel": "SoS"
   },
   "source": [
    "<div class=\"main-title\"> B<sub>1</sub> interactive filtering notebook </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "kernel": "SoS"
   },
   "source": [
    "<div class=\"notebook-description\"><i><b>Project Jupyter together with Jupyter Notebooks exist to develop and enable open-source software with open standards for interactive computing across a wide range of programming lanugages.<br/> The purpose of this interactive notebook is to demonstrate some of the features that Jupyter Notebook provides for its users and to show an example of a possible usage of the notebooks for the field of quantitive magnetic resonance imaging (qMRI).</b></i></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "kernel": "Python3"
   },
   "source": [
    "<div class=\"project-scope\">\n",
    "Jupyter Notebook gives its users the possibility to integrate code (written in more than 40 programming languages), the output of the code and a narrative text that gives it the feel of a real notebook. This makes it possible for scientific texts and calculations of multiple scientific areas and experiments to be nicely integrated in one place, easily shared, reproduced and verified[1]. <br/>\n",
    "    To fulfill this purpose there are many features that Jupyter supports to enable data visualization, displaying equations, tables, figures and live cells. <br/>\n",
    "    This paper focuses around a research topic from **quatitative Magnetic Resonance Imaging (qMRI)** called **B<sub>1</sub> mapping** and uses multiple features available for the Jupyter Notebooks, some of which are the following:\n",
    "    <br/><br/>\n",
    "    <dl class=\"features-used-description\">\n",
    "        <dt>Mixing code and narrative, displaying equations and pictures</dt>\n",
    "        <dd>These are some of the basic features of Jupyter Notebooks which can be used for rich explanation of the research topic.<dd>\n",
    "        <dt>Script of Scripts(SoS) polyglot notebooks</dt>\n",
    "        <dd>SoS Polyglot Notebook is a Jupyter Notebook with a SoS kernel. A kernel in a Jupyter Notebook can be defined as an engine that can execute the programming language written in the notebook.<br/>\n",
    "            SoS Notebook serves as a super kernel to all other Jupyter kernels and allows the use of multiple kernels in one Jupyter notebook[2].<br/>\n",
    "            This project uses kernels for MATLAB/Octave and Python.</dd>\n",
    "        <dt>Plotly Dash</dt>\n",
    "        <dd>Dash is a productive Python framework for building web applications and is ideal for building data visualization apps with highly custom user interfaces in pure Python. It's particularly suited for anyone who works with data in Python [3].</dd>\n",
    "        <dt>Plotly express</dt>\n",
    "        <dd>Plotly Express is a terse, consistent, high-level API for rapid data exploration and figure generation [4]. </dd>\n",
    "    </dl>\n",
    "\n",
    "Apart from this, this Notebook will use code provided by the project <a href=\"https://qmrlab.org/\">**qMRLab**</a>. qMRLab is an open-source software for quantitative analysis of MRI records. <br/> \n",
    "The main goal of the qMRLab project is to provide the community with software that makes data fitting, simulation and protocol optimization as easy as possible for a myriad of different quantitative models [5]. The logo of qMRLab is presented in <a href=\"#qMRLab-fig-1\">**Figure 1**</a>.\n",
    "\n",
    "<div class=\"image-group\">\n",
    "    <img src=\"files/AlURnMZ3.jpg\" class=\"image\" id=\"qMRLab-fig-1\">\n",
    "    <div class=\"image-description\"><b>Figure 1. qMRLab logo</b></div>\n",
    "</div>\n",
    "\n",
    "\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "kernel": "Python3"
   },
   "source": [
    "\n",
    "<div class=\"project-structure\">The following sections will contain a brief explanation of concepts about the B<sub>1</sub> radio-frequency field, the double angle mapping method of the field and the filtering of the resulting images.<br/>\n",
    "    First, there will be an introduction to B<sub>1</sub> field, then an explain about what B<sub>1</sub> mapping is followed by the introduction of the double angle mapping method. Afterwards, a brief explanation of different filtering types that will be used will be provided. The section that follows will introduce the qMRLab project and the modules used from it for this notebook, followed by MATLAB/Octave code implemented to calculate the B<sub>1</sub> DAM maps and their filtered versions. After the code, a new section will give an introduction to the structure of a Plotly Dash application, will give small detail about the dashboard implemented for this project and right after that the dashboard code will be displayed. After the code, the visual output of the whole project will be visible to the user and will enable the interactivity to display different filtered maps for the B<sub>1</sub> mapping method. At the end, a brief conclusion will be presented, followed by acknowledgement and a section of references.\n",
    "    <div class=\"note\">The text in the following cells(sections) might be more advanced for a reader that has no prior knowledge of basics MRI concepts or physics.</div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "kernel": "Python3"
   },
   "source": [
    "<div class=\"B1-field\">\n",
    "    <span class=\"section-heading\"> <i> What is a B<sub>1</sub> field? </i></span>\n",
    "    <div class=\"section-content\">\n",
    "        The transmit radio-frequency (RF) field amplitude (“B<sub>1</sub><sup>+</sup>”, but more frequently written simply as “B<sub>1</sub>” in the context of quantitative MRI imaging) is a quantity that directly impacts the actual flip angle that magnetization in a voxel rotates due to on-resonance RF pulses. <br/>\n",
    "        Spatial inhomogeneity of B<sub>1</sub> leads to spins across the sample experiencing different flip angles, which can lead to differences in image signal intensity throughout a homogeneous sample. Although B<sub>1</sub> can refer to the actual RF magnetic field amplitude (on the order of microTeslas), in the context of quantitative MRI it’s more frequently represented as a normalized correction factor of the nominal flip angle set by the user at the scanner <b> (&alpha;<sub>actual</sub> = B<sub>1</sub>·&alpha;<sub>nominal</sub>)</b> [6]. \n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "kernel": "Python3"
   },
   "source": [
    "<div class=\"B1-field\">\n",
    "    <span class=\"section-heading\"> <i> What is B<sub>1</sub> mapping? </i></span>\n",
    "    <div class=\"section-content\">\n",
    "         B<sub>1</sub> maps are measured as a calibration measurement for quantitative MRI techniques, however, some interesting parameters can be derived directly from B<sub>1</sub> maps, such as the electrical conductivity and permittivity of tissues and the local specific absorption rate (SAR). Even if B<sub>1</sub> is calibrated to a high degree of homogeneity in an empty scanner (e.g. using pickup coils and RF transmit coil design optimization), electrodynamic interactions with tissues (loading/boundaries) will distort the B<sub>1</sub> amplitude profile [6]. <br/><br/>\n",
    "        The general idea behind B<sub>1</sub> mapping is to determine a pulse sequence that varies with respect to the B<sub>1</sub> field and only the B<sub>1</sub> field. MR image signal intensity depends on many variables, a single acquisition is not enough to uniquely quantify the B<sub>1</sub> field. Therefore, at least two images are usually acquired and a mathematical operation is used to cancel out all other undesired characteristics in the image [7]. <br/><br/>\n",
    "        There are multiple mapping techniques used in the quantitative MRI field, some of the most famous being: the  Double-angle method, SDAM introduced by Insko in 1993, the AFI (Actual flip-angle imaging) method introduced in 2007 by Yarnykh and the Bloch-Siegert(BS) method. This notebook will focus on the implementation of the Double Angle Mapping method and different filtering types of the resulting maps. \n",
    "        <div class=\"note\">Although the dashboard is implemented as if two more mapping methods mentioned here are included, they are not implemented and are left as a possible future work both for this notebook and the qMRLab project.</div>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "kernel": "Python3"
   },
   "source": [
    "<div class=\"B1-DAM\">\n",
    "    <span class=\"section-heading\"> <i> Explaining the double angle method for B<sub>1</sub> mapping</i></span>\n",
    "    <div class=\"section-content\">\n",
    "        One of the simplest ways to map B1 in vivo is to acquire two otherwise identical images using different excitation flip angles. The actual voxel-wise flip angles can be then estimated with simple trigonometry, by calculating the ratio in expected signal amplitudes. This is called the Double Angle Method (DA method). Using the Double Angle (DA) method, one image is acquired with double the excitation flip angle than the other, which results in a very simple equation for a spin-echo acquisition pulse sequence demonstrated in the equation ($\\ref{eq:1}$).\n",
    "        <div class=\"equation\">\n",
    "        \\begin{equation}\n",
    "            B_1^{DA}=\\dfrac{arccos(\\dfrac{I_{2\\alpha}}{2I_\\alpha})}{\\alpha}\n",
    "        \\label{eq:1}\n",
    "        \\tag {1}\n",
    "        \\end{equation}\n",
    "        </div>\n",
    "        DA B<sub>1</sub> mapping is easy to implement using pulse sequences available on most scanners. However, to minimize the influence of T1 relaxation in the region of interest, it requires a long TR (at least longer than a few T1’s, but ideally TR ≥ 5T1), usually limiting the pulse sequence to a single-slice technique [6].\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "kernel": "Python3"
   },
   "source": [
    "<div class=\"B1-DAM\">\n",
    "    <span class=\"section-heading\"> <i> Introducing filters </i></span>\n",
    "    <div class=\"section-content\">\n",
    "        Most studies that use B<sub>1</sub> maps do not use the raw maps; instead, they are typically filtered during a pre-processing step to reduce effects like noise and minor artifact, as the B<sub>1</sub> distribution in tissue is expected to be a smoothly varying function. There is a wide range of filtering techniques and setting values reported in the literature [8]. <br/>\n",
    "        For the purpose of this notebook, four types of filters will be used on the raw B<sub>1</sub> map to acquire filtered B<sub>1</sub> maps suitable for display in the dashboard. \n",
    "        <dl class=\"filtering-types-description\">\n",
    "        <dt>Gaussian filter</dt>\n",
    "        <dd>A Gaussian filter in image processing is the smoothing of images using the Gaussian function. It is a widespread effect in graphics software and is used to reduce image detail or reduce image noise. </dd>\n",
    "        <dt>Spline filter</dt>\n",
    "        <dd>The Spline filter is a filter that is implemented to overcome some of the shortcomings of the Gaussian filter such as edge distortion and poor performance in the presence of large shapes.</dd>\n",
    "        <dt>Polynomial filter</dt>\n",
    "        <dd>The polynomial filter tries to approximate surfaces with a polynomial function. The polynomial filter gives better results when a filter mask is also applied, because this way the impact of the image noise will be reduced.</dd>\n",
    "        <dt>Median filter</dt>\n",
    "        <dd>The Median filter is based on the idea of iterating across all the records from the signal and replacing each record with the value of the median from its neighboring records. </dd>\n",
    "    </dl>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "kernel": "Python3"
   },
   "source": [
    "<div class=\"B1-DAM\">\n",
    "    <span class=\"section-heading\"> <i> About qMRLab's B<sub>1</sub> DAM model and the filtering module </i></span>\n",
    "    <div class=\"section-content\">\n",
    "        Open source code from the project: <b>qMRLab</b> will be used to implement the B<sub>1</sub> mapping and the filters of the created maps. The qMRLab project is an open source software for quantitative analysis of magnetic resonance imaging [9].<br />\n",
    "        One of the available methods implemented in qMRLab is the B<sub>1</sub> DAM (Double Angle Mapping) method. The code for this method is written for the programming languages MATLAB and Octave, so accordingly the following code cells use Octave. We use the method by creating an object of class <code>b1_dam</code>, which we will further refer to as <var>model</var>. Then we create a structure that we call <var>data</var> and in it we enter the input arguments for the model, i.e. <var>SFalpha</var> and <var>SF2alpha</var> which are the recordings obtained with an angle of excitation &alpha; and 2&alpha; respectively, and optionally a <var>Mask</var> parameter which is the binary mask that serves to exclude all pixels which do not belong to the scanned tissue. <br/><br/>\n",
    "   \n",
    "Then, the filtering parameters can be set on the <var>model</var>. The <code>b1_dam</code> code offers the following parameters:\n",
    "        <ul>\n",
    "            <li><b>SmoothingFilter_Type</b> - gaussian, median, spline and polynomial</li>\n",
    "            <li><b>SmoothingFilter_Dimension</b> - available values are 2D and 3D </li>\n",
    "            <li><b>SmoothingFilter_sizex, SmoothingFilter_sizey, SmoothingFilter_sizez</b> - filter size in pixels. Used only with gaussian and median filters</li>\n",
    "            <li><b>SmoothingFilter_order</b> - order of the polynomial fitting and the 'amount of smoothness' for spline fitting</li>\n",
    "        </ul>\n",
    "        All of these parameters are inherited from the <code>FilterClass.m</code> which is a common class available in qMRLab. <br/><br/>\n",
    "        The following cells contain the code that takes data (MRI images) from an online repository hosted on <a href=\"https://osf.io/\">osf.io</a>, then it generates the B<sub>1</sub> DAM maps and their filtered versions for filter size/order of 2, 4 and 6 for all the available filtering types and saves them on the local file system.\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "kernel": "Octave"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "warning: function C:\\Users\\Martina VivoBook Pro\\B1dam-project\\mybinder\\b1_map\\qMRLab\\src\\Common\\pulse\\sinc.m shadows a core library function\n",
      "warning: called from\n",
      "    startup at line 2 column 1\n",
      "warning: function C:\\Users\\Martina VivoBook Pro\\B1dam-project\\mybinder\\b1_map\\qMRLab\\External\\NODDI_toolbox_v1.0\\ParforProgMonv2\\example.m shadows a core library function\n",
      "warning: called from\n",
      "    startup at line 2 column 1\n",
      "loading struct\n",
      "loading io\n",
      "loading statistics\n",
      "loading optim\n",
      "loading image\n"
     ]
    }
   ],
   "source": [
    "%% MATLAB/OCTAVE CODE\n",
    "\n",
    "% Adds qMRLab to the path of the environment\n",
    "cd qMRLab\n",
    "startup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "kernel": "Octave"
   },
   "outputs": [],
   "source": [
    "%% MATLAB/OCTAVE CODE\n",
    "\n",
    "% Download brain MRI data\n",
    "cmd = ['curl -L -o b1_map.zip https://osf.io/mw3sq/download/'];\n",
    "try\n",
    "    [STATUS,MESSAGE] = unix(cmd);\n",
    "    unzip('b1_map.zip');\n",
    "catch\n",
    "    copyfile(['..' filesep 'b1_map.zip'], 'b1_map.zip');\n",
    "end\n",
    "unzip('b1_map.zip')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "kernel": "Octave"
   },
   "outputs": [],
   "source": [
    "%% MATLAB/OCTAVE CODE\n",
    "\n",
    "% Create repository for filtered images if such repository doesn't previously exist\n",
    "fn = fullfile(['..' filesep 'ResultsBank']);\n",
    "if ~exist(fn, 'dir')\n",
    "    mkdir(fn);\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "kernel": "Octave",
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ans = 1\n",
      "warning: Matlab-style short-circuit operation performed for operator &\n",
      "warning: called from\n",
      "    load_nii_hdr>read_header at line 114 column 5\n",
      "    load_nii_hdr at line 52 column 14\n",
      "    load_nii at line 184 column 53\n",
      "    load_nii_data at line 3 column 5\n",
      "ans = 1\n",
      "warning: Matlab-style short-circuit operation performed for operator &\n",
      "warning: called from\n",
      "    load_nii_hdr>read_header at line 114 column 5\n",
      "    load_nii_hdr at line 52 column 14\n",
      "    load_nii at line 184 column 53\n",
      "    load_nii_data at line 3 column 5\n",
      "ans = 1\n",
      "warning: Matlab-style short-circuit operation performed for operator &\n",
      "warning: called from\n",
      "    load_nii_hdr>read_header at line 114 column 5\n",
      "    load_nii_hdr at line 52 column 14\n",
      "    load_nii at line 184 column 53\n",
      "    load_nii_data at line 3 column 5\n",
      "method_type = DAM\n",
      "method_type = AFI\n",
      "method_type = BS\n",
      "warning: load: 'C:\\Users\\Martina VivoBook Pro\\B1dam-project\\mybinder\\b1_map\\qMRLab\\docs\\iqmr_gethelp.mat' found by searching load path\n",
      "=============== qMRLab::Fit ======================\n",
      "Operation has been started: b1_dam\n",
      "Elapsed time is 0.149288 seconds.\n",
      "Operation has been completed: b1_dam\n",
      "==================================================\n",
      "warning: load: 'C:\\Users\\Martina VivoBook Pro\\B1dam-project\\mybinder\\b1_map\\qMRLab\\docs\\iqmr_gethelp.mat' found by searching load path\n",
      "=============== qMRLab::Fit ======================\n",
      "Operation has been started: b1_dam\n",
      "Elapsed time is 0.111305 seconds.\n",
      "Operation has been completed: b1_dam\n",
      "==================================================\n",
      "warning: load: 'C:\\Users\\Martina VivoBook Pro\\B1dam-project\\mybinder\\b1_map\\qMRLab\\docs\\iqmr_gethelp.mat' found by searching load path\n",
      "=============== qMRLab::Fit ======================\n",
      "Operation has been started: b1_dam\n",
      "Elapsed time is 0.0976169 seconds.\n",
      "Operation has been completed: b1_dam\n",
      "==================================================\n",
      "warning: load: 'C:\\Users\\Martina VivoBook Pro\\B1dam-project\\mybinder\\b1_map\\qMRLab\\docs\\iqmr_gethelp.mat' found by searching load path\n",
      "=============== qMRLab::Fit ======================\n",
      "Operation has been started: b1_dam\n",
      "Elapsed time is 0.100536 seconds.\n",
      "Operation has been completed: b1_dam\n",
      "==================================================\n",
      "warning: load: 'C:\\Users\\Martina VivoBook Pro\\B1dam-project\\mybinder\\b1_map\\qMRLab\\docs\\iqmr_gethelp.mat' found by searching load path\n",
      "=============== qMRLab::Fit ======================\n",
      "Operation has been started: b1_dam\n",
      "Elapsed time is 0.103591 seconds.\n",
      "Operation has been completed: b1_dam\n",
      "==================================================\n",
      "warning: load: 'C:\\Users\\Martina VivoBook Pro\\B1dam-project\\mybinder\\b1_map\\qMRLab\\docs\\iqmr_gethelp.mat' found by searching load path\n",
      "=============== qMRLab::Fit ======================\n",
      "Operation has been started: b1_dam\n",
      "Elapsed time is 0.112244 seconds.\n",
      "Operation has been completed: b1_dam\n",
      "==================================================\n",
      "warning: load: 'C:\\Users\\Martina VivoBook Pro\\B1dam-project\\mybinder\\b1_map\\qMRLab\\docs\\iqmr_gethelp.mat' found by searching load path\n",
      "=============== qMRLab::Fit ======================\n",
      "Operation has been started: b1_dam\n",
      "Elapsed time is 0.0103569 seconds.\n",
      "Operation has been completed: b1_dam\n",
      "==================================================\n",
      "warning: load: 'C:\\Users\\Martina VivoBook Pro\\B1dam-project\\mybinder\\b1_map\\qMRLab\\docs\\iqmr_gethelp.mat' found by searching load path\n",
      "=============== qMRLab::Fit ======================\n",
      "Operation has been started: b1_dam\n",
      "Elapsed time is 0.00937319 seconds.\n",
      "Operation has been completed: b1_dam\n",
      "==================================================\n",
      "warning: load: 'C:\\Users\\Martina VivoBook Pro\\B1dam-project\\mybinder\\b1_map\\qMRLab\\docs\\iqmr_gethelp.mat' found by searching load path\n",
      "=============== qMRLab::Fit ======================\n",
      "Operation has been started: b1_dam\n",
      "Elapsed time is 0.016917 seconds.\n",
      "Operation has been completed: b1_dam\n",
      "==================================================\n",
      "warning: load: 'C:\\Users\\Martina VivoBook Pro\\B1dam-project\\mybinder\\b1_map\\qMRLab\\docs\\iqmr_gethelp.mat' found by searching load path\n",
      "=============== qMRLab::Fit ======================\n",
      "Operation has been started: b1_dam\n",
      "Elapsed time is 0.00312901 seconds.\n",
      "Operation has been completed: b1_dam\n",
      "==================================================\n",
      "warning: load: 'C:\\Users\\Martina VivoBook Pro\\B1dam-project\\mybinder\\b1_map\\qMRLab\\docs\\iqmr_gethelp.mat' found by searching load path\n",
      "=============== qMRLab::Fit ======================\n",
      "Operation has been started: b1_dam\n",
      "Elapsed time is 0.00776505 seconds.\n",
      "Operation has been completed: b1_dam\n",
      "==================================================\n",
      "warning: load: 'C:\\Users\\Martina VivoBook Pro\\B1dam-project\\mybinder\\b1_map\\qMRLab\\docs\\iqmr_gethelp.mat' found by searching load path\n",
      "=============== qMRLab::Fit ======================\n",
      "Operation has been started: b1_dam\n",
      "Elapsed time is 0.015928 seconds.\n",
      "Operation has been completed: b1_dam\n",
      "==================================================\n",
      "warning: load: 'C:\\Users\\Martina VivoBook Pro\\B1dam-project\\mybinder\\b1_map\\qMRLab\\docs\\iqmr_gethelp.mat' found by searching load path\n",
      "=============== qMRLab::Fit ======================\n",
      "Operation has been started: b1_dam\n",
      "warning: load: 'C:\\Users\\Martina VivoBook Pro\\B1dam-project\\mybinder\\b1_map\\qMRLab\\docs\\iqmr_gethelp.mat' found by searching load path\n",
      "=============== qMRLab::Fit ======================\n",
      "Operation has been started: b1_dam\n",
      "warning: load: 'C:\\Users\\Martina VivoBook Pro\\B1dam-project\\mybinder\\b1_map\\qMRLab\\docs\\iqmr_gethelp.mat' found by searching load path\n",
      "=============== qMRLab::Fit ======================\n",
      "Operation has been started: b1_dam\n",
      "warning: load: 'C:\\Users\\Martina VivoBook Pro\\B1dam-project\\mybinder\\b1_map\\qMRLab\\docs\\iqmr_gethelp.mat' found by searching load path\n",
      "=============== qMRLab::Fit ======================\n",
      "Operation has been started: b1_dam\n",
      "warning: load: 'C:\\Users\\Martina VivoBook Pro\\B1dam-project\\mybinder\\b1_map\\qMRLab\\docs\\iqmr_gethelp.mat' found by searching load path\n",
      "=============== qMRLab::Fit ======================\n",
      "Operation has been started: b1_dam\n",
      "warning: load: 'C:\\Users\\Martina VivoBook Pro\\B1dam-project\\mybinder\\b1_map\\qMRLab\\docs\\iqmr_gethelp.mat' found by searching load path\n",
      "=============== qMRLab::Fit ======================\n",
      "Operation has been started: b1_dam\n",
      "warning: load: 'C:\\Users\\Martina VivoBook Pro\\B1dam-project\\mybinder\\b1_map\\qMRLab\\docs\\iqmr_gethelp.mat' found by searching load path\n",
      "=============== qMRLab::Fit ======================\n",
      "Operation has been started: b1_dam\n",
      "Elapsed time is 0.00947881 seconds.\n",
      "Operation has been completed: b1_dam\n",
      "==================================================\n",
      "warning: load: 'C:\\Users\\Martina VivoBook Pro\\B1dam-project\\mybinder\\b1_map\\qMRLab\\docs\\iqmr_gethelp.mat' found by searching load path\n",
      "=============== qMRLab::Fit ======================\n",
      "Operation has been started: b1_dam\n",
      "Elapsed time is 0.00500488 seconds.\n",
      "Operation has been completed: b1_dam\n",
      "==================================================\n",
      "warning: load: 'C:\\Users\\Martina VivoBook Pro\\B1dam-project\\mybinder\\b1_map\\qMRLab\\docs\\iqmr_gethelp.mat' found by searching load path\n",
      "=============== qMRLab::Fit ======================\n",
      "Operation has been started: b1_dam\n",
      "Elapsed time is 0.00726414 seconds.\n",
      "Operation has been completed: b1_dam\n",
      "==================================================\n",
      "warning: load: 'C:\\Users\\Martina VivoBook Pro\\B1dam-project\\mybinder\\b1_map\\qMRLab\\docs\\iqmr_gethelp.mat' found by searching load path\n",
      "=============== qMRLab::Fit ======================\n",
      "Operation has been started: b1_dam\n",
      "warning: load: 'C:\\Users\\Martina VivoBook Pro\\B1dam-project\\mybinder\\b1_map\\qMRLab\\docs\\iqmr_gethelp.mat' found by searching load path\n",
      "=============== qMRLab::Fit ======================\n",
      "Operation has been started: b1_dam\n",
      "warning: load: 'C:\\Users\\Martina VivoBook Pro\\B1dam-project\\mybinder\\b1_map\\qMRLab\\docs\\iqmr_gethelp.mat' found by searching load path\n",
      "=============== qMRLab::Fit ======================\n",
      "Operation has been started: b1_dam\n"
     ]
    }
   ],
   "source": [
    "%% MATLAB/OCTAVE CODE\n",
    "\n",
    "clear all\n",
    "\n",
    "% Create a Model variable that represents an object from the b1_dam class.\n",
    "Model = b1_dam;\n",
    "\n",
    "% Format data structure so that they may be fit by the model\n",
    "data = struct();\n",
    "data.SFalpha = double(load_nii_data('SFalpha.nii.gz')); % Load data for image with excitation angle value of alpha\n",
    "data.SF2alpha  = double(load_nii_data('SF2alpha.nii.gz')); % Load data for image with excitation angle value of 2*alpha\n",
    "data.Mask=double(load_nii_data(['..' filesep 'SF60-MASK.nii.gz'])); % Set Mask for the model\n",
    "\n",
    "% Setting types of possible mapping methods, filtering_types, dimensions and order/size of filters.\n",
    "% The only implemented method for now is the DAM (Double Angle Mapping) method for B1 mapping.\n",
    "method_types = {'DAM', 'AFI', 'BS'};\n",
    "\n",
    "filtering_types = {'spline', 'polynomial', 'gaussian', 'median'};\n",
    "filtering_dimensions = {'2D', '3D'};\n",
    "filtering_orders = {2, 4, 6};\n",
    "size_methods = {'gaussian', 'median'}; % List of types that use size paramether, and not order\n",
    "\n",
    "% Create separate directory inside ResultsBank folder for each mapping method\n",
    "for mm= 1:length(method_types)\n",
    "    method_type= method_types{mm}\n",
    "    fn = fullfile(['..' filesep 'ResultsBank'], method_type);\n",
    "    if ~exist(fn, 'dir')\n",
    "        mkdir(fn);\n",
    "    end\n",
    "end\n",
    "\n",
    "% Using model to generate map and filtered map for different combinations of filtering parameters\n",
    "% Saving the result files in separate folders of destination_folder_path\n",
    "destination_folder_path = ['..' filesep 'ResultsBank' filesep 'DAM'];\n",
    "for i= 1:length(filtering_types)\n",
    "    filter_type= filtering_types{i};\n",
    "    for j = 1: length(filtering_dimensions)\n",
    "        dimension = filtering_dimensions{j};\n",
    "        for k = 1: length(filtering_orders)\n",
    "            order = filtering_orders{k};\n",
    "            \n",
    "            % Adjust model for filtering\n",
    "            Model.options.Smoothingfilter_Type = filter_type;\n",
    "            Model.options.Smoothingfilter_Dimension = dimension;\n",
    "            \n",
    "            % If filter type is gaussian or median we use the filtering size, otherwise we use filtering order\n",
    "            if sum(strcmp(size_methods, filter_type))>0\n",
    "                Model.options.Smoothingfilter_sizex = order;\n",
    "                Model.options.Smoothingfilter_sizey = order;\n",
    "                Model.options.Smoothingfilter_sizez = order;\n",
    "            else \n",
    "                Model.options.Smoothingfilter_order = order;\n",
    "            end\n",
    "            \n",
    "            % Try to fit data to the model and save output in FitResults variable\n",
    "            try \n",
    "                FitResults = FitData(data,Model);\n",
    "            catch\n",
    "                continue;\n",
    "            end\n",
    "            \n",
    "            # Save FitResults in correct location on disk\n",
    "            B1_raw = FitResults.B1map_raw;\n",
    "            B1_filtered = FitResults.B1map_filtered;\n",
    "            typepath = fullfile(destination_folder_path, filter_type);\n",
    "            mkdir(typepath, [dimension filesep num2str(order)]);\n",
    "            try\n",
    "                fulldestination = fullfile(typepath, [dimension filesep num2str(order) filesep 'B1_raw.mat']);\n",
    "                save(fulldestination, 'B1_raw', '-v7');\n",
    "                fulldestination = fullfile(typepath, [dimension filesep num2str(order) filesep 'B1_filtered.mat']);\n",
    "                save(fulldestination, 'B1_filtered', '-v7');\n",
    "            catch Message\n",
    "                Message;\n",
    "                continue;\n",
    "            end\n",
    "            \n",
    "        end\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "kernel": "Octave"
   },
   "source": [
    "<div class=\"Dashboard\">\n",
    "    <span class=\"section-heading\"> <i> Interactive dashboard </i></span>\n",
    "    <div class=\"section-content\">\n",
    "        The final product for this notebook is an interactive dashboard created using a **Plotly Dash** application and graph figures from **Plotly Express**. <br/>\n",
    "        The dashboard is designed to allow the user to choose a method for B1 mapping, type, dimension and the order of the filter in order to see the resulting B<sub>1</sub> map of these input parameters. \n",
    "        The output displays the original images that were used to create the B<sub>1</sub> map, followed by the raw B<sub>1</sub> map and finally the filtered B<sub>1</sub> map according to the input parameters.\n",
    "        <br/><br/>\n",
    "        To be able to perform this interactive visualization, an application using a distribution of Plotly Dash for Jupyter Notebook is created. Dash is a Python web application library built on Flask, Plotly.js and React.js. The library is suitable for creating applications that provide an adjustable layout of data visualization, making it perfect for use by anyone using Python to work with data. With the help of a few simple templates, Dash manages to abstract all the technologies and protocols that exist or occur in the background and are needed to build an interactive web application [3].<br/>\n",
    "        Dash apps are composed of two parts. The first part is the <code>\"layout\"</code> of the app and it describes what the application looks like. The second part describes the interactivity of the application. \n",
    "        <br/>\n",
    "        The <code>layout</code> is composed of a tree of \"components\" like <code>html.Div</code> and <code>dcc.Graph</code>. The <code>dash_html_components</code> library has a component for every HTML tag. The <code>dash_core_components</code> describe higher-level components that are interactive and are generated with JavaScript, HTML, and CSS through the React.js library. In this project the tree of components is composed of html's <code>h1</code>, <code>h3</code>, <code>div</code>, <code>p</code> and dcc's <code>Graph</code> components.\n",
    "        <br/>\n",
    "        The interactive part of the application can be seen as composed of \"inputs\" that cause specific \"outputs\". The \"inputs\" and \"outputs\" of the application interface in Dash are described declaratively through the <code>app.callback</code> decorator. In Dash, the inputs and outputs of the application are simply the properties of a particular component [3]. In this notebook's dashboard, the inputs are the dropdown components(each with different id) and the outputs are the graph components <code>map_raw</code> and <code>map_filtered</code>. Whenever an input property changes in the dropdown components, the function that the callback decorator wrap will get called automatically and the output graphs will be updated.\n",
    "        <br/><br/>\n",
    "        The graphing figures displayed in the dashboard are created with Plotly Express. Plotly Express is an interface to the famous Python data display library Plotly, which is easy to use and works with neat data to produce easy-to-style figures. Each function of Plotly Express returns an object of the class <code>graph_objects.Figure</code> whose data and appearance are pre-populated according to the arguments provided by the user. \n",
    "        <br/><br/>\n",
    "        The code cell that follows contains the implementation of the layout and the callback function for the Dash application, and the usage of graphs generated and styled with Plotly express.\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "kernel": "SoS"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "E:\\anaconda\\lib\\site-packages\\h5py\\__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n",
      "pixdim[0] (qfac) should be 1 (default) or -1; setting qfac to 1\n",
      "pixdim[0] (qfac) should be 1 (default) or -1; setting qfac to 1\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "  <iframe src=\"/app/endpoints/d4a5224b706141b5973c6fd27b4f24f7/\" width=800 height=600 frameborder=\"0\"></iframe>\n",
       "  <hr/><a href=\"/app/endpoints/d4a5224b706141b5973c6fd27b4f24f7/\" target=\"_new\">Open in new window</a> for /app/endpoints/d4a5224b706141b5973c6fd27b4f24f7/\n",
       "</div>"
      ],
      "text/plain": [
       "<jupyter_plotly_dash.dash_wrapper.JupyterDash at 0x17debd89128>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# PYTHON CODE\n",
    "# Module imports\n",
    "\n",
    "import nibabel as nib\n",
    "\n",
    "import dash\n",
    "import dash_html_components as html\n",
    "import dash_core_components as dcc\n",
    "from dash.dependencies import Input, Output\n",
    "from jupyter_plotly_dash import JupyterDash\n",
    "\n",
    "import plotly_express as px\n",
    "import plotly.graph_objs as go\n",
    "\n",
    "import matplotlib.pyplot as mpl\n",
    "from matplotlib import cm\n",
    "import numpy as np\n",
    "\n",
    "from scipy.io import loadmat\n",
    "import os\n",
    "\n",
    "\n",
    "filesep = os.path.sep;\n",
    "\n",
    "#  Load image with excitation angle value of alpha for display on the final figure \n",
    "SFalpha = nib.load('qMRLab' + filesep + 'SFalpha.nii.gz');\n",
    "data_SFalpha = SFalpha.get_fdata();\n",
    "fig_SFalpha = px.imshow(data_SFalpha, color_continuous_scale='jet', zmin=0.9, zmax=1.05);\n",
    "fig_SFalpha.data[0].showscale=False;\n",
    "fig_SFalpha.data[0].coloraxis=None;\n",
    "fig_SFalpha.update_layout(height=300, margin=dict(l=0, r=5, b=10, t=30), title_text= \"SFalpha\");\n",
    "fig_SFalpha.update_xaxes(showticklabels=False).update_yaxes(showticklabels=False);\n",
    "\n",
    "#  Load image with excitation angle value of 2*alpha for display on the final figure \n",
    "SF2alpha = nib.load('qMRLab' + filesep + 'SF2alpha.nii.gz');\n",
    "data_SF2alpha = SF2alpha.get_fdata();\n",
    "fig_SF2alpha = px.imshow(data_SF2alpha, color_continuous_scale='jet', zmin=0.9, zmax=1.05);\n",
    "fig_SF2alpha.data[0].showscale=False;\n",
    "fig_SF2alpha.data[0].coloraxis=None;\n",
    "fig_SF2alpha.update_layout(height=300, margin=dict(l=0, r=5, b=10, t=30), title_text=\"SF2alpha\");\n",
    "fig_SF2alpha.update_xaxes(showticklabels=False).update_yaxes(showticklabels=False);\n",
    "\n",
    "# Defining the data for all the dropdown lists in a dictionary\n",
    "dropdown_data = {'B1 mapping method' : ['DAM', 'AFI', 'BS'],\n",
    "        'Filter type':['Spline', 'Polynomial', 'Gaussian', 'Median'],\n",
    "        'Dimension':['2D', '3D'], \n",
    "        'Filtering order': [2,4,6]}\n",
    "\n",
    "# Create a JupyterDash application\n",
    "app = JupyterDash(\"b1_dash_app\")\n",
    "\n",
    "# Defining the Dash application layout by adding html and dcc components\n",
    "# The first component is a Div tag that serves as a wrapper.\n",
    "app.layout = html.Div(\n",
    "    [      \n",
    "        # Defining the dashboard header\n",
    "        html.H1([html.I(\"B\"),\n",
    "                 html.I(html.Sub(\"1\")), \n",
    "                 html.I(\" mapping - interactive dashboard\")],\n",
    "                 style={\"text-align\":\"center\",\"font-family\":\"georgia,garamond,serif\", \"font-weight\" : \"700\"}),\n",
    "        \n",
    "        # Describing the purpose of the dashboard in another header tag.\n",
    "        html.H3(\"This is an interactive dashboard that allows the user to choose the displayed output \" +\n",
    "                \"based on different filtering parameters. \", \n",
    "                style={\"text-align\":\"center\",\"font-weight\":\"200\",\"font-family\":\"georgia,garamond,serif\", \n",
    "                       \"color\":\"darkblue\", \"padding-left\":\"15%\",  \"padding-right\":\"15%\"}),\n",
    "        \n",
    "        # Creating a Div tag that will contain all the dropdown lists for user input\n",
    "        html.Div(\n",
    "            [\n",
    "                # Iterating through dictionary variable: dropdown_data and creating dropdowns with corresponding labels and values\n",
    "                html.P([d + \":\", dcc.Dropdown(id=d, options=[dict(label=m, value=m) for m in dropdown_data[d]], value=dropdown_data[d][0])], \n",
    "                      style={\"width\":\"24.3%\", \"display\":\"inline-block\", \"margin-right\":\"5px\"})\n",
    "                for d in dropdown_data.keys()\n",
    "            ],\n",
    "            style={\"width\": \"100%\"},\n",
    "        ),\n",
    "        \n",
    "        # Listing the graphs that should be displayed.\n",
    "        # The graphs SFalpha and SF2alpha will be loaded statically and will display the input images for the method.\n",
    "        # The graphs map_raw and map_filtered will be loaded depеnding on the user input.\n",
    "        # The graph map_raw will display the raw map after applying the mapping method on the input dataset.\n",
    "        # The graph map_filtered will display the filtered map for the mapping method,\n",
    "        # based on the filtering parameters chosen in the available dropdown lists.\n",
    "        dcc.Graph(id=\"SFalpha\", figure = fig_SFalpha, style={\"width\": \"25%\", \"display\": \"inline-block\"}),\n",
    "        dcc.Graph(id=\"SF2alpha\", figure = fig_SF2alpha, style={\"width\": \"25%\", \"display\": \"inline-block\"}),\n",
    "        dcc.Graph(id=\"map_raw\", style={\"width\": \"25%\", \"display\": \"inline-block\"}),\n",
    "        dcc.Graph(id=\"map_filtered\", style={\"width\": \"25%\", \"display\": \"inline-block\"}),\n",
    "    ]\n",
    ")\n",
    "\n",
    "# Adding interactivity to the Dash application by defining a callback function.\n",
    "# The function takes as input the values from all the dropdown lists and returns two figures: the raw map and the filtered map.\n",
    "@app.callback([Output(\"map_raw\", \"figure\"), Output(\"map_filtered\", \"figure\")], [Input(d, \"value\") for d in dropdown_data.keys()])\n",
    "def make_figure(method_type, filtering_type, dimension, order):\n",
    "\n",
    "    # Defining path to raw and filtered files\n",
    "    path = '.' + filesep + 'ResultsBank' + filesep + method_type + filesep + filtering_type.lower() + filesep + dimension + filesep + str(order) + filesep;\n",
    "    file_path_raw = path  + 'B1_raw.mat';\n",
    "    file_path_filtered = path + 'B1_filtered.mat';\n",
    "    \n",
    "    # Creating a graph figure for the raw map and setting its options\n",
    "#     title_for_figure = \"Type: %s, dimension: %s and order %s\" % (filtering_type, dimension, order)\n",
    "    title_for_figure = \"B<sub>1</sub> \" + method_type + \" raw map\";\n",
    "    B1_raw = loadmat(file_path_raw);\n",
    "    b1_raw_data = B1_raw['B1_raw'];\n",
    "    fig_raw = px.imshow(b1_raw_data, color_continuous_scale='jet', zmin=0.9, zmax=1.05);\n",
    "    fig_raw.update_layout(height=300, margin=dict(l=0, r=5, b=10, t=30), title_text= title_for_figure, coloraxis_showscale=False)\n",
    "    fig_raw.update_xaxes(showticklabels=False).update_yaxes(showticklabels=False)\n",
    "\n",
    "    # Creating a graph figure for the filtered map and setting its options\n",
    "#     title_for_figure = \"Type: %s, dimension: %s and order %s\" % (filtering_type, dimension, order)\n",
    "    title_for_figure = \"B<sub>1</sub> \" + method_type + \" filtered map\"\n",
    "    B1_filtered = loadmat(file_path_filtered);\n",
    "    b1_filtered_data = B1_filtered['B1_filtered'];\n",
    "    fig_filtered = px.imshow(b1_filtered_data, color_continuous_scale='jet', zmin=0.9, zmax=1.05);\n",
    "    fig_filtered.update_layout(height=300, margin=dict(l=0, r=5, b=10, t=30), title_text= title_for_figure, coloraxis_showscale=False)\n",
    "    fig_filtered.update_xaxes(showticklabels=False).update_yaxes(showticklabels=False)\n",
    "    \n",
    "    return fig_raw, fig_filtered \n",
    "\n",
    "app"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "kernel": "Python3"
   },
   "source": [
    "<div class=\"Conclusion\">\n",
    "    <span class=\"section-heading\"> <i> Conclusion </i></span>\n",
    "    <div class=\"section-content\">\n",
    "        This notebook used many features of the Jupyter eco-system to demonstrate the vast scope of possibilities that this open-source community enables to researchers, scientists, students and everyone else in need of integrating live code, data visualization, equations and narration that can be easily shared and reproduced.<br/><br/>\n",
    "        The topic of this notebook also briefly talks about an area that is of interest to quantitative MRI and is considered to contain valuable information about the precision and details of MRI images and imaging techniques. The usage of the Jupyter Notebook together with the Script of Scripts makes it convenient to execute code written for MATLAB/Octave by a third party source and afterwards use these results together with modern visualization frameworks for Python to create an interactive dashboard where the user can see the differences of applying different input parameters to a certain output. In the case of the project, code cells were used to generate maps by using B<sub>1</sub> double angle method and filter those maps and afterwards display the maps in an interactive dashboard where the user is able to clearly see the difference in the images when applying different filter types and filters of different orders. In addition to this, the cells written in Markdown serve as great guides to anyone who is interested in what the notebook does and what theory it relies upon, together with images and formulas that additionally explain the concepts of the project.<br/><br/>\n",
    "        To conclude, this notebook proves that the Jupyter Notebook allows the users to build multi-dimensional projects with support for many technologies applicable across different scientific domains. Having this in mind, together with the fast growing community and the large number of scientists, universities and researchers using Jupyter technologies, Project Jupyter appears to have a bright future ahead in the world of science and research and might bring radical changes in the way breakthroughs in scientific areas are discovered and validated.\n",
    "    </div>\n",
    "</div>\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "kernel": "SoS"
   },
   "source": [
    "<div class=\"acknowledgement\">\n",
    "    <div class=\"section-heading\"> Acknowledgement </div>\n",
    "    <div class=\"section-content\">\n",
    "        I would like to express special thanks of gratitude to <b>Nikola Stikov, PhD</b>, <b>Mathieu Boudreau, PhD</b>, <b>Agâh  Karakuzu, MSc</b> and <b>Tomi Boshkovski, MSc</b> for their guidance and support in completing this project. <br/><br/>\n",
    "        I would also like to thank the remaining qMRLab team for their exquisite commitment to working on the qMRLab project and striving for the goal of gathering quantitative MRI under one umbrella.\n",
    "    </div>\n",
    "    <div class=\"signature\">\n",
    "        <div class=\"date\"><b>DATE:</b><br/>May, 2020</div>\n",
    "        <div class=\"sign\"><b><br/><i>Martina Boshkovska</i></b></div>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "kernel": "SoS"
   },
   "source": [
    "<div class=\"references\">\n",
    "    <h3>References</h3>\n",
    "    <ol>\n",
    "        <li>Jupyter.org. 2020. Project Jupyter. [online] Available at: https://jupyter.org/about [Accessed 8 May 2020].</li>\n",
    "        <li>Vatlab.github.io. 2020. Sos - Script Of Script. [online] Available at: https://vatlab.github.io/sos-docs/ [Accessed 8 May 2020].</li>\n",
    "        <li> Dash.plotly.com. 2020. Introduction | Dash For Python Documentation | Plotly. [online] Available at: https://dash.plotly.com/introduction [Accessed 8 May 2020].</li>\n",
    "        <li> Plotly.com. 2020. Plotly Express. [online] Available at: https://plotly.com/python/plotly-express/ [Accessed 8 May 2020].</li>\n",
    "        <li>Qmrlab.org. 2020. Home | Qmrlab. [online] Available at: <https://qmrlab.org/> [Accessed 14 May 2020].</li>\n",
    "        <li>Boudreau, M., 2018. Robust Quantitative Magnetization Transfer Magnetic Resonance Imaging in the Presence of Radiofrequency Field Inhomogeneities (Doctoral dissertation, McGill University Libraries). </li>\n",
    "        <li>Park, D.J., 2014. B1 Mapping for Magnetic Resonance Imaging.</li>\n",
    "        <li>Qmrlab.org. 2020. New Filtering Module | Qmrlab. [online] Available at: https://qmrlab.org/2019/08/08/b1filter.html [Accessed 15 May 2020].</li>\n",
    "        <li>Cabana, J.-F., Gu, Y., Boudreau, M., Levesque, I. R., Atchia, Y., Sled, J. G., Narayanan, S., Arnold, D. L., Pike, G. B., Cohen-Adad, J., Duval, T., Vuong, M.-T. and Stikov, N. (2016), Quantitative magnetization transfer imaging made easy with qMTLab: Software for data simulation, analysis, and visualization. Concepts Magn. Reson.. doi: 10.1002/cmr.a.2135</li>\n",
    "    </ol>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "kernel": "Python3"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "SoS",
   "language": "sos",
   "name": "sos"
  },
  "language_info": {
   "codemirror_mode": "sos",
   "file_extension": ".sos",
   "mimetype": "text/x-sos",
   "name": "sos",
   "nbconvert_exporter": "sos_notebook.converter.SoS_Exporter",
   "pygments_lexer": "sos"
  },
  "sos": {
   "kernels": [
    [
     "Octave",
     "octave",
     "Octave",
     "#dff8fb",
     ""
    ],
    [
     "Python3",
     "python3",
     "Python3",
     "#FFD91A",
     {
      "name": "ipython",
      "version": 3
     }
    ],
    [
     "SoS",
     "sos",
     "",
     "",
     "sos"
    ]
   ],
   "panel": {
    "displayed": true,
    "height": 0,
    "style": "side"
   },
   "version": "0.20.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}