purple-mri 0.0.1__tar.gz

purple_mri-0.0.1/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.1
+Name: purple_mri
+Version: 0.0.1
+Summary: purple_mri: Penn Utilities for Registration and ParcelLation of Ex vivo MRI
+Author-email: Pulkit Khandelwal <kpulkit95@gmail.com>
+Project-URL: Homepage, https://github.com/Pulkit-Khandelwal/purple_mri
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: torch
+Requires-Dist: pykeops
+Requires-Dist: pymeshlab
+Requires-Dist: vtk
+Requires-Dist: SimpleITK
+Requires-Dist: geomloss
+
+# purple-mri: **P**enn **U**tilities for **R**egistration and **P**arcel**L**ation of **E**x vivo **MRI**
+
+We provide a set of tools packaged as `purple-mri` for segmentation, parcellation and registration of ultra high-resolution (< 300 microns) postmortem human brain hemisphere at 7 tesla t2w MRI at native subject-space resolution. This pipeline leverages advances in both deep learning and classical surface-based modeling techniques to produce parcellations in any atlas used in neuroimaging. The developed method allows us to perform vertex-wise analysis in the template space and thereby link morphometry measures with pathology measurements derived from histology.
+
+Check out the [project page](https://pulkit-khandelwal.github.io/exvivo-brain-upenn/) and our latest papers [here](https://direct.mit.edu/imag/article/doi/10.1162/imag_a_00171/120741) and [here](https://arxiv.org/abs/2403.19497).
+
+In particular, `purple-mri` allows you to do the following:
++ obtain an initial 10 label segmentation: cortical GM, normal appearing WM, WMH, medial temporal lobe, corpus callosum, ventricles, caudate, putamen, globus pallidus and thalamus
++ obtain surface-based native subject-space parcellation based on different brain atlases such as: DKT, Economo, Schaeffer etc
++ create population specific volumetric and surface-based templates
++ perform exvivo to invivo registration in volumetric intensity space
++ perform surface-to-surface registration between exvivo or invivo
++ perform intensity-based registration between 9.4 tesla MTL to 7 tesla whole hemsiphere registration
++ perform vertex-wise and group-wise generalized linear modeling analysis for exvivo subject population for morphometry and histology
+
+## Steps (for segmentation and parcellation)
+`purple-mri` follows a series of steps making use of bash scripts and Docker.
+
+### Pre-processing
+Perform bias correction and image normalization/standardization. We use `N4BiasFieldCorrection` as part of the CLI tool [ANTs](https://github.com/ANTsX/ANTs) and [`c3d`](http://www.itksnap.org/pmwiki/pmwiki.php?n=Convert3D.Convert3D). We highly recommend using the option of an input mask in `N4BiasFieldCorrection` which can be obtained via corase threhsolding.
+[Here](https://github.com/Pulkit-Khandelwal/upenn-picsl-brain-ex-vivo/tree/main/misc_scripts/perform_bias_correction.sh) is a sample script.
+
+### Deep learning-based initial labeling and CRUISE-based post-hoc topology correction
+Currently, we have two Docker images. The first image provides the segmentation and the second employs [Nighres/CRUISE](https://nighres.readthedocs.io/en/latest/installation.html) for post-hoc topology correction. 
+Please follow the [link]([https://github.com/Pulkit-Khandelwal/upenn-picsl-brain-ex-vivo/blob/main/exvivo-segm-demo-docker.md](https://github.com/Pulkit-Khandelwal/purple-mri/blob/main/docker/exvivo_docker.md) for detailed instructions on how to use Docker to get the segmentations. Some key commands are emphasized here:
+
+Place the pre-processed image(s) (with a suffix _0000.nii.gz to your filenames) in a folder named `data_for_inference` within your working directory is `/your/working/directory`.
+```
+docker pull pulks/docker_hippogang_exvivo_segm:v${LATEST_TAG}
+
+docker run --gpus all --privileged -v /your/working/directory/:/data/exvivo/ -it pulks/docker_hippogang_exvivo_segm:v${LATEST_TAG} /bin/bash -c "bash /src/commands_nnunet_inference.sh ${OPTION}" >> logs.txt
+```
+You will see the output in `/your/working/directory/data_for_inference/output_from_nnunet_inference`.
+
+Next, correct for topology so that adjoining gyri and sulci are clearly separated. Copy the segmentations from `output_from_nnunet_inference` to a folder `data_for_topology_correction` in your wokring directory.
+```
+docker pull pulks/docker_nighres:v1.0.0
+
+docker run -v /your/working/directory/:/data/cruise_files/ -it pulks/docker_nighres:v1.0.0 /bin/bash -c "bash /data/prepare_cruise_files.sh"
+
+# Locally run the file to get the final combined label file. See instructions [here](https://github.com/Pulkit-Khandelwal/upenn-picsl-brain-ex-vivo/blob/main/exvivo-segm-demo-docker.md) and links referenced therein.
+bash clean_labels_final.sh
+```
+
+### Surface-based modeling to obtain whole-hemisphere parcellations
+Once, you have obtained an initial 10-label topology corrected volumetric segmentation, you can proceed to the surface-based pipeline to obtain parcellations based on your favorite atlas. This step will be on your local machine. No GPUs required. To do this, you should have FreeSurfer installed locally. We have used FreeSurfer version 7.4.0 on linux obtained from [here](https://surfer.nmr.mgh.harvard.edu/fswiki/DownloadAndInstall). Moreover, there are some Python dependencies which can be found in the `dependencies.txt` file and installed using `pip`.
+
+Run the following file which calls in several bash scripts which prepares the data, computes appropriate transformations and re-orients the images, corrects surface topology, and perform the parcellation into Desikan-Killiany-Tourville (DKT), Schaefer, Glasser and the Von Economo-Koskinos atlases.
+
+For the surface-based modeling step, we assume that all the hemishpehrs are right hemispheres. So, we suggest flipping the left t2w MRI and its corresponding segmentation to left using the following `c3d` command: `c3d image_left.nii.gz -flip y image_right_flipped.nii.gz`
+
+Clone the current repository and the run the following script `run_surface_pipeline.sh` from within the `purple_mri` folder which takes the following mandatory arguments:
+`freesurfer_path`: path to the FreeSurfer installtion
+`working_dir`: directory which will have the outputs for each subject stored
+`mri_path`: mri images path
+`segm_path`: 10-label segmentation path
+`external_atlases_path`: directory with files for other atlases
+`num_threads`: number of threads
+
+Place your t2w MRI in a folder `mri_path` and the intial deep learning-based segmentations in `segm_path`.
+Make sure your mri images and segmentation files have the same names ending with `.nii.gz`.
+Place the `fsaverage` in the `working_dir` folder.
+
+```
+cd purple_mri
+
+bash run_surface_pipeline.sh freesurfer_path working_dir mri_path segm_path external_atlases_path num_threads
+```
+
+## Other scripts
+### Intensity-based volumetric template building
+We build intensity-based volumetric templates using the [greedy](https://sites.google.com/view/greedyreg/about?authuser=0) tool. The required binaries (for Linux) and the scripts are located in the the `intensity_template` within the `scripts` directory. Follow the instructions [here](https://github.com/Pulkit-Khandelwal/purple-mri/blob/main/scripts/intensity_template/README.md).
+
+
+### Ex vivo and in vivo registration
+Script `exvivo_invivo_greedy_registration.sh` to register in vivo (t1w) and ex vivo (t2w) MRI is located in the folder `scripts`. We use [greedy](https://sites.google.com/view/greedyreg/about?authuser=0) to register the segmentations of in vivo aseg+aparc labels derived from FreeSurfer and 10-label initial deep learning segmentation of postmortem MRI. The warps are then used to regsiter the MRIs.
+
+### Perform GLM analyses
+We perform vertex-wise analysis in `fsaverage` space to fit a generalized linear model (GLM) between cortical thickness (mm) and with global ratings of amyloid-β, Braak staging, CERAD, and semiquantitative ratings of the medial temporal lobe (MTL) neuronal loss and tau pathology, with age, sex and postmortem interval (PMI) as covariates. You can follow the steps detailed [here](https://github.com/Pulkit-Khandelwal/purple-mri/tree/main/glm).
+
+## Notes
++ Our method has been developed to work on a single exvivo hemisphere.
++ The deep learning-based segmentation was primarily trained on 7T t2w MRI. We have tested the model on t2* flash as well and it works pretty well but, if need be, we recommend re-training the model with some manual labels obtained on t2* flash MRI.
+
+## pip package
+
+## Introductory video
+<div align="center">
+      <a href="https://youtu.be/0BOeUtlWlYw?si=7NeNDsoePOW3_J4Y">
+         <img src="https://github.com/Pulkit-Khandelwal/purple-mri/blob/main/images/thumbnail.png" style="width:75%;">
+      </a>
+</div>
+
+## Citations
++ Khandelwal, P., Duong, M. T., Sadaghiani, S., Lim, S., Denning, A. E., Chung, E., ... & Yushkevich, P. A. (2024). Automated deep learning segmentation of high-resolution 7 tesla postmortem MRI for quantitative analysis of structure-pathology correlations in neurodegenerative diseases. Imaging Neuroscience, 2, 1-30.
++ Khandelwal, P., Duong, M. T., Fuentes, C., Denning, A., Trotman, W., Ittyerah, R., ... & Yushkevich, P. A. (2024). Surface-based parcellation and vertex-wise analysis of ultra high-resolution ex vivo 7 tesla MRI in neurodegenerative diseases. arXiv preprint arXiv:2403.19497.
+

purple_mri-0.0.1/README.md

@@ -0,0 +1,97 @@
+# purple-mri: **P**enn **U**tilities for **R**egistration and **P**arcel**L**ation of **E**x vivo **MRI**
+
+We provide a set of tools packaged as `purple-mri` for segmentation, parcellation and registration of ultra high-resolution (< 300 microns) postmortem human brain hemisphere at 7 tesla t2w MRI at native subject-space resolution. This pipeline leverages advances in both deep learning and classical surface-based modeling techniques to produce parcellations in any atlas used in neuroimaging. The developed method allows us to perform vertex-wise analysis in the template space and thereby link morphometry measures with pathology measurements derived from histology.
+
+Check out the [project page](https://pulkit-khandelwal.github.io/exvivo-brain-upenn/) and our latest papers [here](https://direct.mit.edu/imag/article/doi/10.1162/imag_a_00171/120741) and [here](https://arxiv.org/abs/2403.19497).
+
+In particular, `purple-mri` allows you to do the following:
++ obtain an initial 10 label segmentation: cortical GM, normal appearing WM, WMH, medial temporal lobe, corpus callosum, ventricles, caudate, putamen, globus pallidus and thalamus
++ obtain surface-based native subject-space parcellation based on different brain atlases such as: DKT, Economo, Schaeffer etc
++ create population specific volumetric and surface-based templates
++ perform exvivo to invivo registration in volumetric intensity space
++ perform surface-to-surface registration between exvivo or invivo
++ perform intensity-based registration between 9.4 tesla MTL to 7 tesla whole hemsiphere registration
++ perform vertex-wise and group-wise generalized linear modeling analysis for exvivo subject population for morphometry and histology
+
+## Steps (for segmentation and parcellation)
+`purple-mri` follows a series of steps making use of bash scripts and Docker.
+
+### Pre-processing
+Perform bias correction and image normalization/standardization. We use `N4BiasFieldCorrection` as part of the CLI tool [ANTs](https://github.com/ANTsX/ANTs) and [`c3d`](http://www.itksnap.org/pmwiki/pmwiki.php?n=Convert3D.Convert3D). We highly recommend using the option of an input mask in `N4BiasFieldCorrection` which can be obtained via corase threhsolding.
+[Here](https://github.com/Pulkit-Khandelwal/upenn-picsl-brain-ex-vivo/tree/main/misc_scripts/perform_bias_correction.sh) is a sample script.
+
+### Deep learning-based initial labeling and CRUISE-based post-hoc topology correction
+Currently, we have two Docker images. The first image provides the segmentation and the second employs [Nighres/CRUISE](https://nighres.readthedocs.io/en/latest/installation.html) for post-hoc topology correction. 
+Please follow the [link]([https://github.com/Pulkit-Khandelwal/upenn-picsl-brain-ex-vivo/blob/main/exvivo-segm-demo-docker.md](https://github.com/Pulkit-Khandelwal/purple-mri/blob/main/docker/exvivo_docker.md) for detailed instructions on how to use Docker to get the segmentations. Some key commands are emphasized here:
+
+Place the pre-processed image(s) (with a suffix _0000.nii.gz to your filenames) in a folder named `data_for_inference` within your working directory is `/your/working/directory`.
+```
+docker pull pulks/docker_hippogang_exvivo_segm:v${LATEST_TAG}
+
+docker run --gpus all --privileged -v /your/working/directory/:/data/exvivo/ -it pulks/docker_hippogang_exvivo_segm:v${LATEST_TAG} /bin/bash -c "bash /src/commands_nnunet_inference.sh ${OPTION}" >> logs.txt
+```
+You will see the output in `/your/working/directory/data_for_inference/output_from_nnunet_inference`.
+
+Next, correct for topology so that adjoining gyri and sulci are clearly separated. Copy the segmentations from `output_from_nnunet_inference` to a folder `data_for_topology_correction` in your wokring directory.
+```
+docker pull pulks/docker_nighres:v1.0.0
+
+docker run -v /your/working/directory/:/data/cruise_files/ -it pulks/docker_nighres:v1.0.0 /bin/bash -c "bash /data/prepare_cruise_files.sh"
+
+# Locally run the file to get the final combined label file. See instructions [here](https://github.com/Pulkit-Khandelwal/upenn-picsl-brain-ex-vivo/blob/main/exvivo-segm-demo-docker.md) and links referenced therein.
+bash clean_labels_final.sh
+```
+
+### Surface-based modeling to obtain whole-hemisphere parcellations
+Once, you have obtained an initial 10-label topology corrected volumetric segmentation, you can proceed to the surface-based pipeline to obtain parcellations based on your favorite atlas. This step will be on your local machine. No GPUs required. To do this, you should have FreeSurfer installed locally. We have used FreeSurfer version 7.4.0 on linux obtained from [here](https://surfer.nmr.mgh.harvard.edu/fswiki/DownloadAndInstall). Moreover, there are some Python dependencies which can be found in the `dependencies.txt` file and installed using `pip`.
+
+Run the following file which calls in several bash scripts which prepares the data, computes appropriate transformations and re-orients the images, corrects surface topology, and perform the parcellation into Desikan-Killiany-Tourville (DKT), Schaefer, Glasser and the Von Economo-Koskinos atlases.
+
+For the surface-based modeling step, we assume that all the hemishpehrs are right hemispheres. So, we suggest flipping the left t2w MRI and its corresponding segmentation to left using the following `c3d` command: `c3d image_left.nii.gz -flip y image_right_flipped.nii.gz`
+
+Clone the current repository and the run the following script `run_surface_pipeline.sh` from within the `purple_mri` folder which takes the following mandatory arguments:
+`freesurfer_path`: path to the FreeSurfer installtion
+`working_dir`: directory which will have the outputs for each subject stored
+`mri_path`: mri images path
+`segm_path`: 10-label segmentation path
+`external_atlases_path`: directory with files for other atlases
+`num_threads`: number of threads
+
+Place your t2w MRI in a folder `mri_path` and the intial deep learning-based segmentations in `segm_path`.
+Make sure your mri images and segmentation files have the same names ending with `.nii.gz`.
+Place the `fsaverage` in the `working_dir` folder.
+
+```
+cd purple_mri
+
+bash run_surface_pipeline.sh freesurfer_path working_dir mri_path segm_path external_atlases_path num_threads
+```
+
+## Other scripts
+### Intensity-based volumetric template building
+We build intensity-based volumetric templates using the [greedy](https://sites.google.com/view/greedyreg/about?authuser=0) tool. The required binaries (for Linux) and the scripts are located in the the `intensity_template` within the `scripts` directory. Follow the instructions [here](https://github.com/Pulkit-Khandelwal/purple-mri/blob/main/scripts/intensity_template/README.md).
+
+
+### Ex vivo and in vivo registration
+Script `exvivo_invivo_greedy_registration.sh` to register in vivo (t1w) and ex vivo (t2w) MRI is located in the folder `scripts`. We use [greedy](https://sites.google.com/view/greedyreg/about?authuser=0) to register the segmentations of in vivo aseg+aparc labels derived from FreeSurfer and 10-label initial deep learning segmentation of postmortem MRI. The warps are then used to regsiter the MRIs.
+
+### Perform GLM analyses
+We perform vertex-wise analysis in `fsaverage` space to fit a generalized linear model (GLM) between cortical thickness (mm) and with global ratings of amyloid-β, Braak staging, CERAD, and semiquantitative ratings of the medial temporal lobe (MTL) neuronal loss and tau pathology, with age, sex and postmortem interval (PMI) as covariates. You can follow the steps detailed [here](https://github.com/Pulkit-Khandelwal/purple-mri/tree/main/glm).
+
+## Notes
++ Our method has been developed to work on a single exvivo hemisphere.
++ The deep learning-based segmentation was primarily trained on 7T t2w MRI. We have tested the model on t2* flash as well and it works pretty well but, if need be, we recommend re-training the model with some manual labels obtained on t2* flash MRI.
+
+## pip package
+
+## Introductory video
+<div align="center">
+      <a href="https://youtu.be/0BOeUtlWlYw?si=7NeNDsoePOW3_J4Y">
+         <img src="https://github.com/Pulkit-Khandelwal/purple-mri/blob/main/images/thumbnail.png" style="width:75%;">
+      </a>
+</div>
+
+## Citations
++ Khandelwal, P., Duong, M. T., Sadaghiani, S., Lim, S., Denning, A. E., Chung, E., ... & Yushkevich, P. A. (2024). Automated deep learning segmentation of high-resolution 7 tesla postmortem MRI for quantitative analysis of structure-pathology correlations in neurodegenerative diseases. Imaging Neuroscience, 2, 1-30.
++ Khandelwal, P., Duong, M. T., Fuentes, C., Denning, A., Trotman, W., Ittyerah, R., ... & Yushkevich, P. A. (2024). Surface-based parcellation and vertex-wise analysis of ultra high-resolution ex vivo 7 tesla MRI in neurodegenerative diseases. arXiv preprint arXiv:2403.19497.
+

purple_mri-0.0.1/purple_mri/__main__.py

@@ -0,0 +1,13 @@
+import sys
+import subprocess
+
+arg1 = sys.argv[1]
+arg2 = sys.argv[2]
+arg3 = sys.argv[3]
+arg4 = sys.argv[4]
+arg5 = sys.argv[5]
+arg6 = int(sys.argv[6])
+arg7 = sys.argv[7]
+
+subprocess.run("bash run_surface_pipeline.sh %s %s %s %s %s %s %s" \
+                      % (arg1, arg2, arg3, arg4, arg5, arg6, arg7), shell=True)

purple_mri-0.0.1/purple_mri/scripts/create_mesh.sh

@@ -0,0 +1,25 @@
+working_dir=$1
+tgt_dir_FS_mesh=$2
+tgt_dir_FS_mesh_decimated=$3
+str_split=$4
+for i in $str_split; do subjects+=($i) ; done
+
+hemis=rh
+for subj in "${subjects[@]}"
+do
+  echo ${subj}
+  SUBJECTS_DIR=${working_dir}/${subj}
+  
+  mri_pretess ${SUBJECTS_DIR}/mri/filled.mgz 1 ${SUBJECTS_DIR}/mri/mri.mgz ${tgt_dir_FS_mesh}/${subj}_pretess.mgz
+  mri_tessellate ${tgt_dir_FS_mesh}/${subj}_pretess.mgz 1 ${tgt_dir_FS_mesh}/${subj}.orig.nofix
+  mris_convert ${tgt_dir_FS_mesh}/${subj}.orig.nofix ${tgt_dir_FS_mesh}/${subj}.orig.nofix.vtk
+
+  # decimate the vtk file
+  python3 -m purple_mri.scripts.decimate_mesh ${tgt_dir_FS_mesh} ${tgt_dir_FS_mesh_decimated} ${subj}.orig.nofix.vtk ${subj}.decimated.orig.nofix.vtk
+
+  # convert back to FreeSurfer format and this will act as the input to the topology correction step
+  mris_convert ${tgt_dir_FS_mesh_decimated}/${subj}.decimated.orig.nofix.vtk ${tgt_dir_FS_mesh_decimated}/${subj}.decimated.orig.nofix
+
+  cp ${tgt_dir_FS_mesh_decimated}/${subj}.decimated.orig.nofix ${working_dir}/${subj}/surf/${hemis}.orig.nofix
+
+done;

purple_mri-0.0.1/purple_mri/scripts/decimate_mesh.py

@@ -0,0 +1,296 @@
+import os
+import sys
+import numpy as np
+import torch
+from torch.autograd import grad
+import vtk
+from vtk.util.numpy_support import vtk_to_numpy, numpy_to_vtk
+import pymeshlab
+import pandas as pd
+from pykeops.torch import Vi, Vj
+
+# torch type and device
+use_cuda = torch.cuda.is_available()
+torchdeviceId = torch.device("cuda:0") if use_cuda else "cpu"
+torchdtype = torch.float32
+
+# PyKeOps counterpart
+KeOpsdeviceId = torchdeviceId.index  # id of Gpu device (in case GPU is  used)
+KeOpsdtype = torchdtype.__str__().split(".")[1]  # 'float32'
+
+use_cuda = torch.cuda.is_available()
+torchdeviceId = torch.device("cuda:0") if use_cuda else "cpu"
+
+# Read VTK mesh
+def load_vtk(filename):
+    rd = vtk.vtkPolyDataReader()
+    rd.SetFileName(filename)
+    rd.Update()
+    return rd.GetOutput()
+
+# Read points from the polydata
+def vtk_get_points(pd):
+    return vtk_to_numpy(pd.GetPoints().GetData())
+
+# Read the faces from the polydata
+def vtk_get_triangles(pd):
+    return vtk_to_numpy(pd.GetPolys().GetData()).reshape(-1,4)[:,1:]
+
+# Map all point arrays to cell arrays
+def vtk_all_point_arrays_to_cell_arrays(pd):
+    flt = vtk.vtkPointDataToCellData()
+    flt.SetInputData(pd)
+    flt.Update()
+    return flt.GetOutput()
+
+# Read a point array
+def vtk_get_point_array(pd, name):
+    a = pd.GetPointData().GetArray(name)
+    return vtk_to_numpy(a) if a is not None else None
+
+# Add a cell array to a mesh
+def vtk_set_point_array(pd, name, array, array_type=vtk.VTK_FLOAT):
+    a = numpy_to_vtk(array, array_type=array_type)
+    a.SetName(name)
+    pd.GetPointData().AddArray(a)
+
+# Read a cell array
+def vtk_get_cell_array(pd, name):
+    a = pd.GetCellData().GetArray(name)
+    return vtk_to_numpy(a) if a is not None else None
+
+# Add a cell array to a mesh
+def vtk_set_cell_array(pd, name, array):
+    a = numpy_to_vtk(array)
+    a.SetName(name)
+    pd.GetCellData().AddArray(a)
+
+# Make a VTK polydata from vertices and triangles
+def vtk_make_pd(v, f):
+    pd = vtk.vtkPolyData()
+    pts = vtk.vtkPoints()
+    pts.SetData(numpy_to_vtk(v))
+    pd.SetPoints(pts)
+    ca = vtk.vtkCellArray()
+    ca.SetCells(f.shape[0], numpy_to_vtk(np.insert(f, 0, 3, axis=1).ravel(), array_type=vtk.VTK_ID_TYPE))
+    pd.SetPolys(ca)
+    return pd
+
+# Save VTK polydata
+def save_vtk(pd, filename, binary = False):
+    wr=vtk.vtkPolyDataWriter()
+    wr.SetFileName(filename)
+    wr.SetInputData(pd)
+    #wr.SetFileVersion(1)
+    wr.SetFileVersion(42)
+    #wr.SetFileFormat(1,2)
+    if binary:
+        wr.SetFileTypeToBinary()
+    wr.Update()
+
+# Reduction using pymeshlab
+def decimate(v, f, target_faces):
+    ms = pymeshlab.MeshSet()
+    ms.add_mesh(pymeshlab.Mesh(vertex_matrix=v, face_matrix=f))
+    ms.meshing_decimation_quadric_edge_collapse(targetfacenum=target_faces,
+                                                preserveboundary=True,
+                                                preservenormal=True,
+                                                preservetopology=True,
+                                                planarquadric=True)
+    m0 = ms.mesh(0)
+    return m0.vertex_matrix(), m0.face_matrix()
+
+
+# For LDDMM
+def GaussKernel(sigma):
+    x, y, b = Vi(0, 3), Vj(1, 3), Vj(2, 3)
+    gamma = 1 / (sigma * sigma)
+    D2 = x.sqdist(y)
+    K = (-D2 * gamma).exp()
+    return (K * b).sum_reduction(axis=1)
+
+# For Varifold
+def GaussLinKernel(sigma):
+    x, y, u, v, b = Vi(0, 3), Vj(1, 3), Vi(2, 3), Vj(3, 3), Vj(4, 1)
+    gamma = 1 / (sigma * sigma)
+    D2 = x.sqdist(y)
+    K = (-D2 * gamma).exp() * (u * v).sum() ** 2
+    return (K * b).sum_reduction(axis=1)
+
+# For Currents
+def GaussLinCurrentsKernel(sigma):
+    x, y, u, v = Vi(0, 3), Vj(1, 3), Vi(2, 3), Vj(3, 3)
+    gamma = 1 / (sigma * sigma)
+    D2 = x.sqdist(y)
+    K = (-D2 * gamma).exp() * (u * v).sum()
+    return K.sum_reduction(axis=1)
+
+# For Currents
+def GaussLinCurrentsKernel(sigma):
+    x, y, u, v = Vi(0, 3), Vj(1, 3), Vi(2, 3), Vj(3, 3)
+    gamma = 1 / (sigma * sigma)
+    D2 = x.sqdist(y)
+    K = (-D2 * gamma).exp() * (u * v).sum()
+    return K.sum_reduction(axis=1)
+
+# For Currents to match C++ code
+def GaussLinCurrentsKernelC(sigma):
+    x, y, u, v = Vi(0, 3), Vj(1, 3), Vi(2, 3), Vj(3, 3)
+    gamma = 1 / (2 * sigma * sigma)
+    D2 = x.sqdist(y)
+    K = (-D2 * gamma).exp() * (u * v).sum() * 0.5
+    return K.sum_reduction(axis=1)
+
+
+# Forward integration
+def RalstonIntegrator():
+    def f(ODESystem, x0, nt, deltat=1.0):
+        x = tuple(map(lambda x: x.clone(), x0))
+        dt = deltat / nt
+        l = [x]
+        for i in range(nt):
+            xdot = ODESystem(*x)
+            xi = tuple(map(lambda x, xdot: x + (2 * dt / 3) * xdot, x, xdot))
+            xdoti = ODESystem(*xi)
+            x = tuple(
+                map(
+                    lambda x, xdot, xdoti: x + (0.25 * dt) * (xdot + 3 * xdoti),
+                    x,
+                    xdot,
+                    xdoti,
+                )
+            )
+            l.append(x)
+        return l
+
+    return f
+
+# LDDMM definitions
+
+def Hamiltonian(K):
+    def H(p, q):
+        return 0.5 * (p * K(q, q, p)).sum()
+
+    return H
+
+
+def HamiltonianSystem(K):
+    H = Hamiltonian(K)
+
+    def HS(p, q):
+        Gp, Gq = grad(H(p, q), (p, q), create_graph=True)
+        return -Gq, Gp
+
+    return HS
+
+def Shooting(p0, q0, K, nt=10, Integrator=RalstonIntegrator()):
+    return Integrator(HamiltonianSystem(K), (p0, q0), nt)
+
+
+def Flow(x0, p0, q0, K, deltat=1.0, Integrator=RalstonIntegrator()):
+    HS = HamiltonianSystem(K)
+
+    def FlowEq(x, p, q):
+        return (K(x, q, p),) + HS(p, q)
+
+    return Integrator(FlowEq, (x0, p0, q0), deltat)[0]
+
+
+def LDDMMloss(K, dataloss, gamma=0):
+    def loss(p0, q0):
+        p, q = Shooting(p0, q0, K)[-1]
+        return gamma * Hamiltonian(K)(p0, q0) + dataloss(q)
+
+    return loss
+
+# Basic Varifold loss
+# VT: vertices coordinates of target surface,
+# FS,FT : Face connectivity of source and target surfaces
+# K kernel
+def lossVarifoldSurf(FS, VT, FT, K):
+    def get_center_length_normal(F, V):
+        V0, V1, V2 = (
+            V.index_select(0, F[:, 0]),
+            V.index_select(0, F[:, 1]),
+            V.index_select(0, F[:, 2]),
+        )
+        centers, normals = (V0 + V1 + V2) / 3, 0.5 * torch.cross(V1 - V0, V2 - V0)
+        length = (normals**2).sum(dim=1)[:, None].sqrt()
+        return centers, length, normals / length
+
+    CT, LT, NTn = get_center_length_normal(FT, VT)
+    cst = (LT * K(CT, CT, NTn, NTn, LT)).sum()
+
+    def loss(VS):
+        CS, LS, NSn = get_center_length_normal(FS, VS)
+        return (
+            cst
+            + (LS * K(CS, CS, NSn, NSn, LS)).sum()
+            - 2 * (LS * K(CS, CT, NSn, NTn, LT)).sum()
+        )
+
+    return loss
+
+
+# Also implement a basic currents loss
+def lossCurrentsSurf(FS, VT, FT, K):
+    def get_center_length_normal(F, V):
+        V0, V1, V2 = (
+            V.index_select(0, F[:, 0]),
+            V.index_select(0, F[:, 1]),
+            V.index_select(0, F[:, 2]),
+        )
+        centers, normals = (V0 + V1 + V2) / 3, 0.5 * torch.cross(V1 - V0, V2 - V0)
+        return centers, normals
+
+    CT, NT = get_center_length_normal(FT, VT)
+    cst = K(CT, CT, NT, NT).sum()
+    
+    def loss(VS):
+        CS, NS = get_center_length_normal(FS, VS)
+        tt,ss,st = cst, K(CS, CS, NS, NS).sum(), 2 * K(CS, CT, NS, NT).sum()
+        print(f'tt: {tt}, ss: {ss}, st: {st}')
+        return (
+            cst
+            + K(CS, CS, NS, NS).sum()
+            - 2 * K(CS, CT, NS, NT).sum()
+        )
+
+    return loss
+
+# This function loads a mesh and extracts derived objects/tensors
+def load_mesh(fn, target_faces=None):
+    pd = vtk_all_point_arrays_to_cell_arrays(load_vtk(fn))
+    v, f = vtk_get_points(pd), vtk_get_triangles(pd)
+    if target_faces:
+        v, f = decimate(v, f, target_faces)
+    #lp = mesh_label_prob_maps(pd)
+    return {
+        'fn': fn,
+        'pd': pd,
+        'v': v,
+        'f': f,
+        #'lp': lp,
+        'vt': torch.tensor(v, dtype=torchdtype, device=torchdeviceId).contiguous(),
+        'ft': torch.tensor(f, dtype=torch.long, device=torchdeviceId).contiguous()
+        #'lpt': torch.tensor(lp, dtype=torchdtype, device=torchdeviceId).contiguous()
+    }
+
+
+def closure():
+    optimizer.zero_grad()
+    L = loss(p0, q0)
+    print("loss", L.detach().cpu().numpy())
+    L.backward()
+    return L
+
+print("decimating the mesh............")
+src_path=str(sys.argv[1])
+tgt_path=str(sys.argv[2])
+
+md_src = load_mesh(os.path.join(src_path, sys.argv[3]))
+print(md_src.keys(), len(md_src['f']), len(md_src['v']))
+
+v_dec, f_dec = decimate(md_src['v'], md_src['f'], 300000)
+print(len(v_dec), len(f_dec))
+save_vtk(vtk_make_pd(v_dec, f_dec), os.path.join(tgt_path, sys.argv[4]))

purple_mri-0.0.1/purple_mri/scripts/do_mni_txs.sh

@@ -0,0 +1,32 @@
+freesurfer_path=$1
+working_dir=$2
+str_split=$3
+hemis=rh
+for i in $str_split; do subjects+=($i) ; done
+
+for subj in "${subjects[@]}"
+do
+
+  echo ${subj}
+  SUBJECTS_DIR=${working_dir}/${subj}
+  
+  mri_convert ${SUBJECTS_DIR}/mri/rawavg.mgz ${SUBJECTS_DIR}/mri/orig_conform.mgz --conform
+  
+  tkregister2 --mov ${SUBJECTS_DIR}/mri/rawavg.mgz --targ ${SUBJECTS_DIR}/mri/orig_conform.mgz \
+  --reg ${SUBJECTS_DIR}/mri/transforms/register.native.dat --regheader-center \
+  --noedit --ltaout ${SUBJECTS_DIR}/mri/transforms/init_for_mris_register.lta
+  
+  mri_add_xform_to_header -c ${SUBJECTS_DIR}/mri/transforms/talairach.xfm ${SUBJECTS_DIR}/mri/orig_conform.mgz ${SUBJECTS_DIR}/mri/orig_conform.mgz
+  
+  mri_info ${SUBJECTS_DIR}/mri/orig_conform.mgz
+  
+  ${freesurfer_path}/bin/talairach_avi --i ${SUBJECTS_DIR}/mri/orig_conform.mgz --xfm ${SUBJECTS_DIR}/mri/transforms/talairach.auto.xfm
+  
+  cp ${SUBJECTS_DIR}/mri/transforms/talairach.auto.xfm ${SUBJECTS_DIR}/mri/transforms/talairach.xfm
+  
+  lta_convert --src ${SUBJECTS_DIR}/mri/orig_conform.mgz --trg /data/pulkit/exvivo_reg_reconstruct/freesurfer_installation/freesurfer/average/mni305.cor.mgz \
+  --inxfm ${SUBJECTS_DIR}/mri/transforms/talairach.xfm --outlta ${SUBJECTS_DIR}/mri/transforms/talairach.xfm.lta --subject fsaverage --ltavox2vox
+  
+  mri_add_xform_to_header -c ${SUBJECTS_DIR}/mri/transforms/talairach.xfm ${SUBJECTS_DIR}/mri/orig_conform.mgz ${SUBJECTS_DIR}/mri/orig_conform.mgz
+
+done;

purple_mri-0.0.1/purple_mri/scripts/make_fs_directories.sh

@@ -0,0 +1,43 @@
+working_dir=$1
+generated_files_folder=$2
+mri_dir=$3
+str_split=$4
+for i in $str_split; do subjects+=($i) ; done
+
+hemis=rh
+for subj in "${subjects[@]}"
+do
+  echo ${subj}
+
+  SUBJECTS_DIR=${working_dir}/${subj}
+  mkdir -p ${SUBJECTS_DIR}
+
+  mkdir -p ${SUBJECTS_DIR}/mri \
+  ${SUBJECTS_DIR}/surf \
+  ${SUBJECTS_DIR}/scripts \
+  ${SUBJECTS_DIR}/label \
+  ${SUBJECTS_DIR}/stats \
+  ${SUBJECTS_DIR}/mri/transforms
+
+  mri_convert ${mri_dir}/${subj}.nii.gz ${SUBJECTS_DIR}/mri/${subj}.mgz
+
+  cp ${SUBJECTS_DIR}/mri/${subj}.mgz ${SUBJECTS_DIR}/mri/mri.mgz
+  cp ${SUBJECTS_DIR}/mri/${subj}.mgz ${SUBJECTS_DIR}/mri/brain.mgz
+  cp ${SUBJECTS_DIR}/mri/${subj}.mgz ${SUBJECTS_DIR}/mri/brainmask.mgz
+  cp ${SUBJECTS_DIR}/mri/${subj}.mgz ${SUBJECTS_DIR}/mri/brain.finalsurfs.mgz
+  cp ${SUBJECTS_DIR}/mri/${subj}.mgz ${SUBJECTS_DIR}/mri/rawavg.mgz
+  cp ${SUBJECTS_DIR}/mri/${subj}.mgz ${SUBJECTS_DIR}/mri/norm.mgz
+  cp ${SUBJECTS_DIR}/mri/${subj}.mgz ${SUBJECTS_DIR}/mri/nu.mgz
+  cp ${SUBJECTS_DIR}/mri/${subj}.mgz ${SUBJECTS_DIR}/mri/orig.mgz
+  cp ${SUBJECTS_DIR}/mri/${subj}.mgz ${SUBJECTS_DIR}/mri/T1.mgz
+
+  cp ${generated_files_folder}/${subj}_filled.mgz ${SUBJECTS_DIR}/mri/filled.mgz
+  cp ${generated_files_folder}/${subj}_wm.mgz ${SUBJECTS_DIR}/mri/wm.mgz
+  
+  cp ${generated_files_folder}/${subj}_aseg.presurf.mgz ${SUBJECTS_DIR}/mri/aseg.presurf.mgz
+  cp ${generated_files_folder}/${subj}_aseg.presurf_100.mgz ${SUBJECTS_DIR}/mri/aseg.presurf_100.mgz
+  cp ${generated_files_folder}/${subj}_aseg.mgz ${SUBJECTS_DIR}/mri/aseg.mgz
+  cp ${generated_files_folder}/${subj}_rh.ribbon.mgz ${SUBJECTS_DIR}/mri/${hemis}.ribbon.mgz
+  cp ${generated_files_folder}/${subj}.ribbon.mgz ${SUBJECTS_DIR}/mri/ribbon.mgz
+
+done;

purple_mri-0.0.1/purple_mri/scripts/parcellation.sh

@@ -0,0 +1,236 @@
+working_dir=$1
+str_split=$2
+freesurfer_path=$3
+num_threads=$4
+external_atlases_path=$5
+autodet_stats_dat=$6
+for i in $str_split; do subjects+=($i) ; done
+
+hemis=rh
+hemis_other=lh
+for subj in "${subjects[@]}"
+do
+echo ${subj}
+start=$SECONDS
+
+SUBJECTS_DIR=${working_dir}
+
+######### segm_parc file
+mris_place_surface --adgws-in ${autodet_stats_dat} \
+--wm ${SUBJECTS_DIR}/${subj}/mri/wm.mgz --threads ${num_threads} --invol ${SUBJECTS_DIR}/${subj}/mri/aseg.presurf_100.mgz --${hemis} \
+--i ${SUBJECTS_DIR}/${subj}/surf/${hemis}.orig \
+--o ${SUBJECTS_DIR}/${subj}/surf/${hemis}.white.preaparc --white --seg ${SUBJECTS_DIR}/${subj}/mri/aseg.presurf.mgz
+
+mri_label2label --label-cortex ${SUBJECTS_DIR}/${subj}/surf/${hemis}.white.preaparc ${SUBJECTS_DIR}/${subj}/mri/aseg.presurf.mgz 0 ${SUBJECTS_DIR}/${subj}/label/${hemis}.cortex.label
+
+mris_smooth -n 3 -nw ${SUBJECTS_DIR}/${subj}/surf/${hemis}.white.preaparc ${SUBJECTS_DIR}/${subj}/surf/${hemis}.smoothwm
+mris_inflate ${SUBJECTS_DIR}/${subj}/surf/${hemis}.smoothwm ${SUBJECTS_DIR}/${subj}/surf/${hemis}.inflated
+
+mris_curvature -w ${SUBJECTS_DIR}/${subj}/surf/${hemis}.white.preaparc
+mris_curvature -thresh .999 -n -a 5 -w -distances 10 10 ${SUBJECTS_DIR}/${subj}/surf/${hemis}.inflated
+
+mris_sphere ${SUBJECTS_DIR}/${subj}/surf/${hemis}.inflated ${SUBJECTS_DIR}/${subj}/surf/${hemis}.sphere
+
+mris_register -curv -threads ${num_threads} -inflated -init \
+-reg ${SUBJECTS_DIR}/${subj}/mri/transforms/init_for_mris_register.lta \
+${SUBJECTS_DIR}/${subj}/surf/${hemis}.sphere ${freesurfer_path}/average/${hemis}.folding.atlas.acfb40.noaparc.i12.2016-08-02.tif ${SUBJECTS_DIR}/${subj}/surf/${hemis}.sphere.reg
+
+ln -sf ${hemis}.sphere.reg ${hemis}.fsaverage.sphere.reg
+
+mris_jacobian ${SUBJECTS_DIR}/${subj}/surf/${hemis}.white.preaparc ${SUBJECTS_DIR}/${subj}/surf/${hemis}.sphere.reg ${SUBJECTS_DIR}/${subj}/surf/${hemis}.jacobian_white
+mrisp_paint -a 5 ${freesurfer_path}/average/${hemis}.folding.atlas.acfb40.noaparc.i12.2016-08-02.tif#6 ${SUBJECTS_DIR}/${subj}/surf/${hemis}.sphere.reg ${SUBJECTS_DIR}/${subj}/surf/${hemis}.avg_curv 
+
+mris_ca_label -l ${SUBJECTS_DIR}/${subj}/label/${hemis}.cortex.label -aseg ${SUBJECTS_DIR}/${subj}/mri/aseg.presurf.mgz ${subj} ${hemis} ${SUBJECTS_DIR}/${subj}/surf/${hemis}.sphere.reg ${freesurfer_path}/average/${hemis}.DKaparc.atlas.acfb40.noaparc.i12.2016-08-02.gcs ${SUBJECTS_DIR}/${subj}/label/${hemis}.aparc.annot 
+
+SUBJECTS_DIR=${working_dir}
+
+cd ${SUBJECTS_DIR}/${subj}/mri
+mris_place_surface --adgws-in ${autodet_stats_dat} \
+--seg aseg.presurf.mgz --threads ${num_threads} --wm wm.mgz --invol aseg.presurf_100.mgz --${hemis} --i ../surf/${hemis}.white.preaparc --o ../surf/${hemis}.white --white --nsmooth 0 \
+--rip-label ../label/${hemis}.cortex.label --rip-bg --rip-surf ../surf/${hemis}.white.preaparc --aparc ../label/${hemis}.aparc.annot
+
+cd ${SUBJECTS_DIR}/${subj}/mri
+mris_place_surface --adgws-in ${autodet_stats_dat} \
+--seg aseg.presurf.mgz --threads ${num_threads} --wm wm.mgz \
+--invol aseg.presurf_100.mgz --${hemis} --i ../surf/${hemis}.white --o ../surf/${hemis}.pial.T1 --pial --nsmooth 0 \
+--pin-medial-wall ../label/${hemis}.cortex.label --aparc ../label/${hemis}.aparc.annot \
+--repulse-surf ../surf/${hemis}.white --white-surf ../surf/${hemis}.white \
+--no-rip --intensity 10.00 --curv 10.00
+
+cp ${SUBJECTS_DIR}/${subj}/surf/${hemis}.pial.T1 ${SUBJECTS_DIR}/${subj}/surf/${hemis}.pial
+
+######## white curv
+cd ${SUBJECTS_DIR}/${subj}/mri
+mris_place_surface --curv-map ../surf/${hemis}.white 2 10 ../surf/${hemis}.curv
+
+######## white area
+cd ${SUBJECTS_DIR}/${subj}/mri
+mris_place_surface --area-map ../surf/${hemis}.white ../surf/${hemis}.area
+
+######## pial curv
+cd ${SUBJECTS_DIR}/${subj}/mri
+mris_place_surface --curv-map ../surf/${hemis}.pial 2 10 ../surf/${hemis}.curv.pial
+
+######## pial area
+cd ${SUBJECTS_DIR}/${subj}/mri
+mris_place_surface --area-map ../surf/${hemis}.pial ../surf/${hemis}.area.pial
+
+######## thickness
+cd ${SUBJECTS_DIR}/${subj}/mri
+mris_place_surface --thickness ../surf/${hemis}.white ../surf/${hemis}.pial 20 5 ../surf/${hemis}.thickness
+
+######## area and vertex vol
+cd ${SUBJECTS_DIR}/${subj}/mri
+mris_place_surface --thickness ../surf/${hemis}.white ../surf/${hemis}.pial 20 5 ../surf/${hemis}.thickness
+
+mris_curvature_stats -m --writeCurvatureFiles -G -o ${SUBJECTS_DIR}/${subj}/stats/${hemis}.curv.stats -F smoothwm ${subj} ${hemis} curv sulc
+
+######## Cortical Parc 2
+cd ${SUBJECTS_DIR}/${subj}/mri
+mris_ca_label -l ../label/${hemis}.cortex.label -aseg ../mri/aseg.presurf.mgz ${subj} ${hemis} ../surf/${hemis}.sphere.reg ${freesurfer_path}/average/${hemis}.CDaparc.atlas.acfb40.noaparc.i12.2016-08-02.gcs ../label/${hemis}.aparc.a2009s.annot 
+
+######## Cortical Parc 3
+cd ${SUBJECTS_DIR}/${subj}/mri
+mris_ca_label -l ../label/${hemis}.cortex.label -aseg ../mri/aseg.presurf.mgz ${subj} ${hemis} ../surf/${hemis}.sphere.reg ${freesurfer_path}/average/${hemis}.DKTaparc.atlas.acfb40.noaparc.i12.2016-08-02.gcs ../label/${hemis}.aparc.DKTatlas.annot 
+
+ln -sf ${hemis}.sphere.reg ${hemis}.fsaverage.sphere.reg 
+
+SUBJECTS_DIR=${working_dir}
+
+##### Cortical Parc Schaefer atlas: 7 and 17 networks
+cd ${SUBJECTS_DIR}/${subj}/mri
+mri_surf2surf --hemi ${hemis} \
+  --srcsubject fsaverage \
+  --trgsubject ${subj} \
+  --sval-annot ${external_atlases_path}/schaefer/${hemis}.Schaefer2018_400Parcels_17Networks_order.annot \
+  --tval ${SUBJECTS_DIR}/${subj}/label/${hemis}.aparc.Schaefer2018_400Parcels_17Networks.annot
+
+##### Economo-Koskinos atlas
+cd ${SUBJECTS_DIR}/${subj}/mri
+mris_ca_label -t ${external_atlases_path}/economo/${hemis}.colortable.txt ${subj} ${hemis} ../surf/${hemis}.sphere.reg ${external_atlases_path}/economo/${hemis}.economo.gcs \
+${SUBJECTS_DIR}/${subj}/label/${hemis}.economo.annot
+
+##### Glasser atlas
+cd ${SUBJECTS_DIR}/${subj}/mri
+mri_surf2surf --hemi ${hemis} \
+  --srcsubject fsaverage \
+  --trgsubject ${subj} \
+  --sval-annot ${external_atlases_path}/glasser/${hemis}.HCP-MMP1.annot \
+  --tval ${SUBJECTS_DIR}/${subj}/label/${hemis}.aparc.HCP-MMP1.glasser.annot
+
+SUBJECTS_DIR=${working_dir}
+
+######## dummy left hemis needed for stats computation
+cp ${SUBJECTS_DIR}/${subj}/surf/${hemis}.white ${SUBJECTS_DIR}/${subj}/surf/${hemis_other}.white
+cp ${SUBJECTS_DIR}/${subj}/surf/${hemis}.pial ${SUBJECTS_DIR}/${subj}/surf/${hemis_other}.pial
+cp ${SUBJECTS_DIR}/${subj}/surf/${hemis}.orig.nofix ${SUBJECTS_DIR}/${subj}/surf/${hemis_other}.orig.nofix
+cp ${SUBJECTS_DIR}/${subj}/label/${hemis}.cortex.label ${SUBJECTS_DIR}/${subj}/label/${hemis_other}.cortex.label
+cp ${SUBJECTS_DIR}/${subj}/label/${hemis}.aparc.annot ${SUBJECTS_DIR}/${subj}/label/${hemis_other}.aparc.annot 
+cp ${SUBJECTS_DIR}/${subj}/label/${hemis}.aparc.DKTatlas.annot ${SUBJECTS_DIR}/${subj}/label/${hemis_other}.aparc.DKTatlas.annot
+cp ${SUBJECTS_DIR}/${subj}/label/${hemis}.aparc.a2009s.annot ${SUBJECTS_DIR}/${subj}/label/${hemis_other}.aparc.a2009s.annot
+
+pctsurfcon --s ${subj} --${hemis}-only
+
+mri_brainvol_stats --subject ${subj}
+
+######## AParc-to-ASeg aparc
+cd ${SUBJECTS_DIR}/${subj}/mri
+mri_surf2volseg --o aparc+aseg.mgz --label-cortex --i aseg.mgz --threads ${num_threads} \
+--lh-annot ${SUBJECTS_DIR}/${subj}/label/lh.aparc.annot 1000 \
+--lh-cortex-mask ${SUBJECTS_DIR}/${subj}/label/lh.cortex.label \
+--lh-white ${SUBJECTS_DIR}/${subj}/surf/lh.white \
+--lh-pial ${SUBJECTS_DIR}/${subj}/surf/lh.pial \
+--rh-annot ${SUBJECTS_DIR}/${subj}/label/rh.aparc.annot 2000 \
+--rh-cortex-mask ${SUBJECTS_DIR}/${subj}/label/rh.cortex.label \
+--rh-white ${SUBJECTS_DIR}/${subj}/surf/rh.white \
+--rh-pial ${SUBJECTS_DIR}/${subj}/surf/rh.pial
+
+######## AParc-to-ASeg aparc.a2009s
+cd ${SUBJECTS_DIR}/${subj}/mri
+mri_surf2volseg --o aparc.a2009s+aseg.mgz \
+--label-cortex --i aseg.mgz --threads ${num_threads} \
+--lh-annot ${SUBJECTS_DIR}/${subj}/label/lh.aparc.a2009s.annot 11100 \
+--lh-cortex-mask ${SUBJECTS_DIR}/${subj}/label/lh.cortex.label \
+--lh-white ${SUBJECTS_DIR}/${subj}/surf/lh.white \
+--lh-pial ${SUBJECTS_DIR}/${subj}/surf/lh.pial \
+--rh-annot ${SUBJECTS_DIR}/${subj}/label/rh.aparc.a2009s.annot 12100 \
+--rh-cortex-mask ${SUBJECTS_DIR}/${subj}/label/rh.cortex.label \
+--rh-white ${SUBJECTS_DIR}/${subj}/surf/rh.white \
+--rh-pial ${SUBJECTS_DIR}/${subj}/surf/rh.pial
+
+######## AParc-to-ASeg aparc.DKTatlas
+cd ${SUBJECTS_DIR}/${subj}/mri
+mri_surf2volseg --o aparc.DKTatlas+aseg.mgz \
+--label-cortex --i aseg.mgz --threads ${num_threads} \
+--lh-annot ${SUBJECTS_DIR}/${subj}/label/lh.aparc.DKTatlas.annot 1000 \
+--lh-cortex-mask ${SUBJECTS_DIR}/${subj}/label/lh.cortex.label \
+--lh-white ${SUBJECTS_DIR}/${subj}/surf/lh.white \
+--lh-pial ${SUBJECTS_DIR}/${subj}/surf/lh.pial \
+--rh-annot ${SUBJECTS_DIR}/${subj}/label/rh.aparc.DKTatlas.annot 2000 \
+--rh-cortex-mask ${SUBJECTS_DIR}/${subj}/label/rh.cortex.label \
+--rh-white ${SUBJECTS_DIR}/${subj}/surf/rh.white \
+--rh-pial ${SUBJECTS_DIR}/${subj}/surf/rh.pial
+
+######## WMParc
+cd ${SUBJECTS_DIR}/${subj}/mri
+mri_surf2volseg --o wmparc.mgz \
+--label-wm --i aparc+aseg.mgz --threads ${num_threads} \
+--lh-annot ${SUBJECTS_DIR}/${subj}/label/lh.aparc.annot 3000 \
+--lh-cortex-mask ${SUBJECTS_DIR}/${subj}/label/lh.cortex.label \
+--lh-white ${SUBJECTS_DIR}/${subj}/surf/lh.white \
+--lh-pial ${SUBJECTS_DIR}/${subj}/surf/lh.pial \
+--rh-annot ${SUBJECTS_DIR}/${subj}/label/rh.aparc.annot 4000 \
+--rh-cortex-mask ${SUBJECTS_DIR}/${subj}/label/rh.cortex.label \
+--rh-white ${SUBJECTS_DIR}/${subj}/surf/rh.white \
+--rh-pial ${SUBJECTS_DIR}/${subj}/surf/rh.pial
+
+cd ${SUBJECTS_DIR}/${subj}
+mri_segstats --seg mri/wmparc.mgz \
+--sum stats/wmparc.stats --pv mri/norm.mgz \
+--excludeid 0 --brainmask mri/brainmask.mgz --in mri/norm.mgz \
+--in-intensity-name norm --in-intensity-units MR \
+--subject ${subj} \
+--surf-wm-vol --ctab ${freesurfer_path}/WMParcStatsLUT.txt --etiv
+
+######## Parcellation Stats
+mris_anatomical_stats -th3 -mgz \
+-cortex ${SUBJECTS_DIR}/${subj}/label/${hemis}.cortex.label \
+-f ${SUBJECTS_DIR}/${subj}/stats/${hemis}.aparc.stats \
+-b -a ${SUBJECTS_DIR}/${subj}/label/${hemis}.aparc.annot \
+-c ${SUBJECTS_DIR}/${subj}/label/aparc.annot.ctab ${subj} ${hemis} white
+
+mri_brainvol_stats --subject ${subj}
+
+mris_anatomical_stats -th3 -mgz \
+-cortex ${SUBJECTS_DIR}/${subj}/label/${hemis}.cortex.label \
+-f ${SUBJECTS_DIR}/${subj}/stats/${hemis}.aparc.pial.stats \
+-b -a ${SUBJECTS_DIR}/${subj}/label/${hemis}.aparc.annot \
+-c ${SUBJECTS_DIR}/${subj}/label/aparc.annot.ctab ${subj} ${hemis} pial
+
+######## Parcellation Stats 2
+mris_anatomical_stats -th3 -mgz \
+-cortex ${SUBJECTS_DIR}/${subj}/label/${hemis}.cortex.label \
+-f ${SUBJECTS_DIR}/${subj}/stats/${hemis}.aparc.a2009s.stats \
+-b -a ${SUBJECTS_DIR}/${subj}/label/${hemis}.aparc.a2009s.annot \
+-c ${SUBJECTS_DIR}/${subj}/label/aparc.annot.a2009s.ctab ${subj} ${hemis} white
+
+######## Parcellation Stats 3
+mris_anatomical_stats -th3 -mgz \
+-cortex ${SUBJECTS_DIR}/${subj}/label/${hemis}.cortex.label \
+-f ${SUBJECTS_DIR}/${subj}/stats/${hemis}.aparc.DKTatlas.stats \
+-b -a ${SUBJECTS_DIR}/${subj}/label/${hemis}.aparc.DKTatlas.annot \
+-c ${SUBJECTS_DIR}/${subj}/label/aparc.annot.DKTatlas.ctab ${subj} ${hemis} white
+
+######## ASeg Stats
+mri_segstats --seg ${SUBJECTS_DIR}/${subj}/mri/aseg.mgz \
+--sum ${SUBJECTS_DIR}/${subj}/stats/aseg.stats --pv ${SUBJECTS_DIR}/${subj}/mri/norm.mgz \
+--empty --brainmask ${SUBJECTS_DIR}/${subj}/mri/brainmask.mgz --brain-vol-from-seg \
+--excludeid 0 --excl-ctxgmwm --supratent --subcortgray \
+--in ${SUBJECTS_DIR}/${subj}/mri/norm.mgz --in-intensity-name norm --in-intensity-units MR \
+--etiv --surf-wm-vol --surf-ctx-vol --totalgray --euler \
+--ctab ${freesurfer_path}/ASegStatsLUT.txt \
+--subject ${subj}
+
+duration=$(( SECONDS - start ))
+echo "total time for this subject:" $duration
+done

purple_mri-0.0.1/purple_mri/scripts/prepare_segm_files.sh

@@ -0,0 +1,37 @@
+working_dir=$1
+str_split=$2
+generated_files_folder=$3
+segm_path=$4
+for i in $str_split; do subjects+=($i) ; done
+
+for subj in "${subjects[@]}"
+do
+    echo ${subj}
+
+    cp ${segm_path}/${subj}.nii.gz ${generated_files_folder}/${subj}_reslice_aseg_ready_with_overlap_corrected.nii.gz
+
+    c3d ${generated_files_folder}/${subj}_reslice_aseg_ready_with_overlap_corrected.nii.gz -replace 6 7 -o ${generated_files_folder}/${subj}_reslice_aseg_ready_with_overlap_corrected.nii.gz
+
+    c3d ${generated_files_folder}/${subj}_reslice_aseg_ready_with_overlap_corrected.nii.gz -replace 1 42 2 50 3 51 4 52 5 49 7 41 8 43 9 0 10 53 -o ${generated_files_folder}/${subj}_reslice_aseg_ready_with_overlap_corrected_RH_FS_labels.nii.gz
+
+    mri_convert ${generated_files_folder}/${subj}_reslice_aseg_ready_with_overlap_corrected_RH_FS_labels.nii.gz ${generated_files_folder}/${subj}_aseg.mgz
+    cp ${generated_files_folder}/${subj}_aseg.mgz ${generated_files_folder}/${subj}_aseg.presurf.mgz
+
+    c3d ${generated_files_folder}/${subj}_reslice_aseg_ready_with_overlap_corrected_RH_FS_labels.nii.gz -replace 0 100 42 142 50 150 51 151 52 152 49 149 41 241 43 143 53 153 -o ${generated_files_folder}/${subj}_reslice_aseg_ready_with_overlap_corrected_RH_FS_labels_presurf_100.nii.gz
+    c3d ${generated_files_folder}/${subj}_reslice_aseg_ready_with_overlap_corrected_RH_FS_labels_presurf_100.nii.gz -dup -lstat
+    mri_convert ${generated_files_folder}/${subj}_reslice_aseg_ready_with_overlap_corrected_RH_FS_labels_presurf_100.nii.gz ${generated_files_folder}/${subj}_aseg.presurf_100.mgz
+
+    c3d ${generated_files_folder}/${subj}_reslice_aseg_ready_with_overlap_corrected.nii.gz -retain-labels 2 3 4 5 7 9 -o ${generated_files_folder}/${subj}_reslice_aseg_ready_with_overlap_corrected_WM_only.nii.gz
+    c3d ${generated_files_folder}/${subj}_reslice_aseg_ready_with_overlap_corrected_WM_only.nii.gz -replace 2 1 3 1 4 1 5 1 7 1 9 1 -o ${generated_files_folder}/${subj}_reslice_aseg_ready_with_overlap_corrected_WM_only.nii.gz
+        
+    c3d ${generated_files_folder}/${subj}_reslice_aseg_ready_with_overlap_corrected_WM_only.nii.gz -comp -threshold 1 1 1 0 -o ${generated_files_folder}/${subj}_reslice_aseg_ready_with_overlap_corrected_WM_only_cc.nii.gz
+
+    mri_convert ${generated_files_folder}/${subj}_reslice_aseg_ready_with_overlap_corrected_WM_only_cc.nii.gz ${generated_files_folder}/${subj}_wm.mgz
+    cp ${generated_files_folder}/${subj}_wm.mgz ${generated_files_folder}/${subj}_filled.mgz
+
+    c3d ${generated_files_folder}/${subj}_reslice_aseg_ready_with_overlap_corrected.nii.gz -replace 1 42 2 41 3 41 4 41 5 41 7 41 8 41 9 41 10 0 -o ${generated_files_folder}/${subj}_ribbon.nii.gz
+    c3d ${generated_files_folder}/${subj}_reslice_aseg_ready_with_overlap_corrected.nii.gz -retain-labels 1 -o ${generated_files_folder}/${subj}_rh.ribbon.nii.gz
+
+    mri_convert ${generated_files_folder}/${subj}_rh.ribbon.nii.gz ${generated_files_folder}/${subj}_rh.ribbon.mgz
+    mri_convert ${generated_files_folder}/${subj}_ribbon.nii.gz ${generated_files_folder}/${subj}.ribbon.mgz
+done;

purple_mri-0.0.1/purple_mri/scripts/run_surface_pipeline.sh

@@ -0,0 +1,43 @@
+# read the mri files and create a list of the subjects
+freesurfer_path=$1
+working_dir=$2
+mri_path=$3
+segm_path=$4
+external_atlases_path=$5
+num_threads=$6
+autodet_stats_dat=$7
+
+subjects=()
+for file in ${mri_path}/*.nii.gz
+do
+   fname=$(basename "$file" .nii.gz)
+   subjects+=(${fname})
+done
+
+echo "Here are the list of subjects to be processed: " ${subjects[@]}
+
+##### STEP 1: Prepare files from the initial 10-label deep learning based-segmentation
+generated_files_folder=${working_dir}/files_prepared_for_pipeline
+mkdir -p ${generated_files_folder}
+prepare_segm_files.sh ${working_dir} "${subjects[*]}" ${generated_files_folder} ${segm_path}
+
+##### STEP 2: Create FreeSurfer-like files
+make_fs_directories.sh ${working_dir} ${generated_files_folder} ${mri_path} "${subjects[*]}"
+
+##### STEP 3: Create mesh and downsample the same
+tgt_dir_FS_mesh=${working_dir}/freesurfer_high_res_mesh
+tgt_dir_FS_mesh_decimated=${working_dir}/decimated_mesh
+mkdir -p ${tgt_dir_FS_mesh}
+mkdir -p ${tgt_dir_FS_mesh_decimated}
+
+# this file calls the Python script: decimate_mesh.py
+create_mesh.sh ${working_dir} ${tgt_dir_FS_mesh} ${tgt_dir_FS_mesh_decimated} "${subjects[*]}"
+
+##### STEP 4: Perform some intial regsitration to get all the required orientations
+do_mni_txs.sh ${freesurfer_path} ${working_dir} "${subjects[*]}"
+
+##### STEP 5: Perform surface-based topology correction
+topology_correction.sh ${working_dir} "${subjects[*]}"
+
+##### STEP 6: Perform surface-based parcellation
+parcellation.sh ${working_dir} "${subjects[*]}" ${freesurfer_path} ${num_threads} ${external_atlases_path} ${autodet_stats_dat}

purple_mri-0.0.1/purple_mri/scripts/topology_correction.sh

@@ -0,0 +1,39 @@
+working_dir=$1
+str_split=$2
+for i in $str_split; do subjects+=($i) ; done
+
+hemis=rh
+for subj in "${subjects[@]}"
+do
+echo ${subj}
+start=$SECONDS
+
+SUBJECTS_DIR=${working_dir}/${subj}
+mris_extract_main_component ${SUBJECTS_DIR}/surf/${hemis}.orig.nofix ${SUBJECTS_DIR}/surf/${hemis}.orig.nofix
+
+mris_smooth -nw ${SUBJECTS_DIR}/surf/${hemis}.orig.nofix ${SUBJECTS_DIR}/surf/${hemis}.smoothwm.nofix
+mris_euler_number ${SUBJECTS_DIR}/surf/${hemis}.smoothwm.nofix
+
+mris_inflate -no-save-sulc ${SUBJECTS_DIR}/surf/${hemis}.smoothwm.nofix ${SUBJECTS_DIR}/surf/${hemis}.inflated.nofix
+mris_euler_number ${SUBJECTS_DIR}/surf/${hemis}.inflated.nofix
+
+mris_sphere -q -p 6 -a 128 ${SUBJECTS_DIR}/surf/${hemis}.inflated.nofix ${SUBJECTS_DIR}/surf/${hemis}.qsphere.nofix
+
+SUBJECTS_DIR=${working_dir}
+mris_fix_topology -mgz -sphere qsphere.nofix -inflated inflated.nofix -orig orig.nofix -out orig.premesh -defect defect -ga ${subj} ${hemis} -threads 64 -verbose -errors -warnings
+mris_euler_number ${SUBJECTS_DIR}/${subj}/surf/${hemis}.orig.premesh
+
+mris_inflate ${SUBJECTS_DIR}/${subj}/surf/${hemis}.orig.premesh ${SUBJECTS_DIR}/${subj}/surf/${hemis}.inflated.fixed
+mris_euler_number ${SUBJECTS_DIR}/${subj}/surf/${hemis}.inflated.fixed
+
+mris_remove_intersection ${SUBJECTS_DIR}/${subj}/surf/${hemis}.orig.premesh ${SUBJECTS_DIR}/${subj}/surf/${hemis}.orig.premesh
+mris_extract_main_component ${SUBJECTS_DIR}/${subj}/surf/${hemis}.orig.premesh ${SUBJECTS_DIR}/${subj}/surf/${hemis}.orig.premesh
+mris_euler_number ${SUBJECTS_DIR}/${subj}/surf/${hemis}.orig.premesh
+
+cp ${SUBJECTS_DIR}/${subj}/surf/${hemis}.orig.premesh ${SUBJECTS_DIR}/${subj}/surf/${hemis}.orig
+cp ${SUBJECTS_DIR}/${subj}/surf/${hemis}.inflated.fixed ${SUBJECTS_DIR}/${subj}/surf/${hemis}.inflated
+mris_euler_number ${SUBJECTS_DIR}/${subj}/surf/${hemis}.orig
+
+duration=$(( SECONDS - start ))
+echo "total time for this subject:" $duration
+done

purple_mri-0.0.1/purple_mri.egg-info/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.1
+Name: purple_mri
+Version: 0.0.1
+Summary: purple_mri: Penn Utilities for Registration and ParcelLation of Ex vivo MRI
+Author-email: Pulkit Khandelwal <kpulkit95@gmail.com>
+Project-URL: Homepage, https://github.com/Pulkit-Khandelwal/purple_mri
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: torch
+Requires-Dist: pykeops
+Requires-Dist: pymeshlab
+Requires-Dist: vtk
+Requires-Dist: SimpleITK
+Requires-Dist: geomloss
+
+# purple-mri: **P**enn **U**tilities for **R**egistration and **P**arcel**L**ation of **E**x vivo **MRI**
+
+We provide a set of tools packaged as `purple-mri` for segmentation, parcellation and registration of ultra high-resolution (< 300 microns) postmortem human brain hemisphere at 7 tesla t2w MRI at native subject-space resolution. This pipeline leverages advances in both deep learning and classical surface-based modeling techniques to produce parcellations in any atlas used in neuroimaging. The developed method allows us to perform vertex-wise analysis in the template space and thereby link morphometry measures with pathology measurements derived from histology.
+
+Check out the [project page](https://pulkit-khandelwal.github.io/exvivo-brain-upenn/) and our latest papers [here](https://direct.mit.edu/imag/article/doi/10.1162/imag_a_00171/120741) and [here](https://arxiv.org/abs/2403.19497).
+
+In particular, `purple-mri` allows you to do the following:
++ obtain an initial 10 label segmentation: cortical GM, normal appearing WM, WMH, medial temporal lobe, corpus callosum, ventricles, caudate, putamen, globus pallidus and thalamus
++ obtain surface-based native subject-space parcellation based on different brain atlases such as: DKT, Economo, Schaeffer etc
++ create population specific volumetric and surface-based templates
++ perform exvivo to invivo registration in volumetric intensity space
++ perform surface-to-surface registration between exvivo or invivo
++ perform intensity-based registration between 9.4 tesla MTL to 7 tesla whole hemsiphere registration
++ perform vertex-wise and group-wise generalized linear modeling analysis for exvivo subject population for morphometry and histology
+
+## Steps (for segmentation and parcellation)
+`purple-mri` follows a series of steps making use of bash scripts and Docker.
+
+### Pre-processing
+Perform bias correction and image normalization/standardization. We use `N4BiasFieldCorrection` as part of the CLI tool [ANTs](https://github.com/ANTsX/ANTs) and [`c3d`](http://www.itksnap.org/pmwiki/pmwiki.php?n=Convert3D.Convert3D). We highly recommend using the option of an input mask in `N4BiasFieldCorrection` which can be obtained via corase threhsolding.
+[Here](https://github.com/Pulkit-Khandelwal/upenn-picsl-brain-ex-vivo/tree/main/misc_scripts/perform_bias_correction.sh) is a sample script.
+
+### Deep learning-based initial labeling and CRUISE-based post-hoc topology correction
+Currently, we have two Docker images. The first image provides the segmentation and the second employs [Nighres/CRUISE](https://nighres.readthedocs.io/en/latest/installation.html) for post-hoc topology correction. 
+Please follow the [link]([https://github.com/Pulkit-Khandelwal/upenn-picsl-brain-ex-vivo/blob/main/exvivo-segm-demo-docker.md](https://github.com/Pulkit-Khandelwal/purple-mri/blob/main/docker/exvivo_docker.md) for detailed instructions on how to use Docker to get the segmentations. Some key commands are emphasized here:
+
+Place the pre-processed image(s) (with a suffix _0000.nii.gz to your filenames) in a folder named `data_for_inference` within your working directory is `/your/working/directory`.
+```
+docker pull pulks/docker_hippogang_exvivo_segm:v${LATEST_TAG}
+
+docker run --gpus all --privileged -v /your/working/directory/:/data/exvivo/ -it pulks/docker_hippogang_exvivo_segm:v${LATEST_TAG} /bin/bash -c "bash /src/commands_nnunet_inference.sh ${OPTION}" >> logs.txt
+```
+You will see the output in `/your/working/directory/data_for_inference/output_from_nnunet_inference`.
+
+Next, correct for topology so that adjoining gyri and sulci are clearly separated. Copy the segmentations from `output_from_nnunet_inference` to a folder `data_for_topology_correction` in your wokring directory.
+```
+docker pull pulks/docker_nighres:v1.0.0
+
+docker run -v /your/working/directory/:/data/cruise_files/ -it pulks/docker_nighres:v1.0.0 /bin/bash -c "bash /data/prepare_cruise_files.sh"
+
+# Locally run the file to get the final combined label file. See instructions [here](https://github.com/Pulkit-Khandelwal/upenn-picsl-brain-ex-vivo/blob/main/exvivo-segm-demo-docker.md) and links referenced therein.
+bash clean_labels_final.sh
+```
+
+### Surface-based modeling to obtain whole-hemisphere parcellations
+Once, you have obtained an initial 10-label topology corrected volumetric segmentation, you can proceed to the surface-based pipeline to obtain parcellations based on your favorite atlas. This step will be on your local machine. No GPUs required. To do this, you should have FreeSurfer installed locally. We have used FreeSurfer version 7.4.0 on linux obtained from [here](https://surfer.nmr.mgh.harvard.edu/fswiki/DownloadAndInstall). Moreover, there are some Python dependencies which can be found in the `dependencies.txt` file and installed using `pip`.
+
+Run the following file which calls in several bash scripts which prepares the data, computes appropriate transformations and re-orients the images, corrects surface topology, and perform the parcellation into Desikan-Killiany-Tourville (DKT), Schaefer, Glasser and the Von Economo-Koskinos atlases.
+
+For the surface-based modeling step, we assume that all the hemishpehrs are right hemispheres. So, we suggest flipping the left t2w MRI and its corresponding segmentation to left using the following `c3d` command: `c3d image_left.nii.gz -flip y image_right_flipped.nii.gz`
+
+Clone the current repository and the run the following script `run_surface_pipeline.sh` from within the `purple_mri` folder which takes the following mandatory arguments:
+`freesurfer_path`: path to the FreeSurfer installtion
+`working_dir`: directory which will have the outputs for each subject stored
+`mri_path`: mri images path
+`segm_path`: 10-label segmentation path
+`external_atlases_path`: directory with files for other atlases
+`num_threads`: number of threads
+
+Place your t2w MRI in a folder `mri_path` and the intial deep learning-based segmentations in `segm_path`.
+Make sure your mri images and segmentation files have the same names ending with `.nii.gz`.
+Place the `fsaverage` in the `working_dir` folder.
+
+```
+cd purple_mri
+
+bash run_surface_pipeline.sh freesurfer_path working_dir mri_path segm_path external_atlases_path num_threads
+```
+
+## Other scripts
+### Intensity-based volumetric template building
+We build intensity-based volumetric templates using the [greedy](https://sites.google.com/view/greedyreg/about?authuser=0) tool. The required binaries (for Linux) and the scripts are located in the the `intensity_template` within the `scripts` directory. Follow the instructions [here](https://github.com/Pulkit-Khandelwal/purple-mri/blob/main/scripts/intensity_template/README.md).
+
+
+### Ex vivo and in vivo registration
+Script `exvivo_invivo_greedy_registration.sh` to register in vivo (t1w) and ex vivo (t2w) MRI is located in the folder `scripts`. We use [greedy](https://sites.google.com/view/greedyreg/about?authuser=0) to register the segmentations of in vivo aseg+aparc labels derived from FreeSurfer and 10-label initial deep learning segmentation of postmortem MRI. The warps are then used to regsiter the MRIs.
+
+### Perform GLM analyses
+We perform vertex-wise analysis in `fsaverage` space to fit a generalized linear model (GLM) between cortical thickness (mm) and with global ratings of amyloid-β, Braak staging, CERAD, and semiquantitative ratings of the medial temporal lobe (MTL) neuronal loss and tau pathology, with age, sex and postmortem interval (PMI) as covariates. You can follow the steps detailed [here](https://github.com/Pulkit-Khandelwal/purple-mri/tree/main/glm).
+
+## Notes
++ Our method has been developed to work on a single exvivo hemisphere.
++ The deep learning-based segmentation was primarily trained on 7T t2w MRI. We have tested the model on t2* flash as well and it works pretty well but, if need be, we recommend re-training the model with some manual labels obtained on t2* flash MRI.
+
+## pip package
+
+## Introductory video
+<div align="center">
+      <a href="https://youtu.be/0BOeUtlWlYw?si=7NeNDsoePOW3_J4Y">
+         <img src="https://github.com/Pulkit-Khandelwal/purple-mri/blob/main/images/thumbnail.png" style="width:75%;">
+      </a>
+</div>
+
+## Citations
++ Khandelwal, P., Duong, M. T., Sadaghiani, S., Lim, S., Denning, A. E., Chung, E., ... & Yushkevich, P. A. (2024). Automated deep learning segmentation of high-resolution 7 tesla postmortem MRI for quantitative analysis of structure-pathology correlations in neurodegenerative diseases. Imaging Neuroscience, 2, 1-30.
++ Khandelwal, P., Duong, M. T., Fuentes, C., Denning, A., Trotman, W., Ittyerah, R., ... & Yushkevich, P. A. (2024). Surface-based parcellation and vertex-wise analysis of ultra high-resolution ex vivo 7 tesla MRI in neurodegenerative diseases. arXiv preprint arXiv:2403.19497.
+

purple_mri-0.0.1/purple_mri.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+README.md
+pyproject.toml
+purple_mri/__init__.py
+purple_mri/__main__.py
+purple_mri.egg-info/PKG-INFO
+purple_mri.egg-info/SOURCES.txt
+purple_mri.egg-info/dependency_links.txt
+purple_mri.egg-info/requires.txt
+purple_mri.egg-info/top_level.txt
+purple_mri/scripts/create_mesh.sh
+purple_mri/scripts/decimate_mesh.py
+purple_mri/scripts/do_mni_txs.sh
+purple_mri/scripts/make_fs_directories.sh
+purple_mri/scripts/parcellation.sh
+purple_mri/scripts/prepare_segm_files.sh
+purple_mri/scripts/run_surface_pipeline.sh
+purple_mri/scripts/topology_correction.sh

purple_mri-0.0.1/purple_mri.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

purple_mri-0.0.1/purple_mri.egg-info/requires.txt

@@ -0,0 +1,7 @@
+numpy
+torch
+pykeops
+pymeshlab
+vtk
+SimpleITK
+geomloss

purple_mri-0.0.1/purple_mri.egg-info/top_level.txt

@@ -0,0 +1 @@
+purple_mri

purple_mri-0.0.1/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+    requires = ["setuptools"]
+
+[project]
+name = "purple_mri"
+version = "0.0.1"
+authors = [
+  { name="Pulkit Khandelwal", email="kpulkit95@gmail.com" },
+]
+description = "purple_mri: Penn Utilities for Registration and ParcelLation of Ex vivo MRI"
+dependencies = [
+  'numpy',
+  'torch',
+  'pykeops',
+  'pymeshlab',
+  'vtk',
+  'SimpleITK',
+  'geomloss'
+]
+readme = "README.md"
+[tool.setuptools]
+    script-files = [
+  "purple_mri/scripts/run_surface_pipeline.sh",
+  "purple_mri/scripts/do_mni_txs.sh",
+  "purple_mri/scripts/prepare_segm_files.sh",
+  "purple_mri/scripts/create_mesh.sh",
+  "purple_mri/scripts/make_fs_directories.sh",
+  "purple_mri/scripts/parcellation.sh",
+  "purple_mri/scripts/topology_correction.sh",
+  "purple_mri/scripts/decimate_mesh.py"]
+
+[project.urls]
+Homepage = "https://github.com/Pulkit-Khandelwal/purple_mri"

purple_mri-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+