diff --git a/_episodes/introduction.md b/_episodes/introduction.md index 2876782d..23600b89 100644 --- a/_episodes/introduction.md +++ b/_episodes/introduction.md @@ -49,6 +49,13 @@ gradient directions and corresponding amplitudes. ## Dataset +For the rest of this lesson, we will make use of a subset of a publicly +available dataset, ds000221, originally hosted at [openneuro.org](https://openneuro.org/datasets/ds000221/versions/1.0.0). +The dataset is structured according to the Brain Imaging Data Structure +([BIDS](https://bids-specification.readthedocs.io/en/etable/)). Please check +the [the BIDS-dMRI Setup page](https://carpentries-incubator.github.io/SDC-BIDS-dMRI/setup.html) +to download the dataset. + Below is a tree diagram showing the folder structure of a single MR subject and session within ds000221. This was obtained by using the bash command tree. @@ -109,7 +116,7 @@ tree '../data/ds000221'   │    │ ├── sub-010002_ses-01_acq-SEfmapDWI_dir-AP_epi.nii.gz    │    │ ├── sub-010002_ses-01_acq-SEfmapDWI_dir-PA_epi.json   │    │ └── sub-010002_ses-01_acq-SEfmapDWI_dir-PA_epi.nii.gz - │ └── fmap + │ └── func    │    │ ├── sub-010002_ses-01_task-rest_acq-AP_run-01_bold.json   │    │ └── sub-010002_ses-01_task-rest_acq-AP_run-01_bold.nii.gz └── ses-02/ @@ -122,18 +129,23 @@ tree '../data/ds000221' querying, summarizing and manipulating the BIDS folder structure. We will make use of pybids to query the necessary files. -Lets first pull the metadata from its associated JSON file using the +Let's first pull the metadata from its associated JSON file using the get_metadata() function for the first run. ~~~ +import bids from bids.layout import BIDSLayout +?BIDSLayout + +bids.config.set_option('extension_initial_dot', True) + layout = BIDSLayout("../data/ds000221", validate=False) ~~~ {: .language-python} -Now that we have a layout object, we can work with a BIDS dataset! Lets extract -the metadata. from the dataset. +Now that we have a layout object, we can work with a BIDS dataset! Let's +extract the metadata from the dataset. ~~~ dwi = layout.get(subject='010006', suffix='dwi', extension='nii.gz', return_type='file')[0] @@ -171,16 +183,6 @@ Python) package for processing and analysing diffusion MRI. - Implementations of many state-of-the art algorithms - High performance. Many algorithms implemented in [cython](http://cython.org/) -### Installing dipy - -The easiest way to install Dipy is to use pip! -Additionally, Dipy makes use of the FURY library for -visualization. We will also install this using pip! - -We can install it by entering the following in a terminal -pip install dipy. We will do so using Jupyter Magic in the -following cell! - ### Defining a measurement: GradientTable Dipy has a built-in function that allows us to read in @@ -195,7 +197,7 @@ bval = layout.get_bval(dwi) ~~~ {: .language-python} -Now that we have the necessary diffusion files, lets explore the data! +Now that we have the necessary diffusion files, let's explore the data! ~~~ import numpy as np @@ -243,6 +245,8 @@ bvec_txt = np.genfromtxt(bvec) fig = plt.figure() ax = fig.add_subplot(111, projection='3d') ax.scatter(bvec_txt[0], bvec_txt[1], bvec_txt[2]) + +plt.show() ~~~ {: .language-python} @@ -278,66 +282,66 @@ gtab.bvecs[~gtab.b0s_mask] {: .language-python} ~~~ -array([[ 0.0480948 , -0.518981 , 0.853432 ], - [ 0.980937 , -0.0827268 , -0.175836 ], - [-0.24275 , -0.355443 , -0.902625 ], - [-0.292642 , -0.878897 , 0.376696 ], - [ 0.085518 , -0.362038 , -0.928232 ], - [ 0.470646 , -0.695075 , 0.543473 ], - [-0.865701 , -0.485398 , 0.122274 ], - [ 0.226775 , -0.23832 , 0.944339 ], - [ 0.334443 , -0.89435 , -0.29713 ], - [ 0.727534 , 0.0823542 , 0.681111 ], - [-0.625823 , 0.126479 , 0.769642 ], - [ 0.353667 , -0.886595 , 0.298111 ], - [-0.853084 , -0.472587 , -0.221153 ], - [ 0.516586 , -0.856143 , -0.0125875 ], - [-0.766369 , -0.458916 , 0.449527 ], - [-0.125754 , -0.637058 , -0.760489 ], - [-0.149251 , -0.743085 , 0.652341 ], - [ 0.937341 , -0.348404 , -0.00268246], - [-0.124163 , -0.219376 , 0.967708 ], - [-0.36458 , -0.906103 , -0.214613 ], - [ 0.579767 , -0.204866 , 0.788606 ], - [ 0.445586 , -0.692181 , -0.567749 ], - [-0.905294 , -0.174158 , -0.387442 ], - [-0.282606 , -0.482101 , 0.829284 ], - [-0.731609 , -0.431568 , -0.527729 ], - [ 0.676757 , -0.438047 , -0.591705 ], - [ 0.171374 , -0.758177 , 0.629125 ], - [-0.59121 , -0.711294 , -0.380173 ], - [-0.46017 , -0.155292 , 0.874144 ], - [ 0.845645 , -0.162694 , 0.508345 ], - [-0.130717 , -0.98886 , 0.0712005 ], - [ 0.975624 , -0.0906642 , 0.199845 ], - [-0.288147 , 0.100936 , 0.952252 ], - [ 0.655193 , -0.70285 , 0.276989 ], - [-0.442479 , -0.607006 , -0.660118 ], - [-0.471845 , -0.674107 , 0.56828 ], - [ 0.638596 , -0.702848 , -0.313369 ], - [-0.642432 , -0.712214 , 0.2829 ], - [ 0.850936 , -0.431779 , 0.299125 ], - [-0.240808 , -0.830023 , -0.503063 ], - [-0.578162 , -0.401657 , 0.710211 ], - [ 0.100487 , -0.838741 , -0.535178 ], - [-0.924592 , -0.196278 , 0.326504 ], - [-0.0210952 , -0.967749 , -0.251032 ], - [-0.764669 , -0.142405 , 0.628492 ], - [ 0.197294 , -0.980191 , 0.0173175 ], - [ 0.405727 , 0.0420623 , 0.913026 ], - [ 0.859032 , -0.144763 , -0.491028 ], - [ 0.380277 , -0.486027 , 0.786872 ], - [-0.6891 , -0.721525 , -0.0674049 ], - [ 0.430722 , -0.388461 , -0.814602 ], - [ 0.0366712 , -0.92944 , 0.367147 ], - [-0.540564 , -0.318621 , -0.778634 ], - [ 0.775224 , -0.631369 , -0.0200052 ], - [ 0.0646129 , 0.0600214 , 0.996104 ], - [-0.978577 , -0.203636 , -0.0303294 ], - [ 0.199971 , -0.618334 , -0.760049 ], - [ 0.678143 , -0.446978 , 0.583381 ], - [-0.448761 , -0.888954 , 0.0915084 ], - [ 0.849148 , -0.426713 , -0.311228 ]]) +array([[-2.51881e-02, -3.72268e-01, 9.27783e-01], + [ 9.91276e-01, -1.05773e-01, -7.86433e-02], + [-1.71007e-01, -5.00324e-01, -8.48783e-01], + [-3.28334e-01, -8.07475e-01, 4.90083e-01], + [ 1.59023e-01, -5.08209e-01, -8.46425e-01], + [ 4.19677e-01, -5.94275e-01, 6.86082e-01], + [-8.76364e-01, -4.64096e-01, 1.28844e-01], + [ 1.47409e-01, -8.01322e-02, 9.85824e-01], + [ 3.50020e-01, -9.29191e-01, -1.18704e-01], + [ 6.70475e-01, 1.96486e-01, 7.15441e-01], + [-6.85569e-01, 2.47048e-01, 6.84808e-01], + [ 3.21619e-01, -8.24329e-01, 4.65879e-01], + [-8.35634e-01, -5.07463e-01, -2.10233e-01], + [ 5.08740e-01, -8.43979e-01, 1.69950e-01], + [-8.03836e-01, -3.83790e-01, 4.54481e-01], + [-6.82578e-02, -7.53445e-01, -6.53959e-01], + [-2.07898e-01, -6.27330e-01, 7.50490e-01], + [ 9.31645e-01, -3.38939e-01, 1.30988e-01], + [-2.04382e-01, -5.95385e-02, 9.77079e-01], + [-3.52674e-01, -9.31125e-01, -9.28787e-02], + [ 5.11906e-01, -7.06485e-02, 8.56132e-01], + [ 4.84626e-01, -7.73448e-01, -4.08554e-01], + [-8.71976e-01, -2.40158e-01, -4.26593e-01], + [-3.53191e-01, -3.41688e-01, 8.70922e-01], + [-6.89136e-01, -5.16115e-01, -5.08642e-01], + [ 7.19336e-01, -5.25068e-01, -4.54817e-01], + [ 1.14176e-01, -6.44483e-01, 7.56046e-01], + [-5.63224e-01, -7.67654e-01, -3.05754e-01], + [-5.31237e-01, -1.29342e-02, 8.47125e-01], + [ 7.99914e-01, -7.30043e-02, 5.95658e-01], + [-1.43792e-01, -9.64620e-01, 2.20979e-01], + [ 9.55196e-01, -5.23107e-02, 2.91314e-01], + [-3.64423e-01, 2.53394e-01, 8.96096e-01], + [ 6.24566e-01, -6.44762e-01, 4.40680e-01], + [-3.91818e-01, -7.09411e-01, -5.85845e-01], + [-5.21993e-01, -5.74810e-01, 6.30172e-01], + [ 6.56573e-01, -7.41002e-01, -1.40812e-01], + [-6.68597e-01, -6.60616e-01, 3.41414e-01], + [ 8.20224e-01, -3.72360e-01, 4.34259e-01], + [-2.05263e-01, -9.02465e-01, -3.78714e-01], + [-6.37020e-01, -2.83529e-01, 7.16810e-01], + [ 1.37944e-01, -9.14231e-01, -3.80990e-01], + [-9.49691e-01, -1.45434e-01, 2.77373e-01], + [-7.31922e-03, -9.95911e-01, -9.00386e-02], + [-8.14263e-01, -4.20783e-02, 5.78969e-01], + [ 1.87418e-01, -9.63210e-01, 1.92618e-01], + [ 3.30434e-01, 1.92714e-01, 9.23945e-01], + [ 8.95093e-01, -2.18266e-01, -3.88805e-01], + [ 3.11358e-01, -3.49170e-01, 8.83819e-01], + [-6.86317e-01, -7.27289e-01, -4.54356e-03], + [ 4.92805e-01, -5.14280e-01, -7.01897e-01], + [-8.03482e-04, -8.56796e-01, 5.15655e-01], + [-4.77664e-01, -4.45734e-01, -7.57072e-01], + [ 7.68954e-01, -6.22151e-01, 1.47095e-01], + [-1.55099e-02, 2.22329e-01, 9.74848e-01], + [-9.74410e-01, -2.11297e-01, -7.66740e-02], + [ 2.56251e-01, -7.33793e-01, -6.29193e-01], + [ 6.24656e-01, -3.42071e-01, 7.01992e-01], + [-4.61411e-01, -8.64670e-01, 1.98612e-01], + [ 8.68547e-01, -4.66754e-01, -1.66634e-01]]) ~~~ {: .output} @@ -373,18 +377,7 @@ axonal trajectories via tractography. > > ## Solution > > > > ~~~ -> > dwi_data = layout.get(suffix=dwi', extension='nii.gz', return_type='file') -> > ~~~ -> > {: .language-python} -> {: .solution} -> -> Get the metadata for the diffusion associated with subject 010016. -> -> > ## Solution -> > -> > ~~~ -> > dwi = layout.get(subject='010016', suffix='dwi', extension='nii.gz', return_type='file')[0] -> > layout.get_metadata(dwi) +> > dwi_data = layout.get(suffix='dwi', extension='nii.gz', return_type='file') > > ~~~ > > {: .language-python} > {: .solution} diff --git a/code/introduction/introduction.ipynb b/code/introduction/introduction.ipynb index 8a86527f..a5332cd1 100644 --- a/code/introduction/introduction.ipynb +++ b/code/introduction/introduction.ipynb @@ -6,11 +6,13 @@ "source": [ "# Introduction to Diffusion MRI data\n", "\n", + "_Much of the material in both the current notebook and the upcoming notebooks are adapted from the lessons on [neuroimaging analysis with Python](https://github.com/datacarpentry/python-neuroimaging-lesson)._\n", + "\n", "## Diffusion Weighted Imaging (DWI)\n", "\n", "Diffusion imaging probes the random, microscopic motion of water protons by employing MRI sequences which are sensitive to the geometry and environmental organization surrounding the water protons. This is a popular technique for studying the white matter of the brain. The diffusion within biological structures, such as the brain, are often restricted due to barriers (eg. cell membranes), resulting in a preferred direction of diffusion (anisotropy). A typical diffusion MRI scan will acquire multiple volumes that are sensitive to a particular diffusion direction and result in diffusion-weighted images (DWI). Diffusion that exhibits directionality in the same direction result in an attenuated signal. With further processing (to be discussed later in the lesson), the acquired images can provide measurements which are related to the microscopic changes and estimate white matter trajectories. Images with no diffusion weighting are also acquired as part of the acquisition protocol.\n", "\n", - "![fiber_configurations](DiffusionDirections.png) \\\n", + "![fiber_configurations](../../fig/introduction/DiffusionDirections.png) \\\n", "Diffusion along X, Y, and Z directions" ] }, @@ -20,7 +22,7 @@ "source": [ "## b-values & b-vectors\n", "\n", - "In addition to the acquired diffusion images, two files are collected as part of the diffusion dataset. These files correspond to the gradient amplitude (b-values) and directions (b-vectors) of the diffusion measurement and are named with the extensions `.bval` and `.bvec` respectively. The b-value is the diffusion-sensitizing factor, and reflects the timing & strength of the gradients used to acquire the diffusion-weighted images. The b-vector corresponds to the direction of the diffusion sensitivity. Together these two files define the diffusion MRI measurement as a set of gradient directions and corresponding amplitudes." + "In addition to the acquired diffusion images, two files are collected as part of the diffusion dataset. These files correspond to the gradient amplitude (b-values) and directions (b-vectors) of the diffusion measurement and are named with the extensiosn `.bval` and `.bvec` respectively. The b-value is the diffusion-sensitizing factor, and reflects the timing & strength of the gradients used to acquire the diffusion-weighted images. The b-vector corresponds to the direction of the diffusion sensitivity. Together these two files define the diffusion MRI measurement as a set of gradient directions and corresponding amplitudes." ] }, { @@ -29,46 +31,73 @@ "source": [ "## Dataset\n", "\n", - "For the rest of this tutorial, we will make use of a subset of publicly available dataset, ds000030, from [openneuro.org](https://openneuro.org/datasets/ds000030) The dataset is structured according to the Brain Imaging Data Structure ([BIDS](https://bids-specification.readthedocs.io/en/etable/)). " + "For the rest of this lesson, we will make use of a subset of a publicly available dataset, ds000221, originally hosted at [openneuro.org](https://openneuro.org/datasets/ds000221/versions/1.0.0). The dataset is structured according to the Brain Imaging Data Structure ([BIDS](https://bids-specification.readthedocs.io/en/etable/)). Please check the [the BIDS-dMRI Setup page](https://carpentries-incubator.github.io/SDC-BIDS-dMRI/setup.html) to download the dataset." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Below is a tree diagram showing the folder structure of a single MR session within ds000030. This was obtained by using the bash command `tree`. \n", - "`!tree ../data/ds000030`\n", + "Below is a tree diagram showing the folder structure of a single MR subject and session within ds000221. This was obtained by using the bash command `tree`.\n", + "\n", + "`!tree ../../data/ds000221`\n", "\n", "```\n", - "ds000030\n", + "../../data/ds000221\n", + "├── .bidsignore\n", "├── CHANGES\n", - "├── code\n", "├── dataset_description.json\n", + "├── participants.tsv\n", "├── README\n", - "└── sub-10788/\n", - "    ├── anat\n", - "    │   ├── sub-10788_T1w.json\n", - "    │   └── sub-10788_T1w.nii.gz\n", - "    └── dwi\n", - "       ├── sub-10788_dwi.bval\n", - "       │── sub-10788_dwi.bvec\n", - "       │── sub-10788_dwi.json\n", - "       └── sub-10788_dwi.nii.gz\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "!aws s3 sync --no-sign-request \\\n", - " s3://openneuro/ds000030/ds000030_R1.0.5/uncompressed/sub-10788 \\\n", - " ../../data/ds000030/sub-10788 \\\n", - " --exclude '*' \\\n", - " --include '*T1w*' \\\n", - " --include '*dwi*'" + "├── derivatives/\n", + "├── sub-010001/\n", + "└── sub-010002/\n", + " ├── ses-01/\n", + " │    ├── anat\n", + "    │   │ ├── sub-010002_ses-01_acq-lowres_FLAIR.json\n", + " │ │ ├── sub-010002_ses-01_acq-lowres_FLAIR.nii.gz\n", + " │ │ ├── sub-010002_ses-01_acq-mp2rage_defacemask.nii.gz\n", + " │ │ ├── sub-010002_ses-01_acq-mp2rage_T1map.nii.gz\n", + " │ │ ├── sub-010002_ses-01_acq-mp2rage_T1w.nii.gz\n", + " │ │ ├── sub-010002_ses-01_inv-1_mp2rage.json\n", + " │ │ ├── sub-010002_ses-01_inv-1_mp2rage.nii.gz\n", + " │ │ ├── sub-010002_ses-01_inv-2_mp2rage.json\n", + " │ │ ├── sub-010002_ses-01_inv-2_mp2rage.nii.gz\n", + " │ │ ├── sub-010002_ses-01_T2w.json\n", + " │ │ └── sub-010002_ses-01_T2w.nii.gz\n", + "    │ ├── dwi\n", + "    │    │ ├── sub-010002_ses-01_dwi.bval\n", + "    │    │ │── sub-010002_ses-01_dwi.bvec\n", + "    │    │ │── sub-010002_ses-01_dwi.json\n", + "    │    │ └── sub-010002_ses-01_dwi.nii.gz\n", + "   │ ├── fmap\n", + "    │    │ ├── sub-010002_ses-01_acq-GEfmap_run-01_magnitude1.json\n", + "   │    │ ├── sub-010002_ses-01_acq-GEfmap_run-01_magnitude1.nii.gz\n", + "    │    │ ├── sub-010002_ses-01_acq-GEfmap_run-01_magnitude2.json\n", + "   │    │ ├── sub-010002_ses-01_acq-GEfmap_run-01_magnitude2.nii.gz\n", + "    │    │ ├── sub-010002_ses-01_acq-GEfmap_run-01_phasediff.json\n", + "   │    │ ├── sub-010002_ses-01_acq-GEfmap_run-01_phasediff.nii.gz\n", + "    │    │ ├── sub-010002_ses-01_acq-SEfmapBOLDpost_dir-AP_epi.json\n", + "   │    │ ├── sub-010002_ses-01_acq-SEfmapBOLDpost_dir-AP_epi.nii.gz\n", + "    │    │ ├── sub-010002_ses-01_acq-SEfmapBOLDpost_dir-PA_epi.json\n", + "   │    │ ├── sub-010002_ses-01_acq-SEfmapBOLDpost_dir-PA_epi.nii.gz\n", + "    │    │ ├── sub-010002_ses-01_acq-sefmapBOLDpre_dir-AP_epi.json\n", + "   │    │ ├── sub-010002_ses-01_acq-sefmapBOLDpre_dir-AP_epi.nii.gz\n", + "    │    │ ├── sub-010002_ses-01_acq-sefmapBOLDpre_dir-PA_epi.json\n", + "   │    │ ├── sub-010002_ses-01_acq-sefmapBOLDpre_dir-PA_epi.nii.gz\n", + "    │    │ ├── sub-010002_ses-01_acq-SEfmapBOLDpost_dir-AP_epi.json\n", + "   │    │ ├── sub-010002_ses-01_acq-SEfmapBOLDpost_dir-AP_epi.nii.gz\n", + "    │    │ ├── sub-010002_ses-01_acq-SEfmapBOLDpost_dir-PA_epi.json\n", + "   │    │ ├── sub-010002_ses-01_acq-SEfmapBOLDpost_dir-PA_epi.nii.gz\n", + "    │    │ ├── sub-010002_ses-01_acq-SEfmapDWI_dir-AP_epi.json\n", + "   │    │ ├── sub-010002_ses-01_acq-SEfmapDWI_dir-AP_epi.nii.gz\n", + "    │    │ ├── sub-010002_ses-01_acq-SEfmapDWI_dir-PA_epi.json\n", + "   │    │ └── sub-010002_ses-01_acq-SEfmapDWI_dir-PA_epi.nii.gz\n", + " │ └── func\n", + "    │    │ ├── sub-010002_ses-01_task-rest_acq-AP_run-01_bold.json\n", + "   │    │ └── sub-010002_ses-01_task-rest_acq-AP_run-01_bold.nii.gz\n", + " └── ses-02/\n", + " ```" ] }, { @@ -77,132 +106,45 @@ "source": [ "## Querying a BIDS Dataset\n", "\n", - "[`pybids`](https://bids-standard.github.io/pybids/) is a Python API for querying, summarizing and manipulating the BIDS folder structure. We will make use of `pybids` to query the necessary files. \n", + "[`pybids`](https://bids-standard.github.io/pybids/) is a Python API for querying, summarizing and manipulating the BIDS folder structure. We will make use of `pybids` to query the necessary files.\n", "\n", - "Lets first pull the metadata from its associated JSON file using the `get_metadata()` function for the first run." + "Let's first pull the metadata from its associated JSON file using the `get_metadata()` function for the first run." ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ + "import bids\n", "from bids.layout import BIDSLayout\n", "\n", - "layout = BIDSLayout(\"../../data/ds000030\", validate=False)" + "?BIDSLayout\n", + "\n", + "bids.config.set_option('extension_initial_dot', True)\n", + "\n", + "layout = BIDSLayout(\"../../../data/ds000221\", validate=False)" ] }, { - "cell_type": "code", - "execution_count": 7, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'AccelerationFactorPE': 1,\n", - " 'AcquisitionMatrix': '96/0/0/96',\n", - " 'DeviceSerialNumber': '35343',\n", - " 'EPIFactor': 128,\n", - " 'EchoTime': 0.0926,\n", - " 'EchoTrainLength': 1,\n", - " 'EffectiveEchoSpacing': 0.000689983,\n", - " 'FlipAngle': 90,\n", - " 'ImageType': 'ORIGINAL/PRIMARY/M/ND/MOSAIC',\n", - " 'ImagingFrequency': 123227595,\n", - " 'InPlanePhaseEncodingDirection': 'COL',\n", - " 'MRAcquisitionType': '2D',\n", - " 'MagneticFieldStrength': 3,\n", - " 'ManufacturerModelName': 'TrioTim',\n", - " 'NumberOfAverages': 1,\n", - " 'NumberOfPhaseEncodingSteps': 72,\n", - " 'PatientPosition': 'HFS',\n", - " 'PercentPhaseFieldOfView': 100,\n", - " 'PercentSampling': 100,\n", - " 'PhaseEncodingDirection': 'j-',\n", - " 'PixelBandwidth': 2265,\n", - " 'ProtocolName': 'DTI 64dir',\n", - " 'ReceiveCoilName': 'HeadMatrix',\n", - " 'RepetitionTime': 8.4,\n", - " 'ScanOptions': 'PFP/FS',\n", - " 'ScanningSequence': 'EP',\n", - " 'SequenceName': '*ep_b1000#10',\n", - " 'SequenceVariant': 'SK/SP',\n", - " 'SliceTiming': [4.2175,\n", - " 0,\n", - " 4.3575,\n", - " 0.14,\n", - " 4.4975,\n", - " 0.28,\n", - " 4.6375,\n", - " 0.4225,\n", - " 4.7775,\n", - " 0.5625,\n", - " 4.92,\n", - " 0.7025,\n", - " 5.06,\n", - " 0.8425,\n", - " 5.2,\n", - " 0.985,\n", - " 5.34,\n", - " 1.125,\n", - " 5.4825,\n", - " 1.265,\n", - " 5.6225,\n", - " 1.405,\n", - " 5.7625,\n", - " 1.545,\n", - " 5.9025,\n", - " 1.6875,\n", - " 6.0425,\n", - " 1.8275,\n", - " 6.185,\n", - " 1.9675,\n", - " 6.325,\n", - " 2.1075,\n", - " 6.465,\n", - " 2.2475,\n", - " 6.605,\n", - " 2.39,\n", - " 6.7475,\n", - " 2.53,\n", - " 6.8875,\n", - " 2.67,\n", - " 7.0275,\n", - " 2.81,\n", - " 7.1675,\n", - " 2.9525,\n", - " 7.3075,\n", - " 3.0925,\n", - " 7.45,\n", - " 3.2325,\n", - " 7.59,\n", - " 3.3725,\n", - " 7.73,\n", - " 3.5125,\n", - " 7.87,\n", - " 3.655,\n", - " 8.0125,\n", - " 3.795,\n", - " 8.1525,\n", - " 3.935,\n", - " 8.2925,\n", - " 4.075],\n", - " 'SoftwareVersions': 'syngo MR B15',\n", - " 'TotalReadoutTime': 0.088317824,\n", - " 'TotalScanTimeSec': 556,\n", - " 'TransmitCoilName': 'Body',\n", - " 'VariableFlipAngleFlag': 'N'}" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" + "source": [ + "Now that we have a layout object, we can work with a BIDS dataset! Let's extract the metadata from the dataset." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "jupyter": { + "outputs_hidden": true } - ], + }, + "outputs": [], "source": [ - "dwi = layout.get(subject='10788', suffix='dwi', extension='nii.gz', return_type='file')[0]\n", + "dwi = layout.get(subject='010006', suffix='dwi', extension='nii.gz', return_type='file')[0]\n", "layout.get_metadata(dwi)" ] }, @@ -210,22 +152,16 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## [`dipy`](http://dipy.org)\n", + "## Diffusion Imaging in Python ([dipy](https://dipy.org))\n", "\n", "For this lesson, we will use the `Dipy` (Diffusion Imaging in Python) package for processing and analysing diffusion MRI.\n", "\n", - "### Why `dipy`? \n", + "### Why `dipy`?\n", "\n", "- Fully free and open source\n", "- Implemented in Python. Easy to understand, and easy to use.\n", "- Implementations of many state-of-the art algorithms\n", - "- High performance. Many algorithms implemented in [`cython`](http://cython.org/)\n", - "\n", - "### Installing `dipy`\n", - "\n", - "The easiest way to install `Dipy` is to use `pip`! Additionally, `Dipy` makes use of the FURY library for visualization. We will also install this using `pip`!\n", - "\n", - "We can install it by entering the following in a terminal `pip install dipy`. We will do so using Jupyter Magic in the following cell!" + "- High performance. Many algorithms implemented in [`cython`](http://cython.org/)" ] }, { @@ -239,76 +175,53 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": {}, + "execution_count": null, + "metadata": { + "jupyter": { + "outputs_hidden": true + } + }, "outputs": [], "source": [ - "dwi = layout.get(subject='10788', suffix='dwi', extension='.nii.gz', return_type='file')[0]\n", - "bvec = layout.get(subject='10788', suffix='dwi', extension='bvec', return_type='file')[0]\n", - "bval = layout.get(subject='10788', suffix='dwi', extension='bval', return_type='file')[0]" + "bvec = layout.get_bvec(dwi)\n", + "bval = layout.get_bval(dwi)" ] }, { - "cell_type": "code", - "execution_count": 9, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "import numpy as np\n", - "import nibabel as nib\n", - "\n", - "from mpl_toolkits.mplot3d import Axes3D\n", - "import matplotlib.pyplot as plt\n", - "%matplotlib notebook" + "Now that we have the necessary diffusion files, let's explore the data!" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "data = nib.load(dwi).get_fdata()" + "import numpy as np\n", + "import nibabel as nib\n", + "\n", + "from mpl_toolkits.mplot3d import Axes3D\n", + "import matplotlib.pyplot as plt\n", + "\n", + "data = nib.load(dwi).get_fdata()\n", + "data.shape" ] }, { - "cell_type": "code", - "execution_count": 18, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(96, 96, 60, 65)" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "data.shape" + "We can see that the data is 4 dimensional. The 4th dimension represents the different diffusion directions we are sensitive to. Next, let's take a look at a slice." ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "x_slice = data[58, :, :, 0]\n", "y_slice = data[:, 58, :, 0]\n", @@ -322,63 +235,17 @@ ] }, { - "cell_type": "code", - "execution_count": 24, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], "source": [ - "x_slice = data[58, :, :, 2]\n", - "y_slice = data[:, 58, :, 2]\n", - "z_slice = data[:, :, 30, 2]\n", - "\n", - "slices = [x_slice, y_slice, z_slice]\n", - "\n", - "fig, axes = plt.subplots(1, len(slices))\n", - "for i, slice in enumerate(slices):\n", - " axes[i].imshow(slice.T, cmap=\"gray\", origin=\"lower\")" + "We can also see how the diffusion gradients are represented. This is plotted on a sphere, the further away from the center of the sphere, the stronger the diffusion gradient (increased sensitivity to diffusion)." ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "bvec_txt = np.genfromtxt(bvec)\n", "\n", @@ -386,38 +253,26 @@ "ax = fig.add_subplot(111, projection='3d')\n", "ax.scatter(bvec_txt[0], bvec_txt[1], bvec_txt[2])\n", "\n", - "plt.show" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [], - "source": [ - "from dipy.io.gradients import read_bvals_bvecs\n", - "from dipy.core.gradients import gradient_table\n", - "\n", - "gt_bvals, gt_bvecs = read_bvals_bvecs(bval, bvec)" + "plt.show()" ] }, { "cell_type": "markdown", - "metadata": { - "jupyter": { - "outputs_hidden": true - } - }, + "metadata": {}, "source": [ - "There is a also simple `GradientTable` object implemented in the `dipy.core.gradients` module. The input to the `GradientTable` should be our the values for our gradient directions and amplitudes we just read." + "The files associated with the diffusion gradients need to converted to a `GradientTable` object to be used with `Dipy`. A `GradientTable` object can be implemented using the `dipy.core.gradients` module. The input to the `GradientTable` should be our the values for our gradient directions and amplitudes we read in." ] }, { "cell_type": "code", - "execution_count": 27, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ + "from dipy.io.gradients import read_bvals_bvecs\n", + "from dipy.core.gradients import gradient_table\n", + "\n", + "gt_bvals, gt_bvecs = read_bvals_bvecs(bval, bvec)\n", "gtab = gradient_table(gt_bvals, gt_bvecs)" ] }, @@ -425,90 +280,16 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We will need this gradient table later on to process our data and generate diffusion tensor images (DTI)! \n", + "We will need this gradient table later on to process our data and generate diffusion tensor images (DTI)!\n", "\n", - "There is also a built in function for gradient tables, `b0s_mask` that can be used to separate diffusion weighted measurements from non-diffusion weighted measurements (b=0s/mm^2). Try to extract the vector corresponding to diffusion weighted measurements in the following cell!" + "There is also a built in function for gradient tables, `b0s_mask` that can be used to separate difussion weighted measurements from non-diffusion weighted measurements (b=0s/mm^2). Try to extract the vector corresponding to diffusion weighted measurements in the following cell!" ] }, { "cell_type": "code", - "execution_count": 28, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[-9.99984e-01, 4.03613e-03, 4.03613e-03],\n", - " [-9.92980e-04, -9.99987e-01, 4.98886e-03],\n", - " [-2.48897e-02, 6.53243e-01, -7.56739e-01],\n", - " [-5.89518e-01, 7.69236e-01, 2.46462e-01],\n", - " [ 2.35626e-01, 5.28739e-01, 8.15423e-01],\n", - " [ 8.93067e-01, 2.63666e-01, 3.64570e-01],\n", - " [ 7.97398e-01, 1.33552e-01, -5.88489e-01],\n", - " [ 2.32919e-01, 9.31812e-01, -2.78344e-01],\n", - " [ 9.36380e-01, 1.44036e-01, -3.20072e-01],\n", - " [-5.04032e-01, 8.46814e-01, -1.69873e-01],\n", - " [-3.44841e-01, 8.50410e-01, -3.97351e-01],\n", - " [-4.55850e-01, 6.35469e-01, -6.23202e-01],\n", - " [ 4.87386e-01, 3.93024e-01, 7.79735e-01],\n", - " [-6.16792e-01, 6.76545e-01, -4.02310e-01],\n", - " [ 5.77851e-01, 1.09487e-01, -8.08765e-01],\n", - " [ 8.25555e-01, 5.24662e-01, 2.07818e-01],\n", - " [ 8.94898e-01, -4.48150e-02, 4.44016e-01],\n", - " [-2.89332e-01, 5.45724e-01, -7.86430e-01],\n", - " [-1.15014e-01, 9.64050e-01, -2.39541e-01],\n", - " [ 8.00058e-01, -4.08056e-01, -4.39770e-01],\n", - " [ 5.11970e-01, 8.42290e-01, -1.68625e-01],\n", - " [ 7.89764e-01, -1.57178e-01, -5.92932e-01],\n", - " [ 9.49115e-01, -2.37601e-01, -2.06705e-01],\n", - " [ 2.32032e-01, 7.86655e-01, -5.72132e-01],\n", - " [ 1.96515e-02, 1.91844e-01, -9.81229e-01],\n", - " [-2.15961e-01, 9.57087e-01, 1.93247e-01],\n", - " [ 7.72435e-01, -6.07408e-01, -1.85471e-01],\n", - " [-1.59879e-01, 3.59797e-01, -9.19231e-01],\n", - " [-1.46103e-01, 7.34950e-01, 6.62195e-01],\n", - " [ 8.87180e-01, 4.21444e-01, -1.87872e-01],\n", - " [-5.62338e-01, 2.36544e-01, 7.92353e-01],\n", - " [-3.80669e-01, 1.46788e-01, -9.12987e-01],\n", - " [ 3.05803e-01, 2.02751e-01, -9.30256e-01],\n", - " [ 3.32094e-01, 1.33876e-01, 9.33697e-01],\n", - " [ 9.62206e-01, 2.69443e-01, 3.95029e-02],\n", - " [ 9.59295e-01, -2.09888e-01, 1.88943e-01],\n", - " [-4.50964e-01, 8.90337e-01, 6.27015e-02],\n", - " [ 7.71192e-01, -6.31175e-01, 8.29533e-02],\n", - " [-7.09223e-01, -4.12894e-01, 5.71421e-01],\n", - " [-6.94205e-01, 2.78961e-02, -7.19236e-01],\n", - " [ 6.81181e-01, 5.33350e-01, 5.01528e-01],\n", - " [-1.40978e-01, -7.29050e-01, -6.69784e-01],\n", - " [ 7.40351e-01, -3.93222e-01, 5.45212e-01],\n", - " [-1.01944e-01, 8.25404e-01, -5.55261e-01],\n", - " [ 5.83509e-01, -6.00385e-01, -5.46859e-01],\n", - " [ 8.66669e-02, 3.39104e-01, 9.36748e-01],\n", - " [ 5.50506e-01, 7.95484e-01, 2.53276e-01],\n", - " [ 8.37371e-01, -4.62163e-01, 2.91916e-01],\n", - " [-3.62527e-01, 5.65304e-01, 7.40949e-01],\n", - " [-1.83461e-01, 3.96756e-01, 8.99404e-01],\n", - " [-7.18319e-01, -6.95701e-01, -4.24514e-03],\n", - " [ 4.31996e-01, 6.86464e-01, 5.84933e-01],\n", - " [ 5.00977e-01, 6.94308e-01, -5.16680e-01],\n", - " [ 1.69597e-01, 5.13550e-01, -8.41132e-01],\n", - " [ 4.63360e-01, 4.27481e-01, -7.76246e-01],\n", - " [ 3.84024e-01, -8.12297e-01, -4.38975e-01],\n", - " [ 7.13857e-01, 2.51359e-01, 6.53626e-01],\n", - " [ 2.58398e-01, 8.87277e-01, 3.82061e-01],\n", - " [-9.28270e-04, 8.02399e-02, 9.96775e-01],\n", - " [-3.63633e-02, 9.04616e-01, 4.24675e-01],\n", - " [-5.70681e-01, 3.07326e-01, -7.61495e-01],\n", - " [-2.82028e-01, 1.48741e-01, 9.47806e-01],\n", - " [ 7.19926e-01, 6.12166e-01, -3.27047e-01],\n", - " [ 2.65067e-01, 9.60908e-01, 7.99761e-02]])" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "gtab.bvecs[~gtab.b0s_mask]" ] @@ -517,115 +298,47 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "It is also important to know where our diffusion weighting free measurements are as we need them for registration in our preprocessing, (our next notebook). The gtab.b0s_mask shows that this is our first volume of our dataset." + "It is also important to know where our diffusion weighting free measurements are as we need them for registration in our preprocessing, (our next notebook). The `b0s_mask` shows that this is the first volume of our dataset." ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ True, False, False, False, False, False, False, False, False,\n", - " False, False, False, False, False, False, False, False, False,\n", - " False, False, False, False, False, False, False, False, False,\n", - " False, False, False, False, False, False, False, False, False,\n", - " False, False, False, False, False, False, False, False, False,\n", - " False, False, False, False, False, False, False, False, False,\n", - " False, False, False, False, False, False, False, False, False,\n", - " False, False])" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "gtab.b0s_mask" ] }, { - "cell_type": "code", - "execution_count": 30, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "b0 = data[:, :, :, gtab.b0s_mask]" + "In the next few notebooks, we will talk more about preprocessing the diffusion weighted images and reconstructing the Tensor model" ] }, { - "cell_type": "code", - "execution_count": 31, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(96, 96, 60, 1)" - ] - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "b0.shape" + "## Exercise 1\n", + "\n", + "Get a list of **all** diffusion data in NIfTI file format" ] }, { "cell_type": "code", - "execution_count": 37, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "b0 = np.squeeze(b0)" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "x_slice = b0[58, :, :]\n", - "y_slice = b0[:, 58, :]\n", - "z_slice = b0[:, :, 30]\n", - "\n", - "slices = [x_slice, y_slice, z_slice]\n", - "\n", - "fig, axes = plt.subplots(1, len(slices))\n", - "for i, slice in enumerate(slices):\n", - " axes[i].imshow(slice.T, cmap=\"gray\", origin=\"lower\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In the next few notebooks, we will talk more about preprocessing the diffusion weighted images and reconstructing the Tensor model" + "dwi_data = layout.get(suffix='dwi', extension='nii.gz', return_type='file')" ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -639,7 +352,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.4" + "version": "3.8.10" } }, "nbformat": 4, diff --git a/code/introduction/solutions/introduction_solutions.ipynb b/code/introduction/solutions/introduction_solutions.ipynb index 3a69cd2d..ab2d6672 100644 --- a/code/introduction/solutions/introduction_solutions.ipynb +++ b/code/introduction/solutions/introduction_solutions.ipynb @@ -6,13 +6,13 @@ "source": [ "# Introduction to Diffusion MRI data\n", "\n", - "_*Much of the material in both the current notebook and the upcoming notebooks are adapted from the lessons on [neuroimaging analysis with Python](https://github.com/datacarpentry/python-neuroimaging-lesson)._\n", + "_Much of the material in both the current notebook and the upcoming notebooks are adapted from the lessons on [neuroimaging analysis with Python](https://github.com/datacarpentry/python-neuroimaging-lesson)._\n", "\n", "## Diffusion Weighted Imaging (DWI)\n", "\n", "Diffusion imaging probes the random, microscopic motion of water protons by employing MRI sequences which are sensitive to the geometry and environmental organization surrounding the water protons. This is a popular technique for studying the white matter of the brain. The diffusion within biological structures, such as the brain, are often restricted due to barriers (eg. cell membranes), resulting in a preferred direction of diffusion (anisotropy). A typical diffusion MRI scan will acquire multiple volumes that are sensitive to a particular diffusion direction and result in diffusion-weighted images (DWI). Diffusion that exhibits directionality in the same direction result in an attenuated signal. With further processing (to be discussed later in the lesson), the acquired images can provide measurements which are related to the microscopic changes and estimate white matter trajectories. Images with no diffusion weighting are also acquired as part of the acquisition protocol.\n", "\n", - "![fiber_configurations](images/DiffusionDirections.png) \\\n", + "![fiber_configurations](../../../fig/introduction/DiffusionDirections.png) \\\n", "Diffusion along X, Y, and Z directions" ] }, @@ -31,7 +31,7 @@ "source": [ "## Dataset\n", "\n", - "For the rest of this tutorial, we will make use of a subset of publicly available dataset, ds000030, from [openneuro.org](https://openneuro.org/datasets/ds000030) The dataset is structured according to the Brain Imaging Data Structure ([BIDS](https://bids-specification.readthedocs.io/en/etable/)). " + "For the rest of this lesson, we will make use of a subset of a publicly available dataset, ds000221, originally hosted at [openneuro.org](https://openneuro.org/datasets/ds000221/versions/1.0.0). The dataset is structured according to the Brain Imaging Data Structure ([BIDS](https://bids-specification.readthedocs.io/en/etable/)). Please check the [the BIDS-dMRI Setup page](https://carpentries-incubator.github.io/SDC-BIDS-dMRI/setup.html) to download the dataset." ] }, { @@ -93,7 +93,7 @@ "   │    │ ├── sub-010002_ses-01_acq-SEfmapDWI_dir-AP_epi.nii.gz\n", "    │    │ ├── sub-010002_ses-01_acq-SEfmapDWI_dir-PA_epi.json\n", "   │    │ └── sub-010002_ses-01_acq-SEfmapDWI_dir-PA_epi.nii.gz\n", - " │ └── fmap\n", + " │ └── func\n", "    │    │ ├── sub-010002_ses-01_task-rest_acq-AP_run-01_bold.json\n", "   │    │ └── sub-010002_ses-01_task-rest_acq-AP_run-01_bold.nii.gz\n", " └── ses-02/\n", @@ -106,41 +106,70 @@ "source": [ "## Querying a BIDS Dataset\n", "\n", - "[`pybids`](https://bids-standard.github.io/pybids/) is a Python API for querying, summarizing and manipulating the BIDS folder structure. We will make use of `pybids` to query the necessary files. \n", + "[`pybids`](https://bids-standard.github.io/pybids/) is a Python API for querying, summarizing and manipulating the BIDS folder structure. We will make use of `pybids` to query the necessary files.\n", "\n", - "Lets first pull the metadata from its associated JSON file using the `get_metadata()` function for the first run." + "Let's first pull the metadata from its associated JSON file using the `get_metadata()` function for the first run." ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 1, + "metadata": { + "scrolled": false + }, "outputs": [], "source": [ - "?BIDSLayout" + "import bids\n", + "from bids.layout import BIDSLayout\n", + "\n", + "?BIDSLayout\n", + "\n", + "bids.config.set_option('extension_initial_dot', True)\n", + "\n", + "layout = BIDSLayout(\"../../../data/ds000221\", validate=False)" ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "from bids.layout import BIDSLayout\n", - "\n", - "layout = BIDSLayout(\"../../../data/ds000221\", validate=False)" + "Now that we have a layout object, we can work with a BIDS dataset! Let's extract the metadata from the dataset." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": { - "collapsed": true, "jupyter": { "outputs_hidden": true - } + }, + "scrolled": true }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "{'EchoTime': 0.08,\n", + " 'EffectiveEchoSpacing': 0.000390001,\n", + " 'FlipAngle': 90,\n", + " 'ImageType': ['ORIGINAL', 'PRIMARY', 'DIFFUSION', 'NON'],\n", + " 'MagneticFieldStrength': 3,\n", + " 'Manufacturer': 'Siemens',\n", + " 'ManufacturersModelName': 'Verio',\n", + " 'MultibandAccelerationFactor': 2,\n", + " 'ParallelAcquisitionTechnique': 'GRAPPA',\n", + " 'ParallelReductionFactorInPlane': 2,\n", + " 'PartialFourier': '7/8',\n", + " 'PhaseEncodingDirection': 'j-',\n", + " 'RepetitionTime': 7,\n", + " 'TotalReadoutTime': 0.04914}" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "dwi = layout.get(subject='010006', suffix='dwi', extension='nii.gz', return_type='file')[0]\n", "layout.get_metadata(dwi)" @@ -150,32 +179,16 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## [`dipy`](http://dipy.org)\n", + "## Diffusion Imaging in Python ([dipy](https://dipy.org))\n", "\n", "For this lesson, we will use the `Dipy` (Diffusion Imaging in Python) package for processing and analysing diffusion MRI.\n", "\n", - "### Why `dipy`? \n", + "### Why `dipy`?\n", "\n", "- Fully free and open source\n", "- Implemented in Python. Easy to understand, and easy to use.\n", "- Implementations of many state-of-the art algorithms\n", - "- High performance. Many algorithms implemented in [`cython`](http://cython.org/)\n", - "\n", - "### Installing `dipy`\n", - "\n", - "The easiest way to install `Dipy` is to use `pip`! Additionally, `Dipy` makes use of the FURY library for visualization. We will also install this using `pip`!\n", - "\n", - "We can install it by entering the following in a terminal `pip install dipy`. We will do so using Jupyter Magic in the following cell!" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "! pip install dipy\n", - "! pip install fury" + "- High performance. Many algorithms implemented in [`cython`](http://cython.org/)" ] }, { @@ -189,9 +202,8 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": { - "collapsed": true, "jupyter": { "outputs_hidden": true } @@ -202,35 +214,129 @@ "bval = layout.get_bval(dwi)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have the necessary diffusion files, let's explore the data!" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(128, 128, 88, 67)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "from dipy.io.gradients import read_bvals_bvecs\n", - "from dipy.core.gradients import gradient_table\n", + "import numpy as np\n", + "import nibabel as nib\n", + "\n", + "from mpl_toolkits.mplot3d import Axes3D\n", + "import matplotlib.pyplot as plt\n", "\n", - "gt_bvals, gt_bvecs = read_bvals_bvecs(bval, bvec)" + "data = nib.load(dwi).get_fdata()\n", + "data.shape" ] }, { "cell_type": "markdown", - "metadata": { - "jupyter": { - "outputs_hidden": true + "metadata": {}, + "source": [ + "We can see that the data is 4 dimensional. The 4th dimension represents the different diffusion directions we are sensitive to. Next, let's take a look at a slice." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } - }, + ], "source": [ - "There is a also simple `GradientTable` object implemented in the `dipy.core.gradients` module. The input to the `GradientTable` should be our the values for our gradient directions and amplitudes we just read." + "x_slice = data[58, :, :, 0]\n", + "y_slice = data[:, 58, :, 0]\n", + "z_slice = data[:, :, 30, 0]\n", + "\n", + "slices = [x_slice, y_slice, z_slice]\n", + "\n", + "fig, axes = plt.subplots(1, len(slices))\n", + "for i, slice in enumerate(slices):\n", + " axes[i].imshow(slice.T, cmap=\"gray\", origin=\"lower\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also see how the diffusion gradients are represented. This is plotted on a sphere, the further away from the center of the sphere, the stronger the diffusion gradient (increased sensitivity to diffusion)." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "bvec_txt = np.genfromtxt(bvec)\n", + "\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(111, projection='3d')\n", + "ax.scatter(bvec_txt[0], bvec_txt[1], bvec_txt[2])\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The files associated with the diffusion gradients need to converted to a `GradientTable` object to be used with `Dipy`. A `GradientTable` object can be implemented using the `dipy.core.gradients` module. The input to the `GradientTable` should be our the values for our gradient directions and amplitudes we read in." + ] + }, + { + "cell_type": "code", + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ + "from dipy.io.gradients import read_bvals_bvecs\n", + "from dipy.core.gradients import gradient_table\n", + "\n", + "gt_bvals, gt_bvecs = read_bvals_bvecs(bval, bvec)\n", "gtab = gradient_table(gt_bvals, gt_bvecs)" ] }, @@ -238,16 +344,86 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We will need this gradient table later on to process our data and generate diffusion tensor images (DTI)! \n", + "We will need this gradient table later on to process our data and generate diffusion tensor images (DTI)!\n", "\n", "There is also a built in function for gradient tables, `b0s_mask` that can be used to separate difussion weighted measurements from non-diffusion weighted measurements (b=0s/mm^2). Try to extract the vector corresponding to diffusion weighted measurements in the following cell!" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-2.51881e-02, -3.72268e-01, 9.27783e-01],\n", + " [ 9.91276e-01, -1.05773e-01, -7.86433e-02],\n", + " [-1.71007e-01, -5.00324e-01, -8.48783e-01],\n", + " [-3.28334e-01, -8.07475e-01, 4.90083e-01],\n", + " [ 1.59023e-01, -5.08209e-01, -8.46425e-01],\n", + " [ 4.19677e-01, -5.94275e-01, 6.86082e-01],\n", + " [-8.76364e-01, -4.64096e-01, 1.28844e-01],\n", + " [ 1.47409e-01, -8.01322e-02, 9.85824e-01],\n", + " [ 3.50020e-01, -9.29191e-01, -1.18704e-01],\n", + " [ 6.70475e-01, 1.96486e-01, 7.15441e-01],\n", + " [-6.85569e-01, 2.47048e-01, 6.84808e-01],\n", + " [ 3.21619e-01, -8.24329e-01, 4.65879e-01],\n", + " [-8.35634e-01, -5.07463e-01, -2.10233e-01],\n", + " [ 5.08740e-01, -8.43979e-01, 1.69950e-01],\n", + " [-8.03836e-01, -3.83790e-01, 4.54481e-01],\n", + " [-6.82578e-02, -7.53445e-01, -6.53959e-01],\n", + " [-2.07898e-01, -6.27330e-01, 7.50490e-01],\n", + " [ 9.31645e-01, -3.38939e-01, 1.30988e-01],\n", + " [-2.04382e-01, -5.95385e-02, 9.77079e-01],\n", + " [-3.52674e-01, -9.31125e-01, -9.28787e-02],\n", + " [ 5.11906e-01, -7.06485e-02, 8.56132e-01],\n", + " [ 4.84626e-01, -7.73448e-01, -4.08554e-01],\n", + " [-8.71976e-01, -2.40158e-01, -4.26593e-01],\n", + " [-3.53191e-01, -3.41688e-01, 8.70922e-01],\n", + " [-6.89136e-01, -5.16115e-01, -5.08642e-01],\n", + " [ 7.19336e-01, -5.25068e-01, -4.54817e-01],\n", + " [ 1.14176e-01, -6.44483e-01, 7.56046e-01],\n", + " [-5.63224e-01, -7.67654e-01, -3.05754e-01],\n", + " [-5.31237e-01, -1.29342e-02, 8.47125e-01],\n", + " [ 7.99914e-01, -7.30043e-02, 5.95658e-01],\n", + " [-1.43792e-01, -9.64620e-01, 2.20979e-01],\n", + " [ 9.55196e-01, -5.23107e-02, 2.91314e-01],\n", + " [-3.64423e-01, 2.53394e-01, 8.96096e-01],\n", + " [ 6.24566e-01, -6.44762e-01, 4.40680e-01],\n", + " [-3.91818e-01, -7.09411e-01, -5.85845e-01],\n", + " [-5.21993e-01, -5.74810e-01, 6.30172e-01],\n", + " [ 6.56573e-01, -7.41002e-01, -1.40812e-01],\n", + " [-6.68597e-01, -6.60616e-01, 3.41414e-01],\n", + " [ 8.20224e-01, -3.72360e-01, 4.34259e-01],\n", + " [-2.05263e-01, -9.02465e-01, -3.78714e-01],\n", + " [-6.37020e-01, -2.83529e-01, 7.16810e-01],\n", + " [ 1.37944e-01, -9.14231e-01, -3.80990e-01],\n", + " [-9.49691e-01, -1.45434e-01, 2.77373e-01],\n", + " [-7.31922e-03, -9.95911e-01, -9.00386e-02],\n", + " [-8.14263e-01, -4.20783e-02, 5.78969e-01],\n", + " [ 1.87418e-01, -9.63210e-01, 1.92618e-01],\n", + " [ 3.30434e-01, 1.92714e-01, 9.23945e-01],\n", + " [ 8.95093e-01, -2.18266e-01, -3.88805e-01],\n", + " [ 3.11358e-01, -3.49170e-01, 8.83819e-01],\n", + " [-6.86317e-01, -7.27289e-01, -4.54356e-03],\n", + " [ 4.92805e-01, -5.14280e-01, -7.01897e-01],\n", + " [-8.03482e-04, -8.56796e-01, 5.15655e-01],\n", + " [-4.77664e-01, -4.45734e-01, -7.57072e-01],\n", + " [ 7.68954e-01, -6.22151e-01, 1.47095e-01],\n", + " [-1.55099e-02, 2.22329e-01, 9.74848e-01],\n", + " [-9.74410e-01, -2.11297e-01, -7.66740e-02],\n", + " [ 2.56251e-01, -7.33793e-01, -6.29193e-01],\n", + " [ 6.24656e-01, -3.42071e-01, 7.01992e-01],\n", + " [-4.61411e-01, -8.64670e-01, 1.98612e-01],\n", + " [ 8.68547e-01, -4.66754e-01, -1.66634e-01]])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "gtab.bvecs[~gtab.b0s_mask]" ] @@ -261,9 +437,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "array([ True, False, False, False, False, False, False, False, False,\n", + " False, False, True, False, False, False, False, False, False,\n", + " False, False, False, False, True, False, False, False, False,\n", + " False, False, False, False, False, False, True, False, False,\n", + " False, False, False, False, False, False, False, False, True,\n", + " False, False, False, False, False, False, False, False, False,\n", + " False, True, False, False, False, False, False, False, False,\n", + " False, False, False, True])" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "gtab.b0s_mask" ] @@ -274,17 +468,38 @@ "source": [ "In the next few notebooks, we will talk more about preprocessing the diffusion weighted images and reconstructing the Tensor model" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercise 1\n", + "\n", + "Get a list of **all** diffusion data in NIfTI file format" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Solution" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "dwi_data = layout.get(suffix='dwi', extension='nii.gz', return_type='file')" + ] } ], "metadata": { "kernelspec": { - "name": "python3", - "display_name": "Python 3.7.4 64-bit ('sdc-dmri_venv': pyenv)", - "metadata": { - "interpreter": { - "hash": "df9a1fb9ddadb6ac6ff99c8fe9ccf963050f17681aeb0dab008e78c4d51aff8c" - } - } + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -296,9 +511,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.4" + "version": "3.8.10" } }, "nbformat": 4, "nbformat_minor": 4 -} \ No newline at end of file +}