upload files

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+assets/*.gif filter=lfs diff=lfs merge=lfs -text
+deepatlas/results/Task002_rnmw153_sim_Zsc/training_results/RegNet/*.pth filter=lfs diff=lfs merge=lfs -text
+deepatlas/results/Task002_rnmw153_sim_Zsc/training_results/SegNet/*.pth filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -1,3 +1,191 @@
----
-license: mit
----
+<h2 align="center"> [OTO–HNS2024] A Label-Efficient Framework for Automated Sinonasal CT Segmentation in Image-Guided Surgery </h2>
+<p align="center">
+<a href="https://aao-hnsfjournals.onlinelibrary.wiley.com/doi/10.1002/ohn.868"><img src="https://img.shields.io/badge/Wiley-Paper-red"></a>
+<a href="https://pubmed.ncbi.nlm.nih.gov/38922721/"><img src="https://img.shields.io/badge/PubMed-Link-blue"></a>
+<a href="https://github.com/mikami520/AutoSeg4SinonasalCT"><img src="https://img.shields.io/badge/Code-Page-magenta"></a>
+</p>
+<h5 align="center"><em>Manish Sahu<sup>*</sup>, Yuliang Xiao<sup>*</sup>, Jose L. Porras, Ameen Amanian, Aseem Jain, Andrew Thamboo, Russell H. Taylor, Francis X. Creighton, Masaru Ishii</em></h5>
+<p align="center"> <sup>*</sup> Indicates Equal Contribution </p>
+<p align="center">
+  <a href="#news">News</a> |
+  <a href="#abstract">Abstract</a> |
+  <a href="#installation">Installation</a> |
+  <a href="#preprocess">Preprocess</a> |
+  <a href="#train">Train</a> |
+  <a href="#inference">Inference</a>
+</p>
+
+## News 
+
+**2024.06.07** - The data preprocessing, training, inference, and evaluation code are released.
+
+**2024.06.03** - Our paper is accepted to **American Academy of Otolaryngology–Head and Neck Surgery 2024 (OTO-HNS2024)**.
+
+## Abstract
+
+- Objective: Segmentation, the partitioning of patient imaging into multiple, labeled segments, has several potential clinical benefits but when performed manually is tedious and resource intensive. Automated deep learning (DL)-based segmentation methods can streamline the process. The objective of this study was to evaluate a label-efficient DL pipeline that requires only a small number of annotated scans for semantic segmentation of sinonasal structures in CT scans.
+
+- Methods: Forty CT scans were used in this study including 16 scans in which the nasal septum (NS), inferior turbinate (IT), maxillary sinus (MS), and optic nerve (ON) were manually annotated using an open-source software. A label-efficient DL framework was used to train jointly on a few manually labeled scans and the remaining unlabeled scans. Quantitative analysis was then performed to obtain the number of annotated scans needed to achieve submillimeter average surface distances (ASDs).
+
+- Results: Our findings reveal that merely four labeled scans are necessary to achieve median submillimeter ASDs for large sinonasal structures—NS (0.96 mm), IT (0.74 mm), and MS (0.43 mm), whereas eight scans are required for smaller structures—ON (0.80 mm).
+
+- Conclusion: We have evaluated a label-efficient pipeline for segmentation of sinonasal structures. Empirical results demonstrate that automated DL methods can achieve submillimeter accuracy using a small number of labeled CT scans. Our pipeline has the potential to improve preoperative planning workflows, robotic- and image-guidance navigation systems, computer-assisted diagnosis, and the construction of statistical shape models to quantify population variations.
+
+<p align="center">
+  <img src="assets/nasal.gif" />
+  <b>Figure 1: 3D Heatmap Visualization of Nasal Septum (NS), Inferior Turbinate (IT), Maxillary Sinus (MS), and Optic Nerve (ON)</b>
+</p>
+
+## Installation
+
+### Step 1: Fork This GitHub Repository 
+
+```bash
+git clone https://github.com/mikami520/AutoSeg4SinonasalCT.git
+```
+
+### Step 2: Set Up Environment Using requirements.txt (virtual environment is recommended)
+
+```bash
+pip install -r requirements.txt
+source /path/to/VIRTUAL_ENVIRONMENT/bin/activate 
+```
+
+## Preprocess
+
+### Step 1: Co-align the data (make sure scan and segmentation are co-aligned)
+
+```bash
+cd <path to repo>/deepatlas/preprocess
+```
+
+Co-align the scans and labels (recommendation: similarity registration)
+
+```bash
+python registration_training.py 
+-bp <full path of base dir> 
+-ip <relative path to nifti images dir> 
+-sp <relative path to labels dir>
+-ti <task id> 
+```
+
+If you want to make sure correspondence of the name and value of segmentations, you can add the following commands after above command (**Option for nrrd format**)
+
+```bash
+-sl LabelValue1 LabelName1 LabelValue2 LabelName2 LabelValue3 LabelName3 ...
+```
+
+For example, if I have two labels for maxillary sinus named ```L-MS``` and ```R-MS``` and I want ```L-MS``` matched to ```label 1``` and ```R-MS``` to ```label 2``` (**Pay attention to the order**)
+
+```bash
+python registration_training.py -bp /Users/mikamixiao/Desktop -ip images -sp labels -sl 1 L-MS 2 R-MS
+```
+
+Final output of registered images and segmentations will be saved in 
+
+```text
+base_dir/deepatlas_raw_data_base/task_id/Training_dataset/images && base_dir/deepatlas_raw_data_base/task_id/Training_dataset/labels
+```
+
+### Step 2: Crop Normalize and Flip Data (if needed)
+
+Crop，normalize and flip data to extract region of interest (ROI). **Notice: the images and segmentations should be co-registered. We recommend to use the outputs of Step 2.1**
+
+```bash
+python crop_flip_training.py 
+-fp <if need to flip data, use flag for true and not use for false> 
+-ti <task id> 
+-rs <customized resized shape>
+``` 
+
+**Pay attention to the resized dimension which should not be smaller than cropped dimension**\
+Final output of ROI will be saved in
+
+```text
+base_dir/deepatlas_preprocessed/task_id/Training_dataset/images && base_dir/deepatlas_preprocessed/task_id/Training_dataset/labels
+```
+
+## Train
+
+```bash
+cd <path to repo>/deepatlas/scripts
+python deep_atlas_train.py
+--config <configuration file of network parameters>
+--continue_training <check if need to resume training>
+--train_only <only training or training plus test>
+--plot_network <whether to plot the neural network architecture>
+```
+
+**For detailed information, use ```-h``` to see more instructions**
+Before training, a folder named ```deepatlas_results``` is created automatically under the repository directory. All training results are stored in this folder. A clear structure is shown below:
+
+```text
+DeepAtlas/deepatlas_results/
+    ├── Task001_ET
+    |   └── results
+    |       └── RegNet
+    |           |── anatomy_loss_reg.txt
+    |           |── anatomy_reg_losses.png
+    |           |── reg_net_best.pth
+    |           |── reg_net_training_losses.png
+    |           |── regularization_loss.txt
+    |           |── regularization_reg_losses.png
+    |           |── similarity_loss_reg.txt
+    |           |── similarity_reg_losses.png
+    |       └── SegNet
+    |           |── anatomy_loss_seg.txt
+    |           |── anatomy_seg_losses.png
+    |           |── seg_net_best.pth
+    |           |── seg_net_training_losses.png
+    |           |── supervised_loss_seg.txt
+    |           |── supervised_seg_losses.png
+    |       └── training_log.txt
+    |   └── dataset.json
+    ├── Task002_Nasal_Cavity
+```
+
+## Inference
+
+```
+python deep_atlas_test.py
+-gpu <id of gpu device to use>
+-op <relative path of the prediction result directory>
+-ti <task id and name>
+```
+
+The final prediction results will be saved in the ```DeepAtlas_dataset/Task_id_and_Name``` directory. For example,
+
+```text
+DeepAtlas/DeepAtlas_dataset/
+    ├── Task001_ET
+    |   └── results
+    |       └── RegNet
+    |           |── anatomy_loss_reg.txt
+    |           |── anatomy_reg_losses.png
+    |           |── reg_net_best.pth
+    |           |── reg_net_training_losses.png
+    |           |── regularization_loss.txt
+    |           |── regularization_reg_losses.png
+    |           |── similarity_loss_reg.txt
+    |           |── similarity_reg_losses.png
+    |       └── SegNet
+    |           |── anatomy_loss_seg.txt
+    |           |── anatomy_seg_losses.png
+    |           |── seg_net_best.pth
+    |           |── seg_net_training_losses.png
+    |           |── supervised_loss_seg.txt
+    |           |── supervised_seg_losses.png
+    |       └── training_log.txt
+    |   └── prediction
+    |       └── RegNet
+    |           |── reg_img_losses.txt
+    |           |── reg_seg_dsc.txt
+    |           |── figures containing fixed, moving, warped scans deformation field and jacobian determinant
+    |           |── warped scans and labels in nifti format
+    |       └── SegNet
+    |           |── seg_dsc.txt
+    |           |── predicted labels in nifti format
+    |   └── dataset.json
+    ├── Task002_Nasal_Cavity
+```
+

deepatlas/loss_function/losses.py

@@ -0,0 +1,118 @@
+import monai
+import torch
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def warp_func():
+    warp = monai.networks.blocks.Warp(mode="bilinear", padding_mode="border")
+    return warp
+
+
+def warp_nearest_func():
+    warp_nearest = monai.networks.blocks.Warp(
+        mode="nearest", padding_mode="border")
+    return warp_nearest
+
+
+def lncc_loss_func():
+    lncc_loss = monai.losses.LocalNormalizedCrossCorrelationLoss(
+        spatial_dims=3,
+        kernel_size=3,
+        kernel_type='rectangular',
+        reduction="mean",
+        smooth_nr=1e-5,
+        smooth_dr=1e-5,
+    )
+    return lncc_loss
+
+
+def similarity_loss(displacement_field, image_pair):
+    warp = warp_func()
+    lncc_loss = lncc_loss_func()
+    """ Accepts a batch of displacement fields, shape (B,3,H,W,D),
+        and a batch of image pairs, shape (B,2,H,W,D). """
+    warped_img2 = warp(image_pair[:, [1], :, :, :], displacement_field)
+    return lncc_loss(
+        warped_img2,  # prediction
+        image_pair[:, [0], :, :, :]  # target
+    )
+
+
+def regularization_loss_func():
+    # normalize=True, reduction='mean'
+    return monai.losses.BendingEnergyLoss(normalize=True, reduction='mean')
+
+
+def dice_loss_func():
+    dice_loss = monai.losses.DiceLoss(
+        include_background=True,
+        to_onehot_y=False,
+        softmax=False,
+        reduction="mean"
+    )
+    return dice_loss
+
+
+def dice_loss_func2():
+    dice_loss = monai.losses.DiceLoss(
+        include_background=True,
+        to_onehot_y=True,
+        softmax=True,
+        reduction="mean"
+    )
+    return dice_loss
+
+
+def anatomy_loss(displacement_field, image_pair, seg_net, gt_seg1=None, gt_seg2=None, num_segmentation_classes=None):
+    """
+    Accepts a batch of displacement fields, shape (B,3,H,W,D),
+    and a batch of image pairs, shape (B,2,H,W,D).
+    seg_net is the model used to segment an image,
+      mapping (B,1,H,W,D) to (B,C,H,W,D) where C is the number of segmentation classes.
+    gt_seg1 and gt_seg2 are ground truth segmentations for the images in image_pair, if ground truth is available;
+      if unavailable then they can be None.
+      gt_seg1 and gt_seg2 are expected to be in the form of class labels, with shape (B,1,H,W,D).
+    """
+    if gt_seg1 is not None:
+        # ground truth seg of target image
+        seg1 = monai.networks.one_hot(
+            gt_seg1, num_segmentation_classes
+        )
+    else:
+        # seg_net on target image, "noisy ground truth"
+        seg1 = seg_net(image_pair[:, [0], :, :, :]).softmax(dim=1)
+
+    if gt_seg2 is not None:
+        # ground truth seg of moving image
+        seg2 = monai.networks.one_hot(
+            gt_seg2, num_segmentation_classes
+        )
+    else:
+        # seg_net on moving image, "noisy ground truth"
+        seg2 = seg_net(image_pair[:, [1], :, :, :]).softmax(dim=1)
+
+    # seg1 and seg2 are now in the form of class probabilities at each voxel
+    # The trilinear interpolation of the function `warp` is then safe to use;
+    # it will preserve the probabilistic interpretation of seg2.
+    dice_loss = dice_loss_func()
+    warp = warp_func()
+    return dice_loss(
+        warp(seg2, displacement_field),  # warp of moving image segmentation
+        seg1  # target image segmentation
+    )
+
+
+def reg_losses(batch, device, reg_net, seg_net, num_segmentation_classes):
+    img12 = batch['img12'].to(device)
+    displacement_field12 = reg_net(img12)
+    loss_sim = similarity_loss(displacement_field12, img12)
+    regularization_loss = regularization_loss_func()
+    loss_reg = regularization_loss(displacement_field12)
+
+    gt_seg1 = batch['seg1'].to(device) if 'seg1' in batch.keys() else None
+    gt_seg2 = batch['seg2'].to(device) if 'seg2' in batch.keys() else None
+    loss_ana = anatomy_loss(displacement_field12, img12,
+                            seg_net, gt_seg1, gt_seg2, num_segmentation_classes)
+
+    return loss_sim, loss_reg, loss_ana, displacement_field12

deepatlas/metrics/distanceVertex2Mesh.py

@@ -0,0 +1,64 @@
+import numpy as np
+import pyvista as pv
+import argparse
+import os
+import glob
+import trimesh
+
+
+def parse_command_line():
+    print('---'*10)
+    print('Parsing Command Line Arguments')
+    parser = argparse.ArgumentParser(description='Defacing protocol')
+    parser.add_argument('-bp', metavar='base path', type=str,
+                        help="Absolute path of the base directory")
+    parser.add_argument('-gp', metavar='ground truth path', type=str,
+                        help="Relative path of the ground truth model")
+    parser.add_argument('-pp', metavar='prediction path', type=str,
+                        help="Relative path of the prediction model")
+    argv = parser.parse_args()
+    return argv
+
+
+def distanceVertex2Mesh(mesh, vertex):
+    faces_as_array = mesh.faces.reshape((mesh.n_faces, 4))[:, 1:]
+    mesh_box = trimesh.Trimesh(vertices=mesh.points,
+                               faces=faces_as_array)
+    cp, cd, ci = trimesh.proximity.closest_point(mesh_box, vertex)
+    return cd
+
+
+def main():
+    args = parse_command_line()
+    base = args.bp
+    gt_path = args.gp
+    pred_path = args.pp
+    output_dir = os.path.join(base, 'output')
+    try:
+        os.mkdir(output_dir)
+    except:
+        print(f'{output_dir} already exists')
+
+    for i in glob.glob(os.path.join(base, gt_path) + '/*.vtk'):
+        filename = os.path.basename(i).split('.')[0]
+        #side = os.path.basename(i).split('.')[0].split('_')[0]
+        #scan_name = os.path.basename(i).split('.')[0].split('_')[0]
+        #scan_id = os.path.basename(i).split('.')[0].split('_')[1]
+        output_sub_dir = os.path.join(
+            base, 'output', filename)
+        try:
+            os.mkdir(output_sub_dir)
+        except:
+            print(f'{output_sub_dir} already exists')
+
+        gt_mesh = pv.read(i)
+        pred_mesh = pv.read(os.path.join(
+            base, pred_path, filename + '.vtk'))
+        pred_vertices = np.array(pred_mesh.points)
+        cd = distanceVertex2Mesh(gt_mesh, pred_vertices)
+        pred_mesh['dist'] = cd
+        pred_mesh.save(os.path.join(output_sub_dir, filename + '.vtk'))
+
+
+if __name__ == '__main__':
+    main()

deepatlas/metrics/get_probability_map.py

@@ -0,0 +1,194 @@
+import numpy as np
+import pyvista as pv
+import argparse
+import os
+import glob
+import skeletor as sk
+import trimesh
+import navis
+
+
+def parse_command_line():
+    print('---'*10)
+    print('Parsing Command Line Arguments')
+    parser = argparse.ArgumentParser(description='Defacing protocol')
+    parser.add_argument('-bp', metavar='base path', type=str,
+                        help="Absolute path of the base directory")
+    parser.add_argument('-gp', metavar='ground truth path', type=str,
+                        help="Relative path of the ground truth model")
+    parser.add_argument('-pp', metavar='prediction path', type=str,
+                        help="Relative path of the prediction model")
+    parser.add_argument('-rr', metavar='ratio to split skeleton', type=int, nargs='+',
+                        help="Ratio to split the skeleton")
+    parser.add_argument('-ps', metavar='probability sequences', type=float, nargs='+',
+                        help="Proability sequences for each splitted region")
+    argv = parser.parse_args()
+    return argv
+
+
+def distanceVertex2Path(mesh, skeleton, probability_map):
+    if len(probability_map) == 0:
+        print('empty probability_map !!!')
+        return np.inf
+
+    if not mesh.is_all_triangles():
+        print('only triangulations is allowed (Faces do not have 3 Vertices)!')
+        return np.inf
+
+    if hasattr(mesh, 'points'):
+        points = np.array(mesh.points)
+    else:
+        print('mesh structure must contain fields ''vertices'' and ''faces''!')
+        return np.inf
+
+    if hasattr(skeleton, 'vertices'):
+        vertex = skeleton.vertices
+    else:
+        print('skeleton structure must contain fields ''vertices'' !!!')
+        return np.inf
+
+    numV, dim = points.shape
+    numT, dimT = vertex.shape
+
+    if dim != dimT or dim != 3:
+        print('mesh and vertices must be in 3D space!')
+        return np.inf
+
+    d_min = np.ones(numV, dtype=np.float64) * np.inf
+    pm = []
+    # first check: find closest distance from vertex to vertex
+    for i in range(numV):
+        min_idx = -1
+        for j in range(numT):
+            v1 = points[i, :]
+            v2 = vertex[j, :]
+            d = distance3DV2V(v1, v2)
+            if d < d_min[i]:
+                d_min[i] = d
+                min_idx = j
+
+        pm.append(probability_map[min_idx])
+
+    print("check is finished !!!")
+    return pm
+
+
+def generate_probability_map(skeleton, split_ratio, probability):
+    points = skeleton.vertices
+    center = skeleton.skeleton.centroid
+    x = sorted(points[:, 0])
+    left = []
+    right = []
+    for i in range(len(x)):
+        if x[i] < center[0]:
+            left.append(x[i])
+        else:
+            right.append(x[i])
+
+    right_map = []
+    left_map = []
+    sec_old = 0
+    for j in range(len(split_ratio)):
+        if j == len(split_ratio) - 1:
+            sec_len = len(left) - sec_old
+        else:
+            sec_len = int(round(len(left) * split_ratio[j] / 100))
+
+        for k in range(sec_old, sec_old + sec_len):
+            left_map.append(probability[j])
+
+        sec_old += sec_len
+
+    sec_old = 0
+    for j in range(len(split_ratio)-1, -1, -1):
+        if j == 0:
+            sec_len = len(right) - sec_old
+        else:
+            sec_len = int(round(len(right) * split_ratio[j] / 100))
+
+        for k in range(sec_old, sec_old + sec_len):
+            right_map.append(probability[j])
+
+        sec_old += sec_len
+
+    final_map = []
+    row = points.shape[0]
+    assert len(left) + len(right) == row
+    for m in range(row):
+        ver_x = points[m, 0]
+        if ver_x in left:
+            index = left.index(ver_x)
+            final_map.append(left_map[index])
+        else:
+            index = right.index(ver_x)
+            final_map.append(right_map[index])
+
+    return final_map
+
+
+def skeleton(mesh):
+    faces_as_array = mesh.faces.reshape((mesh.n_faces, 4))[:, 1:]
+    trmesh = trimesh.Trimesh(mesh.points, faces_as_array)
+    fixed = sk.pre.fix_mesh(trmesh, remove_disconnected=5, inplace=False)
+    skel = sk.skeletonize.by_wavefront(fixed, waves=1, step_size=1)
+    # Create a neuron from your skeleton
+    n = navis.TreeNeuron(skel, soma=None)
+    # keep only the two longest linear section in your skeleton
+    long2 = navis.longest_neurite(n, n=2, from_root=False)
+
+    # This renumbers nodes
+    swc = navis.io.swc_io.make_swc_table(long2)
+    # We also need to rename some columns
+    swc = swc.rename({'PointNo': 'node_id', 'Parent': 'parent_id', 'X': 'x',
+                      'Y': 'y', 'Z': 'z', 'Radius': 'radius'}, axis=1).drop('Label', axis=1)
+    # Skeletor excepts node IDs to start with 0, but navis starts at 1 for SWC
+    swc['node_id'] -= 1
+    swc.loc[swc.parent_id > 0, 'parent_id'] -= 1
+    # Create the skeletor.Skeleton
+    skel2 = sk.Skeleton(swc)
+    return skel2
+
+
+def distance3DV2V(v1, v2):
+    d = np.linalg.norm(v1-v2)
+    return d
+
+
+def main():
+    args = parse_command_line()
+    base = args.bp
+    gt_path = args.gp
+    pred_path = args.pp
+    area_ratio = args.rr
+    prob_sequences = args.ps
+    output_dir = os.path.join(base, 'output')
+    try:
+        os.mkdir(output_dir)
+    except:
+        print(f'{output_dir} already exists')
+
+    for i in glob.glob(os.path.join(base, gt_path) + '/*.vtk'):
+        scan_name = os.path.basename(i).split('.')[0].split('_')[1]
+        scan_id = os.path.basename(i).split('.')[0].split('_')[2]
+        output_sub_dir = os.path.join(
+            base, 'output', scan_name + '_' + scan_id)
+        try:
+            os.mkdir(output_sub_dir)
+        except:
+            print(f'{output_sub_dir} already exists')
+
+        gt_mesh = pv.read(i)
+        pred_mesh = pv.read(os.path.join(
+            base, pred_path, 'pred_' + scan_name + '_' + scan_id + '.vtk'))
+        pred_skel = skeleton(pred_mesh)
+        prob_map = generate_probability_map(
+            pred_skel, area_ratio, prob_sequences)
+        pm = distanceVertex2Path(pred_mesh, pred_skel, prob_map)
+        if(pm == np.Inf):
+            print('something with mesh, probability map and skeleton are wrong !!!')
+            return
+        np.savetxt(os.path.join(base, output_sub_dir, scan_id + '.txt'), pm)
+
+
+if __name__ == '__main__':
+    main()

deepatlas/metrics/lookup_tables.py

@@ -0,0 +1,463 @@
+# Copyright 2018 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS-IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import math
+import numpy as np
+ENCODE_NEIGHBOURHOOD_3D_KERNEL = np.array([[[128, 64], [32, 16]], [[8, 4],
+                                                                   [2, 1]]])
+
+"""
+
+lookup_tables.py
+
+all of the lookup-tables functions are borrowed from DeepMind surface_distance repository
+
+"""
+
+
+# _NEIGHBOUR_CODE_TO_NORMALS is a lookup table.
+# For every binary neighbour code
+# (2x2x2 neighbourhood = 8 neighbours = 8 bits = 256 codes)
+# it contains the surface normals of the triangles (called "surfel" for
+# "surface element" in the following). The length of the normal
+# vector encodes the surfel area.
+#
+# created using the marching_cube algorithm
+# see e.g. https://en.wikipedia.org/wiki/Marching_cubes
+# pylint: disable=line-too-long
+_NEIGHBOUR_CODE_TO_NORMALS = [
+    [[0, 0, 0]],
+    [[0.125, 0.125, 0.125]],
+    [[-0.125, -0.125, 0.125]],
+    [[-0.25, -0.25, 0.0], [0.25, 0.25, -0.0]],
+    [[0.125, -0.125, 0.125]],
+    [[-0.25, -0.0, -0.25], [0.25, 0.0, 0.25]],
+    [[0.125, -0.125, 0.125], [-0.125, -0.125, 0.125]],
+    [[0.5, 0.0, -0.0], [0.25, 0.25, 0.25], [0.125, 0.125, 0.125]],
+    [[-0.125, 0.125, 0.125]],
+    [[0.125, 0.125, 0.125], [-0.125, 0.125, 0.125]],
+    [[-0.25, 0.0, 0.25], [-0.25, 0.0, 0.25]],
+    [[0.5, 0.0, 0.0], [-0.25, -0.25, 0.25], [-0.125, -0.125, 0.125]],
+    [[0.25, -0.25, 0.0], [0.25, -0.25, 0.0]],
+    [[0.5, 0.0, 0.0], [0.25, -0.25, 0.25], [-0.125, 0.125, -0.125]],
+    [[-0.5, 0.0, 0.0], [-0.25, 0.25, 0.25], [-0.125, 0.125, 0.125]],
+    [[0.5, 0.0, 0.0], [0.5, 0.0, 0.0]],
+    [[0.125, -0.125, -0.125]],
+    [[0.0, -0.25, -0.25], [0.0, 0.25, 0.25]],
+    [[-0.125, -0.125, 0.125], [0.125, -0.125, -0.125]],
+    [[0.0, -0.5, 0.0], [0.25, 0.25, 0.25], [0.125, 0.125, 0.125]],
+    [[0.125, -0.125, 0.125], [0.125, -0.125, -0.125]],
+    [[0.0, 0.0, -0.5], [0.25, 0.25, 0.25], [-0.125, -0.125, -0.125]],
+    [[-0.125, -0.125, 0.125], [0.125, -0.125, 0.125], [0.125, -0.125, -0.125]],
+    [[-0.125, -0.125, -0.125], [-0.25, -0.25, -0.25],
+        [0.25, 0.25, 0.25], [0.125, 0.125, 0.125]],
+    [[-0.125, 0.125, 0.125], [0.125, -0.125, -0.125]],
+    [[0.0, -0.25, -0.25], [0.0, 0.25, 0.25], [-0.125, 0.125, 0.125]],
+    [[-0.25, 0.0, 0.25], [-0.25, 0.0, 0.25], [0.125, -0.125, -0.125]],
+    [[0.125, 0.125, 0.125], [0.375, 0.375, 0.375],
+        [0.0, -0.25, 0.25], [-0.25, 0.0, 0.25]],
+    [[0.125, -0.125, -0.125], [0.25, -0.25, 0.0], [0.25, -0.25, 0.0]],
+    [[0.375, 0.375, 0.375], [0.0, 0.25, -0.25],
+        [-0.125, -0.125, -0.125], [-0.25, 0.25, 0.0]],
+    [[-0.5, 0.0, 0.0], [-0.125, -0.125, -0.125],
+        [-0.25, -0.25, -0.25], [0.125, 0.125, 0.125]],
+    [[-0.5, 0.0, 0.0], [-0.125, -0.125, -0.125], [-0.25, -0.25, -0.25]],
+    [[0.125, -0.125, 0.125]],
+    [[0.125, 0.125, 0.125], [0.125, -0.125, 0.125]],
+    [[0.0, -0.25, 0.25], [0.0, 0.25, -0.25]],
+    [[0.0, -0.5, 0.0], [0.125, 0.125, -0.125], [0.25, 0.25, -0.25]],
+    [[0.125, -0.125, 0.125], [0.125, -0.125, 0.125]],
+    [[0.125, -0.125, 0.125], [-0.25, -0.0, -0.25], [0.25, 0.0, 0.25]],
+    [[0.0, -0.25, 0.25], [0.0, 0.25, -0.25], [0.125, -0.125, 0.125]],
+    [[-0.375, -0.375, 0.375], [-0.0, 0.25, 0.25],
+        [0.125, 0.125, -0.125], [-0.25, -0.0, -0.25]],
+    [[-0.125, 0.125, 0.125], [0.125, -0.125, 0.125]],
+    [[0.125, 0.125, 0.125], [0.125, -0.125, 0.125], [-0.125, 0.125, 0.125]],
+    [[-0.0, 0.0, 0.5], [-0.25, -0.25, 0.25], [-0.125, -0.125, 0.125]],
+    [[0.25, 0.25, -0.25], [0.25, 0.25, -0.25],
+        [0.125, 0.125, -0.125], [-0.125, -0.125, 0.125]],
+    [[0.125, -0.125, 0.125], [0.25, -0.25, 0.0], [0.25, -0.25, 0.0]],
+    [[0.5, 0.0, 0.0], [0.25, -0.25, 0.25],
+        [-0.125, 0.125, -0.125], [0.125, -0.125, 0.125]],
+    [[0.0, 0.25, -0.25], [0.375, -0.375, -0.375],
+        [-0.125, 0.125, 0.125], [0.25, 0.25, 0.0]],
+    [[-0.5, 0.0, 0.0], [-0.25, -0.25, 0.25], [-0.125, -0.125, 0.125]],
+    [[0.25, -0.25, 0.0], [-0.25, 0.25, 0.0]],
+    [[0.0, 0.5, 0.0], [-0.25, 0.25, 0.25], [0.125, -0.125, -0.125]],
+    [[0.0, 0.5, 0.0], [0.125, -0.125, 0.125], [-0.25, 0.25, -0.25]],
+    [[0.0, 0.5, 0.0], [0.0, -0.5, 0.0]],
+    [[0.25, -0.25, 0.0], [-0.25, 0.25, 0.0], [0.125, -0.125, 0.125]],
+    [[-0.375, -0.375, -0.375], [-0.25, 0.0, 0.25],
+        [-0.125, -0.125, -0.125], [-0.25, 0.25, 0.0]],
+    [[0.125, 0.125, 0.125], [0.0, -0.5, 0.0],
+        [-0.25, -0.25, -0.25], [-0.125, -0.125, -0.125]],
+    [[0.0, -0.5, 0.0], [-0.25, -0.25, -0.25], [-0.125, -0.125, -0.125]],
+    [[-0.125, 0.125, 0.125], [0.25, -0.25, 0.0], [-0.25, 0.25, 0.0]],
+    [[0.0, 0.5, 0.0], [0.25, 0.25, -0.25],
+        [-0.125, -0.125, 0.125], [-0.125, -0.125, 0.125]],
+    [[-0.375, 0.375, -0.375], [-0.25, -0.25, 0.0],
+        [-0.125, 0.125, -0.125], [-0.25, 0.0, 0.25]],
+    [[0.0, 0.5, 0.0], [0.25, 0.25, -0.25], [-0.125, -0.125, 0.125]],
+    [[0.25, -0.25, 0.0], [-0.25, 0.25, 0.0],
+        [0.25, -0.25, 0.0], [0.25, -0.25, 0.0]],
+    [[-0.25, -0.25, 0.0], [-0.25, -0.25, 0.0], [-0.125, -0.125, 0.125]],
+    [[0.125, 0.125, 0.125], [-0.25, -0.25, 0.0], [-0.25, -0.25, 0.0]],
+    [[-0.25, -0.25, 0.0], [-0.25, -0.25, 0.0]],
+    [[-0.125, -0.125, 0.125]],
+    [[0.125, 0.125, 0.125], [-0.125, -0.125, 0.125]],
+    [[-0.125, -0.125, 0.125], [-0.125, -0.125, 0.125]],
+    [[-0.125, -0.125, 0.125], [-0.25, -0.25, 0.0], [0.25, 0.25, -0.0]],
+    [[0.0, -0.25, 0.25], [0.0, -0.25, 0.25]],
+    [[0.0, 0.0, 0.5], [0.25, -0.25, 0.25], [0.125, -0.125, 0.125]],
+    [[0.0, -0.25, 0.25], [0.0, -0.25, 0.25], [-0.125, -0.125, 0.125]],
+    [[0.375, -0.375, 0.375], [0.0, -0.25, -0.25],
+        [-0.125, 0.125, -0.125], [0.25, 0.25, 0.0]],
+    [[-0.125, -0.125, 0.125], [-0.125, 0.125, 0.125]],
+    [[0.125, 0.125, 0.125], [-0.125, -0.125, 0.125], [-0.125, 0.125, 0.125]],
+    [[-0.125, -0.125, 0.125], [-0.25, 0.0, 0.25], [-0.25, 0.0, 0.25]],
+    [[0.5, 0.0, 0.0], [-0.25, -0.25, 0.25],
+        [-0.125, -0.125, 0.125], [-0.125, -0.125, 0.125]],
+    [[-0.0, 0.5, 0.0], [-0.25, 0.25, -0.25], [0.125, -0.125, 0.125]],
+    [[-0.25, 0.25, -0.25], [-0.25, 0.25, -0.25],
+        [-0.125, 0.125, -0.125], [-0.125, 0.125, -0.125]],
+    [[-0.25, 0.0, -0.25], [0.375, -0.375, -0.375],
+        [0.0, 0.25, -0.25], [-0.125, 0.125, 0.125]],
+    [[0.5, 0.0, 0.0], [-0.25, 0.25, -0.25], [0.125, -0.125, 0.125]],
+    [[-0.25, 0.0, 0.25], [0.25, 0.0, -0.25]],
+    [[-0.0, 0.0, 0.5], [-0.25, 0.25, 0.25], [-0.125, 0.125, 0.125]],
+    [[-0.125, -0.125, 0.125], [-0.25, 0.0, 0.25], [0.25, 0.0, -0.25]],
+    [[-0.25, -0.0, -0.25], [-0.375, 0.375, 0.375],
+        [-0.25, -0.25, 0.0], [-0.125, 0.125, 0.125]],
+    [[0.0, 0.0, -0.5], [0.25, 0.25, -0.25], [-0.125, -0.125, 0.125]],
+    [[-0.0, 0.0, 0.5], [0.0, 0.0, 0.5]],
+    [[0.125, 0.125, 0.125], [0.125, 0.125, 0.125],
+        [0.25, 0.25, 0.25], [0.0, 0.0, 0.5]],
+    [[0.125, 0.125, 0.125], [0.25, 0.25, 0.25], [0.0, 0.0, 0.5]],
+    [[-0.25, 0.0, 0.25], [0.25, 0.0, -0.25], [-0.125, 0.125, 0.125]],
+    [[-0.0, 0.0, 0.5], [0.25, -0.25, 0.25],
+        [0.125, -0.125, 0.125], [0.125, -0.125, 0.125]],
+    [[-0.25, 0.0, 0.25], [-0.25, 0.0, 0.25],
+        [-0.25, 0.0, 0.25], [0.25, 0.0, -0.25]],
+    [[0.125, -0.125, 0.125], [0.25, 0.0, 0.25], [0.25, 0.0, 0.25]],
+    [[0.25, 0.0, 0.25], [-0.375, -0.375, 0.375],
+        [-0.25, 0.25, 0.0], [-0.125, -0.125, 0.125]],
+    [[-0.0, 0.0, 0.5], [0.25, -0.25, 0.25], [0.125, -0.125, 0.125]],
+    [[0.125, 0.125, 0.125], [0.25, 0.0, 0.25], [0.25, 0.0, 0.25]],
+    [[0.25, 0.0, 0.25], [0.25, 0.0, 0.25]],
+    [[-0.125, -0.125, 0.125], [0.125, -0.125, 0.125]],
+    [[0.125, 0.125, 0.125], [-0.125, -0.125, 0.125], [0.125, -0.125, 0.125]],
+    [[-0.125, -0.125, 0.125], [0.0, -0.25, 0.25], [0.0, 0.25, -0.25]],
+    [[0.0, -0.5, 0.0], [0.125, 0.125, -0.125],
+        [0.25, 0.25, -0.25], [-0.125, -0.125, 0.125]],
+    [[0.0, -0.25, 0.25], [0.0, -0.25, 0.25], [0.125, -0.125, 0.125]],
+    [[0.0, 0.0, 0.5], [0.25, -0.25, 0.25],
+        [0.125, -0.125, 0.125], [0.125, -0.125, 0.125]],
+    [[0.0, -0.25, 0.25], [0.0, -0.25, 0.25],
+        [0.0, -0.25, 0.25], [0.0, 0.25, -0.25]],
+    [[0.0, 0.25, 0.25], [0.0, 0.25, 0.25], [0.125, -0.125, -0.125]],
+    [[-0.125, 0.125, 0.125], [0.125, -0.125, 0.125], [-0.125, -0.125, 0.125]],
+    [[-0.125, 0.125, 0.125], [0.125, -0.125, 0.125],
+        [-0.125, -0.125, 0.125], [0.125, 0.125, 0.125]],
+    [[-0.0, 0.0, 0.5], [-0.25, -0.25, 0.25],
+        [-0.125, -0.125, 0.125], [-0.125, -0.125, 0.125]],
+    [[0.125, 0.125, 0.125], [0.125, -0.125, 0.125], [0.125, -0.125, -0.125]],
+    [[-0.0, 0.5, 0.0], [-0.25, 0.25, -0.25],
+        [0.125, -0.125, 0.125], [0.125, -0.125, 0.125]],
+    [[0.125, 0.125, 0.125], [-0.125, -0.125, 0.125], [0.125, -0.125, -0.125]],
+    [[0.0, -0.25, -0.25], [0.0, 0.25, 0.25], [0.125, 0.125, 0.125]],
+    [[0.125, 0.125, 0.125], [0.125, -0.125, -0.125]],
+    [[0.5, 0.0, -0.0], [0.25, -0.25, -0.25], [0.125, -0.125, -0.125]],
+    [[-0.25, 0.25, 0.25], [-0.125, 0.125, 0.125],
+        [-0.25, 0.25, 0.25], [0.125, -0.125, -0.125]],
+    [[0.375, -0.375, 0.375], [0.0, 0.25, 0.25],
+        [-0.125, 0.125, -0.125], [-0.25, 0.0, 0.25]],
+    [[0.0, -0.5, 0.0], [-0.25, 0.25, 0.25], [-0.125, 0.125, 0.125]],
+    [[-0.375, -0.375, 0.375], [0.25, -0.25, 0.0],
+        [0.0, 0.25, 0.25], [-0.125, -0.125, 0.125]],
+    [[-0.125, 0.125, 0.125], [-0.25, 0.25, 0.25], [0.0, 0.0, 0.5]],
+    [[0.125, 0.125, 0.125], [0.0, 0.25, 0.25], [0.0, 0.25, 0.25]],
+    [[0.0, 0.25, 0.25], [0.0, 0.25, 0.25]],
+    [[0.5, 0.0, -0.0], [0.25, 0.25, 0.25],
+        [0.125, 0.125, 0.125], [0.125, 0.125, 0.125]],
+    [[0.125, -0.125, 0.125], [-0.125, -0.125, 0.125], [0.125, 0.125, 0.125]],
+    [[-0.25, -0.0, -0.25], [0.25, 0.0, 0.25], [0.125, 0.125, 0.125]],
+    [[0.125, 0.125, 0.125], [0.125, -0.125, 0.125]],
+    [[-0.25, -0.25, 0.0], [0.25, 0.25, -0.0], [0.125, 0.125, 0.125]],
+    [[0.125, 0.125, 0.125], [-0.125, -0.125, 0.125]],
+    [[0.125, 0.125, 0.125], [0.125, 0.125, 0.125]],
+    [[0.125, 0.125, 0.125]],
+    [[0.125, 0.125, 0.125]],
+    [[0.125, 0.125, 0.125], [0.125, 0.125, 0.125]],
+    [[0.125, 0.125, 0.125], [-0.125, -0.125, 0.125]],
+    [[-0.25, -0.25, 0.0], [0.25, 0.25, -0.0], [0.125, 0.125, 0.125]],
+    [[0.125, 0.125, 0.125], [0.125, -0.125, 0.125]],
+    [[-0.25, -0.0, -0.25], [0.25, 0.0, 0.25], [0.125, 0.125, 0.125]],
+    [[0.125, -0.125, 0.125], [-0.125, -0.125, 0.125], [0.125, 0.125, 0.125]],
+    [[0.5, 0.0, -0.0], [0.25, 0.25, 0.25],
+        [0.125, 0.125, 0.125], [0.125, 0.125, 0.125]],
+    [[0.0, 0.25, 0.25], [0.0, 0.25, 0.25]],
+    [[0.125, 0.125, 0.125], [0.0, 0.25, 0.25], [0.0, 0.25, 0.25]],
+    [[-0.125, 0.125, 0.125], [-0.25, 0.25, 0.25], [0.0, 0.0, 0.5]],
+    [[-0.375, -0.375, 0.375], [0.25, -0.25, 0.0],
+        [0.0, 0.25, 0.25], [-0.125, -0.125, 0.125]],
+    [[0.0, -0.5, 0.0], [-0.25, 0.25, 0.25], [-0.125, 0.125, 0.125]],
+    [[0.375, -0.375, 0.375], [0.0, 0.25, 0.25],
+        [-0.125, 0.125, -0.125], [-0.25, 0.0, 0.25]],
+    [[-0.25, 0.25, 0.25], [-0.125, 0.125, 0.125],
+        [-0.25, 0.25, 0.25], [0.125, -0.125, -0.125]],
+    [[0.5, 0.0, -0.0], [0.25, -0.25, -0.25], [0.125, -0.125, -0.125]],
+    [[0.125, 0.125, 0.125], [0.125, -0.125, -0.125]],
+    [[0.0, -0.25, -0.25], [0.0, 0.25, 0.25], [0.125, 0.125, 0.125]],
+    [[0.125, 0.125, 0.125], [-0.125, -0.125, 0.125], [0.125, -0.125, -0.125]],
+    [[-0.0, 0.5, 0.0], [-0.25, 0.25, -0.25],
+        [0.125, -0.125, 0.125], [0.125, -0.125, 0.125]],
+    [[0.125, 0.125, 0.125], [0.125, -0.125, 0.125], [0.125, -0.125, -0.125]],
+    [[-0.0, 0.0, 0.5], [-0.25, -0.25, 0.25],
+        [-0.125, -0.125, 0.125], [-0.125, -0.125, 0.125]],
+    [[-0.125, 0.125, 0.125], [0.125, -0.125, 0.125],
+        [-0.125, -0.125, 0.125], [0.125, 0.125, 0.125]],
+    [[-0.125, 0.125, 0.125], [0.125, -0.125, 0.125], [-0.125, -0.125, 0.125]],
+    [[0.0, 0.25, 0.25], [0.0, 0.25, 0.25], [0.125, -0.125, -0.125]],
+    [[0.0, -0.25, -0.25], [0.0, 0.25, 0.25], [0.0, 0.25, 0.25], [0.0, 0.25, 0.25]],
+    [[0.0, 0.0, 0.5], [0.25, -0.25, 0.25],
+        [0.125, -0.125, 0.125], [0.125, -0.125, 0.125]],
+    [[0.0, -0.25, 0.25], [0.0, -0.25, 0.25], [0.125, -0.125, 0.125]],
+    [[0.0, -0.5, 0.0], [0.125, 0.125, -0.125],
+        [0.25, 0.25, -0.25], [-0.125, -0.125, 0.125]],
+    [[-0.125, -0.125, 0.125], [0.0, -0.25, 0.25], [0.0, 0.25, -0.25]],
+    [[0.125, 0.125, 0.125], [-0.125, -0.125, 0.125], [0.125, -0.125, 0.125]],
+    [[-0.125, -0.125, 0.125], [0.125, -0.125, 0.125]],
+    [[0.25, 0.0, 0.25], [0.25, 0.0, 0.25]],
+    [[0.125, 0.125, 0.125], [0.25, 0.0, 0.25], [0.25, 0.0, 0.25]],
+    [[-0.0, 0.0, 0.5], [0.25, -0.25, 0.25], [0.125, -0.125, 0.125]],
+    [[0.25, 0.0, 0.25], [-0.375, -0.375, 0.375],
+        [-0.25, 0.25, 0.0], [-0.125, -0.125, 0.125]],
+    [[0.125, -0.125, 0.125], [0.25, 0.0, 0.25], [0.25, 0.0, 0.25]],
+    [[-0.25, -0.0, -0.25], [0.25, 0.0, 0.25],
+        [0.25, 0.0, 0.25], [0.25, 0.0, 0.25]],
+    [[-0.0, 0.0, 0.5], [0.25, -0.25, 0.25],
+        [0.125, -0.125, 0.125], [0.125, -0.125, 0.125]],
+    [[-0.25, 0.0, 0.25], [0.25, 0.0, -0.25], [-0.125, 0.125, 0.125]],
+    [[0.125, 0.125, 0.125], [0.25, 0.25, 0.25], [0.0, 0.0, 0.5]],
+    [[0.125, 0.125, 0.125], [0.125, 0.125, 0.125],
+        [0.25, 0.25, 0.25], [0.0, 0.0, 0.5]],
+    [[-0.0, 0.0, 0.5], [0.0, 0.0, 0.5]],
+    [[0.0, 0.0, -0.5], [0.25, 0.25, -0.25], [-0.125, -0.125, 0.125]],
+    [[-0.25, -0.0, -0.25], [-0.375, 0.375, 0.375],
+        [-0.25, -0.25, 0.0], [-0.125, 0.125, 0.125]],
+    [[-0.125, -0.125, 0.125], [-0.25, 0.0, 0.25], [0.25, 0.0, -0.25]],
+    [[-0.0, 0.0, 0.5], [-0.25, 0.25, 0.25], [-0.125, 0.125, 0.125]],
+    [[-0.25, 0.0, 0.25], [0.25, 0.0, -0.25]],
+    [[0.5, 0.0, 0.0], [-0.25, 0.25, -0.25], [0.125, -0.125, 0.125]],
+    [[-0.25, 0.0, -0.25], [0.375, -0.375, -0.375],
+        [0.0, 0.25, -0.25], [-0.125, 0.125, 0.125]],
+    [[-0.25, 0.25, -0.25], [-0.25, 0.25, -0.25],
+        [-0.125, 0.125, -0.125], [-0.125, 0.125, -0.125]],
+    [[-0.0, 0.5, 0.0], [-0.25, 0.25, -0.25], [0.125, -0.125, 0.125]],
+    [[0.5, 0.0, 0.0], [-0.25, -0.25, 0.25],
+        [-0.125, -0.125, 0.125], [-0.125, -0.125, 0.125]],
+    [[-0.125, -0.125, 0.125], [-0.25, 0.0, 0.25], [-0.25, 0.0, 0.25]],
+    [[0.125, 0.125, 0.125], [-0.125, -0.125, 0.125], [-0.125, 0.125, 0.125]],
+    [[-0.125, -0.125, 0.125], [-0.125, 0.125, 0.125]],
+    [[0.375, -0.375, 0.375], [0.0, -0.25, -0.25],
+        [-0.125, 0.125, -0.125], [0.25, 0.25, 0.0]],
+    [[0.0, -0.25, 0.25], [0.0, -0.25, 0.25], [-0.125, -0.125, 0.125]],
+    [[0.0, 0.0, 0.5], [0.25, -0.25, 0.25], [0.125, -0.125, 0.125]],
+    [[0.0, -0.25, 0.25], [0.0, -0.25, 0.25]],
+    [[-0.125, -0.125, 0.125], [-0.25, -0.25, 0.0], [0.25, 0.25, -0.0]],
+    [[-0.125, -0.125, 0.125], [-0.125, -0.125, 0.125]],
+    [[0.125, 0.125, 0.125], [-0.125, -0.125, 0.125]],
+    [[-0.125, -0.125, 0.125]],
+    [[-0.25, -0.25, 0.0], [-0.25, -0.25, 0.0]],
+    [[0.125, 0.125, 0.125], [-0.25, -0.25, 0.0], [-0.25, -0.25, 0.0]],
+    [[-0.25, -0.25, 0.0], [-0.25, -0.25, 0.0], [-0.125, -0.125, 0.125]],
+    [[-0.25, -0.25, 0.0], [-0.25, -0.25, 0.0],
+        [-0.25, -0.25, 0.0], [0.25, 0.25, -0.0]],
+    [[0.0, 0.5, 0.0], [0.25, 0.25, -0.25], [-0.125, -0.125, 0.125]],
+    [[-0.375, 0.375, -0.375], [-0.25, -0.25, 0.0],
+        [-0.125, 0.125, -0.125], [-0.25, 0.0, 0.25]],
+    [[0.0, 0.5, 0.0], [0.25, 0.25, -0.25],
+        [-0.125, -0.125, 0.125], [-0.125, -0.125, 0.125]],
+    [[-0.125, 0.125, 0.125], [0.25, -0.25, 0.0], [-0.25, 0.25, 0.0]],
+    [[0.0, -0.5, 0.0], [-0.25, -0.25, -0.25], [-0.125, -0.125, -0.125]],
+    [[0.125, 0.125, 0.125], [0.0, -0.5, 0.0],
+        [-0.25, -0.25, -0.25], [-0.125, -0.125, -0.125]],
+    [[-0.375, -0.375, -0.375], [-0.25, 0.0, 0.25],
+        [-0.125, -0.125, -0.125], [-0.25, 0.25, 0.0]],
+    [[0.25, -0.25, 0.0], [-0.25, 0.25, 0.0], [0.125, -0.125, 0.125]],
+    [[0.0, 0.5, 0.0], [0.0, -0.5, 0.0]],
+    [[0.0, 0.5, 0.0], [0.125, -0.125, 0.125], [-0.25, 0.25, -0.25]],
+    [[0.0, 0.5, 0.0], [-0.25, 0.25, 0.25], [0.125, -0.125, -0.125]],
+    [[0.25, -0.25, 0.0], [-0.25, 0.25, 0.0]],
+    [[-0.5, 0.0, 0.0], [-0.25, -0.25, 0.25], [-0.125, -0.125, 0.125]],
+    [[0.0, 0.25, -0.25], [0.375, -0.375, -0.375],
+        [-0.125, 0.125, 0.125], [0.25, 0.25, 0.0]],
+    [[0.5, 0.0, 0.0], [0.25, -0.25, 0.25],
+        [-0.125, 0.125, -0.125], [0.125, -0.125, 0.125]],
+    [[0.125, -0.125, 0.125], [0.25, -0.25, 0.0], [0.25, -0.25, 0.0]],
+    [[0.25, 0.25, -0.25], [0.25, 0.25, -0.25],
+        [0.125, 0.125, -0.125], [-0.125, -0.125, 0.125]],
+    [[-0.0, 0.0, 0.5], [-0.25, -0.25, 0.25], [-0.125, -0.125, 0.125]],
+    [[0.125, 0.125, 0.125], [0.125, -0.125, 0.125], [-0.125, 0.125, 0.125]],
+    [[-0.125, 0.125, 0.125], [0.125, -0.125, 0.125]],
+    [[-0.375, -0.375, 0.375], [-0.0, 0.25, 0.25],
+        [0.125, 0.125, -0.125], [-0.25, -0.0, -0.25]],
+    [[0.0, -0.25, 0.25], [0.0, 0.25, -0.25], [0.125, -0.125, 0.125]],
+    [[0.125, -0.125, 0.125], [-0.25, -0.0, -0.25], [0.25, 0.0, 0.25]],
+    [[0.125, -0.125, 0.125], [0.125, -0.125, 0.125]],
+    [[0.0, -0.5, 0.0], [0.125, 0.125, -0.125], [0.25, 0.25, -0.25]],
+    [[0.0, -0.25, 0.25], [0.0, 0.25, -0.25]],
+    [[0.125, 0.125, 0.125], [0.125, -0.125, 0.125]],
+    [[0.125, -0.125, 0.125]],
+    [[-0.5, 0.0, 0.0], [-0.125, -0.125, -0.125], [-0.25, -0.25, -0.25]],
+    [[-0.5, 0.0, 0.0], [-0.125, -0.125, -0.125],
+        [-0.25, -0.25, -0.25], [0.125, 0.125, 0.125]],
+    [[0.375, 0.375, 0.375], [0.0, 0.25, -0.25],
+        [-0.125, -0.125, -0.125], [-0.25, 0.25, 0.0]],
+    [[0.125, -0.125, -0.125], [0.25, -0.25, 0.0], [0.25, -0.25, 0.0]],
+    [[0.125, 0.125, 0.125], [0.375, 0.375, 0.375],
+        [0.0, -0.25, 0.25], [-0.25, 0.0, 0.25]],
+    [[-0.25, 0.0, 0.25], [-0.25, 0.0, 0.25], [0.125, -0.125, -0.125]],
+    [[0.0, -0.25, -0.25], [0.0, 0.25, 0.25], [-0.125, 0.125, 0.125]],
+    [[-0.125, 0.125, 0.125], [0.125, -0.125, -0.125]],
+    [[-0.125, -0.125, -0.125], [-0.25, -0.25, -0.25],
+        [0.25, 0.25, 0.25], [0.125, 0.125, 0.125]],
+    [[-0.125, -0.125, 0.125], [0.125, -0.125, 0.125], [0.125, -0.125, -0.125]],
+    [[0.0, 0.0, -0.5], [0.25, 0.25, 0.25], [-0.125, -0.125, -0.125]],
+    [[0.125, -0.125, 0.125], [0.125, -0.125, -0.125]],
+    [[0.0, -0.5, 0.0], [0.25, 0.25, 0.25], [0.125, 0.125, 0.125]],
+    [[-0.125, -0.125, 0.125], [0.125, -0.125, -0.125]],
+    [[0.0, -0.25, -0.25], [0.0, 0.25, 0.25]],
+    [[0.125, -0.125, -0.125]],
+    [[0.5, 0.0, 0.0], [0.5, 0.0, 0.0]],
+    [[-0.5, 0.0, 0.0], [-0.25, 0.25, 0.25], [-0.125, 0.125, 0.125]],
+    [[0.5, 0.0, 0.0], [0.25, -0.25, 0.25], [-0.125, 0.125, -0.125]],
+    [[0.25, -0.25, 0.0], [0.25, -0.25, 0.0]],
+    [[0.5, 0.0, 0.0], [-0.25, -0.25, 0.25], [-0.125, -0.125, 0.125]],
+    [[-0.25, 0.0, 0.25], [-0.25, 0.0, 0.25]],
+    [[0.125, 0.125, 0.125], [-0.125, 0.125, 0.125]],
+    [[-0.125, 0.125, 0.125]],
+    [[0.5, 0.0, -0.0], [0.25, 0.25, 0.25], [0.125, 0.125, 0.125]],
+    [[0.125, -0.125, 0.125], [-0.125, -0.125, 0.125]],
+    [[-0.25, -0.0, -0.25], [0.25, 0.0, 0.25]],
+    [[0.125, -0.125, 0.125]],
+    [[-0.25, -0.25, 0.0], [0.25, 0.25, -0.0]],
+    [[-0.125, -0.125, 0.125]],
+    [[0.125, 0.125, 0.125]],
+    [[0, 0, 0]]]
+# pylint: enable=line-too-long
+
+
+def create_table_neighbour_code_to_surface_area(spacing_mm):
+    """Returns an array mapping neighbourhood code to the surface elements area.
+    Note that the normals encode the initial surface area. This function computes
+    the area corresponding to the given `spacing_mm`.
+    Args:
+      spacing_mm: 3-element list-like structure. Voxel spacing in x0, x1 and x2
+        direction.
+    """
+    # compute the area for all 256 possible surface elements
+    # (given a 2x2x2 neighbourhood) according to the spacing_mm
+    neighbour_code_to_surface_area = np.zeros([256])
+    for code in range(256):
+        normals = np.array(_NEIGHBOUR_CODE_TO_NORMALS[code])
+        sum_area = 0
+        for normal_idx in range(normals.shape[0]):
+            # normal vector
+            n = np.zeros([3])
+            n[0] = normals[normal_idx, 0] * spacing_mm[1] * spacing_mm[2]
+            n[1] = normals[normal_idx, 1] * spacing_mm[0] * spacing_mm[2]
+            n[2] = normals[normal_idx, 2] * spacing_mm[0] * spacing_mm[1]
+            area = np.linalg.norm(n)
+            sum_area += area
+        neighbour_code_to_surface_area[code] = sum_area
+
+    return neighbour_code_to_surface_area
+
+
+# In the neighbourhood, points are ordered: top left, top right, bottom left,
+# bottom right.
+ENCODE_NEIGHBOURHOOD_2D_KERNEL = np.array([[8, 4], [2, 1]])
+
+
+def create_table_neighbour_code_to_contour_length(spacing_mm):
+    """Returns an array mapping neighbourhood code to the contour length.
+    For the list of possible cases and their figures, see page 38 from:
+    https://nccastaff.bournemouth.ac.uk/jmacey/MastersProjects/MSc14/06/thesis.pdf
+    In 2D, each point has 4 neighbors. Thus, are 16 configurations. A
+    configuration is encoded with '1' meaning "inside the object" and '0' "outside
+    the object". The points are ordered: top left, top right, bottom left, bottom
+    right.
+    The x0 axis is assumed vertical downward, and the x1 axis is horizontal to the
+    right:
+     (0, 0) --> (0, 1)
+       |
+     (1, 0)
+    Args:
+      spacing_mm: 2-element list-like structure. Voxel spacing in x0 and x1
+        directions.
+    """
+    neighbour_code_to_contour_length = np.zeros([16])
+
+    vertical = spacing_mm[0]
+    horizontal = spacing_mm[1]
+    diag = 0.5 * math.sqrt(spacing_mm[0]**2 + spacing_mm[1]**2)
+    # pyformat: disable
+    neighbour_code_to_contour_length[int("00"
+                                         "01", 2)] = diag
+
+    neighbour_code_to_contour_length[int("00"
+                                         "10", 2)] = diag
+
+    neighbour_code_to_contour_length[int("00"
+                                         "11", 2)] = horizontal
+
+    neighbour_code_to_contour_length[int("01"
+                                         "00", 2)] = diag
+
+    neighbour_code_to_contour_length[int("01"
+                                         "01", 2)] = vertical
+
+    neighbour_code_to_contour_length[int("01"
+                                         "10", 2)] = 2*diag
+
+    neighbour_code_to_contour_length[int("01"
+                                         "11", 2)] = diag
+
+    neighbour_code_to_contour_length[int("10"
+                                         "00", 2)] = diag
+
+    neighbour_code_to_contour_length[int("10"
+                                         "01", 2)] = 2*diag
+
+    neighbour_code_to_contour_length[int("10"
+                                         "10", 2)] = vertical
+
+    neighbour_code_to_contour_length[int("10"
+                                         "11", 2)] = diag
+
+    neighbour_code_to_contour_length[int("11"
+                                         "00", 2)] = horizontal
+
+    neighbour_code_to_contour_length[int("11"
+                                         "01", 2)] = diag
+
+    neighbour_code_to_contour_length[int("11"
+                                         "10", 2)] = diag
+    # pyformat: enable
+
+    return neighbour_code_to_contour_length

deepatlas/metrics/metrics.py

@@ -0,0 +1,355 @@
+import numpy as np
+import nibabel as nib
+import ants
+import argparse
+import pandas as pd
+import glob
+import os
+import surface_distance
+import nrrd
+import shutil
+import distanceVertex2Mesh
+import textwrap
+
+
+def parse_command_line():
+    print('---'*10)
+    print('Parsing Command Line Arguments')
+    parser = argparse.ArgumentParser(
+        description='Inference evaluation pipeline for image registration-segmentation', formatter_class=argparse.RawTextHelpFormatter)
+    parser.add_argument('-bp', metavar='base path', type=str,
+                        help="Absolute path of the base directory")
+    parser.add_argument('-gp', metavar='ground truth path', type=str,
+                        help="Relative path of the ground truth segmentation directory")
+    parser.add_argument('-pp', metavar='predicted path', type=str,
+                        help="Relative path of predicted segmentation directory")
+    parser.add_argument('-sp', metavar='save path', type=str,
+                        help="Relative path of CSV file directory to save, if not specify, default is base directory")
+    parser.add_argument('-vt', metavar='validation type', type=str, nargs='+',
+                        help=textwrap.dedent('''Validation type:
+                dsc: Dice Score
+                ahd: Average Hausdorff Distance
+                whd: Weighted Hausdorff Distance
+                        '''))
+    parser.add_argument('-pm', metavar='probability map path', type=str,
+                        help="Relative path of text file directory of probability map")
+    parser.add_argument('-fn', metavar='file name', type=str,
+                        help="name of output file")
+    parser.add_argument('-reg', action='store_true',
+                        help="check if the input files are registration predictions")
+    parser.add_argument('-tp', metavar='type of segmentation', type=str,
+                        help=textwrap.dedent('''Segmentation type:
+                ET: Eustachian Tube
+                NC: Nasal Cavity
+                HT: Head Tumor
+                        '''))
+    parser.add_argument('-sl', metavar='segmentation information list', type=str, nargs='+',
+                        help='a list of label name and corresponding value')
+    parser.add_argument('-cp', metavar='current prefix of filenames', type=str,
+                        help='current prefix of filenames')
+    argv = parser.parse_args()
+    return argv
+
+
+def rename(prefix, filename):
+    name = filename.split('.')[0][-3:]
+    name = prefix + '_' + name
+    return name
+
+def dice_coefficient_and_hausdorff_distance(filename, img_np_pred, img_np_gt, num_classes, spacing, probability_map, dsc, ahd, whd, average_DSC, average_HD):
+    df = pd.DataFrame()
+    data_gt, bool_gt = make_one_hot(img_np_gt, num_classes)
+    data_pred, bool_pred = make_one_hot(img_np_pred, num_classes)
+    for i in range(1, num_classes):
+        df1 = pd.DataFrame([[filename, i]], columns=[
+            'File ID', 'Label Value'])
+        if dsc:
+            if data_pred[i].any():
+                volume_sum = data_gt[i].sum() + data_pred[i].sum()
+                if volume_sum == 0:
+                    return np.NaN
+
+                volume_intersect = (data_gt[i] & data_pred[i]).sum()
+                dice = 2*volume_intersect / volume_sum
+                df1['Dice Score'] = dice
+                average_DSC[i-1] += dice
+            else:
+                dice = 0.0
+                df1['Dice Score'] = dice
+                average_DSC[i-1] += dice
+        if ahd:
+            if data_pred[i].any():
+                avd = average_hausdorff_distance(bool_gt[i], bool_pred[i], spacing)
+                df1['Average Hausdorff Distance'] = avd
+                average_HD[i-1] += avd
+            else:
+                avd = np.nan
+                df1['Average Hausdorff Distance'] = avd
+                average_HD[i-1] += avd
+        if whd:
+            # wgd = weighted_hausdorff_distance(gt, pred, probability_map)
+            # df1['Weighted Hausdorff Distance'] = wgd
+            pass
+
+        df = pd.concat([df, df1])
+    return df, average_DSC, average_HD
+
+
+def make_one_hot(img_np, num_classes):
+    img_one_hot_dice = np.zeros(
+        (num_classes, img_np.shape[0], img_np.shape[1], img_np.shape[2]), dtype=np.int8)
+    img_one_hot_hd = np.zeros(
+        (num_classes, img_np.shape[0], img_np.shape[1], img_np.shape[2]), dtype=bool)
+    for i in range(num_classes):
+        a = (img_np == i)
+        img_one_hot_dice[i, :, :, :] = a
+        img_one_hot_hd[i, :, :, :] = a
+
+    return img_one_hot_dice, img_one_hot_hd
+
+
+def average_hausdorff_distance(img_np_gt, img_np_pred, spacing):
+    surf_distance = surface_distance.compute_surface_distances(
+        img_np_gt, img_np_pred, spacing)
+    gp, pg = surface_distance.compute_average_surface_distance(surf_distance)
+    return (gp + pg) / 2
+
+
+def checkSegFormat(base, segmentation, type, prefix=None):
+    if type == 'gt':
+        save_dir = os.path.join(base, 'gt_reformat_labels')
+        path = segmentation
+    else:
+        save_dir = os.path.join(base, 'pred_reformat_labels')
+        path = os.path.join(base, segmentation)
+    try:
+        os.mkdir(save_dir)
+    except:
+        print(f'{save_dir} already exists')
+
+    for file in os.listdir(path):
+        if type == 'gt':
+            if prefix is not None:
+                name = rename(prefix, file)
+            else:
+                name = file.split('.')[0]
+        else:
+            name = file.split('.')[0]
+
+        if file.endswith('seg.nrrd'):
+            ants_img = ants.image_read(os.path.join(path, file))
+            header = nrrd.read_header(os.path.join(path, file))
+            filename = os.path.join(save_dir, name + '.nii.gz')
+            nrrd2nifti(ants_img, header, filename)
+        elif file.endswith('nii'):
+            image = ants.image_read(os.path.join(path, file))
+            image.to_file(os.path.join(save_dir, name + '.nii.gz'))
+        elif file.endswith('nii.gz'):
+            shutil.copy(os.path.join(path, file), os.path.join(save_dir, name + '.nii.gz'))
+
+    return save_dir
+
+
+def nrrd2nifti(img, header, filename):
+    img_as_np = img.view(single_components=True)
+    data = convert_to_one_hot(img_as_np, header)
+    foreground = np.max(data, axis=0)
+    labelmap = np.multiply(np.argmax(data, axis=0) + 1,
+                           foreground).astype('uint8')
+    segmentation_img = ants.from_numpy(
+        labelmap, origin=img.origin, spacing=img.spacing, direction=img.direction)
+    print('-- Saving NII Segmentations')
+    segmentation_img.to_file(filename)
+
+
+def convert_to_one_hot(data, header, segment_indices=None):
+    print('---'*10)
+    print("converting to one hot")
+
+    layer_values = get_layer_values(header)
+    label_values = get_label_values(header)
+
+    # Newer Slicer NRRD (compressed layers)
+    if layer_values and label_values:
+
+        assert len(layer_values) == len(label_values)
+        if len(data.shape) == 3:
+            x_dim, y_dim, z_dim = data.shape
+        elif len(data.shape) == 4:
+            x_dim, y_dim, z_dim = data.shape[1:]
+
+        num_segments = len(layer_values)
+        one_hot = np.zeros((num_segments, x_dim, y_dim, z_dim))
+
+        if segment_indices is None:
+            segment_indices = list(range(num_segments))
+
+        elif isinstance(segment_indices, int):
+            segment_indices = [segment_indices]
+
+        elif not isinstance(segment_indices, list):
+            print("incorrectly specified segment indices")
+            return
+
+        # Check if NRRD is composed of one layer 0
+        if np.max(layer_values) == 0:
+            for i, seg_idx in enumerate(segment_indices):
+                layer = layer_values[seg_idx]
+                label = label_values[seg_idx]
+                one_hot[i] = 1*(data == label).astype(np.uint8)
+
+        else:
+            for i, seg_idx in enumerate(segment_indices):
+                layer = layer_values[seg_idx]
+                label = label_values[seg_idx]
+                one_hot[i] = 1*(data[layer] == label).astype(np.uint8)
+
+    # Binary labelmap
+    elif len(data.shape) == 3:
+        x_dim, y_dim, z_dim = data.shape
+        num_segments = np.max(data)
+        one_hot = np.zeros((num_segments, x_dim, y_dim, z_dim))
+
+        if segment_indices is None:
+            segment_indices = list(range(1, num_segments + 1))
+
+        elif isinstance(segment_indices, int):
+            segment_indices = [segment_indices]
+
+        elif not isinstance(segment_indices, list):
+            print("incorrectly specified segment indices")
+            return
+
+        for i, seg_idx in enumerate(segment_indices):
+            one_hot[i] = 1*(data == seg_idx).astype(np.uint8)
+
+    # Older Slicer NRRD (already one-hot)
+    else:
+        return data
+
+    return one_hot
+
+
+def get_layer_values(header):
+    layer_values = []
+    num_segments = len([key for key in header.keys() if "Layer" in key])
+    for i in range(num_segments):
+        layer_values.append(int(header['Segment{}_Layer'.format(i)]))
+    return layer_values
+
+
+def get_label_values(header):
+    label_values = []
+    num_segments = len([key for key in header.keys() if "LabelValue" in key])
+    for i in range(num_segments):
+        label_values.append(int(header['Segment{}_LabelValue'.format(i)]))
+    return label_values
+
+
+def main():
+    args = parse_command_line()
+    base = args.bp
+    gt_path = args.gp
+    pred_path = args.pp
+    if args.sp is None:
+        save_path = base
+    else:
+        save_path = args.sp
+    validation_type = args.vt
+    probability_map_path = args.pm
+    filename = args.fn
+    reg = args.reg
+    seg_type = args.tp
+    label_list = args.sl
+    current_prefix = args.cp
+    if probability_map_path is not None:
+        probability_map = np.loadtxt(os.path.join(base, probability_map_path))
+    else:
+        probability_map = None
+    dsc = False
+    ahd = False
+    whd = False
+    for i in range(len(validation_type)):
+        if validation_type[i] == 'dsc':
+            dsc = True
+        elif validation_type[i] == 'ahd':
+            ahd = True
+        elif validation_type[i] == 'whd':
+            whd = True
+        else:
+            print('wrong validation type, please choose correct one !!!')
+            return
+
+    filepath = os.path.join(base, save_path, 'output_' + filename + '.csv')
+    save_dir = os.path.join(base, save_path)
+    gt_output_path = checkSegFormat(base, gt_path, 'gt', current_prefix)
+    pred_output_path = checkSegFormat(base, pred_path, 'pred', current_prefix)
+    try:
+        os.mkdir(save_dir)
+    except:
+        print(f'{save_dir} already exists')
+    
+    try:
+        os.mknod(filepath)
+    except:
+        print(f'{filepath} already exists')
+
+    DSC = pd.DataFrame()
+    file = glob.glob(os.path.join(base, gt_output_path) + '/*nii.gz')[0]
+    seg_file = ants.image_read(file)
+    num_class = np.unique(seg_file.numpy().ravel()).shape[0]
+    average_DSC = np.zeros((num_class-1))
+    average_HD = np.zeros((num_class-1))
+    k = 0
+    for i in glob.glob(os.path.join(base, pred_output_path) + '/*nii.gz'):
+        k += 1
+        pred_img = ants.image_read(i)
+        pred_spacing = list(pred_img.spacing)
+        if reg and seg_type == 'ET':
+            file_name = os.path.basename(i).split('.')[0].split('_')[4] + '_' + os.path.basename(
+                i).split('.')[0].split('_')[5] + '_' + os.path.basename(i).split('.')[0].split('_')[6]
+            file_name1 = os.path.basename(i).split('.')[0]
+        elif reg and seg_type == 'NC':
+            file_name = os.path.basename(i).split(
+                '.')[0].split('_')[3] + '_' + os.path.basename(i).split('.')[0].split('_')[4]
+            file_name1 = os.path.basename(i).split('.')[0]
+        elif reg and seg_type == 'HT':
+            file_name = os.path.basename(i).split('.')[0].split('_')[2]
+            file_name1 = os.path.basename(i).split('.')[0]
+        else:
+            file_name = os.path.basename(i).split('.')[0]
+            file_name1 = os.path.basename(i).split('.')[0]
+        gt_seg = os.path.join(base, gt_output_path, file_name + '.nii.gz')
+        gt_img = ants.image_read(gt_seg)
+        gt_spacing = list(gt_img.spacing)
+
+        if gt_spacing != pred_spacing:
+            print(
+                "Spacing of prediction and ground_truth is not matched, please check again !!!")
+            return
+
+        ref = pred_img
+        data_ref = ref.numpy()
+
+        pred = gt_img
+        data_pred = pred.numpy()
+
+        num_class = len(np.unique(data_pred))
+        ds, aver_DSC, aver_HD = dice_coefficient_and_hausdorff_distance(
+            file_name1, data_ref, data_pred, num_class, pred_spacing, probability_map, dsc, ahd, whd, average_DSC, average_HD)
+        DSC = pd.concat([DSC, ds])
+        average_DSC = aver_DSC
+        average_HD = aver_HD
+
+    avg_DSC = average_DSC / k
+    avg_HD = average_HD / k
+    print(avg_DSC)
+    with open(os.path.join(base, save_path, "metric.txt"), 'w') as f:
+        f.write("Label Value  Label Name  Average Dice Score  Average Mean HD\n")
+        for i in range(len(avg_DSC)):
+            f.write(f'{str(i+1):^12}{str(label_list[2*i+1]):^12}{str(avg_DSC[i]):^20}{str(avg_HD[i]):^18}\n')
+    DSC.to_csv(filepath)
+
+
+if __name__ == '__main__':
+    main()

deepatlas/metrics/surface_distance.py

@@ -0,0 +1,424 @@
+# Copyright 2018 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS-IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language 
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import lookup_tables  # pylint: disable=relative-beyond-top-level
+import numpy as np
+from scipy import ndimage
+
+"""
+
+surface_distance.py
+
+all of the surface_distance functions are borrowed from DeepMind surface_distance repository
+
+"""
+def _assert_is_numpy_array(name, array):
+    """Raises an exception if `array` is not a numpy array."""
+    if not isinstance(array, np.ndarray):
+        raise ValueError("The argument {!r} should be a numpy array, not a "
+                         "{}".format(name, type(array)))
+
+
+def _check_nd_numpy_array(name, array, num_dims):
+    """Raises an exception if `array` is not a `num_dims`-D numpy array."""
+    if len(array.shape) != num_dims:
+        raise ValueError("The argument {!r} should be a {}D array, not of "
+                         "shape {}".format(name, num_dims, array.shape))
+
+
+def _check_2d_numpy_array(name, array):
+    _check_nd_numpy_array(name, array, num_dims=2)
+
+
+def _check_3d_numpy_array(name, array):
+    _check_nd_numpy_array(name, array, num_dims=3)
+
+
+def _assert_is_bool_numpy_array(name, array):
+    _assert_is_numpy_array(name, array)
+    if array.dtype != np.bool:
+        raise ValueError("The argument {!r} should be a numpy array of type bool, "
+                         "not {}".format(name, array.dtype))
+
+
+def _compute_bounding_box(mask):
+    """Computes the bounding box of the masks.
+    This function generalizes to arbitrary number of dimensions great or equal
+    to 1.
+    Args:
+      mask: The 2D or 3D numpy mask, where '0' means background and non-zero means
+        foreground.
+    Returns:
+      A tuple:
+       - The coordinates of the first point of the bounding box (smallest on all
+         axes), or `None` if the mask contains only zeros.
+       - The coordinates of the second point of the bounding box (greatest on all
+         axes), or `None` if the mask contains only zeros.
+    """
+    num_dims = len(mask.shape)
+    bbox_min = np.zeros(num_dims, np.int64)
+    bbox_max = np.zeros(num_dims, np.int64)
+
+    # max projection to the x0-axis
+    proj_0 = np.amax(mask, axis=tuple(range(num_dims))[1:])
+    idx_nonzero_0 = np.nonzero(proj_0)[0]
+    if len(idx_nonzero_0) == 0:  # pylint: disable=g-explicit-length-test
+        return None, None
+
+    bbox_min[0] = np.min(idx_nonzero_0)
+    bbox_max[0] = np.max(idx_nonzero_0)
+
+    # max projection to the i-th-axis for i in {1, ..., num_dims - 1}
+    for axis in range(1, num_dims):
+        max_over_axes = list(range(num_dims))  # Python 3 compatible
+        max_over_axes.pop(axis)  # Remove the i-th dimension from the max
+        max_over_axes = tuple(max_over_axes)  # numpy expects a tuple of ints
+        proj = np.amax(mask, axis=max_over_axes)
+        idx_nonzero = np.nonzero(proj)[0]
+        bbox_min[axis] = np.min(idx_nonzero)
+        bbox_max[axis] = np.max(idx_nonzero)
+
+    return bbox_min, bbox_max
+
+
+def _crop_to_bounding_box(mask, bbox_min, bbox_max):
+    """Crops a 2D or 3D mask to the bounding box specified by `bbox_{min,max}`."""
+    # we need to zeropad the cropped region with 1 voxel at the lower,
+    # the right (and the back on 3D) sides. This is required to obtain the
+    # "full" convolution result with the 2x2 (or 2x2x2 in 3D) kernel.
+    # TODO:  This is correct only if the object is interior to the
+    # bounding box.
+    cropmask = np.zeros((bbox_max - bbox_min) + 2, np.uint8)
+
+    num_dims = len(mask.shape)
+    # pyformat: disable
+    if num_dims == 2:
+        cropmask[0:-1, 0:-1] = mask[bbox_min[0]:bbox_max[0] + 1,
+                                    bbox_min[1]:bbox_max[1] + 1]
+    elif num_dims == 3:
+        cropmask[0:-1, 0:-1, 0:-1] = mask[bbox_min[0]:bbox_max[0] + 1,
+                                          bbox_min[1]:bbox_max[1] + 1,
+                                          bbox_min[2]:bbox_max[2] + 1]
+    # pyformat: enable
+    else:
+        assert False
+
+    return cropmask
+
+
+def _sort_distances_surfels(distances, surfel_areas):
+    """Sorts the two list with respect to the tuple of (distance, surfel_area).
+    Args:
+      distances: The distances from A to B (e.g. `distances_gt_to_pred`).
+      surfel_areas: The surfel areas for A (e.g. `surfel_areas_gt`).
+    Returns:
+      A tuple of the sorted (distances, surfel_areas).
+    """
+    sorted_surfels = np.array(sorted(zip(distances, surfel_areas)))
+    return sorted_surfels[:, 0], sorted_surfels[:, 1]
+
+
+def compute_surface_distances(mask_gt,
+                              mask_pred,
+                              spacing_mm):
+    """Computes closest distances from all surface points to the other surface.
+    This function can be applied to 2D or 3D tensors. For 2D, both masks must be
+    2D and `spacing_mm` must be a 2-element list. For 3D, both masks must be 3D
+    and `spacing_mm` must be a 3-element list. The description is done for the 2D
+    case, and the formulation for the 3D case is present is parenthesis,
+    introduced by "resp.".
+    Finds all contour elements (resp surface elements "surfels" in 3D) in the
+    ground truth mask `mask_gt` and the predicted mask `mask_pred`, computes their
+    length in mm (resp. area in mm^2) and the distance to the closest point on the
+    other contour (resp. surface). It returns two sorted lists of distances
+    together with the corresponding contour lengths (resp. surfel areas). If one
+    of the masks is empty, the corresponding lists are empty and all distances in
+    the other list are `inf`.
+    Args:
+      mask_gt: 2-dim (resp. 3-dim) bool Numpy array. The ground truth mask.
+      mask_pred: 2-dim (resp. 3-dim) bool Numpy array. The predicted mask.
+      spacing_mm: 2-element (resp. 3-element) list-like structure. Voxel spacing
+        in x0 anx x1 (resp. x0, x1 and x2) directions.
+    Returns:
+      A dict with:
+      "distances_gt_to_pred": 1-dim numpy array of type float. The distances in mm
+          from all ground truth surface elements to the predicted surface,
+          sorted from smallest to largest.
+      "distances_pred_to_gt": 1-dim numpy array of type float. The distances in mm
+          from all predicted surface elements to the ground truth surface,
+          sorted from smallest to largest.
+      "surfel_areas_gt": 1-dim numpy array of type float. The length of the
+        of the ground truth contours in mm (resp. the surface elements area in
+        mm^2) in the same order as distances_gt_to_pred.
+      "surfel_areas_pred": 1-dim numpy array of type float. The length of the
+        of the predicted contours in mm (resp. the surface elements area in
+        mm^2) in the same order as distances_gt_to_pred.
+    Raises:
+      ValueError: If the masks and the `spacing_mm` arguments are of incompatible
+        shape or type. Or if the masks are not 2D or 3D.
+    """
+    # The terms used in this function are for the 3D case. In particular, surface
+    # in 2D stands for contours in 3D. The surface elements in 3D correspond to
+    # the line elements in 2D.
+
+    _assert_is_bool_numpy_array("mask_gt", mask_gt)
+    _assert_is_bool_numpy_array("mask_pred", mask_pred)
+
+    if not len(mask_gt.shape) == len(mask_pred.shape) == len(spacing_mm):
+        raise ValueError("The arguments must be of compatible shape. Got mask_gt "
+                         "with {} dimensions ({}) and mask_pred with {} dimensions "
+                         "({}), while the spacing_mm was {} elements.".format(
+                             len(mask_gt.shape),
+                             mask_gt.shape, len(
+                                 mask_pred.shape), mask_pred.shape,
+                             len(spacing_mm)))
+
+    num_dims = len(spacing_mm)
+    if num_dims == 2:
+        _check_2d_numpy_array("mask_gt", mask_gt)
+        _check_2d_numpy_array("mask_pred", mask_pred)
+
+        # compute the area for all 16 possible surface elements
+        # (given a 2x2 neighbourhood) according to the spacing_mm
+        neighbour_code_to_surface_area = (
+            lookup_tables.create_table_neighbour_code_to_contour_length(spacing_mm))
+        kernel = lookup_tables.ENCODE_NEIGHBOURHOOD_2D_KERNEL
+        full_true_neighbours = 0b1111
+    elif num_dims == 3:
+        _check_3d_numpy_array("mask_gt", mask_gt)
+        _check_3d_numpy_array("mask_pred", mask_pred)
+
+        # compute the area for all 256 possible surface elements
+        # (given a 2x2x2 neighbourhood) according to the spacing_mm
+        neighbour_code_to_surface_area = (
+            lookup_tables.create_table_neighbour_code_to_surface_area(spacing_mm))
+        kernel = lookup_tables.ENCODE_NEIGHBOURHOOD_3D_KERNEL
+        full_true_neighbours = 0b11111111
+    else:
+        raise ValueError("Only 2D and 3D masks are supported, not "
+                         "{}D.".format(num_dims))
+
+    # compute the bounding box of the masks to trim the volume to the smallest
+    # possible processing subvolume
+    bbox_min, bbox_max = _compute_bounding_box(mask_gt | mask_pred)
+    # Both the min/max bbox are None at the same time, so we only check one.
+    if bbox_min is None:
+        return {
+            "distances_gt_to_pred": np.array([]),
+            "distances_pred_to_gt": np.array([]),
+            "surfel_areas_gt": np.array([]),
+            "surfel_areas_pred": np.array([]),
+        }
+
+    # crop the processing subvolume.
+    cropmask_gt = _crop_to_bounding_box(mask_gt, bbox_min, bbox_max)
+    cropmask_pred = _crop_to_bounding_box(mask_pred, bbox_min, bbox_max)
+
+    # compute the neighbour code (local binary pattern) for each voxel
+    # the resulting arrays are spacially shifted by minus half a voxel in each
+    # axis.
+    # i.e. the points are located at the corners of the original voxels
+    neighbour_code_map_gt = ndimage.filters.correlate(
+        cropmask_gt.astype(np.uint8), kernel, mode="constant", cval=0)
+    neighbour_code_map_pred = ndimage.filters.correlate(
+        cropmask_pred.astype(np.uint8), kernel, mode="constant", cval=0)
+
+    # create masks with the surface voxels
+    borders_gt = ((neighbour_code_map_gt != 0) &
+                  (neighbour_code_map_gt != full_true_neighbours))
+    borders_pred = ((neighbour_code_map_pred != 0) &
+                    (neighbour_code_map_pred != full_true_neighbours))
+
+    # compute the distance transform (closest distance of each voxel to the
+    # surface voxels)
+    if borders_gt.any():
+        distmap_gt = ndimage.morphology.distance_transform_edt(
+            ~borders_gt, sampling=spacing_mm)
+    else:
+        distmap_gt = np.Inf * np.ones(borders_gt.shape)
+
+    if borders_pred.any():
+        distmap_pred = ndimage.morphology.distance_transform_edt(
+            ~borders_pred, sampling=spacing_mm)
+    else:
+        distmap_pred = np.Inf * np.ones(borders_pred.shape)
+
+    # compute the area of each surface element
+    surface_area_map_gt = neighbour_code_to_surface_area[neighbour_code_map_gt]
+    surface_area_map_pred = neighbour_code_to_surface_area[
+        neighbour_code_map_pred]
+
+    # create a list of all surface elements with distance and area
+    distances_gt_to_pred = distmap_pred[borders_gt]
+    distances_pred_to_gt = distmap_gt[borders_pred]
+    surfel_areas_gt = surface_area_map_gt[borders_gt]
+    surfel_areas_pred = surface_area_map_pred[borders_pred]
+
+    # sort them by distance
+    if distances_gt_to_pred.shape != (0,):
+        distances_gt_to_pred, surfel_areas_gt = _sort_distances_surfels(
+            distances_gt_to_pred, surfel_areas_gt)
+
+    if distances_pred_to_gt.shape != (0,):
+        distances_pred_to_gt, surfel_areas_pred = _sort_distances_surfels(
+            distances_pred_to_gt, surfel_areas_pred)
+
+    return {
+        "distances_gt_to_pred": distances_gt_to_pred,
+        "distances_pred_to_gt": distances_pred_to_gt,
+        "surfel_areas_gt": surfel_areas_gt,
+        "surfel_areas_pred": surfel_areas_pred,
+    }
+
+
+def compute_average_surface_distance(surface_distances):
+    """Returns the average surface distance.
+    Computes the average surface distances by correctly taking the area of each
+    surface element into account. Call compute_surface_distances(...) before, to
+    obtain the `surface_distances` dict.
+    Args:
+      surface_distances: dict with "distances_gt_to_pred", "distances_pred_to_gt"
+      "surfel_areas_gt", "surfel_areas_pred" created by
+      compute_surface_distances()
+    Returns:
+      A tuple with two float values:
+        - the average distance (in mm) from the ground truth surface to the
+          predicted surface
+        - the average distance from the predicted surface to the ground truth
+          surface.
+    """
+    distances_gt_to_pred = surface_distances["distances_gt_to_pred"]
+    distances_pred_to_gt = surface_distances["distances_pred_to_gt"]
+    surfel_areas_gt = surface_distances["surfel_areas_gt"]
+    surfel_areas_pred = surface_distances["surfel_areas_pred"]
+    average_distance_gt_to_pred = (
+        np.sum(distances_gt_to_pred * surfel_areas_gt) / np.sum(surfel_areas_gt))
+    average_distance_pred_to_gt = (
+        np.sum(distances_pred_to_gt * surfel_areas_pred) /
+        np.sum(surfel_areas_pred))
+    return (average_distance_gt_to_pred, average_distance_pred_to_gt)
+
+
+def compute_robust_hausdorff(surface_distances, percent):
+    """Computes the robust Hausdorff distance.
+    Computes the robust Hausdorff distance. "Robust", because it uses the
+    `percent` percentile of the distances instead of the maximum distance. The
+    percentage is computed by correctly taking the area of each surface element
+    into account.
+    Args:
+      surface_distances: dict with "distances_gt_to_pred", "distances_pred_to_gt"
+        "surfel_areas_gt", "surfel_areas_pred" created by
+        compute_surface_distances()
+      percent: a float value between 0 and 100.
+    Returns:
+      a float value. The robust Hausdorff distance in mm.
+    """
+    distances_gt_to_pred = surface_distances["distances_gt_to_pred"]
+    distances_pred_to_gt = surface_distances["distances_pred_to_gt"]
+    surfel_areas_gt = surface_distances["surfel_areas_gt"]
+    surfel_areas_pred = surface_distances["surfel_areas_pred"]
+    if len(distances_gt_to_pred) > 0:  # pylint: disable=g-explicit-length-test
+        surfel_areas_cum_gt = np.cumsum(
+            surfel_areas_gt) / np.sum(surfel_areas_gt)
+        idx = np.searchsorted(surfel_areas_cum_gt, percent/100.0)
+        perc_distance_gt_to_pred = distances_gt_to_pred[
+            min(idx, len(distances_gt_to_pred)-1)]
+    else:
+        perc_distance_gt_to_pred = np.Inf
+
+    if len(distances_pred_to_gt) > 0:  # pylint: disable=g-explicit-length-test
+        surfel_areas_cum_pred = (np.cumsum(surfel_areas_pred) /
+                                 np.sum(surfel_areas_pred))
+        idx = np.searchsorted(surfel_areas_cum_pred, percent/100.0)
+        perc_distance_pred_to_gt = distances_pred_to_gt[
+            min(idx, len(distances_pred_to_gt)-1)]
+    else:
+        perc_distance_pred_to_gt = np.Inf
+
+    return max(perc_distance_gt_to_pred, perc_distance_pred_to_gt)
+
+
+def compute_surface_overlap_at_tolerance(surface_distances, tolerance_mm):
+    """Computes the overlap of the surfaces at a specified tolerance.
+    Computes the overlap of the ground truth surface with the predicted surface
+    and vice versa allowing a specified tolerance (maximum surface-to-surface
+    distance that is regarded as overlapping). The overlapping fraction is
+    computed by correctly taking the area of each surface element into account.
+    Args:
+      surface_distances: dict with "distances_gt_to_pred", "distances_pred_to_gt"
+        "surfel_areas_gt", "surfel_areas_pred" created by
+        compute_surface_distances()
+      tolerance_mm: a float value. The tolerance in mm
+    Returns:
+      A tuple of two float values. The overlap fraction in [0.0, 1.0] of the
+      ground truth surface with the predicted surface and vice versa.
+    """
+    distances_gt_to_pred = surface_distances["distances_gt_to_pred"]
+    distances_pred_to_gt = surface_distances["distances_pred_to_gt"]
+    surfel_areas_gt = surface_distances["surfel_areas_gt"]
+    surfel_areas_pred = surface_distances["surfel_areas_pred"]
+    rel_overlap_gt = (
+        np.sum(surfel_areas_gt[distances_gt_to_pred <= tolerance_mm]) /
+        np.sum(surfel_areas_gt))
+    rel_overlap_pred = (
+        np.sum(surfel_areas_pred[distances_pred_to_gt <= tolerance_mm]) /
+        np.sum(surfel_areas_pred))
+    return (rel_overlap_gt, rel_overlap_pred)
+
+
+def compute_surface_dice_at_tolerance(surface_distances, tolerance_mm):
+    """Computes the _surface_ DICE coefficient at a specified tolerance.
+    Computes the _surface_ DICE coefficient at a specified tolerance. Not to be
+    confused with the standard _volumetric_ DICE coefficient. The surface DICE
+    measures the overlap of two surfaces instead of two volumes. A surface
+    element is counted as overlapping (or touching), when the closest distance to
+    the other surface is less or equal to the specified tolerance. The DICE
+    coefficient is in the range between 0.0 (no overlap) to 1.0 (perfect overlap).
+    Args:
+      surface_distances: dict with "distances_gt_to_pred", "distances_pred_to_gt"
+        "surfel_areas_gt", "surfel_areas_pred" created by
+        compute_surface_distances()
+      tolerance_mm: a float value. The tolerance in mm
+    Returns:
+      A float value. The surface DICE coefficient in [0.0, 1.0].
+    """
+    distances_gt_to_pred = surface_distances["distances_gt_to_pred"]
+    distances_pred_to_gt = surface_distances["distances_pred_to_gt"]
+    surfel_areas_gt = surface_distances["surfel_areas_gt"]
+    surfel_areas_pred = surface_distances["surfel_areas_pred"]
+    overlap_gt = np.sum(surfel_areas_gt[distances_gt_to_pred <= tolerance_mm])
+    overlap_pred = np.sum(
+        surfel_areas_pred[distances_pred_to_gt <= tolerance_mm])
+    surface_dice = (overlap_gt + overlap_pred) / (
+        np.sum(surfel_areas_gt) + np.sum(surfel_areas_pred))
+    return surface_dice
+
+
+def compute_dice_coefficient(mask_gt, mask_pred):
+    """Computes soerensen-dice coefficient.
+    compute the soerensen-dice coefficient between the ground truth mask `mask_gt`
+    and the predicted mask `mask_pred`.
+    Args:
+      mask_gt: 3-dim Numpy array of type bool. The ground truth mask.
+      mask_pred: 3-dim Numpy array of type bool. The predicted mask.
+    Returns:
+      the dice coeffcient as float. If both masks are empty, the result is NaN.
+    """
+    volume_sum = mask_gt.sum() + mask_pred.sum()
+    if volume_sum == 0:
+        return np.NaN
+    volume_intersect = (mask_gt & mask_pred).sum()
+    return 2*volume_intersect / volume_sum

deepatlas/network/network.py

@@ -0,0 +1,56 @@
+import monai
+import torch
+import itk
+import numpy as np
+import matplotlib.pyplot as plt
+from typing import Optional, Sequence, Tuple, Union
+from monai.networks.layers.factories import Act, Norm
+
+
+def segNet(
+    spatial_dim: int,
+    in_channel: int,
+    out_channel: int,
+    channel: Sequence[int],
+    stride: Sequence[int],
+    num_res_unit: int = 0,
+    acts: Union[Tuple, str] = Act.PRELU,
+    norms: Union[Tuple, str] = Norm.INSTANCE,
+    dropouts: float = 0.0,
+):
+    seg_net = monai.networks.nets.UNet(
+        spatial_dims=spatial_dim,  # spatial dims
+        in_channels=in_channel,  # input channels
+        out_channels=out_channel,  # output channels
+        channels=channel,  # channel sequence
+        strides=stride,  # convolutional strides
+        dropout=dropouts,
+        act=acts,
+        norm=norms,
+        num_res_units=num_res_unit
+    )
+    return seg_net
+
+def regNet(
+    spatial_dim: int,
+    in_channel: int,
+    out_channel: int,
+    channel: Sequence[int],
+    stride: Sequence[int],
+    num_res_unit: int = 0,
+    acts: Union[Tuple, str] = Act.PRELU,
+    norms: Union[Tuple, str] = Norm.INSTANCE,
+    dropouts: float = 0.0,
+):
+    reg_net = monai.networks.nets.UNet(
+        spatial_dims=spatial_dim,  # spatial dims
+        in_channels=in_channel,  # input channels
+        out_channels=out_channel,  # output channels
+        channels=channel,  # channel sequence
+        strides=stride,  # convolutional strides
+        dropout=dropouts,
+        act=acts,
+        norm=norms,
+        num_res_units=num_res_unit
+    )
+    return reg_net

deepatlas/preprocess/crop.py

@@ -0,0 +1,264 @@
+import numpy as np
+import glob
+import ants
+import nibabel as nib
+import os
+import argparse
+import sys
+
+
+def parse_command_line():
+    parser = argparse.ArgumentParser(
+        description='pipeline for data preprocessing')
+    parser.add_argument('-bp', metavar='base path', type=str,
+                        help="absolute path of the base directory")
+    parser.add_argument('-ip', metavar='image path', type=str,
+                        help="relative path of the image directory")
+    parser.add_argument('-sp', metavar='segmentation path', type=str,
+                        help="relative path of the image directory")
+    parser.add_argument('-op', metavar='preprocessing result output path', type=str, default='output',
+                        help='relative path of the preprocessing result directory')
+    parser.add_argument('-rs', metavar='shape after resizing', type=int, nargs='+',
+                        help='shape after resizing the image and segmentation. Expected to be 2^N')
+    argv = parser.parse_args()
+    return argv
+
+
+def pad(raw_image, bound_x, bound_y, bound_z, resize, seg=False):
+    diff_x = resize[0] - (bound_x[1]-bound_x[0])
+    diff_y = resize[1] - (bound_y[1]-bound_y[0])
+    diff_z = resize[2] - (bound_z[1]-bound_z[0])
+    #print(diff_x, diff_y, diff_z)
+    if diff_x < 0 or diff_y < 0 or diff_z < 0:
+        sys.exit(
+            'the dimension of ROI is larger than the resizing dimension, please choose a different padding dimension')
+    left_y, right_y = split(diff_y)
+    left_z, right_z = split(diff_z)
+    left_x, right_x = split(diff_x)
+    new_bound_x_left = bound_x[0] - left_x
+    new_bound_x_right = bound_x[1] + right_x
+    new_bound_y_left = bound_y[0] - left_y
+    new_bound_y_right = bound_y[1] + right_y
+    new_bound_z_left = bound_z[0] - left_z
+    new_bound_z_right = bound_z[1] + right_z
+    # check if x_dim out of bounds
+    if new_bound_x_left < 0:
+        new_bound_x_left = 0
+        new_bound_x_right = bound_x[1] + diff_x - bound_x[0]
+
+    elif new_bound_x_right > raw_image.shape[0]:
+        new_bound_x_right = raw_image.shape[0]
+        new_bound_x_left = bound_x[0] - \
+            (diff_x - (raw_image.shape[0] - bound_x[1]))
+    # check if y_dim out of bounds
+    if new_bound_y_left < 0:
+        new_bound_y_left = 0
+        new_bound_y_right = bound_y[1] + diff_y - bound_y[0]
+
+    elif new_bound_y_right > raw_image.shape[1]:
+        new_bound_y_right = raw_image.shape[1]
+        new_bound_y_left = bound_y[0] - \
+            (diff_y - (raw_image.shape[1] - bound_y[1]))
+    # check if z_dim out of bounds
+    if new_bound_z_left < 0:
+        new_bound_z_left = 0
+        new_bound_z_right = bound_z[1] + diff_z - bound_z[0]
+
+    elif new_bound_z_right > raw_image.shape[2]:
+        new_bound_z_right = raw_image.shape[2]
+        new_bound_z_left = bound_z[0] - \
+            (diff_z - (raw_image.shape[2] - bound_z[1]))
+
+    assert new_bound_x_right - new_bound_x_left == resize[0]
+    assert new_bound_y_right - new_bound_y_left == resize[1]
+    assert new_bound_z_right - new_bound_z_left == resize[2]
+    if not seg:
+        return raw_image[new_bound_x_left:new_bound_x_right, new_bound_y_left:new_bound_y_right, new_bound_z_left:new_bound_z_right]
+    else:
+        new_seg = np.zeros_like(raw_image)
+        new_seg[bound_x[0]:bound_x[1],
+                bound_y[0]:bound_y[1], bound_z[0]:bound_z[1]] = raw_image[bound_x[0]:bound_x[1], bound_y[0]:bound_y[1], bound_z[0]:bound_z[1]]
+        return new_seg[new_bound_x_left:new_bound_x_right, new_bound_y_left:new_bound_y_right, new_bound_z_left:new_bound_z_right]
+
+
+def split(distance):
+    if distance == 0:
+        return 0, 0
+
+    half_dist = int(distance / 2)
+    left = int(half_dist * 0.8)
+    right = distance - left
+    return left, right
+
+
+def crop(nib_img, nib_seg, ants_img, ants_seg, resize):
+    img = nib_img.get_fdata()
+    seg = nib_seg.get_fdata()
+    gem = ants.label_geometry_measures(ants_seg, ants_img)
+    low_x = min(list(gem.loc[:, 'BoundingBoxLower_x']))
+    upp_x = max(list(gem.loc[:, 'BoundingBoxUpper_x']))
+    low_y = min(list(gem.loc[:, 'BoundingBoxLower_y']))
+    upp_y = max(list(gem.loc[:, 'BoundingBoxUpper_y']))
+    low_z = min(list(gem.loc[:, 'BoundingBoxLower_z']))
+    upp_z = max(list(gem.loc[:, 'BoundingBoxUpper_z']))
+
+    #img = MinMax_normalization(img)
+    img = Zscore_normalization(img)
+
+    tuple_x = tuple([low_x, upp_x])
+    tuple_y = tuple([low_y, upp_y])
+    tuple_z = tuple([low_z, upp_z])
+    img = pad(img, tuple_x, tuple_y, tuple_z, resize, seg=False)
+    seg = pad(seg, tuple_x, tuple_y, tuple_z, resize, seg=True)
+
+    return img, seg
+
+
+def get_geometry_info(seg_path, img_path):
+    abs_low_x = np.Inf
+    abs_upp_x = -np.Inf
+    abs_low_y = np.Inf
+    abs_upp_y = -np.Inf
+    abs_low_z = np.Inf
+    abs_upp_z = -np.Inf
+    for i in sorted(glob.glob(os.path.join(img_path, '*.nii.gz'))):
+        name = os.path.basename(i)
+        if os.path.exists(os.path.join(seg_path, name)):
+            seg = ants.image_read(os.path.join(seg_path, name))
+            img = ants.image_read(i)
+            gem = ants.label_geometry_measures(seg, img)
+            low_x = min(list(gem.loc[:, 'BoundingBoxLower_x']))
+            upp_x = max(list(gem.loc[:, 'BoundingBoxUpper_x']))
+            low_y = min(list(gem.loc[:, 'BoundingBoxLower_y']))
+            upp_y = max(list(gem.loc[:, 'BoundingBoxUpper_y']))
+            low_z = min(list(gem.loc[:, 'BoundingBoxLower_z']))
+            upp_z = max(list(gem.loc[:, 'BoundingBoxUpper_z']))
+            if low_x < abs_low_x:
+                abs_low_x = low_x
+            if upp_x > abs_upp_x:
+                abs_upp_x = upp_x
+            if low_y < abs_low_y:
+                abs_low_y = low_y
+            if upp_y > abs_upp_y:
+                abs_upp_y = upp_y
+            if low_z < abs_low_z:
+                abs_low_z = low_z
+            if upp_z > abs_upp_z:
+                abs_upp_z = upp_z
+    
+    tuple_x = tuple([abs_low_x, abs_upp_x])
+    tuple_y = tuple([abs_low_y, abs_upp_y])
+    tuple_z = tuple([abs_low_z, abs_upp_z])
+    return [tuple_x, tuple_y, tuple_z]
+
+
+def cropV2(nib_img, ants_img, resize, geo_info):
+    img = nib_img.get_fdata()
+    img = Zscore_normalization(img)
+    tuple_x = geo_info[0]
+    tuple_y = geo_info[1]
+    tuple_z = geo_info[2]
+    img = Zscore_normalization(img)
+    img = pad(img, tuple_x, tuple_y, tuple_z, resize, seg=False)
+    return img
+
+
+def MinMax_normalization(scan):
+    lb = np.amin(scan)
+    ub = np.amax(scan)
+    scan = (scan - lb) / (ub - lb)
+    return scan
+
+
+def Zscore_normalization(scan):
+    mean = np.mean(scan)
+    std = np.std(scan)
+    lb = np.percentile(scan, 0.05)
+    ub = np.percentile(scan, 99.5)
+    scan = np.clip(scan, lb, ub)
+    scan = (scan - mean) / std
+    return scan
+
+
+def load_data(img_path, seg_path):
+    nib_seg = nib.load(seg_path)
+    nib_img = nib.load(img_path)
+    ants_seg = ants.image_read(seg_path)
+    ants_img = ants.image_read(img_path)
+    return nib_img, nib_seg, ants_img, ants_seg
+
+
+def path_to_id(path):
+    ids = []
+    for i in glob.glob(path + '/*nii.gz'):
+        id = os.path.basename(i).split('.')[0]
+        ids.append(id)
+    return ids
+
+
+def save_file(left_img, left_seg, nib_img, nib_seg, output_img, output_seg, scan_id):
+    left_img_nii = nib.Nifti1Image(
+        left_img, affine=nib_img.affine, header=nib_img.header)
+    left_seg_nii = nib.Nifti1Image(
+        left_seg, affine=nib_seg.affine, header=nib_seg.header)
+    left_img_nii.to_filename(os.path.join(
+        output_img, scan_id + '.nii.gz'))
+    left_seg_nii.to_filename(os.path.join(
+        output_seg, scan_id + '.nii.gz'))
+
+
+def save_fileV2(left_img, nib_img, output_img, scan_id):
+    left_img_nii = nib.Nifti1Image(
+        left_img, affine=nib_img.affine, header=nib_img.header)
+    left_img_nii.to_filename(os.path.join(
+        output_img, scan_id + '.nii.gz'))
+
+
+def main():
+    args = parse_command_line()
+    base_path = args.bp
+    image_path = os.path.join(base_path, args.ip)
+    seg_path = os.path.join(base_path, args.sp)
+    output_path = os.path.join(base_path, args.op)
+    resize_shape = args.rs
+    output_img = os.path.join(output_path, 'images')
+    output_seg = os.path.join(output_path, 'labels')
+    label_list = path_to_id(seg_path)
+    geo_info = get_geometry_info(seg_path, image_path)
+    try:
+        os.mkdir(output_path)
+    except:
+        print(f'{output_path} is already existed')
+
+    try:
+        os.mkdir(output_img)
+    except:
+        print(f'{output_img} is already existed')
+
+    try:
+        os.mkdir(output_seg)
+    except:
+        print(f'{output_seg} is already existed')
+
+    for i in sorted(glob.glob(image_path + '/*nii.gz')):
+        id = os.path.basename(i).split('.')[0]
+        if id in label_list:
+            label_path = os.path.join(seg_path, id + '.nii.gz')
+            nib_img, nib_seg, ants_img, ants_seg = load_data(i, label_path)
+            left_img, left_seg = crop(
+                nib_img, nib_seg, ants_img, ants_seg, resize_shape)
+            print(
+                'Scan ID: ' + id + f', before cropping: {nib_img.get_fdata().shape}, after cropping and padding the image and seg: {left_img.shape}')
+            save_file(left_img, left_seg, nib_img,
+                     nib_seg, output_img, output_seg, id)
+        else:
+            nib_img = nib.load(i)
+            ant_img = ants.image_read(i)
+            outImg = cropV2(nib_img, ant_img, resize_shape, geo_info)
+            print(
+                'Scan ID: ' + id + f', before cropping: {nib_img.get_fdata().shape}, after cropping and padding the image: {outImg.shape}')
+            save_fileV2(outImg, nib_img, output_img, id)
+
+
+if __name__ == '__main__':
+    main()

deepatlas/preprocess/crop_flip_test.py

@@ -0,0 +1,303 @@
+import numpy as np
+import glob
+import ants
+import nibabel as nib
+import os
+import argparse
+import sys
+from crop import crop, cropV2, save_fileV2
+from pathlib import Path
+
+def parse_command_line():
+    parser = argparse.ArgumentParser(
+        description='pipeline for data preprocessing')                   
+    parser.add_argument('-rs', metavar='shape after resizing', type=int, nargs='+',
+                        help='shape after resizing the image and segmentation. Expected to be 2^N')
+    parser.add_argument('-fp', action='store_true',
+                        help='check if need to flip the data')
+    parser.add_argument('-ti', metavar='task id and name', type=str,
+                        help='task name and id')
+    parser.add_argument('-op', metavar='output path for both registration & crop step', type=str,
+                        help="should be same name in the registration, crop and final prediction steps")
+    argv = parser.parse_args()
+    return argv
+
+def path_to_id(path):
+    ids = []
+    for i in glob.glob(path + '/*nii.gz'):
+        id = os.path.basename(i).split('.')[0]
+        ids.append(id)
+    return ids
+
+def pad(raw_image, bound_x, bound_y, bound_z, resize, seg=False):
+    diff_x = resize[0] - (bound_x[1]-bound_x[0])
+    diff_y = resize[1] - (bound_y[1]-bound_y[0])
+    diff_z = resize[2] - (bound_z[1]-bound_z[0])
+    if diff_x < 0 or diff_y < 0 or diff_z < 0:
+        sys.exit(
+            'the dimension of ROI is larger than the resizing dimension, please choose a different padding dimension')
+    left_y, right_y = split(diff_y)
+    left_z, right_z = split(diff_z)
+    left_x, right_x = split(diff_x)
+    new_bound_x_left = bound_x[0] - left_x
+    new_bound_x_right = bound_x[1] + right_x
+    new_bound_y_left = bound_y[0] - left_y
+    new_bound_y_right = bound_y[1] + right_y
+    new_bound_z_left = bound_z[0] - left_z
+    new_bound_z_right = bound_z[1] + right_z
+    # check if x_dim out of bounds
+    if new_bound_x_left < 0:
+        new_bound_x_left = 0
+        new_bound_x_right = bound_x[1] + diff_x - bound_x[0]
+
+    elif new_bound_x_right > raw_image.shape[0]:
+        new_bound_x_right = raw_image.shape[0]
+        new_bound_x_left = bound_x[0] - \
+            (diff_x - (raw_image.shape[0] - bound_x[1]))
+    # check if y_dim out of bounds
+    if new_bound_y_left < 0:
+        new_bound_y_left = 0
+        new_bound_y_right = bound_y[1] + diff_y - bound_y[0]
+
+    elif new_bound_y_right > raw_image.shape[1]:
+        new_bound_y_right = raw_image.shape[1]
+        new_bound_y_left = bound_y[0] - \
+            (diff_y - (raw_image.shape[1] - bound_y[1]))
+    # check if z_dim out of bounds
+    if new_bound_z_left < 0:
+        new_bound_z_left = 0
+        new_bound_z_right = bound_z[1] + diff_z - bound_z[0]
+
+    elif new_bound_z_right > raw_image.shape[2]:
+        new_bound_z_right = raw_image.shape[2]
+        new_bound_z_left = bound_z[0] - \
+            (diff_z - (raw_image.shape[2] - bound_z[1]))
+
+    assert new_bound_x_right - new_bound_x_left == resize[0]
+    assert new_bound_y_right - new_bound_y_left == resize[1]
+    assert new_bound_z_right - new_bound_z_left == resize[2]
+    if not seg:
+        return raw_image[new_bound_x_left:new_bound_x_right, new_bound_y_left:new_bound_y_right, new_bound_z_left:new_bound_z_right]
+    else:
+        new_seg = np.zeros_like(raw_image)
+        new_seg[bound_x[0]:bound_x[1],
+                bound_y[0]:bound_y[1], bound_z[0]:bound_z[1]] = raw_image[bound_x[0]:bound_x[1], bound_y[0]:bound_y[1], bound_z[0]:bound_z[1]]
+        return new_seg[new_bound_x_left:new_bound_x_right, new_bound_y_left:new_bound_y_right, new_bound_z_left:new_bound_z_right]
+
+
+def split(distance):
+    if distance == 0:
+        return 0, 0
+
+    half_dist = int(distance / 2)
+    left = int(half_dist * 0.8)
+    right = distance - left
+    return left, right
+
+
+def crop_and_flip(nib_img, nib_seg, ants_img, ants_seg, resize):
+    img = nib_img.get_fdata()
+    seg = nib_seg.get_fdata()
+    gem = ants.label_geometry_measures(ants_seg, ants_img)
+    low_x = min(list(gem.loc[:, 'BoundingBoxLower_x']))
+    upp_x = max(list(gem.loc[:, 'BoundingBoxUpper_x']))
+    low_y = min(list(gem.loc[:, 'BoundingBoxLower_y']))
+    upp_y = max(list(gem.loc[:, 'BoundingBoxUpper_y']))
+    low_z = min(list(gem.loc[:, 'BoundingBoxLower_z']))
+    upp_z = max(list(gem.loc[:, 'BoundingBoxUpper_z']))
+
+    img = Zscore_normalization(img)
+    #img = MinMax_normalization(img)
+    # Compute mid point
+    mid_x = int((low_x + upp_x) / 2)
+
+    tuple_x_left = tuple([low_x, mid_x])
+    tuple_x_right = tuple([mid_x, upp_x])
+    tuple_y = tuple([low_y, upp_y])
+    tuple_z = tuple([low_z, upp_z])
+    left_img = pad(img, tuple_x_left, tuple_y, tuple_z, resize, seg=False)
+    left_seg = pad(seg, tuple_x_left, tuple_y, tuple_z, resize, seg=True)
+    right_img = pad(img, tuple_x_right, tuple_y, tuple_z, resize, seg=False)
+    right_seg = pad(seg, tuple_x_right, tuple_y, tuple_z, resize, seg=True)
+    flipped_right_img = np.flip(right_img, axis=0)
+    flipped_right_seg = np.flip(right_seg, axis=0)
+
+    return left_img, left_seg, flipped_right_img, flipped_right_seg
+
+
+def crop_and_flip_V2(nib_img, ants_img, resize, geo_info):
+    img = nib_img.get_fdata()
+    tuple_x = geo_info[0]
+    tuple_y = geo_info[1]
+    tuple_z = geo_info[2]
+    low_x = tuple_x[0]
+    upp_x = tuple_x[1]
+    img = Zscore_normalization(img)
+    #img = MinMax_normalization(img)
+    # Compute mid point
+    mid_x = int((low_x + upp_x) / 2)
+
+    tuple_x_left = tuple([low_x, mid_x])
+    tuple_x_right = tuple([mid_x, upp_x])
+
+    left_img = pad(img, tuple_x_left, tuple_y, tuple_z, resize, seg=False)
+    right_img = pad(img, tuple_x_right, tuple_y, tuple_z, resize, seg=False)
+    flipped_right_img = np.flip(right_img, axis=0)
+
+    return left_img, flipped_right_img
+
+
+def MinMax_normalization(scan):
+    lb = np.amin(scan)
+    ub = np.amax(scan)
+    scan = (scan - lb) / (ub - lb)
+    return scan
+
+
+def Zscore_normalization(scan):
+    mean = np.mean(scan)
+    std = np.std(scan)
+    lb = np.percentile(scan, 0.05)
+    ub = np.percentile(scan, 99.5)
+    scan = np.clip(scan, lb, ub)
+    scan = (scan - mean) / std
+    return scan
+
+
+def load_data(img_path, seg_path):
+    nib_seg = nib.load(seg_path)
+    nib_img = nib.load(img_path)
+    ants_seg = ants.image_read(seg_path)
+    ants_img = ants.image_read(img_path)
+    return nib_img, nib_seg, ants_img, ants_seg
+
+
+def crop_flip_save_file(left_img, left_seg, flipped_right_img, flipped_right_seg, nib_img, nib_seg, output_img, output_seg, scan_id):
+    left_img_nii = nib.Nifti1Image(
+        left_img, affine=nib_img.affine, header=nib_img.header)
+    left_seg_nii = nib.Nifti1Image(
+        left_seg, affine=nib_seg.affine, header=nib_seg.header)
+    right_img_nii = nib.Nifti1Image(
+        flipped_right_img, affine=nib_img.affine, header=nib_img.header)
+    right_seg_nii = nib.Nifti1Image(
+        flipped_right_seg, affine=nib_seg.affine, header=nib_seg.header)
+    left_img_nii.to_filename(os.path.join(
+        output_img, 'right_' + scan_id + '.nii.gz'))
+    left_seg_nii.to_filename(os.path.join(
+        output_seg, 'right_' + scan_id + '.nii.gz'))
+    right_img_nii.to_filename(os.path.join(
+        output_img, 'left_' + scan_id + '.nii.gz'))
+    right_seg_nii.to_filename(os.path.join(
+        output_seg, 'left_' + scan_id + '.nii.gz'))
+
+def get_geometry_info(seg_path, img_path):
+    template = (glob.glob(seg_path + '/*nii.gz'))[0]
+    template_id = os.path.basename(template).split('.')[0]
+    img = ants.image_read(os.path.join(img_path, template_id + '.nii.gz'))
+    seg = ants.image_read(template)
+    gem = ants.label_geometry_measures(seg, img)
+    low_x = min(list(gem.loc[:, 'BoundingBoxLower_x']))
+    upp_x = max(list(gem.loc[:, 'BoundingBoxUpper_x']))
+    low_y = min(list(gem.loc[:, 'BoundingBoxLower_y']))
+    upp_y = max(list(gem.loc[:, 'BoundingBoxUpper_y']))
+    low_z = min(list(gem.loc[:, 'BoundingBoxLower_z']))
+    upp_z = max(list(gem.loc[:, 'BoundingBoxUpper_z']))
+    tuple_x = tuple([low_x, upp_x])
+    tuple_y = tuple([low_y, upp_y])
+    tuple_z = tuple([low_z, upp_z])
+    return [tuple_x, tuple_y, tuple_z]
+
+
+def crop_flip_save_file_V2(left_img, flipped_right_img, nib_img, output_img, scan_id):
+    left_img_nii = nib.Nifti1Image(
+        left_img, affine=nib_img.affine, header=nib_img.header)
+    right_img_nii = nib.Nifti1Image(
+        flipped_right_img, affine=nib_img.affine, header=nib_img.header)
+    left_img_nii.to_filename(os.path.join(
+        output_img, 'right_' + scan_id + '.nii.gz'))
+    right_img_nii.to_filename(os.path.join(
+        output_img, 'left_' + scan_id + '.nii.gz'))
+
+def crop_save_file(left_img, left_seg, nib_img, nib_seg, output_img, output_seg, scan_id):
+    left_img_nii = nib.Nifti1Image(
+        left_img, affine=nib_img.affine, header=nib_img.header)
+    left_seg_nii = nib.Nifti1Image(
+        left_seg, affine=nib_seg.affine, header=nib_seg.header)
+    left_img_nii.to_filename(os.path.join(
+        output_img, scan_id + '.nii.gz'))
+    left_seg_nii.to_filename(os.path.join(
+        output_seg, scan_id + '.nii.gz'))
+
+
+def main():
+    ROOT_DIR = str(Path(os.getcwd()).parent.parent.absolute())
+    args = parse_command_line()
+    resize_shape = args.rs
+    flipped = args.fp
+    deepatlas_path = ROOT_DIR
+    task_id = args.ti
+    base_path = os.path.join(deepatlas_path, 'deepatlas_raw_data_base', task_id, 'customize_test_data', args.op)
+    image_path = os.path.join(base_path, 'images')
+    seg_path = os.path.join(base_path, 'labels')
+    task_path = os.path.join(deepatlas_path, 'deepatlas_preprocessed', task_id)
+    output_data_path = os.path.join(task_path, 'customize_test_data')
+    out_data_path = os.path.join(output_data_path, args.op)
+    output_img = os.path.join(out_data_path, 'images')
+    output_seg = os.path.join(out_data_path, 'labels')
+    label_list = path_to_id(seg_path)
+    geo_info = get_geometry_info(seg_path, image_path)
+    try:
+        os.mkdir(output_data_path)
+    except:
+        print(f'{output_data_path} is already existed')
+
+    try:
+        os.mkdir(out_data_path)
+    except:
+        print(f'{out_data_path} is already existed')
+
+    try:
+        os.mkdir(output_img)
+    except:
+        print(f'{output_img} is already existed')
+
+    try:
+        os.mkdir(output_seg)
+    except:
+        print(f'{output_seg} is already existed')
+
+    for i in sorted(glob.glob(image_path + '/*nii.gz')):
+        id = os.path.basename(i).split('.')[0]
+        if id in label_list:
+            label_path = os.path.join(seg_path, id + '.nii.gz')
+            nib_img, nib_seg, ants_img, ants_seg = load_data(i, label_path)
+            if flipped:
+                left_img, left_seg, flipped_right_img, flipped_right_seg = crop_and_flip(
+                    nib_img, nib_seg, ants_img, ants_seg, resize_shape)
+                print(
+                    'Scan ID: ' + id + f', img & seg before cropping: {nib_img.get_fdata().shape}, after cropping, flipping and padding: {left_img.shape} and {flipped_right_img.shape}')
+                crop_flip_save_file(left_img, left_seg, flipped_right_img, flipped_right_seg,
+                        nib_img, nib_seg, output_img, output_seg, id)
+            else:
+                left_img, left_seg = crop(
+                    nib_img, nib_seg, ants_img, ants_seg, resize_shape)
+                print(
+                    'Scan ID: ' + id + f', img & seg before cropping: {nib_img.get_fdata().shape}, after cropping and padding the image and seg: {left_img.shape}')
+                crop_save_file(left_img, left_seg, nib_img,
+                        nib_seg, output_img, output_seg, id)
+        else:
+            nib_img = nib.load(i)
+            ant_img = ants.image_read(i)
+            if flipped:
+                left_img, flipped_right_img = crop_and_flip_V2(nib_img, ant_img, resize_shape, geo_info)
+                print(
+                    'Scan ID: ' + id + f', img before cropping: {nib_img.get_fdata().shape}, after cropping, flipping and padding: {left_img.shape} and {flipped_right_img.shape}')
+                crop_flip_save_file_V2(left_img, flipped_right_img, nib_img, output_img, id)
+            else:
+                outImg = cropV2(nib_img, ant_img, resize_shape, geo_info)
+                print(
+                    'Scan ID: ' + id + f', img before cropping: {nib_img.get_fdata().shape}, after cropping and padding the image: {outImg.shape}')
+                save_fileV2(outImg, nib_img, output_img, id)
+
+if __name__ == '__main__':
+    main()

deepatlas/preprocess/crop_flip_training.py

@@ -0,0 +1,332 @@
+import numpy as np
+import glob
+import ants
+import nibabel as nib
+import os
+import argparse
+import sys
+from crop import crop, cropV2, save_fileV2
+from pathlib import Path
+
+def parse_command_line():
+    parser = argparse.ArgumentParser(
+        description='pipeline for data preprocessing')                   
+    parser.add_argument('-rs', metavar='shape after resizing', type=int, nargs='+',
+                        help='shape after resizing the image and segmentation. Expected to be 2^N')
+    parser.add_argument('-fp', action='store_true',
+                        help='check if need to flip the data')
+    parser.add_argument('-ti', metavar='task id and name', type=str,
+                        help='task name and id')
+    argv = parser.parse_args()
+    return argv
+
+def path_to_id(path):
+    ids = []
+    for i in glob.glob(path + '/*nii.gz'):
+        id = os.path.basename(i).split('.')[0]
+        ids.append(id)
+    return ids
+
+def pad(raw_image, bound_x, bound_y, bound_z, resize, seg=False):
+    diff_x = resize[0] - (bound_x[1]-bound_x[0])
+    diff_y = resize[1] - (bound_y[1]-bound_y[0])
+    diff_z = resize[2] - (bound_z[1]-bound_z[0])
+    if diff_x < 0 or diff_y < 0 or diff_z < 0:
+        sys.exit(
+            'the dimension of ROI is larger than the resizing dimension, please choose a different padding dimension')
+    left_y, right_y = split(diff_y)
+    left_z, right_z = split(diff_z)
+    left_x, right_x = split(diff_x)
+    new_bound_x_left = bound_x[0] - left_x
+    new_bound_x_right = bound_x[1] + right_x
+    new_bound_y_left = bound_y[0] - left_y
+    new_bound_y_right = bound_y[1] + right_y
+    new_bound_z_left = bound_z[0] - left_z
+    new_bound_z_right = bound_z[1] + right_z
+    # check if x_dim out of bounds
+    if new_bound_x_left < 0:
+        new_bound_x_left = 0
+        new_bound_x_right = bound_x[1] + diff_x - bound_x[0]
+
+    elif new_bound_x_right > raw_image.shape[0]:
+        new_bound_x_right = raw_image.shape[0]
+        new_bound_x_left = bound_x[0] - \
+            (diff_x - (raw_image.shape[0] - bound_x[1]))
+    # check if y_dim out of bounds
+    if new_bound_y_left < 0:
+        new_bound_y_left = 0
+        new_bound_y_right = bound_y[1] + diff_y - bound_y[0]
+
+    elif new_bound_y_right > raw_image.shape[1]:
+        new_bound_y_right = raw_image.shape[1]
+        new_bound_y_left = bound_y[0] - \
+            (diff_y - (raw_image.shape[1] - bound_y[1]))
+    # check if z_dim out of bounds
+    if new_bound_z_left < 0:
+        new_bound_z_left = 0
+        new_bound_z_right = bound_z[1] + diff_z - bound_z[0]
+
+    elif new_bound_z_right > raw_image.shape[2]:
+        new_bound_z_right = raw_image.shape[2]
+        new_bound_z_left = bound_z[0] - \
+            (diff_z - (raw_image.shape[2] - bound_z[1]))
+
+    assert new_bound_x_right - new_bound_x_left == resize[0]
+    assert new_bound_y_right - new_bound_y_left == resize[1]
+    assert new_bound_z_right - new_bound_z_left == resize[2]
+    if not seg:
+        return raw_image[new_bound_x_left:new_bound_x_right, new_bound_y_left:new_bound_y_right, new_bound_z_left:new_bound_z_right]
+    else:
+        new_seg = np.zeros_like(raw_image)
+        new_seg[bound_x[0]:bound_x[1],
+                bound_y[0]:bound_y[1], bound_z[0]:bound_z[1]] = raw_image[bound_x[0]:bound_x[1], bound_y[0]:bound_y[1], bound_z[0]:bound_z[1]]
+        return new_seg[new_bound_x_left:new_bound_x_right, new_bound_y_left:new_bound_y_right, new_bound_z_left:new_bound_z_right]
+
+
+def split(distance):
+    if distance == 0:
+        return 0, 0
+
+    half_dist = int(distance / 2)
+    left = int(half_dist * 0.8)
+    right = distance - left
+    return left, right
+
+
+def crop_and_flip(nib_img, nib_seg, ants_img, ants_seg, resize):
+    img = nib_img.get_fdata()
+    seg = nib_seg.get_fdata()
+    gem = ants.label_geometry_measures(ants_seg, ants_img)
+    low_x = min(list(gem.loc[:, 'BoundingBoxLower_x']))
+    upp_x = max(list(gem.loc[:, 'BoundingBoxUpper_x']))
+    low_y = min(list(gem.loc[:, 'BoundingBoxLower_y']))
+    upp_y = max(list(gem.loc[:, 'BoundingBoxUpper_y']))
+    low_z = min(list(gem.loc[:, 'BoundingBoxLower_z']))
+    upp_z = max(list(gem.loc[:, 'BoundingBoxUpper_z']))
+
+    img = Zscore_normalization(img)
+    #img = MinMax_normalization(img)
+    # Compute mid point
+    mid_x = int((low_x + upp_x) / 2)
+
+    tuple_x_left = tuple([low_x, mid_x])
+    tuple_x_right = tuple([mid_x, upp_x])
+    tuple_y = tuple([low_y, upp_y])
+    tuple_z = tuple([low_z, upp_z])
+    left_img = pad(img, tuple_x_left, tuple_y, tuple_z, resize, seg=False)
+    left_seg = pad(seg, tuple_x_left, tuple_y, tuple_z, resize, seg=True)
+    right_img = pad(img, tuple_x_right, tuple_y, tuple_z, resize, seg=False)
+    right_seg = pad(seg, tuple_x_right, tuple_y, tuple_z, resize, seg=True)
+    flipped_right_img = np.flip(right_img, axis=0)
+    flipped_right_seg = np.flip(right_seg, axis=0)
+
+    return left_img, left_seg, flipped_right_img, flipped_right_seg
+
+
+def crop_and_flip_V2(nib_img, ants_img, resize, geo_info):
+    img = nib_img.get_fdata()
+    tuple_x = geo_info[0]
+    tuple_y = geo_info[1]
+    tuple_z = geo_info[2]
+    low_x = tuple_x[0]
+    upp_x = tuple_x[1]
+    img = Zscore_normalization(img)
+    #img = MinMax_normalization(img)
+    # Compute mid point
+    mid_x = int((low_x + upp_x) / 2)
+
+    tuple_x_left = tuple([low_x, mid_x])
+    tuple_x_right = tuple([mid_x, upp_x])
+
+    left_img = pad(img, tuple_x_left, tuple_y, tuple_z, resize, seg=False)
+    right_img = pad(img, tuple_x_right, tuple_y, tuple_z, resize, seg=False)
+    flipped_right_img = np.flip(right_img, axis=0)
+
+    return left_img, flipped_right_img
+
+
+def MinMax_normalization(scan):
+    lb = np.amin(scan)
+    ub = np.amax(scan)
+    scan = (scan - lb) / (ub - lb)
+    return scan
+
+
+def Zscore_normalization(scan):
+    mean = np.mean(scan)
+    std = np.std(scan)
+    lb = np.percentile(scan, 0.05)
+    ub = np.percentile(scan, 99.5)
+    scan = np.clip(scan, lb, ub)
+    scan = (scan - mean) / std
+    return scan
+
+
+def load_data(img_path, seg_path):
+    nib_seg = nib.load(seg_path)
+    nib_img = nib.load(img_path)
+    ants_seg = ants.image_read(seg_path)
+    ants_img = ants.image_read(img_path)
+    return nib_img, nib_seg, ants_img, ants_seg
+
+
+def crop_flip_save_file(left_img, left_seg, flipped_right_img, flipped_right_seg, nib_img, nib_seg, output_img, output_seg, scan_id):
+    left_img_nii = nib.Nifti1Image(
+        left_img, affine=nib_img.affine, header=nib_img.header)
+    left_seg_nii = nib.Nifti1Image(
+        left_seg, affine=nib_seg.affine, header=nib_seg.header)
+    right_img_nii = nib.Nifti1Image(
+        flipped_right_img, affine=nib_img.affine, header=nib_img.header)
+    right_seg_nii = nib.Nifti1Image(
+        flipped_right_seg, affine=nib_seg.affine, header=nib_seg.header)
+    left_img_nii.to_filename(os.path.join(
+        output_img, 'right_' + scan_id + '.nii.gz'))
+    left_seg_nii.to_filename(os.path.join(
+        output_seg, 'right_' + scan_id + '.nii.gz'))
+    right_img_nii.to_filename(os.path.join(
+        output_img, 'left_' + scan_id + '.nii.gz'))
+    right_seg_nii.to_filename(os.path.join(
+        output_seg, 'left_' + scan_id + '.nii.gz'))
+
+def get_geometry_info(seg_path, img_path):
+    abs_low_x = np.Inf
+    abs_upp_x = -np.Inf
+    abs_low_y = np.Inf
+    abs_upp_y = -np.Inf
+    abs_low_z = np.Inf
+    abs_upp_z = -np.Inf
+    for i in sorted(glob.glob(os.path.join(img_path, '*.nii.gz'))):
+        name = os.path.basename(i)
+        if os.path.exists(os.path.join(seg_path, name)):
+            seg = ants.image_read(os.path.join(seg_path, name))
+            img = ants.image_read(i)
+            gem = ants.label_geometry_measures(seg, img)
+            low_x = min(list(gem.loc[:, 'BoundingBoxLower_x']))
+            upp_x = max(list(gem.loc[:, 'BoundingBoxUpper_x']))
+            low_y = min(list(gem.loc[:, 'BoundingBoxLower_y']))
+            upp_y = max(list(gem.loc[:, 'BoundingBoxUpper_y']))
+            low_z = min(list(gem.loc[:, 'BoundingBoxLower_z']))
+            upp_z = max(list(gem.loc[:, 'BoundingBoxUpper_z']))
+            if low_x < abs_low_x:
+                abs_low_x = low_x
+            if upp_x > abs_upp_x:
+                abs_upp_x = upp_x
+            if low_y < abs_low_y:
+                abs_low_y = low_y
+            if upp_y > abs_upp_y:
+                abs_upp_y = upp_y
+            if low_z < abs_low_z:
+                abs_low_z = low_z
+            if upp_z > abs_upp_z:
+                abs_upp_z = upp_z
+    
+    tuple_x = tuple([abs_low_x, abs_upp_x])
+    tuple_y = tuple([abs_low_y, abs_upp_y])
+    tuple_z = tuple([abs_low_z, abs_upp_z])
+    return [tuple_x, tuple_y, tuple_z]
+
+
+def crop_flip_save_file_V2(left_img, flipped_right_img, nib_img, output_img, scan_id):
+    left_img_nii = nib.Nifti1Image(
+        left_img, affine=nib_img.affine, header=nib_img.header)
+    right_img_nii = nib.Nifti1Image(
+        flipped_right_img, affine=nib_img.affine, header=nib_img.header)
+    left_img_nii.to_filename(os.path.join(
+        output_img, 'right_' + scan_id + '.nii.gz'))
+    right_img_nii.to_filename(os.path.join(
+        output_img, 'left_' + scan_id + '.nii.gz'))
+
+def crop_save_file(left_img, left_seg, nib_img, nib_seg, output_img, output_seg, scan_id):
+    left_img_nii = nib.Nifti1Image(
+        left_img, affine=nib_img.affine, header=nib_img.header)
+    left_seg_nii = nib.Nifti1Image(
+        left_seg, affine=nib_seg.affine, header=nib_seg.header)
+    left_img_nii.to_filename(os.path.join(
+        output_img, scan_id + '.nii.gz'))
+    left_seg_nii.to_filename(os.path.join(
+        output_seg, scan_id + '.nii.gz'))
+
+
+def main():
+    ROOT_DIR = str(Path(os.getcwd()).parent.parent.absolute())
+    args = parse_command_line()
+    resize_shape = args.rs
+    flipped = args.fp
+    deepatlas_path = ROOT_DIR
+    task_id = args.ti
+    base_path = os.path.join(deepatlas_path, 'deepatlas_raw_data_base', task_id, 'Training_dataset')
+    image_path = os.path.join(base_path, 'images')
+    seg_path = os.path.join(base_path, 'labels')
+    output_path = os.path.join(deepatlas_path, 'deepatlas_preprocessed')
+    task_path = os.path.join(deepatlas_path, 'deepatlas_preprocessed', task_id)
+    training_data_path = os.path.join(deepatlas_path, 'deepatlas_preprocessed', task_id, 'Training_dataset')
+    output_img = os.path.join(deepatlas_path, 'deepatlas_preprocessed', task_id, 'Training_dataset', 'images')
+    output_seg = os.path.join(deepatlas_path, 'deepatlas_preprocessed', task_id, 'Training_dataset', 'labels')
+    label_list = path_to_id(seg_path)
+    geo_info = get_geometry_info(seg_path, image_path)
+    print(geo_info)
+    try:
+        os.mkdir(output_path)
+    except:
+        print(f'{output_path} is already existed')
+
+    try:
+        os.mkdir(task_path)
+    except:
+        print(f'{task_path} is already existed')
+    
+    try:
+        os.mkdir(training_data_path)
+    except:
+        print(f"{training_data_path} already exists")
+
+    try:
+        os.mkdir(output_path)
+    except:
+        print(f'{output_path} is already existed')
+
+    try:
+        os.mkdir(output_img)
+    except:
+        print(f'{output_img} is already existed')
+
+    try:
+        os.mkdir(output_seg)
+    except:
+        print(f'{output_seg} is already existed')
+
+    for i in sorted(glob.glob(image_path + '/*nii.gz')):
+        id = os.path.basename(i).split('.')[0]
+        if id in label_list:
+            label_path = os.path.join(seg_path, id + '.nii.gz')
+            nib_img, nib_seg, ants_img, ants_seg = load_data(i, label_path)
+            if flipped:
+                left_img, left_seg, flipped_right_img, flipped_right_seg = crop_and_flip(
+                    nib_img, nib_seg, ants_img, ants_seg, resize_shape)
+                print(
+                    'Scan ID: ' + id + f', img & seg before cropping: {nib_img.get_fdata().shape}, after cropping, flipping and padding: {left_img.shape} and {flipped_right_img.shape}')
+                crop_flip_save_file(left_img, left_seg, flipped_right_img, flipped_right_seg,
+                        nib_img, nib_seg, output_img, output_seg, id)
+            else:
+                left_img, left_seg = crop(
+                    nib_img, nib_seg, ants_img, ants_seg, resize_shape)
+                print(
+                    'Scan ID: ' + id + f', img & seg before cropping: {nib_img.get_fdata().shape}, after cropping and padding the image and seg: {left_img.shape}')
+                crop_save_file(left_img, left_seg, nib_img,
+                        nib_seg, output_img, output_seg, id)
+        else:
+            nib_img = nib.load(i)
+            ant_img = ants.image_read(i)
+            if flipped:
+                left_img, flipped_right_img = crop_and_flip_V2(nib_img, ant_img, resize_shape, geo_info)
+                print(
+                    'Scan ID: ' + id + f', img before cropping: {nib_img.get_fdata().shape}, after cropping, flipping and padding: {left_img.shape} and {flipped_right_img.shape}')
+                crop_flip_save_file_V2(left_img, flipped_right_img, nib_img, output_img, id)
+            else:
+                outImg = cropV2(nib_img, ant_img, resize_shape, geo_info)
+                print(
+                    'Scan ID: ' + id + f', img before cropping: {nib_img.get_fdata().shape}, after cropping and padding the image: {outImg.shape}')
+                save_fileV2(outImg, nib_img, output_img, id)
+
+if __name__ == '__main__':
+    main()

deepatlas/preprocess/generate_info.py

@@ -0,0 +1,133 @@
+'''
+python3 split_data.py RegisteredImageFolderPath RegisteredLabelFolderPath
+Given the parameter as the path to the registered images, 
+function creates two folders in the base directory (same level as this script), randomly putting in
+70 percent of images into the train and 30 percent to the test
+'''
+import os
+import glob
+import random
+import shutil
+from pathlib import Path
+from typing import Tuple
+import numpy as np
+from collections import OrderedDict
+import json
+import argparse
+import sys
+from collections import namedtuple
+
+ROOT_DIR = str(Path(os.getcwd()).parent.parent.absolute())
+sys.path.insert(0, os.path.join(ROOT_DIR, 'deepatlas/utils'))
+
+from utils import (
+    make_if_dont_exist, load_json
+)
+"""
+creates a folder at a specified folder path if it does not exists
+folder_path : relative path of the folder (from cur_dir) which needs to be created
+over_write :(default: False) if True overwrite the existing folder 
+ """
+def parse_command_line():
+    print('Parsing Command Line Arguments')
+    parser = argparse.ArgumentParser(
+        description='pipeline for dataset split')
+    parser.add_argument('--config', metavar='path to the configuration file', type=str,
+                        help='absolute path to the configuration file')
+    parser.add_argument('--train_only', action='store_true',
+                        help='only training or training plus test')
+    argv = parser.parse_args()
+    return argv
+
+
+def split(img, seg, seg_path):
+    label = []
+    unlabel = []
+    total = []
+    for i in img:
+        name = os.path.basename(i)
+        seg_name = os.path.join(seg_path, name)
+        if seg_name in seg:
+            item = {"img": i,
+                    "seg": seg_name}
+            label.append(item)
+        else:
+            item = {"img": i}
+            unlabel.append(item)
+
+        total.append(item)
+    return label, unlabel, total
+
+def main():
+    random.seed(2938649572)
+    ROOT_DIR = str(Path(os.getcwd()).parent.parent.absolute())
+    args = parse_command_line()
+    config = args.config
+    config = load_json(config)
+    config = namedtuple("config", config.keys())(*config.values())
+    task_id = config.task_name
+    k_fold = config.num_fold
+    folder_name = config.folder_name
+    train_only = args.train_only
+    deepatlas_path = ROOT_DIR
+    base_path = os.path.join(deepatlas_path, "deepatlas_preprocessed")
+    task_path = os.path.join(base_path, task_id)
+    img_path = os.path.join(task_path, 'Training_dataset', 'images')
+    seg_path = os.path.join(task_path, 'Training_dataset', 'labels')
+    image_list = glob.glob(img_path + "/*.nii.gz")
+    label_list = glob.glob(seg_path + "/*.nii.gz")
+    label, unlabel, total = split(image_list, label_list, seg_path)
+    piece_data = {}
+    info_path = os.path.join(task_path, 'Training_dataset', 'data_info')
+    folder_path = os.path.join(info_path, folder_name)
+    make_if_dont_exist(info_path)
+    make_if_dont_exist(folder_path)
+    
+    if not train_only: 
+        # compute number of scans for each fold
+        num_images = len(image_list)
+        num_each_fold_scan = divmod(num_images, k_fold)[0]
+        fold_num_scan = np.repeat(num_each_fold_scan, k_fold)
+        num_remain_scan = divmod(num_images, k_fold)[1]
+        count = 0
+        while num_remain_scan > 0:
+            fold_num_scan[count] += 1
+            count = (count+1) % k_fold 
+            num_remain_scan -= 1
+        
+        # compute number of labels for each fold
+        num_seg = len(label_list)
+        num_each_fold_seg = divmod(num_seg, k_fold)[0]
+        fold_num_seg = np.repeat(num_each_fold_seg, k_fold)
+        num_remain_seg = divmod(num_seg, k_fold)[1]
+        count = 0
+        while num_remain_seg > 0:
+            fold_num_seg[count] += 1
+            count = (count+1) % k_fold 
+            num_remain_seg -= 1
+        
+        random.shuffle(unlabel)
+        random.shuffle(label)
+        start_point = 0
+        start_point1 = 0
+        # select scans for each fold
+        for m in range(k_fold):
+            piece_data[f'fold_{m+1}'] = label[start_point:start_point+fold_num_seg[m]]
+            fold_num_unlabel = fold_num_scan[m] - fold_num_seg[m]
+            piece_data[f'fold_{m+1}'].extend(unlabel[start_point1:start_point1+fold_num_unlabel])
+            start_point += fold_num_seg[m]
+            start_point1 += fold_num_unlabel
+        
+        info_json_path = os.path.join(folder_path, f'info.json')
+    else:
+        piece_data = total
+        info_json_path = os.path.join(folder_path, f'info_train_only.json')
+    
+    with open(info_json_path, 'w') as f:
+        json.dump(piece_data, f, indent=4, sort_keys=True)
+
+    if os.path.exists(info_json_path):
+        print("new info json file created!")
+
+if __name__ == '__main__':
+    main()

deepatlas/preprocess/process_data.py

@@ -0,0 +1,164 @@
+import monai
+import torch
+import itk
+import numpy as np
+import glob
+import os
+
+
+def path_to_id(path):
+    return os.path.basename(path).split('.')[0]
+
+
+def split_data(img_path, seg_path, num_seg):
+    total_img_paths = []
+    total_seg_paths = []
+    for i in sorted(glob.glob(img_path + '/*.nii.gz')):
+        total_img_paths.append(i)
+
+    for j in sorted(glob.glob(seg_path + '/*.nii.gz')):
+        total_seg_paths.append(j)
+
+    np.random.shuffle(total_img_paths)
+    num_train = int(round(len(total_seg_paths)*0.8))
+    num_test = len(total_seg_paths) - num_train
+    seg_train = total_seg_paths[:num_train]
+    seg_test = total_seg_paths[num_train:]
+    img_train = []
+    img_test = []
+    test = []
+    train = []
+    img_ids = list(map(path_to_id, total_img_paths))
+    img_ids1 = img_ids
+    total_img_paths1 = total_img_paths
+    seg_ids_test = map(path_to_id, seg_test)
+    seg_ids_train = map(path_to_id, seg_train)
+    for seg_index, seg_id in enumerate(seg_ids_test):
+        data_item = {}
+        assert seg_id in img_ids
+        img_test.append(total_img_paths[img_ids.index(seg_id)])
+        data_item['img'] = total_img_paths[img_ids.index(seg_id)]
+        total_img_paths1.pop(img_ids1.index(seg_id))
+        img_ids1.pop(img_ids1.index(seg_id))
+        data_item['seg'] = seg_test[seg_index]
+        test.append(data_item)
+
+    img_train = total_img_paths1
+    np.random.shuffle(seg_train)
+    if num_seg < len(seg_train):    
+        seg_train_available = seg_train[:num_seg]
+    else:
+        seg_train_available = seg_train
+    seg_ids = list(map(path_to_id, seg_train_available))
+    img_ids = map(path_to_id, img_train)
+    for img_index, img_id in enumerate(img_ids):
+        data_item = {'img': img_train[img_index]}
+        if img_id in seg_ids:
+            data_item['seg'] = seg_train_available[seg_ids.index(img_id)]
+        train.append(data_item)
+
+    num_train = len(img_train)
+    return train, test, num_train, num_test
+
+
+def load_seg_dataset(train, valid):
+    transform_seg_available = monai.transforms.Compose(
+        transforms=[
+            monai.transforms.LoadImageD(keys=['img', 'seg'], image_only=True),
+            monai.transforms.AddChannelD(keys=['img', 'seg']),
+            monai.transforms.SpacingD(keys=['img', 'seg'], pixdim=(1., 1., 1.), mode=('trilinear', 'nearest')),
+            monai.transforms.ToTensorD(keys=['img', 'seg'])
+        ]
+    )
+    itk.ProcessObject.SetGlobalWarningDisplay(False)
+    dataset_seg_available_train = monai.data.CacheDataset(
+        data=train,
+        transform=transform_seg_available,
+        cache_num=16,
+        hash_as_key=True
+    )
+
+    dataset_seg_available_valid = monai.data.CacheDataset(
+        data=valid,
+        transform=transform_seg_available,
+        cache_num=16,
+        hash_as_key=True
+    )
+    return dataset_seg_available_train, dataset_seg_available_valid
+
+
+def load_reg_dataset(train, valid):
+    transform_pair = monai.transforms.Compose(
+        transforms=[
+            monai.transforms.LoadImageD(
+                keys=['img1', 'seg1', 'img2', 'seg2'], image_only=True, allow_missing_keys=True),
+            monai.transforms.ToTensorD(
+                keys=['img1', 'seg1', 'img2', 'seg2'], allow_missing_keys=True),
+            monai.transforms.AddChannelD(
+                keys=['img1', 'seg1', 'img2', 'seg2'], allow_missing_keys=True),
+            monai.transforms.SpacingD(keys=['img1', 'seg1', 'img2', 'seg2'], pixdim=(1., 1., 1.), mode=(
+                'trilinear', 'nearest', 'trilinear', 'nearest'), allow_missing_keys=True),
+            monai.transforms.ConcatItemsD(
+                keys=['img1', 'img2'], name='img12', dim=0),
+            monai.transforms.DeleteItemsD(keys=['img1', 'img2'])
+        ]
+    )
+    dataset_pairs_train_subdivided = {
+        seg_availability: monai.data.CacheDataset(
+            data=data_list,
+            transform=transform_pair,
+            cache_num=32,
+            hash_as_key=True
+        )
+        for seg_availability, data_list in train.items()
+    }
+
+    dataset_pairs_valid_subdivided = {
+        seg_availability: monai.data.CacheDataset(
+            data=data_list,
+            transform=transform_pair,
+            cache_num=32,
+            hash_as_key=True
+        )
+        for seg_availability, data_list in valid.items()
+    }
+    return dataset_pairs_train_subdivided, dataset_pairs_valid_subdivided
+
+
+def take_data_pairs(data, symmetric=True):
+    """Given a list of dicts that have keys for an image and maybe a segmentation,
+    return a list of dicts corresponding to *pairs* of images and maybe segmentations.
+    Pairs consisting of a repeated image are not included.
+    If symmetric is set to True, then for each pair that is included, its reverse is also included"""
+    data_pairs = []
+    for i in range(len(data)):
+        j_limit = len(data) if symmetric else i
+        for j in range(j_limit):
+            if j == i:
+                continue
+            d1 = data[i]
+            d2 = data[j]
+            pair = {
+                'img1': d1['img'],
+                'img2': d2['img']
+            }
+            if 'seg' in d1.keys():
+                pair['seg1'] = d1['seg']
+            if 'seg' in d2.keys():
+                pair['seg2'] = d2['seg']
+            data_pairs.append(pair)
+    return data_pairs
+
+
+def subdivide_list_of_data_pairs(data_pairs_list):
+    out_dict = {'00': [], '01': [], '10': [], '11': []}
+    for d in data_pairs_list:
+        if 'seg1' in d.keys() and 'seg2' in d.keys():
+            out_dict['11'].append(d)
+        elif 'seg1' in d.keys():
+            out_dict['10'].append(d)
+        elif 'seg2' in d.keys():
+            out_dict['01'].append(d)
+        else:
+            out_dict['00'].append(d)
+    return out_dict

deepatlas/preprocess/registration_test.py

@@ -0,0 +1,364 @@
+import os
+import ants
+import nrrd
+import numpy as np
+import glob
+import slicerio
+import shutil
+import argparse
+from pathlib import Path
+
+def parse_command_line():
+    print('---'*10)
+    print('Parsing Command Line Arguments')
+    parser = argparse.ArgumentParser(
+        description='pipeline for dataset co-alignment')
+    parser.add_argument('-bp', metavar='base path', type=str,
+                        help="absolute path of the base directory")
+    parser.add_argument('-op', metavar='output path for both registration & crop steps', type=str,
+                        help="relative path of the output directory, should be same name in the registration, crop and final prediction steps")
+    parser.add_argument('-template', metavar='template scan path', type=str,
+                        help="relative path of the template scan directory")
+    parser.add_argument('-target_scan', metavar='target scan path', type=str,
+                        help="relative path of the target image directory")
+    parser.add_argument('-target_seg', metavar='target segmentation path', type=str,
+                        help="relative path of the target segmentation directory")
+    parser.add_argument('-sl', metavar='segmentation information list', type=str, nargs='+',
+                        help='a list of label name and corresponding value')
+    parser.add_argument('-ti', metavar='task id and name', type=str,
+                        help='task name and id')
+    argv = parser.parse_args()
+    return argv
+
+
+def split_and_registration(template, target, base, template_images_path, target_images_path, seg_path, img_out_path, seg_out_path, template_fomat, target_fomat, has_label=False):
+    print('---'*10)
+    print('Creating file paths')
+    # Define the path for template, target, and segmentations (from template)
+    fixed_path = os.path.join(base, template_images_path, template + '.' + template_fomat)
+    moving_path = os.path.join(base, target_images_path, target + '.' + target_fomat)
+    images_output = os.path.join(img_out_path, target + '.nii.gz')
+    print('---'*10)
+    print('Reading in the template and target image')
+    # Read the template and target image
+    template_image = ants.image_read(fixed_path)
+    target_image = ants.image_read(moving_path)
+    print('---'*10)
+    print('Performing the template and target image registration')
+    transform_forward = ants.registration(fixed=template_image, moving=target_image,
+                                          type_of_transform="Similarity", verbose=False)
+    if has_label:
+        segmentation_path = os.path.join(
+            base, seg_path, target + '.nii.gz')
+        segmentation_output = os.path.join(
+            seg_out_path, target + '.nii.gz')
+        print('---'*10)
+        print('Reading in the segmentation')
+        # Split segmentations into individual components
+        segment_target = ants.image_read(segmentation_path)
+        print('---'*10)
+        print('Applying the transformation for label propagation and image registration')
+        predicted_targets_image = ants.apply_transforms(
+            fixed=template_image,
+            moving=segment_target,
+            transformlist=transform_forward["fwdtransforms"],
+            interpolator="genericLabel",
+            verbose=False)
+        predicted_targets_image.to_file(segmentation_output)
+
+    reg_img = ants.apply_transforms(
+        fixed=template_image,
+        moving=target_image,
+        transformlist=transform_forward["fwdtransforms"],
+        interpolator="linear",
+        verbose=False)
+    print('---'*10)
+    print("writing out transformed template segmentation")
+    reg_img.to_file(images_output)
+    print('Label Propagation & Image Registration complete')
+
+
+def convert_to_one_hot(data, header, segment_indices=None):
+    print('---'*10)
+    print("converting to one hot")
+
+    layer_values = get_layer_values(header)
+    label_values = get_label_values(header)
+
+    # Newer Slicer NRRD (compressed layers)
+    if layer_values and label_values:
+
+        assert len(layer_values) == len(label_values)
+        if len(data.shape) == 3:
+            x_dim, y_dim, z_dim = data.shape
+        elif len(data.shape) == 4:
+            x_dim, y_dim, z_dim = data.shape[1:]
+
+        num_segments = len(layer_values)
+        one_hot = np.zeros((num_segments, x_dim, y_dim, z_dim))
+
+        if segment_indices is None:
+            segment_indices = list(range(num_segments))
+
+        elif isinstance(segment_indices, int):
+            segment_indices = [segment_indices]
+
+        elif not isinstance(segment_indices, list):
+            print("incorrectly specified segment indices")
+            return
+
+        # Check if NRRD is composed of one layer 0
+        if np.max(layer_values) == 0:
+            for i, seg_idx in enumerate(segment_indices):
+                layer = layer_values[seg_idx]
+                label = label_values[seg_idx]
+                one_hot[i] = 1*(data == label).astype(np.uint8)
+
+        else:
+            for i, seg_idx in enumerate(segment_indices):
+                layer = layer_values[seg_idx]
+                label = label_values[seg_idx]
+                one_hot[i] = 1*(data[layer] == label).astype(np.uint8)
+
+    # Binary labelmap
+    elif len(data.shape) == 3:
+        x_dim, y_dim, z_dim = data.shape
+        num_segments = np.max(data)
+        one_hot = np.zeros((num_segments, x_dim, y_dim, z_dim))
+
+        if segment_indices is None:
+            segment_indices = list(range(1, num_segments + 1))
+
+        elif isinstance(segment_indices, int):
+            segment_indices = [segment_indices]
+
+        elif not isinstance(segment_indices, list):
+            print("incorrectly specified segment indices")
+            return
+
+        for i, seg_idx in enumerate(segment_indices):
+            one_hot[i] = 1*(data == seg_idx).astype(np.uint8)
+
+    # Older Slicer NRRD (already one-hot)
+    else:
+        return data
+
+    return one_hot
+
+
+def get_layer_values(header, indices=None):
+    layer_values = []
+    num_segments = len([key for key in header.keys() if "Layer" in key])
+    for i in range(num_segments):
+        layer_values.append(int(header['Segment{}_Layer'.format(i)]))
+    return layer_values
+
+
+def get_label_values(header, indices=None):
+    label_values = []
+    num_segments = len([key for key in header.keys() if "LabelValue" in key])
+    for i in range(num_segments):
+        label_values.append(int(header['Segment{}_LabelValue'.format(i)]))
+    return label_values
+
+
+def get_num_segments(header, indices=None):
+    num_segments = len([key for key in header.keys() if "LabelValue" in key])
+    return num_segments
+
+
+def checkCorrespondence(segmentation, base, paired_list, filename):
+    print(filename)
+    assert type(paired_list) == list
+    data, tempSeg = nrrd.read(os.path.join(base, segmentation, filename))
+    seg_info = slicerio.read_segmentation_info(
+        os.path.join(base, segmentation, filename))
+    output_voxels, output_header = slicerio.extract_segments(
+        data, tempSeg, seg_info, paired_list)
+    output = os.path.join(base, 'MatchedSegs/' +
+                          filename)
+    nrrd.write(output, output_voxels, output_header)
+    print('---'*10)
+    print('Check the label names and values')
+    print(slicerio.read_segmentation_info(output))
+    return output
+
+
+def checkSegFormat(base, segmentation, paired_list, check=False):
+    path = os.path.join(base, segmentation)
+    save_dir = os.path.join(base, 're-format_labels')
+    try:
+        os.mkdir(save_dir)
+    except:
+        print(f'{save_dir} already exists')
+
+    for file in os.listdir(path):
+        name = file.split('.')[0]
+        if file.endswith('seg.nrrd') or file.endswith('nrrd'):
+            if check:
+                output_path = checkCorrespondence(
+                    segmentation, base, paired_list, file)
+                ants_img = ants.image_read(output_path)
+                header = nrrd.read_header(output_path)
+            else:
+                ants_img = ants.image_read(os.path.join(path, file))
+                header = nrrd.read_header(os.path.join(path, file))
+            segmentations = True
+            filename = os.path.join(save_dir, name + '.nii.gz')
+            nrrd2nifti(ants_img, header, filename, segmentations)
+        elif file.endswith('nii'):
+            image = ants.image_read(os.path.join(path, file))
+            image.to_file(os.path.join(save_dir, name + '.nii.gz'))
+        elif file.endswith('nii.gz'):
+            shutil.copy(os.path.join(path, file), save_dir)
+
+    return save_dir
+
+
+def nrrd2nifti(img, header, filename, segmentations=True):
+    img_as_np = img.view(single_components=segmentations)
+    if segmentations:
+        data = convert_to_one_hot(img_as_np, header)
+        foreground = np.max(data, axis=0)
+        labelmap = np.multiply(np.argmax(data, axis=0) + 1,
+                               foreground).astype('uint8')
+        segmentation_img = ants.from_numpy(
+            labelmap, origin=img.origin, spacing=img.spacing, direction=img.direction)
+        print('-- Saving NII Segmentations')
+        segmentation_img.to_file(filename)
+    else:
+        print('-- Saving NII Volume')
+        img.to_file(filename)
+
+
+def find_template(base, image_path, fomat):
+    scans = sorted(glob.glob(os.path.join(base, image_path) + '/*' + fomat))
+    template = os.path.basename(scans[0]).split('.')[0]
+    return template
+
+
+def find_template_V2(base, image_path, fomat):
+    maxD = -np.inf
+    for i in glob.glob(os.path.join(base, image_path) + '/*' + fomat):
+        id = os.path.basename(i).split('.')[0]
+        img = ants.image_read(i)
+        thirdD = img.shape[2]
+        if thirdD > maxD:
+            template = id
+            maxD = thirdD
+
+    return template
+
+
+def path_to_id(path, fomat):
+    ids = []
+    for i in glob.glob(path + '/*' + fomat):
+        id = os.path.basename(i).split('.')[0]
+        ids.append(id)
+    return ids
+
+
+def checkFormat(base, images_path):
+    path = os.path.join(base, images_path)
+    for file in os.listdir(path):
+        if file.endswith('.nii'):
+            ret = 'nii'
+            break
+        elif file.endswith('.nii.gz'):
+            ret = 'nii.gz'
+            break
+        elif file.endswith('.nrrd'):
+            ret = 'nrrd'
+            break
+        elif file.endswith('.seg.nrrd'):
+            ret = 'seg.nrrd'
+            break
+    return ret
+
+
+def main():
+    ROOT_DIR = str(Path(os.getcwd()).parent.parent.absolute())
+    args = parse_command_line()
+    base = args.bp
+    template_path = args.template
+    target_seg = args.target_seg
+    target_scan = args.target_scan
+    label_list = args.sl
+    task_id = args.ti
+    deepatlas_path = ROOT_DIR
+    task_path = os.path.join(deepatlas_path, 'deepatlas_raw_data_base', task_id)
+    output_data_path = os.path.join(task_path, 'customize_test_data')
+    out_data_path = os.path.join(output_data_path, args.op)
+    images_output = os.path.join(out_data_path, 'images')
+    labels_output = os.path.join(out_data_path, 'labels')
+    template_fomat = checkFormat(base, template_path)
+    target_fomat = checkFormat(base, target_scan)
+    fomat_seg = checkFormat(base, target_seg)
+    template = os.path.basename(glob.glob(os.path.join(base, template_path) + '/*' + template_fomat)[0]).split('.')[0]
+    label_lists = path_to_id(os.path.join(base, target_seg), fomat_seg)
+    if label_list is not None:
+        matched_output = os.path.join(base, 'MatchedSegs')
+        try:
+            os.mkdir(matched_output)
+        except:
+            print(f"{matched_output} already exists")
+
+    try:
+        os.mkdir(output_data_path)
+    except:
+        print(f"{output_data_path} already exists")
+    
+    try:
+        os.mkdir(out_data_path)
+    except:
+        print(f"{out_data_path} already exists")
+
+    try:
+        os.mkdir(images_output)
+    except:
+        print(f"{images_output} already exists")
+
+    try:
+        os.mkdir(labels_output)
+    except:
+        print(f"{labels_output} already exists")
+
+    paired_list = []
+    if label_list is not None:
+        for i in range(0, len(label_list), 2):
+            if not label_list[i].isdigit():
+                print(
+                    "Wrong order of input argument for pair-wising label value and its name !!!")
+                return
+            else:
+                value = label_list[i]
+                if not label_list[i+1].isdigit():
+                    key = label_list[i+1]
+                    ele = tuple((key, value))
+                    paired_list.append(ele)
+                else:
+                    print(
+                        "Wrong input argument for pair-wising label value and its name !!!")
+                    return
+
+            # print(new_segmentation)
+        seg_output_path = checkSegFormat(
+            base, target_seg, paired_list, check=True)
+
+    else:
+        seg_output_path = checkSegFormat(
+            base, target_seg, paired_list, check=False)
+
+    for i in sorted(glob.glob(os.path.join(base, target_scan) + '/*' + target_fomat)):
+        id = os.path.basename(i).split('.')[0]
+        target = id
+        if id in label_lists:
+            split_and_registration(
+                template, target, base, template_path, target_scan, seg_output_path, images_output, labels_output, template_fomat, target_fomat, has_label=True)
+        else:
+            split_and_registration(
+                template, target, base, template_path, target_scan, seg_output_path, images_output, labels_output, template_fomat, target_fomat, has_label=False)
+
+
+if __name__ == '__main__':
+    main()

deepatlas/preprocess/registration_training.py

@@ -0,0 +1,379 @@
+import os
+import ants
+import nrrd
+import numpy as np
+import glob
+import slicerio
+import shutil
+import argparse
+from pathlib import Path
+
+def parse_command_line():
+    print('---'*10)
+    print('Parsing Command Line Arguments')
+    parser = argparse.ArgumentParser(
+        description='pipeline for dataset co-alignment')
+    parser.add_argument('-bp', metavar='base path', type=str,
+                        help="Absolute path of the base directory")
+    parser.add_argument('-ip', metavar='image path', type=str,
+                        help="Relative path of the image directory")
+    parser.add_argument('-sp', metavar='segmentation path', type=str,
+                        help="Relative path of the image directory")
+    parser.add_argument('-sl', metavar='segmentation information list', type=str, nargs='+',
+                        help='a list of label name and corresponding value')
+    parser.add_argument('-ti', metavar='task id and name', type=str,
+                        help='task name and id')
+    argv = parser.parse_args()
+    return argv
+
+
+def split_and_registration(template, target, base, template_images_path, target_images_path, seg_path, img_out_path, seg_out_path, template_fomat, target_fomat, checked=False, has_label=False):
+    print('---'*10)
+    print('Creating file paths')
+    # Define the path for template, target, and segmentations (from template)
+    fixed_path = os.path.join(base, template_images_path, template + '.' + template_fomat)
+    moving_path = os.path.join(base, target_images_path, target + '.' + target_fomat)
+    images_output = os.path.join(img_out_path, target + '.nii.gz')
+    print('---'*10)
+    print('Reading in the template and target image')
+    # Read the template and target image
+    template_image = ants.image_read(fixed_path)
+    target_image = ants.image_read(moving_path)
+    print('---'*10)
+    print('Performing the template and target image registration')
+    transform_forward = ants.registration(fixed=template_image, moving=target_image,
+                                          type_of_transform="Similarity", verbose=False)
+    if has_label:
+        segmentation_path = os.path.join(
+            base, seg_path, target + '.nii.gz')
+        segmentation_output = os.path.join(
+            seg_out_path, target + '.nii.gz')
+        print('---'*10)
+        print('Reading in the segmentation')
+        # Split segmentations into individual components
+        segment_target = ants.image_read(segmentation_path)
+        print('---'*10)
+        print('Applying the transformation for label propagation and image registration')
+        predicted_targets_image = ants.apply_transforms(
+            fixed=template_image,
+            moving=segment_target,
+            transformlist=transform_forward["fwdtransforms"],
+            interpolator="genericLabel",
+            verbose=False)
+        predicted_targets_image.to_file(segmentation_output)
+
+    reg_img = ants.apply_transforms(
+        fixed=template_image,
+        moving=target_image,
+        transformlist=transform_forward["fwdtransforms"],
+        interpolator="linear",
+        verbose=False)
+    print('---'*10)
+    print("writing out transformed template segmentation")
+    reg_img.to_file(images_output)
+    print('Label Propagation & Image Registration complete')
+
+
+def convert_to_one_hot(data, header, segment_indices=None):
+    print('---'*10)
+    print("converting to one hot")
+
+    layer_values = get_layer_values(header)
+    label_values = get_label_values(header)
+
+    # Newer Slicer NRRD (compressed layers)
+    if layer_values and label_values:
+
+        assert len(layer_values) == len(label_values)
+        if len(data.shape) == 3:
+            x_dim, y_dim, z_dim = data.shape
+        elif len(data.shape) == 4:
+            x_dim, y_dim, z_dim = data.shape[1:]
+
+        num_segments = len(layer_values)
+        one_hot = np.zeros((num_segments, x_dim, y_dim, z_dim))
+
+        if segment_indices is None:
+            segment_indices = list(range(num_segments))
+
+        elif isinstance(segment_indices, int):
+            segment_indices = [segment_indices]
+
+        elif not isinstance(segment_indices, list):
+            print("incorrectly specified segment indices")
+            return
+
+        # Check if NRRD is composed of one layer 0
+        if np.max(layer_values) == 0:
+            for i, seg_idx in enumerate(segment_indices):
+                layer = layer_values[seg_idx]
+                label = label_values[seg_idx]
+                one_hot[i] = 1*(data == label).astype(np.uint8)
+
+        else:
+            for i, seg_idx in enumerate(segment_indices):
+                layer = layer_values[seg_idx]
+                label = label_values[seg_idx]
+                one_hot[i] = 1*(data[layer] == label).astype(np.uint8)
+
+    # Binary labelmap
+    elif len(data.shape) == 3:
+        x_dim, y_dim, z_dim = data.shape
+        num_segments = np.max(data)
+        one_hot = np.zeros((num_segments, x_dim, y_dim, z_dim))
+
+        if segment_indices is None:
+            segment_indices = list(range(1, num_segments + 1))
+
+        elif isinstance(segment_indices, int):
+            segment_indices = [segment_indices]
+
+        elif not isinstance(segment_indices, list):
+            print("incorrectly specified segment indices")
+            return
+
+        for i, seg_idx in enumerate(segment_indices):
+            one_hot[i] = 1*(data == seg_idx).astype(np.uint8)
+
+    # Older Slicer NRRD (already one-hot)
+    else:
+        return data
+
+    return one_hot
+
+
+def get_layer_values(header, indices=None):
+    layer_values = []
+    num_segments = len([key for key in header.keys() if "Layer" in key])
+    for i in range(num_segments):
+        layer_values.append(int(header['Segment{}_Layer'.format(i)]))
+    return layer_values
+
+
+def get_label_values(header, indices=None):
+    label_values = []
+    num_segments = len([key for key in header.keys() if "LabelValue" in key])
+    for i in range(num_segments):
+        label_values.append(int(header['Segment{}_LabelValue'.format(i)]))
+    return label_values
+
+
+def get_num_segments(header, indices=None):
+    num_segments = len([key for key in header.keys() if "LabelValue" in key])
+    return num_segments
+
+
+def checkCorrespondence(segmentation, base, paired_list, filename):
+    print(filename)
+    assert type(paired_list) == list
+    data, tempSeg = nrrd.read(os.path.join(base, segmentation, filename))
+    seg_info = slicerio.read_segmentation_info(
+        os.path.join(base, segmentation, filename))
+    output_voxels, output_header = slicerio.extract_segments(
+        data, tempSeg, seg_info, paired_list)
+    output = os.path.join(base, 'MatchedSegs/' +
+                          filename)
+    nrrd.write(output, output_voxels, output_header)
+    print('---'*10)
+    print('Check the label names and values')
+    print(slicerio.read_segmentation_info(output))
+    return output
+
+
+def checkSegFormat(base, segmentation, paired_list, check=False):
+    path = os.path.join(base, segmentation)
+    save_dir = os.path.join(base, 're-format_labels')
+    try:
+        os.mkdir(save_dir)
+    except:
+        print(f'{save_dir} already exists')
+
+    for file in os.listdir(path):
+        name = file.split('.')[0]
+        if file.endswith('seg.nrrd') or file.endswith('nrrd'):
+            if check:
+                output_path = checkCorrespondence(
+                    segmentation, base, paired_list, file)
+                ants_img = ants.image_read(output_path)
+                header = nrrd.read_header(output_path)
+            else:
+                ants_img = ants.image_read(os.path.join(path, file))
+                header = nrrd.read_header(os.path.join(path, file))
+            segmentations = True
+            filename = os.path.join(save_dir, name + '.nii.gz')
+            nrrd2nifti(ants_img, header, filename, segmentations)
+        elif file.endswith('nii'):
+            image = ants.image_read(os.path.join(path, file))
+            image.to_file(os.path.join(save_dir, name + '.nii.gz'))
+        elif file.endswith('nii.gz'):
+            shutil.copy(os.path.join(path, file), save_dir)
+
+    return save_dir
+
+
+def nrrd2nifti(img, header, filename, segmentations=True):
+    img_as_np = img.view(single_components=segmentations)
+    if segmentations:
+        data = convert_to_one_hot(img_as_np, header)
+        foreground = np.max(data, axis=0)
+        labelmap = np.multiply(np.argmax(data, axis=0) + 1,
+                               foreground).astype('uint8')
+        segmentation_img = ants.from_numpy(
+            labelmap, origin=img.origin, spacing=img.spacing, direction=img.direction)
+        print('-- Saving NII Segmentations')
+        segmentation_img.to_file(filename)
+    else:
+        print('-- Saving NII Volume')
+        img.to_file(filename)
+
+
+def find_template(base, image_path, fomat):
+    scans = sorted(glob.glob(os.path.join(base, image_path) + '/*' + fomat))
+    template = os.path.basename(scans[0]).split('.')[0]
+    return template
+
+
+def find_template_V2(base, image_path, fomat):
+    maxD = -np.inf
+    for i in glob.glob(os.path.join(base, image_path) + '/*' + fomat):
+        id = os.path.basename(i).split('.')[0]
+        img = ants.image_read(i)
+        thirdD = img.shape[2]
+        if thirdD > maxD:
+            template = id
+            maxD = thirdD
+
+    return template
+
+
+def path_to_id(path, fomat):
+    ids = []
+    for i in glob.glob(path + '/*' + fomat):
+        id = os.path.basename(i).split('.')[0]
+        ids.append(id)
+    return ids
+
+
+def checkFormat(base, images_path):
+    path = os.path.join(base, images_path)
+    for file in os.listdir(path):
+        if file.endswith('.nii'):
+            ret = 'nii'
+            break
+        elif file.endswith('.nii.gz'):
+            ret = 'nii.gz'
+            break
+        elif file.endswith('.nrrd'):
+            ret = 'nrrd'
+            break
+        elif file.endswith('.seg.nrrd'):
+            ret = 'seg.nrrd'
+            break
+    return ret
+
+
+def main():
+    ROOT_DIR = str(Path(os.getcwd()).parent.parent.absolute())
+    args = parse_command_line()
+    base = args.bp
+    images_path = args.ip
+    segmentation = args.sp
+    label_list = args.sl
+    task_id = args.ti
+    deepatlas_path = ROOT_DIR
+    raw_data_path = os.path.join(deepatlas_path, 'deepatlas_raw_data_base')
+    task_path = os.path.join(deepatlas_path, 'deepatlas_raw_data_base', task_id)
+    training_data_path = os.path.join(deepatlas_path, 'deepatlas_raw_data_base', task_id, 'Training_dataset')
+    images_output = os.path.join(deepatlas_path, 'deepatlas_raw_data_base', task_id, 'Training_dataset', 'images')
+    labels_output = os.path.join(deepatlas_path, 'deepatlas_raw_data_base', task_id, 'Training_dataset', 'labels')
+    fomat = checkFormat(base, images_path)
+    fomat_seg = checkFormat(base, segmentation)
+    template = find_template(base, images_path, fomat)
+    label_lists = path_to_id(os.path.join(base, segmentation), fomat_seg)
+    if label_list is not None:
+        matched_output = os.path.join(base, 'MatchedSegs')
+        try:
+            os.mkdir(matched_output)
+        except:
+            print(f"{matched_output} already exists")
+
+    try:
+        os.mkdir(raw_data_path)
+    except:
+        print(f"{raw_data_path} already exists")
+    
+    try:
+        os.mkdir(task_path)
+    except:
+        print(f"{task_path} already exists")
+    
+    try:
+        os.mkdir(training_data_path)
+    except:
+        print(f"{training_data_path} already exists")
+
+    try:
+        os.mkdir(images_output)
+    except:
+        print(f"{images_output} already exists")
+
+    try:
+        os.mkdir(labels_output)
+    except:
+        print(f"{labels_output} already exists")
+
+    paired_list = []
+    if label_list is not None:
+        for i in range(0, len(label_list), 2):
+            if not label_list[i].isdigit():
+                print(
+                    "Wrong order of input argument for pair-wising label value and its name !!!")
+                return
+            else:
+                value = label_list[i]
+                if not label_list[i+1].isdigit():
+                    key = label_list[i+1]
+                    ele = tuple((key, value))
+                    paired_list.append(ele)
+                else:
+                    print(
+                        "Wrong input argument for pair-wising label value and its name !!!")
+                    return
+
+            # print(new_segmentation)
+        seg_output_path = checkSegFormat(
+            base, segmentation, paired_list, check=True)
+
+    else:
+        seg_output_path = checkSegFormat(
+            base, segmentation, paired_list, check=False)
+
+    for i in sorted(glob.glob(os.path.join(base, images_path) + '/*' + fomat)):
+        id = os.path.basename(i).split('.')[0]
+        if id == template:
+            pass
+        else:
+            target = id
+            if id in label_lists:
+                split_and_registration(
+                    template, target, base, images_path, images_path, seg_output_path, images_output, labels_output, fomat, fomat, checked=False, has_label=True)
+            else:
+                split_and_registration(
+                    template, target, base, images_path, images_path, seg_output_path, images_output, labels_output, fomat, fomat, checked=False, has_label=False)
+
+    image = ants.image_read(os.path.join(
+        base, images_path, template + '.' + fomat))
+    image.to_file(os.path.join(images_output, template + '.nii.gz'))
+
+    images_path = images_output
+    fomat = 'nii.gz'
+    if template in label_lists:
+        split_and_registration(
+            target, template, base, images_path, images_path, seg_output_path, images_output, labels_output, fomat, fomat, checked=True, has_label=True)
+    else:
+        split_and_registration(
+            target, template, base, images_path, images_path, seg_output_path, images_output, labels_output, fomat, fomat, checked=True, has_label=False)
+
+
+if __name__ == '__main__':
+    main()

deepatlas/scripts/deep_atlas.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+source ~/proj_MONAI/bin/activate
+cd ~/DeepAtlasV2/DeepAtlas/deepatlas/preprocess
+#python3 registration_training.py -bp ~/HN_data/modified/data -ip images -sp labels -ti Task003_HN33_numres2_25lab
+#python3 crop_flip_training.py -rs 240 240 144 -ti Task003_HN33_numres2_25lab
+#python3 generate_info.py -ti Task003_test -kf 5
+cd ~/DeepAtlasV2/DeepAtlas/deepatlas/scripts
+CUDA_VISIBLE_DEVICES=1 python3 deep_atlas_train.py --config ~/DeepAtlasV2/DeepAtlas/deepatlas_config/config_test.json --continue_training
+CUDA_VISIBLE_DEVICES=1 python3 deep_atlas_test.py --config ~/DeepAtlasV2/DeepAtlas/deepatlas_config/config_test.json
+#CUDA_VISIBLE_DEVICES=1 python3 deep_atlas_train.py --config ~/DeepAtlas/deepatlas_config/config_NC_2gt.json 
+#CUDA_VISIBLE_DEVICES=1 python3 deep_atlas_test.py --config ~/DeepAtlas/deepatlas_config/config_NC_2gt.json
+#CUDA_VISIBLE_DEVICES=1 python3 deep_atlas_train.py --config ~/DeepAtlas/deepatlas_config/config_NC_4gt.json 
+#CUDA_VISIBLE_DEVICES=1 python3 deep_atlas_test.py --config ~/DeepAtlas/deepatlas_config/config_NC_4gt.json

deepatlas/scripts/deep_atlas_test.py

@@ -0,0 +1,80 @@
+from pkg_resources import add_activation_listener
+import monai
+import torch
+import itk
+import numpy as np
+import os.path
+import argparse
+import sys
+from pathlib import Path
+import deep_atlas_train
+from collections import namedtuple
+
+ROOT_DIR = str(Path(os.getcwd()).parent.parent.absolute())
+sys.path.insert(0, os.path.join(ROOT_DIR, 'deepatlas/test'))
+sys.path.insert(0, os.path.join(ROOT_DIR, 'deepatlas/utils'))
+from test import (
+    seg_training_inference, reg_training_inference
+)
+from utils import (
+    make_if_dont_exist, load_json
+)
+
+def parse_command_line():
+    parser = argparse.ArgumentParser(
+        description='pipeline for deep atlas test')
+    parser.add_argument('--config', metavar='path to the configuration file', type=str,
+                        help='absolute path to the configuration file')
+    parser.add_argument('--train_only', action='store_true',
+                        help='only training or training plus test')
+    argv = parser.parse_args()
+    return argv
+
+
+def main():
+    ROOT_DIR = str(Path(os.getcwd()).parent.parent.absolute())
+    args = parse_command_line()
+    monai.utils.set_determinism(seed=2938649572)
+    config = args.config
+    train_only = args.train_only
+    config = load_json(config)
+    config = namedtuple("config", config.keys())(*config.values())
+    if len(config.info_name.split('_')) <= 1 or not train_only:
+        task = config.task_name
+        if torch.cuda.is_available():
+            device = torch.device("cuda:" + str(torch.cuda.current_device()))
+        output_path = os.path.join(ROOT_DIR, 'deepatlas_results', task, f'set_{config.exp_set}',f'{config.num_seg_used}gt', config.folder_name, 'training_predicted_results')
+        make_if_dont_exist(output_path)
+        
+        for i in range(1, config.num_fold+1):
+            num_fold = f'fold_{i}'
+            json_path = os.path.join(
+                ROOT_DIR, 'deepatlas_results', task, f'set_{config.exp_set}',f'{config.num_seg_used}gt', config.folder_name, 'training_results', num_fold, 'dataset.json')
+            #num_fold = json_file['num_fold']
+            output_fold_path = os.path.join(output_path, num_fold)
+            seg_model_path = os.path.join(Path(json_path).parent.absolute(), 'SegNet', 'model', 'seg_net_best.pth')
+            reg_model_path = os.path.join(Path(json_path).parent.absolute(), 'RegNet', 'model', 'reg_net_best.pth')
+            labels = config.labels
+            num_label = len(labels.keys())
+            network_info = config.network
+            spatial_dim = network_info['spatial_dim']
+            dropout = network_info['dropout']
+            activation_type = network_info['activation_type']
+            normalization_type = network_info['normalization_type']
+            num_res = network_info['num_res']
+            seg_path = os.path.join(output_fold_path, 'SegNet')
+            reg_path = os.path.join(output_fold_path, 'RegNet')
+            make_if_dont_exist(output_fold_path)
+            make_if_dont_exist(seg_path)
+            make_if_dont_exist(reg_path)
+            seg_net = deep_atlas_train.get_seg_net(
+                spatial_dim, num_label, dropout, activation_type, normalization_type, num_res)
+            reg_net = deep_atlas_train.get_reg_net(
+                spatial_dim, spatial_dim, dropout, activation_type, normalization_type, num_res)
+            seg_training_inference(seg_net, device, seg_model_path, seg_path, num_label, json_path=json_path, data=None)
+            reg_training_inference(reg_net, device, reg_model_path, reg_path, num_label, json_path=json_path, data=None)
+    else:
+        print('train only, test will be done in the future !!!')
+
+if __name__ == '__main__':
+    main()

deepatlas/scripts/deep_atlas_test_customized.py

@@ -0,0 +1,120 @@
+from pkg_resources import add_activation_listener
+import monai
+import torch
+import itk
+import numpy as np
+import os.path
+import argparse
+import sys
+from pathlib import Path
+import deep_atlas_train
+import glob
+
+ROOT_DIR = str(Path(os.getcwd()).parent.parent.absolute())
+sys.path.insert(0, os.path.join(ROOT_DIR, 'deepatlas/test'))
+
+from test import (
+    seg_training_inference, load_json, reg_training_inference
+)
+
+def parse_command_line():
+    parser = argparse.ArgumentParser(
+        description='pipeline for deep atlas test')
+    parser.add_argument('-gpu', metavar='id of gpu', type=str, default='0',
+                        help='id of gpu device to use')
+    parser.add_argument('-ti', metavar='task id and name', type=str,
+                        help='task name and id')
+    parser.add_argument('-nf', metavar='number of fold', type=int,
+                        help='number of fold for testing')
+    parser.add_argument('-op', metavar='output path for prediction step', type=str,
+                        help="relative path of the output directory, should be same name in the registration, crop and final prediction steps")
+    argv = parser.parse_args()
+    return argv
+
+
+def path_to_id(path):
+    return os.path.basename(path).split('.')[0]
+
+
+def main():
+    ROOT_DIR = str(Path(os.getcwd()).parent.parent.absolute())
+    args = parse_command_line()
+    gpu = args.gpu
+    task = args.ti
+    num_fold = f'fold_{args.nf}'
+    output_path = os.path.join(ROOT_DIR, 'deepatlas_results', task, 'customize_predicted_results')
+    fold_path = os.path.join(output_path, num_fold)
+    out_path = os.path.join(fold_path, args.op)
+    json_path = os.path.join(
+        ROOT_DIR, 'deepatlas_results', task, "training_results", num_fold, 'dataset.json')
+    seg_model_path = os.path.join(
+        ROOT_DIR, 'deepatlas_results', task, 'training_results', num_fold, 'SegNet', 'seg_net_best.pth')
+    reg_model_path = os.path.join(
+        ROOT_DIR, 'deepatlas_results', task, 'training_results', num_fold, 'RegNet', 'reg_net_best.pth')
+    json_file = load_json(json_path)
+    labels = json_file['labels']
+    num_label = len(labels.keys())
+    network_info = json_file['network']
+    spatial_dim = network_info['spatial_dim']
+    dropout = network_info['dropout']
+    activation_type = network_info['activation_type']
+    normalization_type = network_info['normalization_type']
+    num_res = network_info['num_res']
+    device = torch.device("cuda:" + gpu)
+    output_seg_path = os.path.join(out_path, 'SegNet')
+    output_reg_path = os.path.join(out_path, 'RegNet')
+    try:
+        os.mkdir(output_path)
+    except:
+        print(f'{output_path} is already existed !!!')
+
+    try:
+        os.mkdir(fold_path)
+    except:
+        print(f'{fold_path} is already existed !!!')
+    
+    try:
+        os.mkdir(out_path)
+    except:
+        print(f'{out_path} is already existed !!!')
+
+    try:
+        os.mkdir(output_seg_path)
+    except:
+        print(f'{output_seg_path} is already existed !!!')
+
+    try:
+        os.mkdir(output_reg_path)
+    except:
+        print(f'{output_reg_path} is already existed !!!')
+
+    seg_net = deep_atlas_train.get_seg_net(
+        spatial_dim, num_label, dropout, activation_type, normalization_type, num_res)
+    reg_net = deep_atlas_train.get_reg_net(
+        spatial_dim, spatial_dim, dropout, activation_type, normalization_type, num_res)
+    
+    img_path = os.path.join(ROOT_DIR, 'deepatlas_preprocessed', task, 'customize_test_data', args.op, 'images')
+    seg_path = os.path.join(ROOT_DIR, 'deepatlas_preprocessed', task, 'customize_test_data', args.op, 'labels')
+    total_img_paths = []
+    total_seg_paths = []
+    for i in sorted(glob.glob(img_path + '/*.nii.gz')):
+        total_img_paths.append(i)
+
+    for j in sorted(glob.glob(seg_path + '/*.nii.gz')):
+        total_seg_paths.append(j)
+    
+    seg_ids = list(map(path_to_id, total_seg_paths))
+    img_ids = map(path_to_id, total_img_paths)
+    data = []
+    for img_index, img_id in enumerate(img_ids):
+        data_item = {'img': total_img_paths[img_index]}
+        if img_id in seg_ids:
+            data_item['seg'] = total_seg_paths[seg_ids.index(img_id)]
+        data.append(data_item)
+
+    seg_training_inference(seg_net, device, seg_model_path, output_seg_path, num_label, json_path=None, data=data)
+    reg_training_inference(reg_net, device, reg_model_path, output_reg_path, num_label, json_path=None, data=data)
+
+
+if __name__ == '__main__':
+    main()

deepatlas/scripts/deep_atlas_test_customized.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+source ~/proj_MONAI/bin/activate
+cd ~/DeepAtlas/deepatlas/preprocess
+python3 registration_test.py -op firstTest -bp ~/Test_data -template template -target_scan target -target_seg target_seg -sl 1 Ear 2 Mid 3 Nasal -ti Task001_SepET
+python3 crop_flip_test.py -rs 128 128 128 -fp -ti Task001_SepET -op firstTest
+cd ~/DeepAtlas/deepatlas/scripts
+python3 deep_atlas_test_customized.py -gpu 0 -ti Task001_SepET -op firstTest -nf 5

deepatlas/scripts/deep_atlas_train.py

@@ -0,0 +1,482 @@
+import seg_train
+from pathlib import Path
+from collections import OrderedDict
+import json
+import sys
+import argparse
+import os.path
+import glob
+import random
+import matplotlib.pyplot as plt
+import torch
+import monai
+import logging
+import shutil
+from collections import namedtuple
+import numpy as np
+import datetime
+
+ROOT_DIR = str(Path(os.getcwd()).parent.parent.absolute())
+sys.path.insert(0, os.path.join(ROOT_DIR, 'deepatlas/preprocess'))
+sys.path.insert(0, os.path.join(ROOT_DIR, 'deepatlas/network'))
+sys.path.insert(0, os.path.join(ROOT_DIR, 'deepatlas/train'))
+sys.path.insert(0, os.path.join(ROOT_DIR, 'deepatlas/utils'))
+from train import (
+    train_network
+)
+from network import (
+    regNet, segNet
+)
+from process_data import (
+    split_data, load_seg_dataset, load_reg_dataset, take_data_pairs, subdivide_list_of_data_pairs
+)
+from utils import (
+    load_json, make_if_dont_exist
+)
+
+def parse_command_line():
+    parser = argparse.ArgumentParser(
+        description='pipeline for deep atlas train')
+    parser.add_argument('--config', metavar='path to the configuration file', type=str,
+                        help='absolute path to the configuration file')
+    parser.add_argument('--continue_training', action='store_true',
+                        help='use this if you want to continue a training')
+    parser.add_argument('--train_only', action='store_true',
+                        help='only training or training plus test')
+    parser.add_argument('--plot_network', action='store_true',
+                        help='whether to plot the network')
+    argv = parser.parse_args()
+    return argv
+
+
+def get_seg_net(spatial_dims, num_label, dropout, activation_type, normalization_type, num_res):
+    seg_net = segNet(
+        spatial_dim=spatial_dims,  # spatial dims
+        in_channel=1,  # input channels
+        out_channel=num_label,  # output channels
+        channel=(8, 16, 16, 32, 32, 64, 64),  # channel sequence
+        stride=(1, 2, 1, 2, 1, 2),  # convolutional strides
+        dropouts=dropout,
+        acts=activation_type,
+        norms=normalization_type,
+        num_res_unit=num_res
+    )
+    return seg_net
+
+
+def get_reg_net(spatial_dims, num_label, dropout, activation_type, normalization_type, num_res):
+    reg_net = regNet(
+        spatial_dim=spatial_dims,  # spatial dims
+        in_channel=2,  # input channels
+        out_channel=num_label,  # output channels
+        channel=(16, 32, 32, 32, 32),  # channel sequence
+        stride=(1, 2, 2, 2),  # convolutional strides
+        dropouts=dropout,
+        acts=activation_type,
+        norms=normalization_type,
+        num_res_unit=num_res
+    )
+    return reg_net
+
+
+def setup_logger(logger_name, log_file, level=logging.INFO):
+    log_setup = logging.getLogger(logger_name)
+    formatter = logging.Formatter('%(asctime)s %(message)s', datefmt="%Y-%m-%d %H:%M:%S")
+    fileHandler = logging.FileHandler(log_file, mode='w')
+    fileHandler.setFormatter(formatter)
+    streamHandler = logging.StreamHandler()
+    streamHandler.setFormatter(formatter)
+    log_setup.setLevel(level)
+    log_setup.addHandler(fileHandler)
+    log_setup.addHandler(streamHandler)
+
+def classify_data(data_info, fold):
+    lab_each_fold = {}
+    lab = []
+    unlab = []
+    total_seg = 0
+    total_seg_each_fold = {}
+    for key, value in data_info.items():
+        if key != f'fold_{fold}':
+            lab_each_fold[key] = []
+            total_seg_each_fold[key] = 0
+            for val in value:
+                if 'seg' not in val.keys():
+                    unlab.append(val)
+                else:
+                    lab_each_fold[key].append(val)
+                    lab.append(val)
+                    total_seg += 1
+                    total_seg_each_fold[key] += 1
+                    
+    return lab_each_fold, lab, unlab, total_seg, total_seg_each_fold
+
+def select_n_seg(lab, fold, num, total_seg_each_fold):
+    seg_items = lab[f'fold_{fold}']
+    num_seg = len(seg_items)
+    rand_num = random.sample(range(num_seg), num)
+    seg_item = np.array(seg_items)[np.array(rand_num)]
+    seg_items.pop(rand_num[0])
+    total_seg_each_fold[f'fold_{fold}'] -= 1
+    lab[f'fold_{fold}'] = seg_items
+    return list(seg_item), lab, total_seg_each_fold
+
+def combine_data(data_info, fold, exp, num_seg):
+    all_fold = np.arange(len(data_info.keys())) + 1
+    num_train_fold = len(data_info.keys()) - 1
+    fake_train_fold = np.delete(all_fold, fold-1)
+    fake_train_fold = np.tile(fake_train_fold, 2)
+    real_train_fold = fake_train_fold[fold-1:fold+num_train_fold-1]
+    train = []
+    test = []
+    for j in data_info[f'fold_{fold}']:
+        if 'seg' in j.keys():
+            test.append(j)
+    
+    lab_each_fold, lab, unlab, total_seg, total_seg_each_fold = classify_data(data_info, fold)
+    if total_seg < num_seg:
+        num_seg = total_seg
+    
+    num_each_fold_seg = divmod(num_seg, num_train_fold)[0]
+    fold_num_seg = np.repeat(num_each_fold_seg, num_train_fold)
+    num_remain_seg = divmod(num_seg, num_train_fold)[1]
+    count = 0
+    while num_remain_seg > 0:
+        fold_num_seg[count] += 1
+        count = (count+1) % num_train_fold
+        num_remain_seg -= 1
+    
+    train = unlab
+    k = 0
+    while num_seg > 0:
+        next_fold = real_train_fold[k]
+        if total_seg_each_fold[f'fold_{next_fold}'] > 0:
+            seg_items, lab_each_fold, total_seg_each_fold = select_n_seg(lab_each_fold, next_fold, 1, total_seg_each_fold)
+            train.extend(seg_items)     
+            num_seg -= 1
+        k = (k+1) % 4
+            
+    num_segs = 0
+    if exp != 1:
+        for key, value in total_seg_each_fold.items():
+            if value != 0:
+                for j in lab_each_fold[key]:
+                    item = {'img': j['img']}
+                    train.append(item)
+                    total_seg_each_fold[key] -= 1
+        for key, value in total_seg_each_fold.items():
+            num_segs += value
+        
+        assert num_segs == 0
+    
+    return train, test
+
+
+def main():
+    args = parse_command_line()
+    config = args.config
+    continue_training = args.continue_training
+    train_only = args.train_only
+    config = load_json(config)
+    config = namedtuple("config", config.keys())(*config.values())
+    folder_name = config.folder_name
+    num_seg_used = config.num_seg_used
+    experiment_set = config.exp_set
+    monai.utils.set_determinism(seed=2938649572)
+    data_path = os.path.join(ROOT_DIR, 'deepatlas_results')
+    base_path = os.path.join(ROOT_DIR, 'deepatlas_preprocessed')
+    task = os.path.join(data_path, config.task_name)
+    exp_path = os.path.join(task, f'set_{experiment_set}')
+    gt_path = os.path.join(exp_path, f'{num_seg_used}gt')
+    folder_path = os.path.join(gt_path, folder_name)
+    result_path = os.path.join(folder_path, 'training_results')
+    if train_only:
+        info_name = 'info_train_only'
+    else:
+        info_name = 'info'
+    info_path = os.path.join(base_path, config.task_name, 'Training_dataset', 'data_info', folder_name, info_name+'.json')
+    info = load_json(info_path)
+    if torch.cuda.is_available():
+        device = torch.device("cuda:" + str(torch.cuda.current_device()))
+    
+    spatial_dim = config.network['spatial_dim']
+    dropout = config.network['dropout']
+    activation_type = config.network['activation_type']
+    normalization_type = config.network['normalization_type']
+    num_res = config.network['num_res']
+    lr_reg = config.network["registration_network_learning_rate"]
+    lr_seg = config.network["segmentation_network_learning_rate"]
+    lam_a = config.network["anatomy_loss_weight"]
+    lam_sp = config.network["supervised_segmentation_loss_weight"]
+    lam_re = config.network["regularization_loss_weight"]
+    max_epoch = config.network["number_epoch"]
+    val_step = config.network["validation_step"]
+    make_if_dont_exist(data_path)
+    make_if_dont_exist(task)
+    make_if_dont_exist(exp_path)
+    make_if_dont_exist(gt_path)
+    make_if_dont_exist(folder_path)
+    make_if_dont_exist(result_path)
+    
+    if not continue_training:
+        start_fold = 1
+    else:
+        folds = sorted(os.listdir(result_path))
+        if len(folds) == 0:
+            continue_training = False
+            start_fold = 1
+        else:
+            last_fold_num = folds[-1].split('_')[-1]
+            start_fold = int(last_fold_num)
+    
+    if train_only:
+        num_fold = 1
+    else:
+        num_fold = config.num_fold
+    
+    for i in range (start_fold, num_fold+1):
+        if not train_only:
+            fold_path = os.path.join(result_path, f'fold_{i}')
+            result_seg_path = os.path.join(fold_path, 'SegNet')
+            result_reg_path = os.path.join(fold_path, 'RegNet')
+        else:
+            fold_path = os.path.join(result_path, f'all')
+            result_seg_path = os.path.join(fold_path, 'SegNet')
+            result_reg_path = os.path.join(fold_path, 'RegNet')
+        
+        make_if_dont_exist(fold_path)
+        make_if_dont_exist(result_reg_path)
+        make_if_dont_exist(result_seg_path)
+        datetime_object = 'training_log_' + datetime.datetime.now().strftime("%Y_%m_%d_%H_%M_%S") + '.log'
+        log_path = os.path.join(fold_path, datetime_object)
+        
+        if not train_only:
+            if not continue_training:
+                setup_logger(f'log_{i}', log_path)
+                logger = logging.getLogger(f'log_{i}')
+                logger.info(f"Start Pipeline with fold_{i}")
+            else:
+                setup_logger(f'log_{i+1}', log_path)
+                logger = logging.getLogger(f'log_{i+1}')
+                logger.info(f"Resume Pipeline with fold_{i}")
+        else:
+            setup_logger(f'all', log_path)
+            logger = logging.getLogger(f'all')
+            logger.info(f"Start Pipeline with all data")
+
+        if not os.path.exists(os.path.join(fold_path, 'dataset.json')):
+            logger.info('prepare dataset into train and test')
+            json_dict = OrderedDict()
+            json_dict['name'] = os.path.basename(task).split('_')[0]
+            json_dict['description'] = '_'.join(os.path.basename(task).split('_')[1:])
+            json_dict['tensorImageSize'] = "4D"
+            json_dict['reference'] = "MODIFY"
+            json_dict['licence'] = "MODIFY"
+            json_dict['release'] = "0.0"
+            json_dict['modality'] = {
+                "0": "CT"
+            }
+            json_dict['labels'] = config.labels
+            json_dict['network'] = config.network
+            json_dict['experiment_set'] = experiment_set
+            if not train_only:
+                json_dict['num_fold'] = f'fold_{i}'
+                train, test = combine_data(info, i, experiment_set, num_seg_used)
+            else:
+                json_dict['num_fold'] = 'all'
+                train = info
+                test = []
+                num_seg_used = len(list(filter(lambda d: 'seg' in d.keys(), train)))
+            #num_seg = 15
+            #train, test, num_train, num_test = split_data(img_path, seg_path, num_seg) 
+            #print(type(train))
+            
+            num_seg = num_seg_used
+            num_train = len(train)
+            num_test = len(test)
+            #print(train.keys())
+            json_dict['total_numScanTraining'] = num_train
+            json_dict['total_numLabelTraining'] = num_seg
+            json_dict['total_numTest'] = num_test
+            json_dict['total_train'] = train
+            json_dict['total_test'] = test
+            # prepare segmentation dataset
+            logger.info('prepare segmentation dataset')
+            data_seg_available = list(filter(lambda d: 'seg' in d.keys(), train))
+            data_seg_unavailable = list(filter(lambda d: 'seg' not in d.keys(), train))
+            data_seg_available_train, data_seg_available_valid = \
+                monai.data.utils.partition_dataset(data_seg_available, ratios=(8, 2))
+            json_dict['seg_numTrain'] = len(data_seg_available_train)
+            json_dict['seg_train'] = data_seg_available_train
+            json_dict['seg_numValid'] = len(data_seg_available_valid)
+            json_dict['seg_valid'] = data_seg_available_valid
+            dataset_seg_available_train, dataset_seg_available_valid = load_seg_dataset(
+                data_seg_available_train, data_seg_available_valid)
+            data_item = random.choice(dataset_seg_available_train)
+            img_shape = data_item['seg'].unsqueeze(0).shape[2:]
+            num_label = len(torch.unique(data_item['seg']))
+            logger.info('prepare segmentation network')
+            seg_net = get_seg_net(spatial_dim, num_label, dropout,
+                                activation_type, normalization_type, num_res)
+            # prepare registration dataset
+            logger.info('prepare registration dataset')
+            data_without_seg_valid = data_seg_unavailable + data_seg_available_train
+            data_valid, data_train = monai.data.utils.partition_dataset(
+                data_without_seg_valid,  # Note the order
+                ratios=(2, 8),  # Note the order
+                shuffle=False
+            )
+            data_paires_without_seg_valid = take_data_pairs(data_without_seg_valid)
+            data_pairs_valid = take_data_pairs(data_valid)
+            data_pairs_train = take_data_pairs(data_train)
+            data_pairs_valid_subdivided = subdivide_list_of_data_pairs(
+                data_pairs_valid)
+            data_pairs_train_subdivided = subdivide_list_of_data_pairs(
+                data_pairs_train)
+            num_train_reg_net = len(data_pairs_train)
+            num_valid_reg_net = len(data_pairs_valid)
+            num_train_both = len(data_pairs_train_subdivided['01']) +\
+                len(data_pairs_train_subdivided['10']) +\
+                len(data_pairs_train_subdivided['11'])
+            json_dict['reg_seg_numTrain'] = num_train_reg_net
+            json_dict['reg_seg_numTrain_00'] = len(data_pairs_train_subdivided['00'])
+            json_dict['reg_seg_train_00'] = data_pairs_train_subdivided['00']
+            json_dict['reg_seg_numTrain_01'] = len(data_pairs_train_subdivided['01'])
+            json_dict['reg_seg_train_01'] = data_pairs_train_subdivided['01']
+            json_dict['reg_seg_numTrain_10'] = len(data_pairs_train_subdivided['10'])
+            json_dict['reg_seg_train_10'] = data_pairs_train_subdivided['10']
+            json_dict['reg_seg_numTrain_11'] = len(data_pairs_train_subdivided['11'])
+            json_dict['reg_seg_train_11'] = data_pairs_train_subdivided['11']
+            json_dict['reg_numValid'] = num_valid_reg_net
+            json_dict['reg_numValid_00'] = len(data_pairs_valid_subdivided['00'])
+            json_dict['reg_valid_00'] = data_pairs_valid_subdivided['00']
+            json_dict['reg_numValid_01'] = len(data_pairs_valid_subdivided['01'])
+            json_dict['reg_valid_01'] = data_pairs_valid_subdivided['01']
+            json_dict['reg_numValid_10'] = len(data_pairs_valid_subdivided['10'])
+            json_dict['reg_valid_10'] = data_pairs_valid_subdivided['10']
+            json_dict['reg_numValid_11'] = len(data_pairs_valid_subdivided['11'])
+            json_dict['reg_valid_11'] = data_pairs_valid_subdivided['11']
+            print(f"""We have {num_train_both} pairs to train reg_net and seg_net together, and an additional {num_train_reg_net - num_train_both} to train reg_net alone.""")
+            print(f"We have {num_valid_reg_net} pairs for reg_net validation.")
+
+            dataset_pairs_train_subdivided, dataset_pairs_valid_subdivided = load_reg_dataset(
+                data_pairs_train_subdivided, data_pairs_valid_subdivided)
+            logger.info('prepare registration network')
+            reg_net = get_reg_net(spatial_dim, spatial_dim, dropout,
+                                activation_type, normalization_type, num_res)
+            logger.info('generate dataset json file')
+            with open(os.path.join(fold_path, 'dataset.json'), 'w') as f:
+                json.dump(json_dict, f, indent=4, sort_keys=False)
+
+        else:
+            dataset_json = load_json(os.path.join(fold_path, 'dataset.json'))
+            
+            data_seg_available_train = dataset_json['seg_train']
+            data_seg_available_valid = dataset_json['seg_valid']
+            dataset_seg_available_train, dataset_seg_available_valid = load_seg_dataset(data_seg_available_train, data_seg_available_valid)
+            data_item = random.choice(dataset_seg_available_train)
+            img_shape = data_item['seg'].unsqueeze(0).shape[2:]
+            num_label = len(torch.unique(data_item['seg']))
+            logger.info('prepare segmentation network')
+            seg_net = get_seg_net(spatial_dim, num_label, dropout, activation_type, normalization_type, num_res)
+            
+            data_pairs_train_subdivided = {
+                '00': dataset_json['reg_seg_train_00'],
+                '01': dataset_json['reg_seg_train_01'],
+                '10': dataset_json['reg_seg_train_10'],
+                '11': dataset_json['reg_seg_train_11']
+            }
+            data_pairs_valid_subdivided = {
+                '00': dataset_json['reg_valid_00'],
+                '01': dataset_json['reg_valid_01'],
+                '10': dataset_json['reg_valid_10'],
+                '11': dataset_json['reg_valid_11']
+            }
+            num_train_reg_net = dataset_json['reg_seg_numTrain']
+            num_valid_reg_net = dataset_json['reg_numValid']
+            num_train_both = len(data_pairs_train_subdivided['01']) +\
+                len(data_pairs_train_subdivided['10']) +\
+                len(data_pairs_train_subdivided['11'])
+            print(f"""We have {num_train_both} pairs to train reg_net and seg_net together,
+            and an additional {num_train_reg_net - num_train_both} to train reg_net alone.""")
+            print(f"We have {num_valid_reg_net} pairs for reg_net validation.")
+
+            dataset_pairs_train_subdivided, dataset_pairs_valid_subdivided = load_reg_dataset(
+                data_pairs_train_subdivided, data_pairs_valid_subdivided)
+            logger.info('prepare registration network')
+            reg_net = get_reg_net(spatial_dim, spatial_dim, dropout,
+                                activation_type, normalization_type, num_res)
+
+        
+        dataloader_train_seg = monai.data.DataLoader(
+            dataset_seg_available_train,
+            batch_size=2,
+            num_workers=4,
+            shuffle=True
+        )
+        dataloader_valid_seg = monai.data.DataLoader(
+            dataset_seg_available_valid,
+            batch_size=4,
+            num_workers=4,
+            shuffle=False
+        )
+        dataloader_train_reg = {
+            seg_availability: monai.data.DataLoader(
+                dataset,
+                batch_size=1,
+                num_workers=4,
+                shuffle=True
+            )
+            # empty dataloaders are not a thing-- put an empty list if needed
+            if len(dataset) > 0 else []
+            for seg_availability, dataset in dataset_pairs_train_subdivided.items()
+        }
+        dataloader_valid_reg = {
+            seg_availability: monai.data.DataLoader(
+                dataset,
+                batch_size=2,
+                num_workers=4,
+                shuffle=True  # Shuffle validation data because we will only take a sample for validation each time
+            )
+            # empty dataloaders are not a thing-- put an empty list if needed
+            if len(dataset) > 0 else []
+            for seg_availability, dataset in dataset_pairs_valid_subdivided.items()
+        }
+        train_network(dataloader_train_reg,
+                      dataloader_valid_reg,
+                      dataloader_train_seg,
+                      dataloader_valid_seg,
+                      device,
+                      seg_net,
+                      reg_net,
+                      num_label,
+                      lr_reg,
+                      lr_seg,
+                      lam_a,
+                      lam_sp,
+                      lam_re,
+                      max_epoch,
+                      val_step,
+                      result_seg_path,
+                      result_reg_path,
+                      logger,
+                      img_shape,
+                      plot_network=args.plot_network,
+                      continue_training=continue_training
+                      )
+    '''
+    seg_train.train_seg(
+        dataloader_train_seg,
+        dataloader_valid_seg,
+        device,
+        seg_net,
+        lr_seg,
+        max_epoch,
+        val_step,
+        result_seg_path
+    )
+    '''
+
+if __name__ == '__main__':
+    torch.cuda.empty_cache()
+    main()

deepatlas/scripts/seg_train.py

@@ -0,0 +1,83 @@
+#import generators
+import monai
+import torch
+import numpy as np
+import matplotlib.pyplot as plt
+import os
+import sys
+
+from pathlib import Path
+
+ROOT_DIR = str(Path(os.getcwd()).parent.parent.absolute())
+sys.path.insert(0, os.path.join(ROOT_DIR, 'deepatlas/utils'))
+sys.path.insert(0, os.path.join(ROOT_DIR, 'deepatlas/loss_function'))
+from utils import (
+    preview_image, preview_3D_vector_field, preview_3D_deformation,
+    jacobian_determinant
+)
+from losses import (
+    warp_func, warp_nearest_func, lncc_loss_func, dice_loss_func, reg_losses, dice_loss_func2
+)
+
+def train_seg(dataloader_train_seg,
+              dataloader_valid_seg,
+              device,
+              seg_net,
+              lr_seg,
+              max_epoch,
+              val_step,
+              result_seg_path
+              ):
+# (if already done then you may skip to and uncomment the checkpoint loading cell below)
+
+    seg_net.to(device)
+
+    learning_rate = 1e-3
+    optimizer = torch.optim.Adam(seg_net.parameters(), learning_rate)
+
+    max_epochs = 300
+    training_losses = []
+    validation_losses = []
+    val_interval = 5
+    dice_loss = dice_loss_func2()
+    for epoch_number in range(max_epochs):
+
+        print(f"Epoch {epoch_number+1}/{max_epochs}:")
+
+        seg_net.train()
+        losses = []
+        for batch in dataloader_train_seg:
+            imgs = batch['img'].to(device)
+            true_segs = batch['seg'].to(device)
+
+            optimizer.zero_grad()
+            predicted_segs = seg_net(imgs)
+            loss = dice_loss(predicted_segs, true_segs)
+            loss.backward()
+            optimizer.step()
+
+            losses.append(loss.item())
+
+        training_loss = np.mean(losses)
+        print(f"\ttraining loss: {training_loss}")
+        training_losses.append([epoch_number, training_loss])
+
+        if epoch_number % val_interval == 0:
+            seg_net.eval()
+            losses = []
+            with torch.no_grad():
+                for batch in dataloader_valid_seg:
+                    imgs = batch['img'].to(device)
+                    true_segs = batch['seg'].to(device)
+                    predicted_segs = seg_net(imgs)
+                    loss = dice_loss(predicted_segs, true_segs)
+                    losses.append(loss.item())
+
+            validation_loss = np.mean(losses)
+            print(f"\tvalidation loss: {validation_loss}")
+            validation_losses.append([epoch_number, validation_loss])
+    
+    # Free up some memory
+    del loss, predicted_segs, true_segs, imgs
+    torch.cuda.empty_cache()
+    torch.save(seg_net.state_dict(), os.path.join(result_seg_path, 'seg_net_best.pth'))

deepatlas/test/test.py

@@ -0,0 +1,536 @@
+import monai
+import torch
+import itk
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib as mpl
+import os
+import nibabel as nib
+import sys
+import json
+from pathlib import Path
+mpl.rc('figure', max_open_warning = 0)
+ROOT_DIR = str(Path(os.getcwd()).parent.parent.absolute())
+sys.path.insert(0, os.path.join(ROOT_DIR, 'deepatlas/utils'))
+sys.path.insert(0, os.path.join(ROOT_DIR, 'deepatlas/loss_function'))
+sys.path.insert(0, os.path.join(ROOT_DIR, 'deepatlas/preprocess'))
+
+from process_data import (
+    take_data_pairs, subdivide_list_of_data_pairs
+)
+from utils import (
+    plot_2D_vector_field, jacobian_determinant, plot_2D_deformation, load_json
+)
+from losses import (
+    warp_func, warp_nearest_func, lncc_loss_func, dice_loss_func2, dice_loss_func
+)
+
+def load_seg_dataset(data_list):
+    transform_seg_available = monai.transforms.Compose(
+        transforms=[
+            monai.transforms.LoadImageD(keys=['img', 'seg'], image_only=True, allow_missing_keys=True),
+            #monai.transforms.TransposeD(
+                #keys=['img', 'seg'], indices=(2, 1, 0)),
+            monai.transforms.AddChannelD(keys=['img', 'seg'], allow_missing_keys=True),
+            monai.transforms.SpacingD(keys=['img', 'seg'], pixdim=(1., 1., 1.), mode=('trilinear', 'nearest'), allow_missing_keys=True),
+            #monai.transforms.OrientationD(keys=['img', 'seg'], axcodes='RAS'),
+            monai.transforms.ToTensorD(keys=['img', 'seg'], allow_missing_keys=True)
+        ]
+    )
+    itk.ProcessObject.SetGlobalWarningDisplay(False)
+    dataset_seg_available_train = monai.data.CacheDataset(
+        data=data_list,
+        transform=transform_seg_available,
+        cache_num=16,
+        hash_as_key=True
+    )
+    return dataset_seg_available_train
+
+
+def load_reg_dataset(data_list):
+    transform_pair = monai.transforms.Compose(
+        transforms=[
+            monai.transforms.LoadImageD(
+                keys=['img1', 'seg1', 'img2', 'seg2'], image_only=True, allow_missing_keys=True),
+            #monai.transforms.TransposeD(keys=['img1', 'seg1', 'img2', 'seg2'], indices=(2, 1, 0), allow_missing_keys=True),
+            # if resize is not None else monai.transforms.Identity()
+            monai.transforms.ToTensorD(
+                keys=['img1', 'seg1', 'img2', 'seg2'], allow_missing_keys=True),
+            monai.transforms.AddChannelD(
+                keys=['img1', 'seg1', 'img2', 'seg2'], allow_missing_keys=True),
+            monai.transforms.SpacingD(keys=['img1', 'seg1', 'img2', 'seg2'], pixdim=(1., 1., 1.), mode=(
+                'trilinear', 'nearest', 'trilinear', 'nearest'), allow_missing_keys=True),
+            #monai.transforms.OrientationD(
+                #keys=['img1', 'seg1', 'img2', 'seg2'], axcodes='RAS', allow_missing_keys=True),
+            monai.transforms.ConcatItemsD(
+                keys=['img1', 'img2'], name='img12', dim=0),
+            monai.transforms.DeleteItemsD(keys=['img1', 'img2']),
+        ]
+    )
+    dataset_pairs_train_subdivided = {
+        seg_availability: monai.data.CacheDataset(
+            data=data,
+            transform=transform_pair,
+            cache_num=32,
+            hash_as_key=True
+        )
+        for seg_availability, data in data_list.items()
+    }
+
+    return dataset_pairs_train_subdivided
+
+def get_nii_info(data, reg=False):
+    headers = []
+    affines = []
+    ids = []
+    if not reg:
+        for i in range(len(data)):
+            item = data[i]
+            if 'seg' in item.keys():
+                id = os.path.basename(item['seg']).split('.')[0]
+                seg = nib.load(item['seg'])
+                num_labels = len(np.unique(seg.get_fdata()))
+                headers.append(seg.header)
+                affines.append(seg.affine)
+                ids.append(id)
+            else:
+                id = os.path.basename(item['img']).split('.')[0]
+                img = nib.load(item['img'])
+                headers.append(img.header)
+                affines.append(img.affine)
+                ids.append(id)
+    else:
+        headers = {'00': [], '01': [], '10': [], '11': []}
+        affines = {'00': [], '01': [], '10': [], '11': []}
+        ids = {'00': [], '01': [], '10': [], '11': []}
+        for i in range(len(data)):
+            header = {}
+            affine = {}
+            id = {}
+            item = data[i]
+            keys = item.keys()
+            if 'seg1' in keys and 'seg2' in keys:
+                for key in keys:
+                    idd = os.path.basename(item[key]).split('.')[0]
+                    ele = nib.load(item[key])
+                    header[key] = ele.header
+                    affine[key] = ele.affine
+                    id[key] = idd
+
+                headers['11'].append(header)
+                affines['11'].append(affine)
+                ids['11'].append(id)
+            elif 'seg1' in keys:
+                for key in keys:
+                    idd = os.path.basename(item[key]).split('.')[0]
+                    ele = nib.load(item[key])
+                    header[key] = ele.header
+                    affine[key] = ele.affine
+                    id[key] = idd
+
+                headers['10'].append(header)
+                affines['10'].append(affine)
+                ids['10'].append(id)
+            elif 'seg2' in keys:
+                for key in keys:
+                    idd = os.path.basename(item[key]).split('.')[0]
+                    ele = nib.load(item[key])
+                    header[key] = ele.header
+                    affine[key] = ele.affine
+                    id[key] = idd
+
+                headers['01'].append(header)
+                affines['01'].append(affine)
+                ids['01'].append(id)
+            else:
+                for key in keys:
+                    idd = os.path.basename(item[key]).split('.')[0]
+                    ele = nib.load(item[key])
+                    header[key] = ele.header
+                    affine[key] = ele.affine
+                    id[key] = idd
+                
+                headers['00'].append(header)
+                affines['00'].append(affine)
+                ids['00'].append(id)
+
+    return headers, affines, ids
+
+
+def seg_training_inference(seg_net, device, model_path, output_path, num_label, json_path=None, data=None):
+    if json_path is not None:
+        assert data is None
+        json_file = load_json(json_path)
+        raw_data = json_file['total_test']
+    else:
+        assert data is not None
+        raw_data = data
+    headers, affines, ids = get_nii_info(raw_data, reg=False)
+    seg_net.to(device)
+    seg_net.load_state_dict(torch.load(model_path, map_location=device))
+    seg_net.eval()
+    dice_metric = monai.metrics.DiceMetric(include_background=False, reduction='none')
+    data_seg = load_seg_dataset(raw_data)
+    k = 0
+    eval_losses = []
+    eval_los = []
+    for i in data_seg:
+        has_seg = False
+        header1 = headers[k]
+        affine1 = affines[k]
+        id = ids[k]
+        data_item = i
+        test_input = data_item['img']
+        if 'seg' in data_item.keys():
+            test_gt = data_item['seg']
+            has_seg = True
+        with torch.no_grad():
+            test_seg_predicted = seg_net(test_input.unsqueeze(0).to(device)).cpu()
+
+        prediction = torch.argmax(torch.softmax(
+            test_seg_predicted, dim=1), dim=1, keepdim=True)[0, 0]
+        prediction1 = torch.argmax(torch.softmax(
+            test_seg_predicted, dim=1), dim=1, keepdim=True)
+        
+        onehot_pred = monai.networks.one_hot(prediction1, num_label)
+        if has_seg:
+            onehot_gt = monai.networks.one_hot(test_gt.unsqueeze(0), num_label)
+            dsc = dice_metric(onehot_pred, onehot_gt).numpy()
+            eval_los.append(dsc)
+            eval_loss = f"Scan ID: {id}, dice score: {dsc}"
+            eval_losses.append(eval_loss)
+        
+        pred_np = prediction.detach().cpu().numpy()
+        print(f'{id}: {np.unique(pred_np)}')
+
+        pred_np = pred_np.astype('int16')
+        nii = nib.Nifti1Image(pred_np, affine=affine1, header=header1)
+        nii.header.get_xyzt_units()
+        nib.save(nii, (os.path.join(output_path, id + '.nii.gz')))
+        k += 1
+
+        del test_seg_predicted
+
+    average = np.mean(eval_los, 0)
+   
+    with open(os.path.join(output_path, 'seg_dsc.txt'), 'w') as f:
+        for s in eval_losses:
+            f.write(s + '\n')
+        f.write('\n\nAverage Dice Score: ' + str(average))
+    torch.cuda.empty_cache()
+
+
+def reg_training_inference(reg_net, device, model_path, output_path, num_label, json_path=None, data=None):
+    if json_path is not None:
+        assert data is None
+        json_file = load_json(json_path)
+        raw_data = json_file['total_test']
+    else:
+        assert data is not None
+        raw_data = data
+    # Run this cell to try out reg net on a random validation pair
+    reg_net.to(device)
+    reg_net.load_state_dict(torch.load(model_path, map_location=device))
+    reg_net.eval()
+    data_list = take_data_pairs(raw_data)
+    headers, affines, ids = get_nii_info(data_list, reg=True)
+    subvided_data_list = subdivide_list_of_data_pairs(data_list)
+    subvided_dataset = load_reg_dataset(subvided_data_list)
+    warp = warp_func()
+    warp_nearest = warp_nearest_func()
+    lncc_loss = lncc_loss_func()
+    k = 0
+    if len(subvided_data_list['01']) != 0:
+        dataset01 = subvided_dataset['01']
+        #test_len = int(len(dataset01) / 4)
+        for j in range(len(dataset01)):
+            data_item = dataset01[j]
+            img12 = data_item['img12'].unsqueeze(0).to(device)
+            moving_raw_seg = data_item['seg2'].unsqueeze(0).to(device)
+            moving_seg = monai.networks.one_hot(moving_raw_seg, num_label)
+            id = ids['01'][k]
+            affine = affines['01'][k]
+            header = headers['01'][k]
+            with torch.no_grad():
+                reg_net_example_output = reg_net(img12)
+
+            example_warped_image = warp(
+                img12[:, [1], :, :, :],  # moving image
+                reg_net_example_output  # warping
+            )
+            example_warped_seg = warp_nearest(
+                moving_seg,
+                reg_net_example_output
+            )
+            moving_img = img12[0, 1, :, :, :]
+            target_img = img12[0, 0, :, :, :]
+            id_target_img = id['img1']
+            id_moving_img = id['img2']
+            head_target_img = header['img1']
+            head_target_seg = header['img1']
+            aff_target_img = affine['img1']
+            aff_target_seg = affine['img1']
+            prediction = torch.argmax(torch.softmax(
+                example_warped_seg, dim=1), dim=1, keepdim=True)[0, 0]
+            prediction1 = torch.argmax(torch.softmax(
+                example_warped_seg, dim=1), dim=1, keepdim=True)
+            warped_img_np = example_warped_image[0, 0].detach().cpu().numpy()
+            #warped_img_np = np.transpose(warped_img_np, (2, 1, 0))
+            warped_seg_np = prediction.detach().cpu().numpy()
+            #warped_seg_np = np.transpose(warped_seg_np, (2, 1, 0))
+            nii_seg = nib.Nifti1Image(
+                warped_seg_np, affine=aff_target_seg, header=head_target_seg)
+            nii = nib.Nifti1Image(
+                warped_img_np, affine=aff_target_img, header=head_target_img)
+            nii.to_filename(os.path.join(
+                output_path, id_moving_img + '_to_' + id_target_img + '.nii.gz'))
+            nii_seg.to_filename(os.path.join(
+                output_path, id_moving_img + '_to_' + id_target_img + '_seg.nii.gz'))
+            grid_spacing = 5
+            det = jacobian_determinant(reg_net_example_output.cpu().detach()[0])
+            visualize(target_img.cpu(),
+                        id_target_img,
+                        moving_img.cpu(),
+                        id_moving_img,
+                        example_warped_image[0, 0].cpu(),
+                        reg_net_example_output.cpu().detach()[0],
+                        det,
+                        grid_spacing,
+                        normalize_by='slice',
+                        cmap='gray',
+                        threshold=None,
+                        linewidth=1,
+                        color='darkblue',
+                        downsampling=None,
+                        threshold_det=0,
+                        output=output_path
+                        )
+            k += 1
+            del reg_net_example_output, img12, example_warped_image, example_warped_seg
+    
+    if len(subvided_data_list['11']) != 0:
+        dataset11 = subvided_dataset['11']
+        k = 0
+        eval_losses_img = []
+        eval_losses_seg = []
+        eval_los = []
+        #test_len = int(len(dataset11) / 4)
+        for i in range(len(dataset11)):
+            data_item = dataset11[i]
+            img12 = data_item['img12'].unsqueeze(0).to(device)
+            gt_raw_seg = data_item['seg1'].unsqueeze(0).to(device)
+            moving_raw_seg = data_item['seg2'].unsqueeze(0).to(device)
+            moving_seg = monai.networks.one_hot(moving_raw_seg, num_label)
+            gt_seg = monai.networks.one_hot(gt_raw_seg, num_label)
+            id = ids['11'][k]
+            affine = affines['11'][k]
+            header = headers['11'][k]
+            with torch.no_grad():
+                reg_net_example_output = reg_net(img12)
+
+            example_warped_image = warp(
+                img12[:, [1], :, :, :],  # moving image
+                reg_net_example_output  # warping
+            )
+            example_warped_seg = warp_nearest(
+                moving_seg,
+                reg_net_example_output
+            )
+            moving_img = img12[0, 1, :, :, :]
+            target_img = img12[0, 0, :, :, :]
+            id_target_img = id['img1']
+            id_moving_img = id['img2']
+            head_target_img = header['img1']
+            head_target_seg = header['seg1']
+            aff_target_img = affine['img1']
+            aff_target_seg = affine['seg1']
+            dice_metric = monai.metrics.DiceMetric(include_background=False, reduction='none')
+            prediction = torch.argmax(torch.softmax(
+                example_warped_seg, dim=1), dim=1, keepdim=True)[0, 0]
+            prediction1 = torch.argmax(torch.softmax(
+                example_warped_seg, dim=1), dim=1, keepdim=True)
+            onehot_pred = monai.networks.one_hot(prediction1, num_label)
+            dsc = dice_metric(onehot_pred, gt_seg).detach().cpu().numpy()
+            eval_los.append(dsc)
+            eval_loss_seg = f"Scan {id_moving_img} to {id_target_img}, dice score: {dsc}"
+            eval_losses_seg.append(eval_loss_seg)
+            warped_img_np = example_warped_image[0, 0].detach().cpu().numpy()
+            #warped_img_np = np.transpose(warped_img_np, (2, 1, 0))
+            warped_seg_np = prediction.detach().cpu().numpy()
+            #warped_seg_np = np.transpose(warped_seg_np, (2, 1, 0))
+            nii_seg = nib.Nifti1Image(
+                warped_seg_np, affine=aff_target_seg, header=head_target_seg)
+            nii = nib.Nifti1Image(
+                warped_img_np, affine=aff_target_img, header=head_target_img)
+            nii.to_filename(os.path.join(
+                output_path, id_moving_img + '_to_' + id_target_img + '.nii.gz'))
+            nii_seg.to_filename(os.path.join(
+                output_path, id_moving_img + '_to_' + id_target_img + '_seg.nii.gz'))
+            grid_spacing = 5
+            det = jacobian_determinant(reg_net_example_output.cpu().detach()[0])
+            visualize(target_img.cpu(),
+                    id_target_img,
+                    moving_img.cpu(),
+                    id_moving_img,
+                    example_warped_image[0, 0].cpu(),
+                    reg_net_example_output.cpu().detach()[0],
+                    det,
+                    grid_spacing,
+                    normalize_by='slice',
+                    cmap='gray',
+                    threshold=None,
+                    linewidth=1,
+                    color='darkblue',
+                    downsampling=None,
+                    threshold_det=0,
+                    output=output_path
+                    )
+            loss = lncc_loss(example_warped_image, img12[:, [0], :, :, :]).item()
+            eval_loss_img = f"Warped {id_moving_img} to {id_target_img}, similarity loss: {loss}, number of folds: {(det<=0).sum()}"
+            eval_losses_img.append(eval_loss_img)
+            k += 1
+            del reg_net_example_output, img12, example_warped_image, example_warped_seg
+
+        with open(os.path.join(output_path, "reg_img_losses.txt"), 'w') as f:
+            for s in eval_losses_img:
+                f.write(s + '\n')
+
+        average = np.mean(eval_los, 0)
+        with open(os.path.join(output_path, "reg_seg_dsc.txt"), 'w') as f:
+            for s in eval_losses_seg:
+                f.write(s + '\n')
+            f.write('\n\nAverage Dice Score: ' + str(average))
+    torch.cuda.empty_cache()
+
+def visualize(target,
+              target_id,
+              moving,
+              moving_id,
+              warped,
+              vector_field,
+              det,
+              grid_spacing,
+              normalize_by='volume',
+              cmap=None,
+              threshold=None,
+              linewidth=1,
+              color='red',
+              downsampling=None,
+              threshold_det=None,
+              output=None
+              ):
+    if normalize_by == "slice":
+        vmin = None
+        vmax_moving = None
+        vmax_target = None
+        vmax_warped = None
+        vmax_det = None
+    elif normalize_by == "volume":
+        vmin = 0
+        vmax_moving = moving.max().item()
+        vmax_target = target.max().item()
+        vmax_warped = warped.max().item()
+        vmax_det = det.max().item()
+    else:
+        raise(ValueError(
+            f"Invalid value '{normalize_by}' given for normalize_by"))
+
+    # half-way slices
+    plt.figure(figsize=(24, 24))
+    x, y, z = np.array(moving.shape)//2
+    moving_imgs = (moving[x, :, :], moving[:, y, :], moving[:, :, z])
+    target_imgs = (target[x, :, :], target[:, y, :], target[:, :, z])
+    warped_imgs = (warped[x, :, :], warped[:, y, :], warped[:, :, z])
+    det_imgs = (det[x, :, :], det[:, y, :], det[:, :, z])
+    for i in range(3):
+        im = moving_imgs[i]
+        plt.subplot(6, 3, i+1)
+        plt.axis('off')
+        plt.title(f'moving image: {moving_id}')
+        plt.imshow(im, origin='lower', vmin=vmin, vmax=vmax_moving, cmap=cmap)
+        # threshold will be useful when displaying jacobian determinant images;
+        # we will want to clearly see where the jacobian determinant is negative
+        if threshold is not None:
+            red = np.zeros(im.shape+(4,))  # RGBA array
+            red[im <= threshold] = [1, 0, 0, 1]
+            plt.imshow(red, origin='lower')
+
+    for k in range(3):
+        j = k + 4
+        im = target_imgs[k]
+        plt.subplot(6, 3, j)
+        plt.axis('off')
+        plt.title(f'target image: {target_id}')
+        plt.imshow(im, origin='lower', vmin=vmin, vmax=vmax_target, cmap=cmap)
+        # threshold will be useful when displaying jacobian determinant images;
+        # we will want to clearly see where the jacobian determinant is negative
+        if threshold is not None:
+            red = np.zeros(im.shape+(4,))  # RGBA array
+            red[im <= threshold] = [1, 0, 0, 1]
+            plt.imshow(red, origin='lower')
+
+    for m in range(3):
+        j = 7 + m
+        im = warped_imgs[m]
+        plt.subplot(6, 3, j)
+        plt.axis('off')
+        plt.title(f'warped image: {moving_id} to {target_id}')
+        plt.imshow(im, origin='lower', vmin=vmin, vmax=vmax_warped, cmap=cmap)
+        # threshold will be useful when displaying jacobian determinant images;
+        # we will want to clearly see where the jacobian determinant is negative
+        if threshold is not None:
+            red = np.zeros(im.shape+(4,))  # RGBA array
+            red[im <= threshold] = [1, 0, 0, 1]
+            plt.imshow(red, origin='lower')
+
+    if downsampling is None:
+        # guess a reasonable downsampling value to make a nice plot
+        downsampling = max(1, int(max(vector_field.shape[1:])) >> 5)
+
+    x, y, z = np.array(vector_field.shape[1:])//2  # half-way slices
+    plt.subplot(6, 3, 10)
+    plt.axis('off')
+    plt.title(f'deformation vector field: {moving_id} to {target_id}')
+    plot_2D_vector_field(vector_field[[1, 2], x, :, :], downsampling)
+    plt.subplot(6, 3, 11)
+    plt.axis('off')
+    plt.title(f'deformation vector field: {moving_id} to {target_id}')
+    plot_2D_vector_field(vector_field[[0, 2], :, y, :], downsampling)
+    plt.subplot(6, 3, 12)
+    plt.axis('off')
+    plt.title(f'deformation vector field: {moving_id} to {target_id}')
+    plot_2D_vector_field(vector_field[[0, 1], :, :, z], downsampling)
+
+    x, y, z = np.array(vector_field.shape[1:])//2  # half-way slices
+    plt.subplot(6, 3, 13)
+    plt.axis('off')
+    plt.title(f'deformation vector field on grid: {moving_id} to {target_id}')
+    plot_2D_deformation(
+        vector_field[[1, 2], x, :, :], grid_spacing, linewidth=linewidth, color=color)
+    plt.subplot(6, 3, 14)
+    plt.axis('off')
+    plt.title(f'deformation vector field on grid: {moving_id} to {target_id}')
+    plot_2D_deformation(
+        vector_field[[0, 2], :, y, :], grid_spacing, linewidth=linewidth, color=color)
+    plt.subplot(6, 3, 15)
+    plt.axis('off')
+    plt.title(f'deformation vector field on grid: {moving_id} to {target_id}')
+    plot_2D_deformation(
+        vector_field[[0, 1], :, :, z], grid_spacing, linewidth=linewidth, color=color)
+
+    for n in range(3):
+        o = n + 16
+        im = det_imgs[n]
+        plt.subplot(6, 3, o)
+        plt.axis('off')
+        plt.title(f'jacobian determinant: {moving_id} to {target_id}')
+        plt.imshow(im, origin='lower', vmin=vmin, vmax=vmax_det, cmap=None)
+        # threshold will be useful when displaying jacobian determinant images;
+        # we will want to clearly see where the jacobian determinant is negative
+        if threshold_det is not None:
+            red = np.zeros(im.shape+(4,))  # RGBA array
+            red[im <= threshold_det] = [1, 0, 0, 1]
+            plt.imshow(red, origin='lower')
+
+    plt.savefig(os.path.join(
+        output, f'reg_net_infer_{moving_id}_to_{target_id}.png'))

deepatlas/train/generators.py

@@ -0,0 +1,45 @@
+import monai
+import torch
+import itk
+import numpy as np
+import matplotlib.pyplot as plt
+import random
+import glob
+import os.path
+import argparse
+import sys
+
+
+def create_batch_generator(dataloader_subdivided, weights=None):
+    """
+    Create a batch generator that samples data pairs with various segmentation availabilities.
+
+    Arguments:
+        dataloader_subdivided : a mapping from the labels in seg_availabilities to dataloaders
+        weights : a list of probabilities, one for each label in seg_availabilities;
+                  if not provided then we weight by the number of data items of each type,
+                  effectively sampling uniformly over the union of the datasets
+
+    Returns: batch_generator
+        A function that accepts a number of batches to sample and that returns a generator.
+        The generator will weighted-randomly pick one of the seg_availabilities and
+        yield the next batch from the corresponding dataloader.
+    """
+    seg_availabilities = ['00', '01', '10', '11']
+    if weights is None:
+        weights = np.array([len(dataloader_subdivided[s]) for s in seg_availabilities])
+    weights = np.array(weights)
+    weights = weights / weights.sum()
+    dataloader_subdivided_as_iterators = {s: iter(d) for s, d in dataloader_subdivided.items()}
+
+    def batch_generator(num_batches_to_sample):
+        for _ in range(num_batches_to_sample):
+            seg_availability = np.random.choice(seg_availabilities, p=weights)
+            try:
+                yield next(dataloader_subdivided_as_iterators[seg_availability])
+            except StopIteration:  # If dataloader runs out, restart it
+                dataloader_subdivided_as_iterators[seg_availability] =\
+                    iter(dataloader_subdivided[seg_availability])
+                yield next(dataloader_subdivided_as_iterators[seg_availability])
+    return batch_generator
+ 

deepatlas/train/train.py

@@ -0,0 +1,444 @@
+import generators
+import monai
+import torch
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib
+import os
+import sys
+from pathlib import Path
+import pickle
+
+ROOT_DIR = str(Path(os.getcwd()).parent.parent.absolute())
+sys.path.insert(0, os.path.join(ROOT_DIR, 'deepatlas/utils'))
+sys.path.insert(0, os.path.join(ROOT_DIR, 'deepatlas/loss_function'))
+from utils import (
+    preview_image, preview_3D_vector_field, preview_3D_deformation,
+    jacobian_determinant, plot_progress, make_if_dont_exist, save_seg_checkpoint, save_reg_checkpoint, load_latest_checkpoint,
+    load_best_checkpoint, load_valid_checkpoint, plot_architecture
+)
+from losses import (
+    warp_func, warp_nearest_func, lncc_loss_func, dice_loss_func, reg_losses, dice_loss_func2
+)
+
+
+def swap_training(network_to_train, network_to_not_train):
+    """
+        Switch out of training one network and into training another
+    """
+
+    for param in network_to_not_train.parameters():
+        param.requires_grad = False
+
+    for param in network_to_train.parameters():
+        param.requires_grad = True
+
+    network_to_not_train.eval()
+    network_to_train.train()
+
+def train_network(dataloader_train_reg,
+                  dataloader_valid_reg,
+                  dataloader_train_seg,
+                  dataloader_valid_seg,
+                  device,
+                  seg_net,
+                  reg_net,
+                  num_segmentation_classes,
+                  lr_reg,
+                  lr_seg,
+                  lam_a,
+                  lam_sp,
+                  lam_re,
+                  max_epoch,
+                  val_step,
+                  result_seg_path,
+                  result_reg_path,
+                  logger,
+                  img_shape,
+                  plot_network=False,
+                  continue_training=False
+                  ):
+    # Training cell
+    
+    make_if_dont_exist(os.path.join(result_seg_path, 'training_plot'))
+    make_if_dont_exist(os.path.join(result_reg_path, 'training_plot'))
+    make_if_dont_exist(os.path.join(result_seg_path, 'model'))
+    make_if_dont_exist(os.path.join(result_reg_path, 'model'))
+    make_if_dont_exist(os.path.join(result_seg_path, 'checkpoints'))
+    make_if_dont_exist(os.path.join(result_reg_path, 'checkpoints'))
+    
+    ROOT_DIR = str(Path(result_reg_path).parent.absolute())
+    seg_availabilities = ['00', '01', '10', '11']
+    batch_generator_train_reg = generators.create_batch_generator(
+        dataloader_train_reg)
+    batch_generator_valid_reg = generators.create_batch_generator(
+        dataloader_valid_reg)
+    seg_train_sampling_weights = [
+        0] + [len(dataloader_train_reg[s]) for s in seg_availabilities[1:]]
+    print('----------'*10)
+    print(f"""When training seg_net alone, segmentation availabilities {seg_availabilities}
+    will be sampled with respective weights {seg_train_sampling_weights}""")
+    batch_generator_train_seg = generators.create_batch_generator(
+        dataloader_train_reg, seg_train_sampling_weights)
+    seg_net = seg_net.to(device)
+    reg_net = reg_net.to(device)
+
+    learning_rate_reg = lr_reg
+    optimizer_reg = torch.optim.Adam(reg_net.parameters(), learning_rate_reg)
+    scheduler_reg = torch.optim.lr_scheduler.StepLR(optimizer_reg, step_size=70, gamma=0.2, verbose=True)
+    learning_rate_seg = lr_seg
+    optimizer_seg = torch.optim.Adam(seg_net.parameters(), learning_rate_seg)
+    scheduler_seg = torch.optim.lr_scheduler.StepLR(optimizer_seg, step_size=50, gamma=0.2, verbose=True)
+    last_epoch = 0
+    
+    training_losses_reg = []
+    validation_losses_reg = []
+    training_losses_seg = []
+    validation_losses_seg = []
+    regularization_loss_reg = []
+    anatomy_loss_reg = []
+    similarity_loss_reg = []
+    supervised_loss_seg = []
+    anatomy_loss_seg = []
+    best_seg_validation_loss = float('inf')
+    best_reg_validation_loss = float('inf')
+    
+    last_epoch_valid = 0
+    if continue_training:
+        if os.path.exists(os.path.join(result_seg_path, 'checkpoints', 'valid_checkpoint.pth')) and os.path.exists(os.path.join(result_reg_path, 'checkpoints', 'valid_checkpoint.pth')):
+            if os.path.exists(os.path.join(result_seg_path, 'checkpoints', 'best_checkpoint.pth')) and os.path.exists(os.path.join(result_reg_path, 'checkpoints', 'best_checkpoint.pth')): 
+                best_seg_validation_loss = load_best_checkpoint(os.path.join(result_reg_path, 'checkpoints'), device)
+                best_reg_validation_loss = load_best_checkpoint(os.path.join(result_seg_path, 'checkpoints'), device)
+            
+            all_validation_losses_reg = load_valid_checkpoint(os.path.join(result_reg_path, 'checkpoints'), device)
+            all_validation_losses_seg = load_valid_checkpoint(os.path.join(result_seg_path, 'checkpoints'), device)
+            validation_losses_reg = all_validation_losses_reg['total_loss']
+            validation_losses_seg = all_validation_losses_seg['total_loss']
+            last_epoch_valid = np.minimum(len(validation_losses_reg), len(validation_losses_seg))
+            validation_losses_reg = validation_losses_reg[:last_epoch_valid]
+            validation_losses_seg = validation_losses_seg[:last_epoch_valid]
+            np_validation_losses_reg = np.array(validation_losses_reg)
+            np_validation_losses_seg = np.array(validation_losses_seg)
+            if best_reg_validation_loss not in np_validation_losses_reg[:, 1]:
+                best_reg_validation_loss = np.min(np_validation_losses_reg[:, 1])
+                if os.path.exists(os.path.join(result_reg_path, 'model', 'reg_net_last_best.pth')):
+                    assert os.path.exists(os.path.join(result_reg_path, 'model', 'reg_net_best.pth'))
+                    os.remove(os.path.join(result_reg_path, 'model', 'reg_net_best.pth'))
+                    os.rename(os.path.join(result_reg_path, 'model', 'reg_net_last_best.pth'), os.path.join(result_reg_path, 'model', 'reg_net_best.pth'))
+            if best_seg_validation_loss not in np_validation_losses_seg[:, 1]:
+                best_seg_validation_loss = np.min(np_validation_losses_seg[:, 1])
+                if os.path.exists(os.path.join(result_seg_path, 'model', 'seg_net_last_best.pth')):
+                    assert os.path.exists(os.path.join(result_seg_path, 'model', 'seg_net_best.pth'))
+                    os.remove(os.path.join(result_seg_path, 'model', 'seg_net_best.pth'))
+                    os.rename(os.path.join(result_seg_path, 'model', 'seg_net_last_best.pth'), os.path.join(result_seg_path, 'model', 'seg_net_best.pth'))
+        else:
+            if os.path.exists(os.path.join(result_seg_path, 'checkpoints', 'valid_checkpoint.pth')):
+                os.remove(os.path.join(result_seg_path, 'checkpoints', 'valid_checkpoint.pth'))  
+            elif os.path.exists(os.path.join(result_reg_path, 'checkpoints', 'valid_checkpoint.pth')):
+                os.remove(os.path.join(result_reg_path, 'checkpoints', 'valid_checkpoint.pth'))
+        
+        if last_epoch_valid != 0 and os.path.exists(os.path.join(result_seg_path, 'checkpoints', 'latest_checkpoint.pth')) and os.path.exists(os.path.join(result_reg_path, 'checkpoints', 'latest_checkpoint.pth')):
+            reg_net, optimizer_reg, all_training_losses_reg = load_latest_checkpoint(os.path.join(result_reg_path, 'checkpoints'), reg_net, optimizer_reg, device)
+            seg_net, optimizer_seg, all_training_losses_seg = load_latest_checkpoint(os.path.join(result_seg_path, 'checkpoints'), seg_net, optimizer_seg, device)
+            regularization_loss_reg = all_training_losses_reg['regular_loss']
+            anatomy_loss_reg = all_training_losses_reg['ana_loss']
+            similarity_loss_reg = all_training_losses_reg['sim_loss']
+            supervised_loss_seg = all_training_losses_seg['super_loss']
+            anatomy_loss_seg = all_training_losses_seg['ana_loss']
+            training_losses_reg = all_training_losses_reg['total_loss']
+            training_losses_seg = all_training_losses_seg['total_loss']
+            last_epoch_train = np.min(np.array([last_epoch_valid * val_step, len(training_losses_reg), len(training_losses_seg)]))
+            regularization_loss_reg = regularization_loss_reg[:last_epoch_train]
+            anatomy_loss_reg = anatomy_loss_reg[:last_epoch_train]
+            similarity_loss_reg = similarity_loss_reg[:last_epoch_train]
+            supervised_loss_seg = supervised_loss_seg[:last_epoch_train]
+            anatomy_loss_seg = anatomy_loss_seg[:last_epoch_train]
+            training_losses_reg = training_losses_reg[:last_epoch_train]
+            training_losses_seg = training_losses_seg[:last_epoch_train]
+
+            last_epoch = last_epoch_train
+        else:
+            if os.path.exists(os.path.join(result_seg_path, 'checkpoints', 'latest_checkpoint.pth')):
+                os.remove(os.path.join(result_seg_path, 'checkpoints', 'latest_checkpoint.pth'))  
+            elif os.path.exists(os.path.join(result_reg_path, 'checkpoints', 'latest_checkpoint.pth')):
+                os.remove(os.path.join(result_reg_path, 'checkpoints', 'latest_checkpoint.pth'))
+    
+    if len(dataloader_valid_reg) == 0:
+        validation_losses_reg = []
+    
+    if len(dataloader_valid_seg) == 0:
+        validation_losses_seg = []
+    
+    lambda_a = lam_a  # anatomy loss weight
+    lambda_sp = lam_sp  # supervised segmentation loss weight
+
+    # regularization loss weight
+    # monai has provided normalized bending energy loss
+    # no need to modify the weight according to the image size
+    lambda_r = lam_re
+
+    max_epochs = max_epoch
+    reg_phase_training_batches_per_epoch = 10
+    # Fewer batches needed, because seg_net converges more quickly
+    seg_phase_training_batches_per_epoch = 5
+    reg_phase_num_validation_batches_to_use = 10
+    val_interval = val_step
+    if plot_network:
+        plot_architecture(seg_net, img_shape, seg_phase_training_batches_per_epoch, 'SegNet', result_seg_path)
+        plot_architecture(reg_net, img_shape, reg_phase_training_batches_per_epoch, 'RegNet', result_reg_path)
+    
+    logger.info('Start Training')
+
+    for epoch_number in range(last_epoch, max_epochs):
+
+        logger.info(f"Epoch {epoch_number+1}/{max_epochs}:")
+            # ------------------------------------------------
+            #         reg_net training, with seg_net frozen
+            # ------------------------------------------------
+
+            # Keep computational graph in memory for reg_net, but not for seg_net, and do reg_net.train()
+        swap_training(reg_net, seg_net)
+
+        losses = []
+        regularization_loss = []
+        similarity_loss = []
+        anatomy_loss = []
+        for batch in batch_generator_train_reg(reg_phase_training_batches_per_epoch):
+            optimizer_reg.zero_grad()
+            loss_sim, loss_reg, loss_ana, df = reg_losses(
+                batch, device, reg_net, seg_net, num_segmentation_classes)
+            loss = loss_sim + lambda_r * loss_reg + lambda_a * loss_ana
+            loss.backward()
+            optimizer_reg.step()
+            losses.append(loss.item())
+            regularization_loss.append(loss_reg.item())
+            similarity_loss.append(loss_sim.item())
+            anatomy_loss.append(loss_ana.item())
+        
+        #preview_3D_vector_field(df.cpu().detach()[0], ep=epoch_number, path=result_reg_path)
+
+        training_loss_reg = np.mean(losses)
+        regularization_loss_reg.append(
+            [epoch_number+1, np.mean(regularization_loss)])
+        similarity_loss_reg.append([epoch_number+1, np.mean(similarity_loss)])
+        anatomy_loss_reg.append([epoch_number+1, np.mean(anatomy_loss)])
+        logger.info(f"\treg training loss: {training_loss_reg}")
+        training_losses_reg.append([epoch_number+1, training_loss_reg])
+        logger.info("\tsave latest reg_net checkpoint")
+        save_reg_checkpoint(reg_net, optimizer_reg, epoch_number, training_loss_reg, sim_loss=similarity_loss_reg, regular_loss=regularization_loss_reg, ana_loss=anatomy_loss_reg, total_loss=training_losses_reg, save_dir=os.path.join(result_reg_path, 'checkpoints'), name='latest')
+        # validation process
+        if len(dataloader_valid_reg) == 0:
+            logger.info("\tno enough dataset for validation")
+            save_reg_checkpoint(reg_net, optimizer_reg, epoch_number, training_loss_reg, sim_loss=similarity_loss_reg, regular_loss=regularization_loss_reg, ana_loss=anatomy_loss_reg, total_loss=training_losses_reg, save_dir=os.path.join(result_reg_path, 'checkpoints'), name='best')
+            save_reg_checkpoint(reg_net, optimizer_reg, epoch_number, training_loss_reg, sim_loss=similarity_loss_reg, regular_loss=regularization_loss_reg, ana_loss=anatomy_loss_reg, total_loss=training_losses_reg, save_dir=os.path.join(result_reg_path, 'checkpoints'), name='valid')
+            if os.path.exists(os.path.join(result_reg_path, 'model', 'reg_net_best.pth')):
+                if os.path.exists(os.path.join(result_reg_path, 'model', 'reg_net_last_best.pth')):
+                    os.remove(os.path.join(result_reg_path, 'model', 'reg_net_last_best.pth'))
+                os.rename(os.path.join(result_reg_path, 'model', 'reg_net_best.pth'), os.path.join(result_reg_path, 'model', 'reg_net_last_best.pth'))
+            torch.save(reg_net.state_dict(), os.path.join(result_reg_path, 'model', 'reg_net_best.pth'))
+        else:
+            if epoch_number % val_interval == 0:
+                reg_net.eval()
+                losses = []
+                with torch.no_grad():
+                    for batch in batch_generator_valid_reg(reg_phase_num_validation_batches_to_use):
+                        loss_sim, loss_reg, loss_ana, dv = reg_losses(
+                            batch, device, reg_net, seg_net, num_segmentation_classes)
+                        loss = loss_sim + lambda_r * loss_reg + lambda_a * loss_ana
+                        losses.append(loss.item())
+                
+                validation_loss_reg = np.mean(losses)
+                logger.info(f"\treg validation loss: {validation_loss_reg}")
+                validation_losses_reg.append([epoch_number+1, validation_loss_reg])
+
+                if validation_loss_reg < best_reg_validation_loss:
+                    best_reg_validation_loss = validation_loss_reg
+                    logger.info("\tsave best reg_net checkpoint and model")
+                    save_reg_checkpoint(reg_net, optimizer_reg, epoch_number, best_reg_validation_loss, total_loss=validation_losses_reg, save_dir=os.path.join(result_reg_path, 'checkpoints'), name='best')
+                    if os.path.exists(os.path.join(result_reg_path, 'model', 'reg_net_best.pth')):
+                        if os.path.exists(os.path.join(result_reg_path, 'model', 'reg_net_last_best.pth')):
+                            os.remove(os.path.join(result_reg_path, 'model', 'reg_net_last_best.pth'))
+                        os.rename(os.path.join(result_reg_path, 'model', 'reg_net_best.pth'), os.path.join(result_reg_path, 'model', 'reg_net_last_best.pth'))
+                    torch.save(reg_net.state_dict(), os.path.join(result_reg_path, 'model', 'reg_net_best.pth'))
+                save_reg_checkpoint(reg_net, optimizer_reg, epoch_number, validation_loss_reg, total_loss=validation_losses_reg, save_dir=os.path.join(result_reg_path, 'checkpoints'), name='valid')
+        
+        plot_progress(logger, os.path.join(result_reg_path, 'training_plot'), training_losses_reg, validation_losses_reg, 'reg_net_training_loss')   
+        plot_progress(logger, os.path.join(result_reg_path, 'training_plot'), regularization_loss_reg, [], 'regularization_reg_net_loss')
+        plot_progress(logger, os.path.join(result_reg_path, 'training_plot'), anatomy_loss_reg, [], 'anatomy_reg_net_loss')
+        plot_progress(logger, os.path.join(result_reg_path, 'training_plot'), similarity_loss_reg, [], 'similarity_reg_net_loss')
+        # scheduler_reg.step()
+        # Free up memory
+        del loss, loss_sim, loss_reg, loss_ana
+        torch.cuda.empty_cache()
+
+        # ------------------------------------------------
+        #         seg_net training, with reg_net frozen
+        # ------------------------------------------------
+
+        # Keep computational graph in memory for seg_net, but not for reg_net, and do seg_net.train()
+        logger.info('\t'+'----'*10)
+        swap_training(seg_net, reg_net)
+        losses = []
+        supervised_loss = []
+        anatomy_loss = []
+        dice_loss = dice_loss_func()
+        warp = warp_func()
+        warp_nearest = warp_nearest_func()
+        dice_loss2 = dice_loss_func2()
+        for batch in batch_generator_train_seg(seg_phase_training_batches_per_epoch):
+            optimizer_seg.zero_grad()
+
+            img12 = batch['img12'].to(device)
+
+            displacement_fields = reg_net(img12)
+            seg1_predicted = seg_net(img12[:, [0], :, :, :]).softmax(dim=1)
+            seg2_predicted = seg_net(img12[:, [1], :, :, :]).softmax(dim=1)
+
+            # Below we compute the following:
+            # loss_supervised: supervised segmentation loss; compares ground truth seg with predicted seg
+            # loss_anatomy: anatomy loss; compares warped seg of moving image to seg of target image
+            # loss_metric: a single supervised seg loss, as a metric to track the progress of training
+
+            if 'seg1' in batch.keys() and 'seg2' in batch.keys():
+                seg1 = monai.networks.one_hot(
+                    batch['seg1'].to(device), num_segmentation_classes)
+                seg2 = monai.networks.one_hot(
+                    batch['seg2'].to(device), num_segmentation_classes)
+                loss_metric = dice_loss(seg2_predicted, seg2)
+                loss_supervised = loss_metric + dice_loss(seg1_predicted, seg1)
+                # The above supervised loss looks a bit different from the one in the paper
+                # in that it includes predictions for both images in the current image pair;
+                # we might as well do this, since we have gone to the trouble of loading
+                # both segmentations into memory.
+
+            elif 'seg1' in batch.keys():  # seg1 available, but no seg2
+                seg1 = monai.networks.one_hot(
+                    batch['seg1'].to(device), num_segmentation_classes)
+                loss_metric = dice_loss(seg1_predicted, seg1)
+                loss_supervised = loss_metric
+                seg2 = seg2_predicted  # Use this in anatomy loss
+
+            else:  # seg2 available, but no seg1
+                assert('seg2' in batch.keys())
+                seg2 = monai.networks.one_hot(
+                    batch['seg2'].to(device), num_segmentation_classes)
+                loss_metric = dice_loss(seg2_predicted, seg2)
+                loss_supervised = loss_metric
+                seg1 = seg1_predicted  # Use this in anatomy loss
+
+            # seg1 and seg2 should now be in the form of one-hot class probabilities
+
+            loss_anatomy = dice_loss(warp_nearest(seg2, displacement_fields), seg1)\
+                if 'seg1' in batch.keys() or 'seg2' in batch.keys()\
+                else 0.  # It wouldn't really be 0, but it would not contribute to training seg_net
+
+            # (If you want to refactor this code for *joint* training of reg_net and seg_net,
+            #  then use the definition of anatomy loss given in the function anatomy_loss above,
+            #  where differentiable warping is used and reg net can be trained with it.)
+
+            loss = lambda_a * loss_anatomy + lambda_sp * loss_supervised
+            loss.backward()
+            optimizer_seg.step()
+
+            losses.append(loss_metric.item())
+            supervised_loss.append(loss_supervised.item())
+            anatomy_loss.append(loss_anatomy.item())
+
+        training_loss_seg = np.mean(losses)
+        supervised_loss_seg.append([epoch_number+1, np.mean(supervised_loss)])
+        anatomy_loss_seg.append([epoch_number+1, np.mean(anatomy_loss)])
+        logger.info(f"\tseg training loss: {training_loss_seg}")
+        training_losses_seg.append([epoch_number+1, training_loss_seg])
+        logger.info("\tsave latest seg_net checkpoint")
+        save_seg_checkpoint(seg_net, optimizer_seg, epoch_number, training_loss_seg, super_loss=supervised_loss_seg,ana_loss=anatomy_loss_seg, total_loss=training_losses_seg, save_dir=os.path.join(result_seg_path, 'checkpoints'), name='latest')
+        
+        if len(dataloader_valid_seg) == 0:
+            logger.info("\tno enough dataset for validation")
+            save_seg_checkpoint(seg_net, optimizer_seg, epoch_number, training_loss_seg, super_loss=supervised_loss_seg,ana_loss=anatomy_loss_seg, total_loss=training_losses_seg, save_dir=os.path.join(result_seg_path, 'checkpoints'), name='valid')
+            save_seg_checkpoint(seg_net, optimizer_seg, epoch_number, training_loss_seg, super_loss=supervised_loss_seg,ana_loss=anatomy_loss_seg, total_loss=training_losses_seg, save_dir=os.path.join(result_seg_path, 'checkpoints'), name='best')
+            if os.path.exists(os.path.join(result_seg_path, 'model', 'seg_net_best.pth')):
+                if os.path.exists(os.path.join(result_seg_path, 'model', 'seg_net_last_best.pth')):
+                    os.remove(os.path.join(result_seg_path, 'model', 'seg_net_last_best.pth'))
+                os.rename(os.path.join(result_seg_path, 'model', 'seg_net_best.pth'), os.path.join(result_seg_path, 'model', 'seg_net_last_best.pth'))
+            torch.save(seg_net.state_dict(), os.path.join(result_seg_path, 'model', 'seg_net_best.pth'))
+        else:
+            if epoch_number % val_interval == 0:
+                # The following validation loop would not do anything in the case
+                # where there is just one segmentation available,
+                # because data_seg_available_valid would be empty.
+                seg_net.eval()
+                losses = []
+                with torch.no_grad():
+                    for batch in dataloader_valid_seg:
+                        imgs = batch['img'].to(device)
+                        true_segs = batch['seg'].to(device)
+                        predicted_segs = seg_net(imgs)
+                        loss = dice_loss2(predicted_segs, true_segs)
+                        losses.append(loss.item())
+
+                validation_loss_seg = np.mean(losses)
+                logger.info(f"\tseg validation loss: {validation_loss_seg}")
+                validation_losses_seg.append([epoch_number+1, validation_loss_seg])
+
+                if validation_loss_seg < best_seg_validation_loss:
+                    best_seg_validation_loss = validation_loss_seg
+                    logger.info("\tsave best seg_net checkpoint and model")
+                    save_seg_checkpoint(seg_net, optimizer_seg, epoch_number, best_seg_validation_loss, total_loss=validation_losses_seg, save_dir=os.path.join(result_seg_path, 'checkpoints'), name='best')
+                    if os.path.exists(os.path.join(result_seg_path, 'model', 'seg_net_best.pth')):
+                        if os.path.exists(os.path.join(result_seg_path, 'model', 'seg_net_last_best.pth')):
+                            os.remove(os.path.join(result_seg_path, 'model', 'seg_net_last_best.pth'))
+                        os.rename(os.path.join(result_seg_path, 'model', 'seg_net_best.pth'), os.path.join(result_seg_path, 'model', 'seg_net_last_best.pth'))
+                    torch.save(seg_net.state_dict(), os.path.join(result_seg_path, 'model', 'seg_net_best.pth'))
+                save_seg_checkpoint(seg_net, optimizer_seg, epoch_number, validation_loss_seg, total_loss=validation_losses_seg, save_dir=os.path.join(result_seg_path, 'checkpoints'), name='valid')
+        
+        plot_progress(logger, os.path.join(result_seg_path, 'training_plot'), training_losses_seg, validation_losses_seg, 'seg_net_training_loss')
+        plot_progress(logger, os.path.join(result_seg_path, 'training_plot'), anatomy_loss_seg, [], 'anatomy_seg_net_loss')
+        plot_progress(logger, os.path.join(result_seg_path, 'training_plot'), supervised_loss_seg, [], 'supervised_seg_net_loss')   
+        logger.info(f"\tseg lr: {optimizer_seg.param_groups[0]['lr']}")
+        logger.info(f"\treg lr: {optimizer_reg.param_groups[0]['lr']}")
+        # scheduler_seg.step()
+        # Free up memory
+        del (loss, seg1, seg2, displacement_fields, img12, loss_supervised, loss_anatomy, loss_metric,\
+            seg1_predicted, seg2_predicted)
+        torch.cuda.empty_cache()
+
+    if len(validation_losses_reg) == 0:
+        logger.info('Only small number of pairs are used for training, no need to do validation. Replace best validation loss with training loss !!!')
+        logger.info(f'Best reg_net validation loss: {training_loss_reg}')
+    else:
+        logger.info(f"Best reg_net validation loss: {best_reg_validation_loss}")
+    
+    if len(validation_losses_seg) == 0:
+        logger.info('Only one label is used for training, no need to do validation. Replace best validation loss with training loss !!!')
+        logger.info(f'Best seg_net validation loss: {training_loss_seg}')
+    else:
+        logger.info(f"Best seg_net validation loss: {best_seg_validation_loss}")
+    
+    # save reg training losses
+    reg_training_pkl = [{'training_losses': training_losses_reg},
+                        {'anatomy_loss': anatomy_loss_reg},
+                        {'similarity_loss': similarity_loss_reg},
+                        {'regularization_loss': regularization_loss_reg}
+                        ]
+    if len(validation_losses_reg) != 0:
+        reg_training_pkl.append({'validation_losses': validation_losses_reg})
+        reg_training_pkl.append({'best_reg_validation_loss': best_reg_validation_loss})
+    else:
+        reg_training_pkl.append({'best_reg_validation_loss': training_loss_reg})
+    
+    # save seg training losses
+    seg_training_pkl = [{'training_losses': training_losses_seg},
+                        {'anatomy_loss': anatomy_loss_seg},
+                        {'supervised_loss': supervised_loss_seg}
+                        ]
+    if len(validation_losses_seg) != 0:
+        seg_training_pkl.append({'validation_losses': validation_losses_seg})
+        seg_training_pkl.append({'best_seg_validation_loss': best_seg_validation_loss})
+    else:
+        seg_training_pkl.append({'best_seg_validation_loss': training_loss_seg})
+    
+    with open(os.path.join(result_reg_path, 'training_plot', 'reg_training_losses.pkl'), 'wb') as f:
+        pickle.dump(reg_training_pkl, f)
+    
+    with open(os.path.join(result_seg_path, 'training_plot', 'seg_training_losses.pkl'), 'wb') as ff:
+        pickle.dump(seg_training_pkl, ff)

deepatlas/utils/utils.py

@@ -0,0 +1,294 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import monai
+import torch
+import os
+import json
+import matplotlib
+import shutil
+from torchview import draw_graph
+
+def plot_architecture(network, img_shape, batch_size, name, save_dir):
+    if name == 'SegNet':
+        num_channels = 1
+    else:
+        num_channels = 2
+    
+    H, D, W = img_shape
+    model_graph = draw_graph(network, 
+                             input_size=(batch_size, num_channels, H, D, W), 
+                             device='meta', 
+                             roll=True, 
+                             expand_nested=True, 
+                             save_graph=True, 
+                             filename=f"{name}_Graph",
+                             directory=save_dir)
+    
+def make_if_dont_exist(folder_path, overwrite=False):
+    if os.path.exists(folder_path):
+        if not overwrite:
+            print(f'{folder_path} exists.')
+        else:
+            print(f"{folder_path} overwritten")
+            shutil.rmtree(folder_path, ignore_errors = True)
+            os.makedirs(folder_path)
+    else:
+        os.makedirs(folder_path)
+        print(f"{folder_path} created!")
+
+def preview_image(image_array, normalize_by="volume", cmap=None, figsize=(12, 12), threshold=None):
+    """
+    Display three orthogonal slices of the given 3D image.
+
+    image_array is assumed to be of shape (H,W,D)
+
+    If a number is provided for threshold, then pixels for which the value
+    is below the threshold will be shown in red
+    """
+    plt.figure()
+    if normalize_by == "slice":
+        vmin = None
+        vmax = None
+    elif normalize_by == "volume":
+        vmin = 0
+        vmax = image_array.max().item()
+    else:
+        raise(ValueError(
+            f"Invalid value '{normalize_by}' given for normalize_by"))
+
+    # half-way slices
+    x, y, z = np.array(image_array.shape)//2
+    imgs = (image_array[x, :, :], image_array[:, y, :], image_array[:, :, z])
+
+    fig, axs = plt.subplots(1, 3, figsize=figsize)
+    for ax, im in zip(axs, imgs):
+        ax.axis('off')
+        ax.imshow(im, origin='lower', vmin=vmin, vmax=vmax, cmap=cmap)
+
+        # threshold will be useful when displaying jacobian determinant images;
+        # we will want to clearly see where the jacobian determinant is negative
+        if threshold is not None:
+            red = np.zeros(im.shape+(4,))  # RGBA array
+            red[im <= threshold] = [1, 0, 0, 1]
+            ax.imshow(red, origin='lower')
+
+    plt.savefig('test.png')
+
+
+def plot_2D_vector_field(vector_field, downsampling):
+    """Plot a 2D vector field given as a tensor of shape (2,H,W).
+
+    The plot origin will be in the lower left.
+    Using "x" and "y" for the rightward and upward directions respectively,
+      the vector at location (x,y) in the plot image will have
+      vector_field[1,y,x] as its x-component and
+      vector_field[0,y,x] as its y-component.
+    """
+    downsample2D = monai.networks.layers.factories.Pool['AVG', 2](
+        kernel_size=downsampling)
+    vf_downsampled = downsample2D(vector_field.unsqueeze(0))[0]
+    plt.quiver(
+        vf_downsampled[1, :, :], vf_downsampled[0, :, :],
+        angles='xy', scale_units='xy', scale=downsampling,
+        headwidth=4.
+    )
+
+
+def preview_3D_vector_field(vector_field, downsampling=None, ep=None, path=None):
+    """
+    Display three orthogonal slices of the given 3D vector field.
+
+    vector_field should be a tensor of shape (3,H,W,D)
+
+    Vectors are projected into the viewing plane, so you are only seeing
+    their components in the viewing plane.
+    """
+
+    if downsampling is None:
+        # guess a reasonable downsampling value to make a nice plot
+        downsampling = max(1, int(max(vector_field.shape[1:])) >> 5)
+
+    x, y, z = np.array(vector_field.shape[1:])//2  # half-way slices
+    plt.figure(figsize=(18, 6))
+    plt.subplot(1, 3, 1)
+    plt.axis('off')
+    plot_2D_vector_field(vector_field[[1, 2], x, :, :], downsampling)
+    plt.subplot(1, 3, 2)
+    plt.axis('off')
+    plot_2D_vector_field(vector_field[[0, 2], :, y, :], downsampling)
+    plt.subplot(1, 3, 3)
+    plt.axis('off')
+    plot_2D_vector_field(vector_field[[0, 1], :, :, z], downsampling)
+    plt.savefig(os.path.join(path, f'df_{ep}.png'))
+
+
+def plot_2D_deformation(vector_field, grid_spacing, **kwargs):
+    """
+    Interpret vector_field as a displacement vector field defining a deformation,
+    and plot an x-y grid warped by this deformation.
+
+    vector_field should be a tensor of shape (2,H,W)
+    """
+    _, H, W = vector_field.shape
+    grid_img = np.zeros((H, W))
+    grid_img[np.arange(0, H, grid_spacing), :] = 1
+    grid_img[:, np.arange(0, W, grid_spacing)] = 1
+    grid_img = torch.tensor(grid_img, dtype=vector_field.dtype).unsqueeze(
+        0)  # adds channel dimension, now (C,H,W)
+    warp = monai.networks.blocks.Warp(mode="bilinear", padding_mode="zeros")
+    grid_img_warped = warp(grid_img.unsqueeze(0), vector_field.unsqueeze(0))[0]
+    plt.imshow(grid_img_warped[0], origin='lower', cmap='gist_gray')
+
+
+def preview_3D_deformation(vector_field, grid_spacing, **kwargs):
+    """
+    Interpret vector_field as a displacement vector field defining a deformation,
+    and plot warped grids along three orthogonal slices.
+
+    vector_field should be a tensor of shape (3,H,W,D)
+    kwargs are passed to matplotlib plotting
+
+    Deformations are projected into the viewing plane, so you are only seeing
+    their components in the viewing plane.
+    """
+    x, y, z = np.array(vector_field.shape[1:])//2  # half-way slices
+    plt.figure(figsize=(18, 6))
+    plt.subplot(1, 3, 1)
+    plt.axis('off')
+    plot_2D_deformation(vector_field[[1, 2], x, :, :], grid_spacing, **kwargs)
+    plt.subplot(1, 3, 2)
+    plt.axis('off')
+    plot_2D_deformation(vector_field[[0, 2], :, y, :], grid_spacing, **kwargs)
+    plt.subplot(1, 3, 3)
+    plt.axis('off')
+    plot_2D_deformation(vector_field[[0, 1], :, :, z], grid_spacing, **kwargs)
+    plt.show()
+
+
+def jacobian_determinant(vf):
+    """
+    Given a displacement vector field vf, compute the jacobian determinant scalar field.
+
+    vf is assumed to be a vector field of shape (3,H,W,D),
+    and it is interpreted as the displacement field.
+    So it is defining a discretely sampled map from a subset of 3-space into 3-space,
+    namely the map that sends point (x,y,z) to the point (x,y,z)+vf[:,x,y,z].
+    This function computes a jacobian determinant by taking discrete differences in each spatial direction.
+
+    Returns a numpy array of shape (H-1,W-1,D-1).
+    """
+
+    _, H, W, D = vf.shape
+
+    # Compute discrete spatial derivatives
+    def diff_and_trim(array, axis): return np.diff(
+        array, axis=axis)[:, :(H-1), :(W-1), :(D-1)]
+    dx = diff_and_trim(vf, 1)
+    dy = diff_and_trim(vf, 2)
+    dz = diff_and_trim(vf, 3)
+
+    # Add derivative of identity map
+    dx[0] += 1
+    dy[1] += 1
+    dz[2] += 1
+
+    # Compute determinant at each spatial location
+    det = dx[0]*(dy[1]*dz[2]-dz[1]*dy[2]) - dy[0]*(dx[1]*dz[2] -
+                                                   dz[1]*dx[2]) + dz[0]*(dx[1]*dy[2]-dy[1]*dx[2])
+
+    return det
+
+def load_json(json_path):
+    assert type(json_path) == str
+    fjson = open(json_path, 'r')
+    json_file = json.load(fjson)
+    return json_file
+
+def plot_progress(logger, save_dir, train_loss, val_loss, name):
+    """
+    Should probably by improved
+    :return:
+    """
+    assert len(train_loss) != 0
+    train_loss = np.array(train_loss)
+    try:
+        font = {'weight': 'normal',
+                'size': 18}
+
+        matplotlib.rc('font', **font)
+
+        fig = plt.figure(figsize=(30, 24))
+        ax = fig.add_subplot(111)
+        ax.plot(train_loss[:,0], train_loss[:,1], color='b', ls='-', label="loss_tr")
+        if len(val_loss) != 0:
+            val_loss = np.array(val_loss)
+            ax.plot(val_loss[:, 0], val_loss[:, 1], color='r', ls='-', label="loss_val")
+
+        ax.set_xlabel("epoch")
+        ax.set_ylabel("loss")
+        ax.legend()
+        ax.set_title(name)
+        fig.savefig(os.path.join(save_dir, name + ".png"))
+        plt.cla()
+        plt.close(fig)
+    except:
+        logger.info(f"failed to plot {name} training progress")
+
+def save_reg_checkpoint(network, optimizer, epoch, best_loss, sim_loss=None, regular_loss=None, ana_loss=None, total_loss=None, save_dir=None, name=None):
+    all_loss = {
+        'best_loss': best_loss,
+        'total_loss': total_loss,
+    }
+    if sim_loss is not None:
+        all_loss['sim_loss'] = sim_loss
+    if regular_loss is not None:
+        all_loss['regular_loss'] = regular_loss
+    if ana_loss is not None:
+        all_loss['ana_loss'] = ana_loss
+    
+    torch.save({
+        'epoch': epoch,
+        'network_state_dict': network.state_dict(),
+        'optimizer_state_dict': optimizer.state_dict(),
+        'all_loss': all_loss,
+    }, os.path.join(save_dir, name+'_checkpoint.pth'))
+
+
+def save_seg_checkpoint(network, optimizer, epoch, best_loss, super_loss=None, ana_loss=None, total_loss=None, save_dir=None, name=None):
+    all_loss = {
+        'best_loss': best_loss,
+        'total_loss': total_loss,
+    }
+    if super_loss is not None:
+        all_loss['super_loss'] = super_loss
+    if ana_loss is not None:
+        all_loss['ana_loss'] = ana_loss
+    
+    torch.save({
+        'epoch': epoch,
+        'network_state_dict': network.state_dict(),
+        'optimizer_state_dict': optimizer.state_dict(),
+        'all_loss': all_loss,
+    }, os.path.join(save_dir, name+'_checkpoint.pth'))
+
+
+def load_latest_checkpoint(path, network, optimizer, device):
+    checkpoint_path = os.path.join(path, 'latest_checkpoint.pth')
+    checkpoint = torch.load(checkpoint_path, map_location=device)
+    network.load_state_dict(checkpoint['network_state_dict'])
+    optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
+    all_loss = checkpoint['all_loss']
+    return network, optimizer, all_loss
+
+def load_valid_checkpoint(path, device):
+    checkpoint_path = os.path.join(path, 'valid_checkpoint.pth')
+    checkpoint = torch.load(checkpoint_path, map_location=device)
+    all_loss = checkpoint['all_loss']
+    return all_loss
+
+def load_best_checkpoint(path, device):
+    checkpoint_path = os.path.join(path, 'best_checkpoint.pth')
+    checkpoint = torch.load(checkpoint_path, map_location=device)
+    best_loss = checkpoint['all_loss']['best_loss']
+    return best_loss
+

deepatlas_config/config_sample.json

@@ -0,0 +1,28 @@
+{
+    "task_name": "Task002_rnmw153_sim_Zsc",
+    "folder_name": "folder_name",
+    "info_name": "info",
+    "num_seg_used": 1,
+    "exp_set": 2,
+    "labels": {
+        "0": "background",
+        "1": "Spetum",
+        "2": "IT",
+        "3": "MS"
+    },
+    "network": {
+        "spatial_dim": 3,
+        "dropout": 0.2,
+        "activation_type": "leakyrelu",
+        "normalization_type": "batch",
+        "num_res": 0,
+        "anatomy_loss_weight": 15.0,
+        "supervised_segmentation_loss_weight": 3.0,
+        "regularization_loss_weight": 5e-6,
+        "registration_network_learning_rate": 1e-3,
+        "segmentation_network_learning_rate": 5e-4,
+        "number_epoch": 10,
+        "validation_step": 1
+    },
+    "num_fold": 2
+}

deepatlas_results/Task002_rnmw153_sim_Zsc/dataset.json

@@ -0,0 +1,647 @@
+{
+    "name": "Task002",
+    "description": "rnmw153",
+    "tensorImageSize": "4D",
+    "reference": "MODIFY",
+    "licence": "MODIFY",
+    "release": "0.0",
+    "modality": {
+        "0": "CT"
+    },
+    "labels": {
+        "0": "background",
+        "1": "Septum",
+        "2": "IT",
+        "3": "MS"
+    },
+    "network": {
+        "spatial_dim": 3,
+        "dropout": 0.2,
+        "activation_type": "leakyrelu",
+        "normalization_type": "batch",
+        "num_res": 0
+    },
+    "total_numScanTraining": 12,
+    "total_numLabelTraining": 10,
+    "total_numTest": 5,
+    "total_train": [
+        {
+            "img": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_190.nii.gz",
+            "seg": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_190.nii.gz"
+        },
+        {
+            "img": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_174.nii.gz",
+            "seg": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_174.nii.gz"
+        },
+        {
+            "img": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_140.nii.gz",
+            "seg": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_140.nii.gz"
+        },
+        {
+            "img": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_192.nii.gz",
+            "seg": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_192.nii.gz"
+        },
+        {
+            "img": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_194.nii.gz",
+            "seg": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_194.nii.gz"
+        },
+        {
+            "img": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_181.nii.gz"
+        },
+        {
+            "img": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_138.nii.gz",
+            "seg": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_138.nii.gz"
+        },
+        {
+            "img": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_183.nii.gz",
+            "seg": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_183.nii.gz"
+        },
+        {
+            "img": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_170.nii.gz",
+            "seg": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_170.nii.gz"
+        },
+        {
+            "img": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_171.nii.gz",
+            "seg": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_171.nii.gz"
+        },
+        {
+            "img": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_175.nii.gz"
+        },
+        {
+            "img": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_191.nii.gz",
+            "seg": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_191.nii.gz"
+        }
+    ],
+    "total_test": [
+        {
+            "img": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_141.nii.gz",
+            "seg": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_141.nii.gz"
+        },
+        {
+            "img": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_169.nii.gz",
+            "seg": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_169.nii.gz"
+        },
+        {
+            "img": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_135.nii.gz",
+            "seg": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_135.nii.gz"
+        },
+        {
+            "img": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_172.nii.gz",
+            "seg": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_172.nii.gz"
+        },
+        {
+            "img": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_146.nii.gz",
+            "seg": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_146.nii.gz"
+        }
+    ],
+    "seg_numTrain": 10,
+    "seg_train": [
+        {
+            "img": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_190.nii.gz",
+            "seg": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_190.nii.gz"
+        },
+        {
+            "img": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_174.nii.gz",
+            "seg": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_174.nii.gz"
+        },
+        {
+            "img": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_140.nii.gz",
+            "seg": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_140.nii.gz"
+        },
+        {
+            "img": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_192.nii.gz",
+            "seg": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_192.nii.gz"
+        },
+        {
+            "img": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_194.nii.gz",
+            "seg": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_194.nii.gz"
+        },
+        {
+            "img": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_138.nii.gz",
+            "seg": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_138.nii.gz"
+        },
+        {
+            "img": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_183.nii.gz",
+            "seg": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_183.nii.gz"
+        },
+        {
+            "img": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_170.nii.gz",
+            "seg": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_170.nii.gz"
+        },
+        {
+            "img": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_171.nii.gz",
+            "seg": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_171.nii.gz"
+        },
+        {
+            "img": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_191.nii.gz",
+            "seg": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_191.nii.gz"
+        }
+    ],
+    "reg_numTrain": 58,
+    "reg_train": [
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_181.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_175.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_181.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_190.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_190.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_181.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_174.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_174.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_181.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_140.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_140.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_181.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_192.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_192.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_181.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_194.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_194.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_181.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_138.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_138.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_181.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_183.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_183.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_181.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_170.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_170.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_175.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_181.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_175.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_190.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_190.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_175.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_174.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_174.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_175.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_140.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_140.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_175.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_192.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_192.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_175.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_194.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_194.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_175.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_138.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_138.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_175.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_183.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_183.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_175.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_170.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_170.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_190.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_181.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_190.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_190.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_175.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_190.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_190.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_174.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_190.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_174.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_190.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_140.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_190.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_140.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_190.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_192.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_190.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_192.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_190.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_194.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_190.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_194.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_190.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_138.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_190.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_138.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_190.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_183.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_190.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_183.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_190.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_170.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_190.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_170.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_174.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_181.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_174.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_174.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_175.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_174.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_174.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_190.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_174.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_190.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_174.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_140.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_174.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_140.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_174.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_192.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_174.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_192.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_174.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_194.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_174.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_194.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_174.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_138.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_174.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_138.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_174.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_183.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_174.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_183.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_174.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_170.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_174.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_170.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_140.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_181.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_140.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_140.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_175.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_140.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_140.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_190.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_140.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_190.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_140.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_174.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_140.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_174.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_140.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_192.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_140.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_192.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_140.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_194.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_140.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_194.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_140.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_138.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_140.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_138.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_140.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_183.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_140.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_183.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_140.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_170.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_140.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_170.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_192.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_181.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_192.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_192.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_175.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_192.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_192.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_190.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_192.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_190.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_192.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_174.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_192.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_174.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_192.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_140.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_192.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_140.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_192.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_194.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_192.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_194.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_192.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_138.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_192.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_138.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_192.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_183.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_192.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_183.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_192.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_170.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_192.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_170.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_194.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_181.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_194.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_194.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_175.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_194.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_194.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_190.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_194.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_190.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_194.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_174.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_194.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_174.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_194.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_140.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_194.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_140.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_194.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_192.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_194.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_192.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_194.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_138.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_194.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_138.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_194.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_183.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_194.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_183.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_194.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_170.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_194.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_170.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_138.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_181.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_138.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_138.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_175.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_138.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_138.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_190.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_138.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_190.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_138.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_174.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_138.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_174.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_138.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_140.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_138.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_140.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_138.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_192.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_138.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_192.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_138.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_194.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_138.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_194.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_138.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_183.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_138.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_183.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_138.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_170.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_138.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_170.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_183.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_181.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_183.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_183.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_175.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_183.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_183.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_190.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_183.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_190.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_183.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_174.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_183.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_174.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_183.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_140.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_183.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_140.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_183.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_192.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_183.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_192.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_183.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_194.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_183.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_194.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_183.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_138.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_183.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_138.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_183.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_170.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_183.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_170.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_170.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_181.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_170.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_170.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_175.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_170.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_170.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_190.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_170.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_190.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_170.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_174.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_170.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_174.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_170.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_140.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_170.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_140.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_170.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_192.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_170.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_192.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_170.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_194.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_170.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_194.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_170.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_138.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_170.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_138.nii.gz"
+        },
+        {
+            "img1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_170.nii.gz",
+            "img2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/images/IR_183.nii.gz",
+            "seg1": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_170.nii.gz",
+            "seg2": "/home/ameen/Nasal Cavity/similarity/output_Zscore/labels/IR_183.nii.gz"
+        }
+    ]
+}

deepatlas_results/Task002_rnmw153_sim_Zsc/training_results/RegNet/anatomy_loss_reg.txt

@@ -0,0 +1,150 @@
+0.000000000000000000e+00 3.135408550500869973e-01
+1.000000000000000000e+00 3.057660102844238503e-01
+2.000000000000000000e+00 3.184201985597610585e-01
+3.000000000000000000e+00 3.163259848952293396e-01
+4.000000000000000000e+00 2.804470062255859375e-01
+5.000000000000000000e+00 2.842357277870178334e-01
+6.000000000000000000e+00 2.638818100094795227e-01
+7.000000000000000000e+00 2.777637779712677224e-01
+8.000000000000000000e+00 2.861650839447975048e-01
+9.000000000000000000e+00 2.704068765044212452e-01
+1.000000000000000000e+01 3.000330477952957153e-01
+1.100000000000000000e+01 2.721584409475326649e-01
+1.200000000000000000e+01 2.716749116778373607e-01
+1.300000000000000000e+01 2.548105090856552235e-01
+1.400000000000000000e+01 2.633110970258712991e-01
+1.500000000000000000e+01 2.299902319908141979e-01
+1.600000000000000000e+01 2.469595715403556935e-01
+1.700000000000000000e+01 2.442218318581581005e-01
+1.800000000000000000e+01 2.519750177860259899e-01
+1.900000000000000000e+01 2.407886266708373912e-01
+2.000000000000000000e+01 2.488558292388916016e-01
+2.100000000000000000e+01 2.248426392674446050e-01
+2.200000000000000000e+01 2.140324071049690136e-01
+2.300000000000000000e+01 2.415555238723754994e-01
+2.400000000000000000e+01 2.159206911921501271e-01
+2.500000000000000000e+01 2.323278933763504028e-01
+2.600000000000000000e+01 2.173769950866699108e-01
+2.700000000000000000e+01 2.162912964820861705e-01
+2.800000000000000000e+01 2.229687616229057423e-01
+2.900000000000000000e+01 2.084074690937995911e-01
+3.000000000000000000e+01 2.109835729002952631e-01
+3.100000000000000000e+01 1.859750419855117909e-01
+3.200000000000000000e+01 2.157837614417076055e-01
+3.300000000000000000e+01 2.094791114330291637e-01
+3.400000000000000000e+01 2.009812265634536854e-01
+3.500000000000000000e+01 2.076985687017440796e-01
+3.600000000000000000e+01 1.918238341808319036e-01
+3.700000000000000000e+01 2.009931191802024897e-01
+3.800000000000000000e+01 1.700636789202690236e-01
+3.900000000000000000e+01 1.962646290659904591e-01
+4.000000000000000000e+01 1.972826182842254694e-01
+4.100000000000000000e+01 1.782805666327476612e-01
+4.200000000000000000e+01 1.880114108324050792e-01
+4.300000000000000000e+01 1.938056230545043834e-01
+4.400000000000000000e+01 1.713560804724693354e-01
+4.500000000000000000e+01 1.633046224713325389e-01
+4.600000000000000000e+01 1.850738257169723400e-01
+4.700000000000000000e+01 1.752641960978507940e-01
+4.800000000000000000e+01 1.752187252044677679e-01
+4.900000000000000000e+01 1.773821949958801214e-01
+5.000000000000000000e+01 1.690604001283645685e-01
+5.100000000000000000e+01 1.769385010004043690e-01
+5.200000000000000000e+01 1.649790585041046032e-01
+5.300000000000000000e+01 1.689535513520240839e-01
+5.400000000000000000e+01 1.614030286669731196e-01
+5.500000000000000000e+01 1.654360249638557323e-01
+5.600000000000000000e+01 1.637925118207931574e-01
+5.700000000000000000e+01 1.591141849756240734e-01
+5.800000000000000000e+01 1.615763455629348755e-01
+5.900000000000000000e+01 1.589841812849044911e-01
+6.000000000000000000e+01 1.529493838548660334e-01
+6.100000000000000000e+01 1.629365801811218373e-01
+6.200000000000000000e+01 1.529535248875618092e-01
+6.300000000000000000e+01 1.433281436562538202e-01
+6.400000000000000000e+01 1.461468547582626398e-01
+6.500000000000000000e+01 1.441940695047378429e-01
+6.600000000000000000e+01 1.612766250967979376e-01
+6.700000000000000000e+01 1.452899366617202703e-01
+6.800000000000000000e+01 1.482794821262359564e-01
+6.900000000000000000e+01 1.440321028232574574e-01
+7.000000000000000000e+01 1.642172396183013972e-01
+7.100000000000000000e+01 1.393341615796089283e-01
+7.200000000000000000e+01 1.509022817015647777e-01
+7.300000000000000000e+01 1.408919513225555531e-01
+7.400000000000000000e+01 1.379217818379402105e-01
+7.500000000000000000e+01 1.428895592689514160e-01
+7.600000000000000000e+01 1.432754531502723749e-01
+7.700000000000000000e+01 1.401198387145995983e-01
+7.800000000000000000e+01 1.369169071316719000e-01
+7.900000000000000000e+01 1.263125658035278431e-01
+8.000000000000000000e+01 1.471106737852096447e-01
+8.100000000000000000e+01 1.456460162997245678e-01
+8.200000000000000000e+01 1.409068360924720653e-01
+8.300000000000000000e+01 1.299625962972640880e-01
+8.400000000000000000e+01 1.286012873053550831e-01
+8.500000000000000000e+01 1.319817781448364147e-01
+8.600000000000000000e+01 1.319406539201736506e-01
+8.700000000000000000e+01 1.317121580243110768e-01
+8.800000000000000000e+01 1.380098029971122686e-01
+8.900000000000000000e+01 1.200489461421966608e-01
+9.000000000000000000e+01 1.301555976271629445e-01
+9.100000000000000000e+01 1.210053414106369019e-01
+9.200000000000000000e+01 1.437995210289955139e-01
+9.300000000000000000e+01 1.279117614030838013e-01
+9.400000000000000000e+01 1.311841651797294728e-01
+9.500000000000000000e+01 1.248174116015434293e-01
+9.600000000000000000e+01 1.231958493590354919e-01
+9.700000000000000000e+01 1.236210078001022394e-01
+9.800000000000000000e+01 1.223133817315101568e-01
+9.900000000000000000e+01 1.261768355965614263e-01
+1.000000000000000000e+02 1.200880080461502047e-01
+1.010000000000000000e+02 1.136251106858253423e-01
+1.020000000000000000e+02 1.246556535363197299e-01
+1.030000000000000000e+02 1.171860009431839045e-01
+1.040000000000000000e+02 1.222651720046997043e-01
+1.050000000000000000e+02 1.313052698969841003e-01
+1.060000000000000000e+02 1.185701236128807040e-01
+1.070000000000000000e+02 1.071438625454902704e-01
+1.080000000000000000e+02 1.211932659149169977e-01
+1.090000000000000000e+02 1.245229557156562750e-01
+1.100000000000000000e+02 1.179555296897888128e-01
+1.110000000000000000e+02 1.208368360996246310e-01
+1.120000000000000000e+02 1.135055571794509888e-01
+1.130000000000000000e+02 1.190253823995590238e-01
+1.140000000000000000e+02 1.186841472983360263e-01
+1.150000000000000000e+02 1.164834693074226352e-01
+1.160000000000000000e+02 1.146582379937171881e-01
+1.170000000000000000e+02 1.105820655822753878e-01
+1.180000000000000000e+02 1.155817240476608304e-01
+1.190000000000000000e+02 1.081655591726303073e-01
+1.200000000000000000e+02 1.141833648085594233e-01
+1.210000000000000000e+02 1.167039632797241266e-01
+1.220000000000000000e+02 1.074711605906486511e-01
+1.230000000000000000e+02 1.112695679068565341e-01
+1.240000000000000000e+02 1.128994792699813815e-01
+1.250000000000000000e+02 1.113000258803367587e-01
+1.260000000000000000e+02 1.078018143773078891e-01
+1.270000000000000000e+02 1.133237540721893366e-01
+1.280000000000000000e+02 1.072465956211090116e-01
+1.290000000000000000e+02 9.828051179647445679e-02
+1.300000000000000000e+02 1.064729228615760859e-01
+1.310000000000000000e+02 1.107094034552574130e-01
+1.320000000000000000e+02 1.105445966124534579e-01
+1.330000000000000000e+02 1.167655438184738159e-01
+1.340000000000000000e+02 1.096195027232170077e-01
+1.350000000000000000e+02 1.055271387100219782e-01
+1.360000000000000000e+02 1.070695728063583430e-01
+1.370000000000000000e+02 1.155413240194320679e-01
+1.380000000000000000e+02 1.030856594443321228e-01
+1.390000000000000000e+02 1.036047086119651767e-01
+1.400000000000000000e+02 1.098298564553260859e-01
+1.410000000000000000e+02 1.069389253854751559e-01
+1.420000000000000000e+02 1.012663558125495855e-01
+1.430000000000000000e+02 1.033536165952682467e-01
+1.440000000000000000e+02 9.961889088153838556e-02
+1.450000000000000000e+02 1.054751142859458868e-01
+1.460000000000000000e+02 9.932236373424530029e-02
+1.470000000000000000e+02 1.011745497584342901e-01
+1.480000000000000000e+02 1.033044055104255649e-01
+1.490000000000000000e+02 1.022559776902198792e-01

deepatlas_results/Task002_rnmw153_sim_Zsc/training_results/RegNet/reg_net_best.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8cc749e4e671c0952e9c02aa07070ae002ff4513eb1cfe40699333010553fdc4
+size 980151

deepatlas_results/Task002_rnmw153_sim_Zsc/training_results/RegNet/regularization_loss.txt

@@ -0,0 +1,150 @@
+0.000000000000000000e+00 9.647657734375000291e+04
+1.000000000000000000e+00 5.600248164062500291e+04
+2.000000000000000000e+00 4.622505507812499854e+04
+3.000000000000000000e+00 4.267595859375000146e+04
+4.000000000000000000e+00 4.140668750000000000e+04
+5.000000000000000000e+00 4.083900624999999854e+04
+6.000000000000000000e+00 4.204608710937500291e+04
+7.000000000000000000e+00 4.270976679687500291e+04
+8.000000000000000000e+00 4.361334960937500000e+04
+9.000000000000000000e+00 4.175023124999999709e+04
+1.000000000000000000e+01 4.343883320312500291e+04
+1.100000000000000000e+01 4.333560429687499709e+04
+1.200000000000000000e+01 4.219379726562499854e+04
+1.300000000000000000e+01 4.281041914062500291e+04
+1.400000000000000000e+01 4.174859609374999854e+04
+1.500000000000000000e+01 4.179512265625000146e+04
+1.600000000000000000e+01 4.092214960937500291e+04
+1.700000000000000000e+01 3.970900468749999709e+04
+1.800000000000000000e+01 3.924284062499999709e+04
+1.900000000000000000e+01 3.987322109374999854e+04
+2.000000000000000000e+01 4.095302929687500000e+04
+2.100000000000000000e+01 4.022246718749999854e+04
+2.200000000000000000e+01 3.631811601562499709e+04
+2.300000000000000000e+01 3.764023359375000291e+04
+2.400000000000000000e+01 3.785904765624999709e+04
+2.500000000000000000e+01 3.709597187500000291e+04
+2.600000000000000000e+01 3.850280976562500291e+04
+2.700000000000000000e+01 3.662425742187500146e+04
+2.800000000000000000e+01 3.526093242187499709e+04
+2.900000000000000000e+01 3.509209101562500291e+04
+3.000000000000000000e+01 3.490247851562500000e+04
+3.100000000000000000e+01 3.441726445312499709e+04
+3.200000000000000000e+01 3.833977851562500291e+04
+3.300000000000000000e+01 3.641356210937500146e+04
+3.400000000000000000e+01 3.424167519531249854e+04
+3.500000000000000000e+01 3.409850781250000000e+04
+3.600000000000000000e+01 3.476144804687499709e+04
+3.700000000000000000e+01 3.356663320312499854e+04
+3.800000000000000000e+01 3.360199863281250146e+04
+3.900000000000000000e+01 3.168097812500000146e+04
+4.000000000000000000e+01 3.086164238281250073e+04
+4.100000000000000000e+01 3.135119082031249854e+04
+4.200000000000000000e+01 3.230545429687499927e+04
+4.300000000000000000e+01 3.258044433593750000e+04
+4.400000000000000000e+01 2.970054238281249854e+04
+4.500000000000000000e+01 2.943311367187499854e+04
+4.600000000000000000e+01 3.069561796875000073e+04
+4.700000000000000000e+01 3.084135527343750073e+04
+4.800000000000000000e+01 3.094149082031250146e+04
+4.900000000000000000e+01 2.917231191406249854e+04
+5.000000000000000000e+01 3.135592246093750146e+04
+5.100000000000000000e+01 3.039203046874999927e+04
+5.200000000000000000e+01 3.012575664062500073e+04
+5.300000000000000000e+01 2.929403671875000146e+04
+5.400000000000000000e+01 3.106284863281250000e+04
+5.500000000000000000e+01 2.953302207031250146e+04
+5.600000000000000000e+01 2.830232207031250073e+04
+5.700000000000000000e+01 2.767354257812500146e+04
+5.800000000000000000e+01 2.854511542968749927e+04
+5.900000000000000000e+01 2.938652421875000073e+04
+6.000000000000000000e+01 2.757793476562499927e+04
+6.100000000000000000e+01 2.856210996093750146e+04
+6.200000000000000000e+01 2.805230800781249854e+04
+6.300000000000000000e+01 2.844989472656249927e+04
+6.400000000000000000e+01 2.834025332031249854e+04
+6.500000000000000000e+01 2.716633906249999927e+04
+6.600000000000000000e+01 2.722970449218749854e+04
+6.700000000000000000e+01 2.794483691406250000e+04
+6.800000000000000000e+01 2.762657714843750000e+04
+6.900000000000000000e+01 2.724710195312499854e+04
+7.000000000000000000e+01 2.686259179687500000e+04
+7.100000000000000000e+01 2.665010078124999927e+04
+7.200000000000000000e+01 2.729690820312500000e+04
+7.300000000000000000e+01 2.626355722656250146e+04
+7.400000000000000000e+01 2.985540253906249927e+04
+7.500000000000000000e+01 2.803707324218750000e+04
+7.600000000000000000e+01 2.577971601562499927e+04
+7.700000000000000000e+01 2.677021953125000073e+04
+7.800000000000000000e+01 2.589360351562500000e+04
+7.900000000000000000e+01 2.609319492187500146e+04
+8.000000000000000000e+01 2.626737285156250073e+04
+8.100000000000000000e+01 2.685944707031250073e+04
+8.200000000000000000e+01 2.635484394531249927e+04
+8.300000000000000000e+01 2.569543984374999854e+04
+8.400000000000000000e+01 2.600875253906250146e+04
+8.500000000000000000e+01 2.468057636718749927e+04
+8.600000000000000000e+01 2.744214921875000073e+04
+8.700000000000000000e+01 2.801404296875000000e+04
+8.800000000000000000e+01 2.714639218750000146e+04
+8.900000000000000000e+01 2.564207910156250000e+04
+9.000000000000000000e+01 2.602158124999999927e+04
+9.100000000000000000e+01 2.704508945312500146e+04
+9.200000000000000000e+01 2.489874941406249854e+04
+9.300000000000000000e+01 2.557005625000000146e+04
+9.400000000000000000e+01 2.650752558593749927e+04
+9.500000000000000000e+01 2.507230214843749854e+04
+9.600000000000000000e+01 2.503884765625000000e+04
+9.700000000000000000e+01 2.575267187500000000e+04
+9.800000000000000000e+01 2.467629902343749927e+04
+9.900000000000000000e+01 2.569107050781249927e+04
+1.000000000000000000e+02 2.621700605468749927e+04
+1.010000000000000000e+02 2.429901914062500146e+04
+1.020000000000000000e+02 2.468174355468749854e+04
+1.030000000000000000e+02 2.494141835937499854e+04
+1.040000000000000000e+02 2.521128085937500146e+04
+1.050000000000000000e+02 2.498605429687500146e+04
+1.060000000000000000e+02 2.586065898437500073e+04
+1.070000000000000000e+02 2.588916445312499854e+04
+1.080000000000000000e+02 2.418775214843749927e+04
+1.090000000000000000e+02 2.435215859374999854e+04
+1.100000000000000000e+02 2.436132246093749927e+04
+1.110000000000000000e+02 2.536200878906250000e+04
+1.120000000000000000e+02 2.559010410156250146e+04
+1.130000000000000000e+02 2.506657070312499854e+04
+1.140000000000000000e+02 2.503773847656249927e+04
+1.150000000000000000e+02 2.437319042968750000e+04
+1.160000000000000000e+02 2.431990234375000000e+04
+1.170000000000000000e+02 2.550118984374999854e+04
+1.180000000000000000e+02 2.292500937500000146e+04
+1.190000000000000000e+02 2.438267910156249854e+04
+1.200000000000000000e+02 2.415241660156250146e+04
+1.210000000000000000e+02 2.505895195312500073e+04
+1.220000000000000000e+02 2.397140292968750146e+04
+1.230000000000000000e+02 2.385521972656250000e+04
+1.240000000000000000e+02 2.429430468750000000e+04
+1.250000000000000000e+02 2.560967167968750073e+04
+1.260000000000000000e+02 2.449504160156250146e+04
+1.270000000000000000e+02 2.443714902343750146e+04
+1.280000000000000000e+02 2.286358164062500146e+04
+1.290000000000000000e+02 2.320438867187500000e+04
+1.300000000000000000e+02 2.252850078125000073e+04
+1.310000000000000000e+02 2.351528867187500146e+04
+1.320000000000000000e+02 2.366736621093750000e+04
+1.330000000000000000e+02 2.437287714843749927e+04
+1.340000000000000000e+02 2.427623671874999854e+04
+1.350000000000000000e+02 2.388841269531250146e+04
+1.360000000000000000e+02 2.342027714843750073e+04
+1.370000000000000000e+02 2.348164023437500146e+04
+1.380000000000000000e+02 2.264112851562500146e+04
+1.390000000000000000e+02 2.282989589843749854e+04
+1.400000000000000000e+02 2.346099238281249927e+04
+1.410000000000000000e+02 2.252648867187499854e+04
+1.420000000000000000e+02 2.377134687499999927e+04
+1.430000000000000000e+02 2.372876152343750073e+04
+1.440000000000000000e+02 2.412109472656250000e+04
+1.450000000000000000e+02 2.291069023437500073e+04
+1.460000000000000000e+02 2.278465429687500000e+04
+1.470000000000000000e+02 2.236802773437499854e+04
+1.480000000000000000e+02 2.275189082031249927e+04
+1.490000000000000000e+02 2.340973125000000073e+04

deepatlas_results/Task002_rnmw153_sim_Zsc/training_results/RegNet/similarity_loss_reg.txt

@@ -0,0 +1,150 @@
+0.000000000000000000e+00 -4.168474763631820901e-01
+1.000000000000000000e+00 -4.263603955507278553e-01
+2.000000000000000000e+00 -4.308078646659850852e-01
+3.000000000000000000e+00 -4.473009109497070312e-01
+4.000000000000000000e+00 -4.597851067781448253e-01
+5.000000000000000000e+00 -4.279521614313125388e-01
+6.000000000000000000e+00 -4.499931335449218750e-01
+7.000000000000000000e+00 -4.442608237266540416e-01
+8.000000000000000000e+00 -4.535590052604675515e-01
+9.000000000000000000e+00 -4.448471128940582053e-01
+1.000000000000000000e+01 -4.357178181409835926e-01
+1.100000000000000000e+01 -4.437347769737243763e-01
+1.200000000000000000e+01 -4.458012044429778831e-01
+1.300000000000000000e+01 -4.529227972030639426e-01
+1.400000000000000000e+01 -4.295926243066787720e-01
+1.500000000000000000e+01 -4.595782548189163430e-01
+1.600000000000000000e+01 -4.517234951257705911e-01
+1.700000000000000000e+01 -4.423192799091338889e-01
+1.800000000000000000e+01 -4.439570069313049094e-01
+1.900000000000000000e+01 -4.530792713165283092e-01
+2.000000000000000000e+01 -4.530134618282318226e-01
+2.100000000000000000e+01 -4.569927573204040638e-01
+2.200000000000000000e+01 -4.498479574918746726e-01
+2.300000000000000000e+01 -4.429930806159972922e-01
+2.400000000000000000e+01 -4.545052170753479115e-01
+2.500000000000000000e+01 -4.589251607656478771e-01
+2.600000000000000000e+01 -4.480702817440033181e-01
+2.700000000000000000e+01 -4.614715576171875000e-01
+2.800000000000000000e+01 -4.644932091236114724e-01
+2.900000000000000000e+01 -4.536971420049667469e-01
+3.000000000000000000e+01 -4.618920236825942993e-01
+3.100000000000000000e+01 -4.454625546932220459e-01
+3.200000000000000000e+01 -4.432837992906570324e-01
+3.300000000000000000e+01 -4.556560337543487660e-01
+3.400000000000000000e+01 -4.563916087150573508e-01
+3.500000000000000000e+01 -4.624453812837600597e-01
+3.600000000000000000e+01 -4.610332757234573142e-01
+3.700000000000000000e+01 -4.534836649894714578e-01
+3.800000000000000000e+01 -4.493382364511490090e-01
+3.900000000000000000e+01 -4.612041652202606423e-01
+4.000000000000000000e+01 -4.481392472982406727e-01
+4.100000000000000000e+01 -4.574688106775283702e-01
+4.200000000000000000e+01 -4.585757911205291526e-01
+4.300000000000000000e+01 -4.591083139181136863e-01
+4.400000000000000000e+01 -4.620190680027008168e-01
+4.500000000000000000e+01 -4.439658433198928611e-01
+4.600000000000000000e+01 -4.682959735393524281e-01
+4.700000000000000000e+01 -4.619445204734802246e-01
+4.800000000000000000e+01 -4.570848613977432362e-01
+4.900000000000000000e+01 -4.644496768712997326e-01
+5.000000000000000000e+01 -4.555140912532806285e-01
+5.100000000000000000e+01 -4.544000834226608054e-01
+5.200000000000000000e+01 -4.539999753236770852e-01
+5.300000000000000000e+01 -4.513368487358093151e-01
+5.400000000000000000e+01 -4.691209405660629050e-01
+5.500000000000000000e+01 -4.700714707374572532e-01
+5.600000000000000000e+01 -4.616314649581909069e-01
+5.700000000000000000e+01 -4.689020931720733754e-01
+5.800000000000000000e+01 -4.532034665346145741e-01
+5.900000000000000000e+01 -4.531166106462478638e-01
+6.000000000000000000e+01 -4.678452193737029918e-01
+6.100000000000000000e+01 -4.622920960187911765e-01
+6.200000000000000000e+01 -4.603021264076233021e-01
+6.300000000000000000e+01 -4.684280097484588845e-01
+6.400000000000000000e+01 -4.558636069297790638e-01
+6.500000000000000000e+01 -4.540676534175872581e-01
+6.600000000000000000e+01 -4.655692547559738270e-01
+6.700000000000000000e+01 -4.540375351905822643e-01
+6.800000000000000000e+01 -4.677469283342361450e-01
+6.900000000000000000e+01 -4.726172119379043468e-01
+7.000000000000000000e+01 -4.646616935729980247e-01
+7.100000000000000000e+01 -4.598768830299377330e-01
+7.200000000000000000e+01 -4.578260272741317971e-01
+7.300000000000000000e+01 -4.739276260137558205e-01
+7.400000000000000000e+01 -4.653645187616348156e-01
+7.500000000000000000e+01 -4.734996885061263927e-01
+7.600000000000000000e+01 -4.475734978914260864e-01
+7.700000000000000000e+01 -4.597442090511322244e-01
+7.800000000000000000e+01 -4.581354439258575328e-01
+7.900000000000000000e+01 -4.675897061824798584e-01
+8.000000000000000000e+01 -4.581032097339630127e-01
+8.100000000000000000e+01 -4.732825607061386108e-01
+8.200000000000000000e+01 -4.634899914264679066e-01
+8.300000000000000000e+01 -4.642924636602401844e-01
+8.400000000000000000e+01 -4.618958413600921520e-01
+8.500000000000000000e+01 -4.642670065164565818e-01
+8.600000000000000000e+01 -4.682172983884811401e-01
+8.700000000000000000e+01 -4.585850000381469505e-01
+8.800000000000000000e+01 -4.672844409942626953e-01
+8.900000000000000000e+01 -4.735285311937332264e-01
+9.000000000000000000e+01 -4.580027431249618641e-01
+9.100000000000000000e+01 -4.744705915451049583e-01
+9.200000000000000000e+01 -4.685657173395156860e-01
+9.300000000000000000e+01 -4.644354701042175404e-01
+9.400000000000000000e+01 -4.517805755138397106e-01
+9.500000000000000000e+01 -4.675363123416900746e-01
+9.600000000000000000e+01 -4.589057117700576782e-01
+9.700000000000000000e+01 -4.702290564775467030e-01
+9.800000000000000000e+01 -4.703976273536681907e-01
+9.900000000000000000e+01 -4.785565227270126565e-01
+1.000000000000000000e+02 -4.528923690319061057e-01
+1.010000000000000000e+02 -4.802600026130676159e-01
+1.020000000000000000e+02 -4.595269829034805409e-01
+1.030000000000000000e+02 -4.649816811084747092e-01
+1.040000000000000000e+02 -4.689352661371231079e-01
+1.050000000000000000e+02 -4.574464380741119496e-01
+1.060000000000000000e+02 -4.783898264169693104e-01
+1.070000000000000000e+02 -4.619613021612167247e-01
+1.080000000000000000e+02 -4.732825309038162231e-01
+1.090000000000000000e+02 -4.757978379726409690e-01
+1.100000000000000000e+02 -4.625800907611846702e-01
+1.110000000000000000e+02 -4.597027510404586570e-01
+1.120000000000000000e+02 -4.668075680732727273e-01
+1.130000000000000000e+02 -4.745635837316513062e-01
+1.140000000000000000e+02 -4.598248332738876232e-01
+1.150000000000000000e+02 -4.670720726251602062e-01
+1.160000000000000000e+02 -4.626205563545227051e-01
+1.170000000000000000e+02 -4.646981835365295299e-01
+1.180000000000000000e+02 -4.784785419702529685e-01
+1.190000000000000000e+02 -4.665146172046661377e-01
+1.200000000000000000e+02 -4.636369466781616322e-01
+1.210000000000000000e+02 -4.779191941022872814e-01
+1.220000000000000000e+02 -4.682897418737411721e-01
+1.230000000000000000e+02 -4.683959364891052135e-01
+1.240000000000000000e+02 -4.700077801942825206e-01
+1.250000000000000000e+02 -4.585238367319107167e-01
+1.260000000000000000e+02 -4.785058617591858021e-01
+1.270000000000000000e+02 -4.674418091773986927e-01
+1.280000000000000000e+02 -4.701861381530761941e-01
+1.290000000000000000e+02 -4.776402652263641579e-01
+1.300000000000000000e+02 -4.825747549533844216e-01
+1.310000000000000000e+02 -4.672817528247833474e-01
+1.320000000000000000e+02 -4.682697743177414162e-01
+1.330000000000000000e+02 -4.557759791612625011e-01
+1.340000000000000000e+02 -4.726522713899612427e-01
+1.350000000000000000e+02 -4.733480244874954113e-01
+1.360000000000000000e+02 -4.721144646406173484e-01
+1.370000000000000000e+02 -4.663318544626235962e-01
+1.380000000000000000e+02 -4.689928203821182029e-01
+1.390000000000000000e+02 -4.694450110197067039e-01
+1.400000000000000000e+02 -4.788974851369857677e-01
+1.410000000000000000e+02 -4.824941486120223888e-01
+1.420000000000000000e+02 -4.659789711236953513e-01
+1.430000000000000000e+02 -4.698489278554916493e-01
+1.440000000000000000e+02 -4.578673005104064719e-01
+1.450000000000000000e+02 -4.711187154054641835e-01
+1.460000000000000000e+02 -4.698738873004913441e-01
+1.470000000000000000e+02 -4.764148712158203236e-01
+1.480000000000000000e+02 -4.688631236553192361e-01
+1.490000000000000000e+02 -4.754804491996765248e-01

deepatlas_results/Task002_rnmw153_sim_Zsc/training_results/SegNet/anatomy_loss_seg.txt

@@ -0,0 +1,150 @@
+0.000000000000000000e+00 3.573212802410125621e-01
+1.000000000000000000e+00 3.016310274600982888e-01
+2.000000000000000000e+00 3.048958837985992210e-01
+3.000000000000000000e+00 2.943183720111847146e-01
+4.000000000000000000e+00 2.476005643606185858e-01
+5.000000000000000000e+00 2.876864552497863659e-01
+6.000000000000000000e+00 2.401628106832504328e-01
+7.000000000000000000e+00 2.676642984151840210e-01
+8.000000000000000000e+00 3.030611872673034668e-01
+9.000000000000000000e+00 2.673193246126174816e-01
+1.000000000000000000e+01 2.679113417863845936e-01
+1.100000000000000000e+01 2.307161211967468373e-01
+1.200000000000000000e+01 2.748242348432540783e-01
+1.300000000000000000e+01 2.454477936029434149e-01
+1.400000000000000000e+01 2.550766199827194103e-01
+1.500000000000000000e+01 2.454825192689895630e-01
+1.600000000000000000e+01 2.595056265592575184e-01
+1.700000000000000000e+01 2.408376395702362116e-01
+1.800000000000000000e+01 2.127094238996505848e-01
+1.900000000000000000e+01 2.307042092084884699e-01
+2.000000000000000000e+01 2.654647767543792947e-01
+2.100000000000000000e+01 2.419243335723876842e-01
+2.200000000000000000e+01 1.945116668939590454e-01
+2.300000000000000000e+01 2.601417511701583640e-01
+2.400000000000000000e+01 2.282205909490585272e-01
+2.500000000000000000e+01 1.868903011083603016e-01
+2.600000000000000000e+01 2.246729880571365356e-01
+2.700000000000000000e+01 1.985089689493179377e-01
+2.800000000000000000e+01 2.106462895870208629e-01
+2.900000000000000000e+01 1.747411251068115290e-01
+3.000000000000000000e+01 2.289323359727859497e-01
+3.100000000000000000e+01 1.958036184310913141e-01
+3.200000000000000000e+01 2.018931955099105835e-01
+3.300000000000000000e+01 2.011176228523254284e-01
+3.400000000000000000e+01 1.889271199703216608e-01
+3.500000000000000000e+01 1.674630045890808105e-01
+3.600000000000000000e+01 1.861122012138366755e-01
+3.700000000000000000e+01 1.871975004673004095e-01
+3.800000000000000000e+01 1.833468735218048151e-01
+3.900000000000000000e+01 1.996963977813720759e-01
+4.000000000000000000e+01 1.846072256565093883e-01
+4.100000000000000000e+01 1.742737770080566295e-01
+4.200000000000000000e+01 2.073888182640075684e-01
+4.300000000000000000e+01 1.943298697471618763e-01
+4.400000000000000000e+01 1.664489269256591852e-01
+4.500000000000000000e+01 1.703320384025573675e-01
+4.600000000000000000e+01 1.856246024370193370e-01
+4.700000000000000000e+01 1.825020164251327515e-01
+4.800000000000000000e+01 1.809851735830307062e-01
+4.900000000000000000e+01 1.618491530418396107e-01
+5.000000000000000000e+01 1.872929453849792591e-01
+5.100000000000000000e+01 1.632001817226410023e-01
+5.200000000000000000e+01 1.654672086238861139e-01
+5.300000000000000000e+01 1.620430082082748302e-01
+5.400000000000000000e+01 1.371830523014068715e-01
+5.500000000000000000e+01 1.343375712633133046e-01
+5.600000000000000000e+01 1.760016560554504284e-01
+5.700000000000000000e+01 1.373514264822006115e-01
+5.800000000000000000e+01 1.455889701843261774e-01
+5.900000000000000000e+01 1.405129104852676503e-01
+6.000000000000000000e+01 1.435708492994308416e-01
+6.100000000000000000e+01 1.453709840774536077e-01
+6.200000000000000000e+01 1.409398466348648071e-01
+6.300000000000000000e+01 1.430866688489914051e-01
+6.400000000000000000e+01 1.614443391561508068e-01
+6.500000000000000000e+01 1.450980633497238048e-01
+6.600000000000000000e+01 1.543001860380172618e-01
+6.700000000000000000e+01 1.640612185001373291e-01
+6.800000000000000000e+01 1.423606038093566950e-01
+6.900000000000000000e+01 1.569118171930313221e-01
+7.000000000000000000e+01 1.287293732166290283e-01
+7.100000000000000000e+01 1.371597200632095337e-01
+7.200000000000000000e+01 1.361799329519271795e-01
+7.300000000000000000e+01 1.242990702390670832e-01
+7.400000000000000000e+01 1.306319057941436879e-01
+7.500000000000000000e+01 1.288085937500000056e-01
+7.600000000000000000e+01 1.403280854225158747e-01
+7.700000000000000000e+01 1.227280646562576294e-01
+7.800000000000000000e+01 1.201626896858215277e-01
+7.900000000000000000e+01 1.346704751253127996e-01
+8.000000000000000000e+01 1.323057174682617243e-01
+8.100000000000000000e+01 1.253492325544357244e-01
+8.200000000000000000e+01 1.406400591135024969e-01
+8.300000000000000000e+01 1.207172423601150513e-01
+8.400000000000000000e+01 1.101396143436431940e-01
+8.500000000000000000e+01 1.376777350902557429e-01
+8.600000000000000000e+01 1.213785856962203979e-01
+8.700000000000000000e+01 1.210385411977767944e-01
+8.800000000000000000e+01 1.205412358045578058e-01
+8.900000000000000000e+01 1.240068972110748291e-01
+9.000000000000000000e+01 1.313861519098281916e-01
+9.100000000000000000e+01 1.162600874900817927e-01
+9.200000000000000000e+01 1.444916546344757191e-01
+9.300000000000000000e+01 1.275196611881256048e-01
+9.400000000000000000e+01 1.161691457033157404e-01
+9.500000000000000000e+01 1.160799205303192083e-01
+9.600000000000000000e+01 1.090261936187744141e-01
+9.700000000000000000e+01 1.152943998575210599e-01
+9.800000000000000000e+01 1.182651966810226440e-01
+9.900000000000000000e+01 1.337907671928405817e-01
+1.000000000000000000e+02 1.144938826560974177e-01
+1.010000000000000000e+02 1.012444019317626925e-01
+1.020000000000000000e+02 1.067855119705200251e-01
+1.030000000000000000e+02 1.236552417278289767e-01
+1.040000000000000000e+02 1.269590228796005360e-01
+1.050000000000000000e+02 1.210491657257080078e-01
+1.060000000000000000e+02 1.159689813852310125e-01
+1.070000000000000000e+02 1.056069612503051786e-01
+1.080000000000000000e+02 1.093798547983169528e-01
+1.090000000000000000e+02 1.066102117300033597e-01
+1.100000000000000000e+02 1.021177589893341037e-01
+1.110000000000000000e+02 1.069174706935882568e-01
+1.120000000000000000e+02 1.110250294208526556e-01
+1.130000000000000000e+02 9.386113286018371582e-02
+1.140000000000000000e+02 1.091269701719284058e-01
+1.150000000000000000e+02 1.106141597032546942e-01
+1.160000000000000000e+02 1.080716401338577271e-01
+1.170000000000000000e+02 1.028281450271606445e-01
+1.180000000000000000e+02 1.077720254659652738e-01
+1.190000000000000000e+02 1.014000862836837713e-01
+1.200000000000000000e+02 9.986269772052765170e-02
+1.210000000000000000e+02 1.082169353961944525e-01
+1.220000000000000000e+02 1.062078773975372314e-01
+1.230000000000000000e+02 9.392457008361816684e-02
+1.240000000000000000e+02 9.641477167606353482e-02
+1.250000000000000000e+02 9.422739148139953891e-02
+1.260000000000000000e+02 1.075347006320953314e-01
+1.270000000000000000e+02 1.135191649198532132e-01
+1.280000000000000000e+02 1.168108433485031128e-01
+1.290000000000000000e+02 9.352702796459197443e-02
+1.300000000000000000e+02 9.605710506439209262e-02
+1.310000000000000000e+02 1.090006858110427884e-01
+1.320000000000000000e+02 9.683288931846618930e-02
+1.330000000000000000e+02 9.844864010810852606e-02
+1.340000000000000000e+02 1.054120570421218928e-01
+1.350000000000000000e+02 9.830847680568695346e-02
+1.360000000000000000e+02 1.000306367874145563e-01
+1.370000000000000000e+02 9.272636771202087680e-02
+1.380000000000000000e+02 1.006171077489852878e-01
+1.390000000000000000e+02 1.118859261274337824e-01
+1.400000000000000000e+02 1.046191841363906805e-01
+1.410000000000000000e+02 8.171942234039306086e-02
+1.420000000000000000e+02 1.026437968015670721e-01
+1.430000000000000000e+02 9.383668601512909491e-02
+1.440000000000000000e+02 9.504491984844207209e-02
+1.450000000000000000e+02 9.691132009029387873e-02
+1.460000000000000000e+02 8.896677196025848389e-02
+1.470000000000000000e+02 9.473379850387572687e-02
+1.480000000000000000e+02 1.006733357906341580e-01
+1.490000000000000000e+02 9.622145295143127997e-02

deepatlas_results/Task002_rnmw153_sim_Zsc/training_results/SegNet/seg_net_best.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e382064530f8590b4127db57db6ee98b4b79040a590525f63d95fa460d690262
+size 1776995

deepatlas_results/Task002_rnmw153_sim_Zsc/training_results/SegNet/supervised_loss_seg.txt

@@ -0,0 +1,150 @@
+0.000000000000000000e+00 1.733888983726501465e+00
+1.000000000000000000e+00 1.593058300018310502e+00
+2.000000000000000000e+00 1.494779181480407670e+00
+3.000000000000000000e+00 1.429337716102600186e+00
+4.000000000000000000e+00 1.373311591148376420e+00
+5.000000000000000000e+00 1.280220198631286666e+00
+6.000000000000000000e+00 1.216743969917297274e+00
+7.000000000000000000e+00 1.151879334449767978e+00
+8.000000000000000000e+00 1.086084175109863326e+00
+9.000000000000000000e+00 1.050439834594726562e+00
+1.000000000000000000e+01 9.904136300086975320e-01
+1.100000000000000000e+01 9.567036032676696777e-01
+1.200000000000000000e+01 8.834496736526489258e-01
+1.300000000000000000e+01 7.900542855262756570e-01
+1.400000000000000000e+01 7.233480453491211160e-01
+1.500000000000000000e+01 6.199273467063903809e-01
+1.600000000000000000e+01 5.056837856769561546e-01
+1.700000000000000000e+01 4.857193410396575817e-01
+1.800000000000000000e+01 4.253516137599945290e-01
+1.900000000000000000e+01 4.271430134773254172e-01
+2.000000000000000000e+01 3.491494953632354736e-01
+2.100000000000000000e+01 3.284499764442443959e-01
+2.200000000000000000e+01 3.067165911197662354e-01
+2.300000000000000000e+01 2.683328092098236084e-01
+2.400000000000000000e+01 2.582681179046630859e-01
+2.500000000000000000e+01 2.431777745485305675e-01
+2.600000000000000000e+01 2.249853909015655518e-01
+2.700000000000000000e+01 2.175073951482772716e-01
+2.800000000000000000e+01 1.966677635908126720e-01
+2.900000000000000000e+01 1.976582705974578857e-01
+3.000000000000000000e+01 1.807560890913009755e-01
+3.100000000000000000e+01 1.774290740489959661e-01
+3.200000000000000000e+01 1.617186486721038929e-01
+3.300000000000000000e+01 1.491658687591552734e-01
+3.400000000000000000e+01 1.535357415676116832e-01
+3.500000000000000000e+01 1.475964188575744629e-01
+3.600000000000000000e+01 1.511343628168106135e-01
+3.700000000000000000e+01 1.474127322435379028e-01
+3.800000000000000000e+01 1.469620764255523682e-01
+3.900000000000000000e+01 1.410338491201400812e-01
+4.000000000000000000e+01 1.299730122089385875e-01
+4.100000000000000000e+01 1.394026368856429998e-01
+4.200000000000000000e+01 1.289871841669082697e-01
+4.300000000000000000e+01 1.210025578737258939e-01
+4.400000000000000000e+01 1.204812556505203275e-01
+4.500000000000000000e+01 1.196763992309570340e-01
+4.600000000000000000e+01 1.261142402887344416e-01
+4.700000000000000000e+01 1.218511372804641779e-01
+4.800000000000000000e+01 1.194722831249237088e-01
+4.900000000000000000e+01 1.288411766290664673e-01
+5.000000000000000000e+01 1.119768887758254977e-01
+5.100000000000000000e+01 1.179918527603149442e-01
+5.200000000000000000e+01 1.148449391126632746e-01
+5.300000000000000000e+01 1.055811911821365329e-01
+5.400000000000000000e+01 1.184314042329788208e-01
+5.500000000000000000e+01 1.090945541858673040e-01
+5.600000000000000000e+01 1.205644398927688543e-01
+5.700000000000000000e+01 1.117961019277572687e-01
+5.800000000000000000e+01 1.032131254673004095e-01
+5.900000000000000000e+01 1.119620203971862793e-01
+6.000000000000000000e+01 1.121469020843505887e-01
+6.100000000000000000e+01 1.092023879289627103e-01
+6.200000000000000000e+01 9.816411733627319891e-02
+6.300000000000000000e+01 1.041563123464584323e-01
+6.400000000000000000e+01 9.367077052593231201e-02
+6.500000000000000000e+01 9.781143367290497104e-02
+6.600000000000000000e+01 1.039855718612670843e-01
+6.700000000000000000e+01 1.064048498868942205e-01
+6.800000000000000000e+01 9.728896617889404297e-02
+6.900000000000000000e+01 9.509651362895965576e-02
+7.000000000000000000e+01 1.091342180967330988e-01
+7.100000000000000000e+01 1.016811817884445135e-01
+7.200000000000000000e+01 9.881042540073395331e-02
+7.300000000000000000e+01 9.882293939590454379e-02
+7.400000000000000000e+01 9.637998342514038363e-02
+7.500000000000000000e+01 8.356971442699431818e-02
+7.600000000000000000e+01 9.902868270874023993e-02
+7.700000000000000000e+01 9.420894980430602472e-02
+7.800000000000000000e+01 9.882737100124358576e-02
+7.900000000000000000e+01 8.918197154998779019e-02
+8.000000000000000000e+01 9.358719289302826205e-02
+8.100000000000000000e+01 9.849358797073363980e-02
+8.200000000000000000e+01 9.094970524311066229e-02
+8.300000000000000000e+01 8.850618600845336359e-02
+8.400000000000000000e+01 9.836201965808868963e-02
+8.500000000000000000e+01 8.451730310916900912e-02
+8.600000000000000000e+01 9.442334473133087713e-02
+8.700000000000000000e+01 9.012276530265808661e-02
+8.800000000000000000e+01 9.159993231296539862e-02
+8.900000000000000000e+01 9.661512672901154120e-02
+9.000000000000000000e+01 8.947120308876037320e-02
+9.100000000000000000e+01 8.729224503040314276e-02
+9.200000000000000000e+01 8.756603598594665805e-02
+9.300000000000000000e+01 9.022055566310882568e-02
+9.400000000000000000e+01 8.931825757026672086e-02
+9.500000000000000000e+01 8.704317510128020685e-02
+9.600000000000000000e+01 7.626191675662993830e-02
+9.700000000000000000e+01 8.811458647251128873e-02
+9.800000000000000000e+01 8.427759408950805109e-02
+9.900000000000000000e+01 9.522518515586853027e-02
+1.000000000000000000e+02 8.465408682823180597e-02
+1.010000000000000000e+02 9.000419974327086847e-02
+1.020000000000000000e+02 8.839070796966552734e-02
+1.030000000000000000e+02 8.643541038036346713e-02
+1.040000000000000000e+02 8.619004189968108853e-02
+1.050000000000000000e+02 8.245641589164734442e-02
+1.060000000000000000e+02 8.474771082401275080e-02
+1.070000000000000000e+02 7.968198657035827082e-02
+1.080000000000000000e+02 8.239192962646484097e-02
+1.090000000000000000e+02 8.238035738468170444e-02
+1.100000000000000000e+02 7.307147681713103970e-02
+1.110000000000000000e+02 8.209990262985229770e-02
+1.120000000000000000e+02 8.047128319740295965e-02
+1.130000000000000000e+02 8.432724773883819303e-02
+1.140000000000000000e+02 8.143997788429260809e-02
+1.150000000000000000e+02 8.467923998832702082e-02
+1.160000000000000000e+02 8.954935073852539340e-02
+1.170000000000000000e+02 8.563154935836791992e-02
+1.180000000000000000e+02 8.093344271183014471e-02
+1.190000000000000000e+02 8.262177705764769953e-02
+1.200000000000000000e+02 7.641595602035522461e-02
+1.210000000000000000e+02 8.638529181480407437e-02
+1.220000000000000000e+02 7.834772765636444092e-02
+1.230000000000000000e+02 7.112940549850463312e-02
+1.240000000000000000e+02 7.886535525321961004e-02
+1.250000000000000000e+02 8.096686303615570346e-02
+1.260000000000000000e+02 8.270101547241211215e-02
+1.270000000000000000e+02 8.261188268661498468e-02
+1.280000000000000000e+02 7.751703858375549872e-02
+1.290000000000000000e+02 7.759350836277008334e-02
+1.300000000000000000e+02 7.186951637268065851e-02
+1.310000000000000000e+02 8.247119784355164129e-02
+1.320000000000000000e+02 8.166118562221527655e-02
+1.330000000000000000e+02 7.848928868770599365e-02
+1.340000000000000000e+02 7.621280252933501642e-02
+1.350000000000000000e+02 7.483861744403838556e-02
+1.360000000000000000e+02 7.931372225284576138e-02
+1.370000000000000000e+02 8.355411291122435968e-02
+1.380000000000000000e+02 8.021936714649199884e-02
+1.390000000000000000e+02 7.726681828498840887e-02
+1.400000000000000000e+02 7.638082504272461493e-02
+1.410000000000000000e+02 7.744624912738799771e-02
+1.420000000000000000e+02 8.268800675868988315e-02
+1.430000000000000000e+02 7.466401755809784491e-02
+1.440000000000000000e+02 7.775481343269348422e-02
+1.450000000000000000e+02 7.511828839778900146e-02
+1.460000000000000000e+02 7.727222442626953403e-02
+1.470000000000000000e+02 7.235211730003357489e-02
+1.480000000000000000e+02 6.813707947731018066e-02
+1.490000000000000000e+02 8.162583112716674527e-02

deepatlas_results/Task002_rnmw153_sim_Zsc/training_results/training_log.txt

@@ -0,0 +1,515 @@
+Deep Atlas Training Log
+Epoch 1/150:
+	reg training loss: 4.7686481952667235
+	reg validation loss: 10.761622428894043
+	seg training loss: 0.8673096179962159
+	seg validation loss: 0.8539321422576904
+Epoch 2/150:
+	reg training loss: 4.440142178535462
+	seg training loss: 0.7938556432723999
+Epoch 3/150:
+	reg training loss: 4.576620316505432
+	seg training loss: 0.7535318613052369
+Epoch 4/150:
+	reg training loss: 4.510968661308288
+	seg training loss: 0.7162851691246033
+Epoch 5/150:
+	reg training loss: 3.9539534568786623
+	seg training loss: 0.6908728837966919
+Epoch 6/150:
+	reg training loss: 4.039778637886047
+	reg validation loss: 9.18710708618164
+	seg training loss: 0.6406762003898621
+	seg validation loss: 0.6347227096557617
+Epoch 7/150:
+	reg training loss: 3.7184645175933837
+	seg training loss: 0.6085501194000245
+Epoch 8/150:
+	reg training loss: 3.935744595527649
+	seg training loss: 0.5736919283866883
+Epoch 9/150:
+	reg training loss: 4.056983923912048
+	seg training loss: 0.5408016562461853
+Epoch 10/150:
+	reg training loss: 3.8200072050094604
+	seg training loss: 0.514945924282074
+Epoch 11/150:
+	reg training loss: 4.281972050666809
+	reg validation loss: 8.052876472473145
+	seg training loss: 0.49536322355270385
+	seg validation loss: 0.5146540403366089
+Epoch 12/150:
+	reg training loss: 3.855319881439209
+	seg training loss: 0.469755756855011
+Epoch 13/150:
+	reg training loss: 3.840291428565979
+	seg training loss: 0.42938312888145447
+Epoch 14/150:
+	reg training loss: 3.583286929130554
+	seg training loss: 0.4022633254528046
+Epoch 15/150:
+	reg training loss: 3.728816819190979
+	seg training loss: 0.35690702199935914
+Epoch 16/150:
+	reg training loss: 3.199250864982605
+	reg validation loss: 7.420182704925537
+	seg training loss: 0.3086260259151459
+	seg validation loss: 0.3790477514266968
+Epoch 17/150:
+	reg training loss: 3.4572808742523193
+	seg training loss: 0.2525585561990738
+Epoch 18/150:
+	reg training loss: 3.419553208351135
+	seg training loss: 0.25260117650032043
+Epoch 19/150:
+	reg training loss: 3.5318825006484986
+	seg training loss: 0.2083510458469391
+Epoch 20/150:
+	reg training loss: 3.3581162214279177
+	seg training loss: 0.19577946960926057
+Epoch 21/150:
+	reg training loss: 3.4845890760421754
+	reg validation loss: 6.422091484069824
+	seg training loss: 0.1768558830022812
+	seg validation loss: 0.27210915088653564
+Epoch 22/150:
+	reg training loss: 3.116759204864502
+	seg training loss: 0.173543781042099
+Epoch 23/150:
+	reg training loss: 2.9422287225723265
+	seg training loss: 0.15092406868934632
+Epoch 24/150:
+	reg training loss: 3.36854088306427
+	seg training loss: 0.13847693502902986
+Epoch 25/150:
+	reg training loss: 2.9736003637313844
+	seg training loss: 0.12616726756095886
+Epoch 26/150:
+	reg training loss: 3.2114731550216673
+	reg validation loss: 5.498345851898193
+	seg training loss: 0.12545039653778076
+	seg validation loss: 0.18503624200820923
+Epoch 27/150:
+	reg training loss: 3.0050987243652343
+	seg training loss: 0.10894768834114074
+Epoch 28/150:
+	reg training loss: 2.9660191535949707
+	seg training loss: 0.11309540569782257
+Epoch 29/150:
+	reg training loss: 3.056342911720276
+	seg training loss: 0.09028413593769073
+Epoch 30/150:
+	reg training loss: 2.84787540435791
+	seg training loss: 0.0988813042640686
+Epoch 31/150:
+	reg training loss: 2.8773739337921143
+	reg validation loss: 4.607907295227051
+	seg training loss: 0.08548430800437927
+	seg validation loss: 0.15550243854522705
+Epoch 32/150:
+	reg training loss: 2.5162493228912353
+	seg training loss: 0.09200616478919983
+Epoch 33/150:
+	reg training loss: 2.9851715087890627
+	seg training loss: 0.08785836696624756
+Epoch 34/150:
+	reg training loss: 2.868598449230194
+	seg training loss: 0.07595799565315246
+Epoch 35/150:
+	reg training loss: 2.72953519821167
+	seg training loss: 0.07890819311141968
+Epoch 36/150:
+	reg training loss: 2.823525643348694
+	reg validation loss: 4.391824245452881
+	seg training loss: 0.07334268689155579
+	seg validation loss: 0.12950095534324646
+Epoch 37/150:
+	reg training loss: 2.5901314973831178
+	seg training loss: 0.077168008685112
+Epoch 38/150:
+	reg training loss: 2.7292463064193724
+	seg training loss: 0.07764174640178681
+Epoch 39/150:
+	reg training loss: 2.2696269154548645
+	seg training loss: 0.07477926909923553
+Epoch 40/150:
+	reg training loss: 2.641170156002045
+	seg training loss: 0.061516857147216795
+Epoch 41/150:
+	reg training loss: 2.665408182144165
+	reg validation loss: 4.314706802368164
+	seg training loss: 0.06822904944419861
+	seg validation loss: 0.12480152398347855
+Epoch 42/150:
+	reg training loss: 2.373495626449585
+	seg training loss: 0.06400893926620484
+Epoch 43/150:
+	reg training loss: 2.5231226563453673
+	seg training loss: 0.06552021205425262
+Epoch 44/150:
+	reg training loss: 2.610878252983093
+	seg training loss: 0.05810818076133728
+Epoch 45/150:
+	reg training loss: 2.256824862957001
+	seg training loss: 0.06144440770149231
+Epoch 46/150:
+	reg training loss: 2.1527690529823302
+	reg validation loss: 3.9034616947174072
+	seg training loss: 0.06828641891479492
+	seg validation loss: 0.130331888794899
+Epoch 47/150:
+	reg training loss: 2.4612895011901856
+	seg training loss: 0.06633291244506836
+Epoch 48/150:
+	reg training loss: 2.3212251901626586
+	seg training loss: 0.061132407188415526
+Epoch 49/150:
+	reg training loss: 2.3259034633636473
+	seg training loss: 0.05672590732574463
+Epoch 50/150:
+	reg training loss: 2.3421448111534118
+	seg training loss: 0.06588823199272156
+Epoch 51/150:
+	reg training loss: 2.237171542644501
+	reg validation loss: 4.078887939453125
+	seg training loss: 0.050005200505256656
+	seg validation loss: 0.1283894181251526
+Epoch 52/150:
+	reg training loss: 2.351637578010559
+	seg training loss: 0.06055374145507812
+Epoch 53/150:
+	reg training loss: 2.1713146924972535
+	seg training loss: 0.05193628370761871
+Epoch 54/150:
+	reg training loss: 2.2294365763664246
+	seg training loss: 0.0519787073135376
+Epoch 55/150:
+	reg training loss: 2.107238698005676
+	seg training loss: 0.060818183422088626
+Epoch 56/150:
+	reg training loss: 2.159134030342102
+	reg validation loss: 3.430917263031006
+	seg training loss: 0.05758752822875977
+	seg validation loss: 0.1234513595700264
+Epoch 57/150:
+	reg training loss: 2.136767840385437
+	seg training loss: 0.060886308550834656
+Epoch 58/150:
+	reg training loss: 2.056178319454193
+	seg training loss: 0.059524261951446535
+Epoch 59/150:
+	reg training loss: 2.1131672978401186
+	seg training loss: 0.05477309226989746
+Epoch 60/150:
+	reg training loss: 2.0785787463188172
+	seg training loss: 0.05750834941864014
+Epoch 61/150:
+	reg training loss: 1.9642852187156676
+	reg validation loss: 3.592482089996338
+	seg training loss: 0.053974205255508424
+	seg validation loss: 0.12239720672369003
+Epoch 62/150:
+	reg training loss: 2.1245671629905702
+	seg training loss: 0.049260133504867555
+Epoch 63/150:
+	reg training loss: 1.9742623448371888
+	seg training loss: 0.05120005905628204
+Epoch 64/150:
+	reg training loss: 1.8237436056137084
+	seg training loss: 0.05164272785186767
+Epoch 65/150:
+	reg training loss: 1.8780404806137085
+	seg training loss: 0.04497153162956238
+Epoch 66/150:
+	reg training loss: 1.8446750402450562
+	reg validation loss: 3.5688796043395996
+	seg training loss: 0.05031183362007141
+	seg validation loss: 0.11342131346464157
+Epoch 67/150:
+	reg training loss: 2.089728665351868
+	seg training loss: 0.04955594837665558
+Epoch 68/150:
+	reg training loss: 1.8650356769561767
+	seg training loss: 0.05126414000988007
+Epoch 69/150:
+	reg training loss: 1.8945781350135804
+	seg training loss: 0.05113123655319214
+Epoch 70/150:
+	reg training loss: 1.824099862575531
+	seg training loss: 0.050078588724136355
+Epoch 71/150:
+	reg training loss: 2.132909834384918
+	reg validation loss: 3.5110559463500977
+	seg training loss: 0.05057660043239594
+	seg validation loss: 0.11465368419885635
+Epoch 72/150:
+	reg training loss: 1.7633860468864442
+	seg training loss: 0.04853618741035461
+Epoch 73/150:
+	reg training loss: 1.9421926975250243
+	seg training loss: 0.048684078454971316
+Epoch 74/150:
+	reg training loss: 1.770769429206848
+	seg training loss: 0.0517791211605072
+Epoch 75/150:
+	reg training loss: 1.7527392029762268
+	seg training loss: 0.049894532561302184
+Epoch 76/150:
+	reg training loss: 1.8100290656089784
+	reg validation loss: 3.362490653991699
+	seg training loss: 0.03936699628829956
+	seg validation loss: 0.11438566446304321
+Epoch 77/150:
+	reg training loss: 1.8304568886756898
+	seg training loss: 0.04833044111728668
+Epoch 78/150:
+	reg training loss: 1.7759044528007508
+	seg training loss: 0.05147920846939087
+Epoch 79/150:
+	reg training loss: 1.7250861644744873
+	seg training loss: 0.048552751541137695
+Epoch 80/150:
+	reg training loss: 1.5575646996498107
+	seg training loss: 0.04389434158802032
+Epoch 81/150:
+	reg training loss: 1.879893720149994
+	reg validation loss: 3.3051137924194336
+	seg training loss: 0.0443111389875412
+	seg validation loss: 0.12079031765460968
+Epoch 82/150:
+	reg training loss: 1.8457049012184144
+	seg training loss: 0.04815846085548401
+Epoch 83/150:
+	reg training loss: 1.7818867683410644
+	seg training loss: 0.048137256503105165
+Epoch 84/150:
+	reg training loss: 1.6136236906051635
+	seg training loss: 0.0441769927740097
+Epoch 85/150:
+	reg training loss: 1.5971672058105468
+	seg training loss: 0.05148882269859314
+Epoch 86/150:
+	reg training loss: 1.6388625502586365
+	reg validation loss: 3.5887608528137207
+	seg training loss: 0.040018555521965024
+	seg validation loss: 0.12744276225566864
+Epoch 87/150:
+	reg training loss: 1.6481032490730285
+	seg training loss: 0.04862010776996613
+Epoch 88/150:
+	reg training loss: 1.6571676015853882
+	seg training loss: 0.04402497112751007
+Epoch 89/150:
+	reg training loss: 1.7385945796966553
+	seg training loss: 0.04975014328956604
+Epoch 90/150:
+	reg training loss: 1.4554160475730895
+	seg training loss: 0.04796398878097534
+Epoch 91/150:
+	reg training loss: 1.6244391560554505
+	reg validation loss: 3.2644922733306885
+	seg training loss: 0.03874439895153046
+	seg validation loss: 0.11166677623987198
+Epoch 92/150:
+	reg training loss: 1.475834959745407
+	seg training loss: 0.04821090996265411
+Epoch 93/150:
+	reg training loss: 1.8129208445549012
+	seg training loss: 0.04149874150753021
+Epoch 94/150:
+	reg training loss: 1.582091224193573
+	seg training loss: 0.04493129253387451
+Epoch 95/150:
+	reg training loss: 1.648519515991211
+	seg training loss: 0.044540634751319884
+Epoch 96/150:
+	reg training loss: 1.530086386203766
+	reg validation loss: 3.317974090576172
+	seg training loss: 0.0466022789478302
+	seg validation loss: 0.13395804166793823
+Epoch 97/150:
+	reg training loss: 1.514226257801056
+	seg training loss: 0.03777629733085632
+Epoch 98/150:
+	reg training loss: 1.5128494262695313
+	seg training loss: 0.04635457992553711
+Epoch 99/150:
+	reg training loss: 1.4876845955848694
+	seg training loss: 0.041973233222961426
+Epoch 100/150:
+	reg training loss: 1.5425513625144958
+	seg training loss: 0.043033072352409364
+Epoch 101/150:
+	reg training loss: 1.4795127868652345
+	reg validation loss: 3.278428554534912
+	seg training loss: 0.04391896724700928
+	seg validation loss: 0.10932398587465286
+Epoch 102/150:
+	reg training loss: 1.3456117391586304
+	seg training loss: 0.0463683158159256
+Epoch 103/150:
+	reg training loss: 1.5337165355682374
+	seg training loss: 0.04557084739208221
+Epoch 104/150:
+	reg training loss: 1.4175154209136962
+	seg training loss: 0.041203317046165464
+Epoch 105/150:
+	reg training loss: 1.491098737716675
+	seg training loss: 0.04438801407814026
+Epoch 106/150:
+	reg training loss: 1.637062907218933
+	reg validation loss: 3.325711250305176
+	seg training loss: 0.039811649918556215
+	seg validation loss: 0.11083932965993881
+Epoch 107/150:
+	reg training loss: 1.4294653177261352
+	seg training loss: 0.040769177675247195
+Epoch 108/150:
+	reg training loss: 1.2746424674987793
+	seg training loss: 0.039609703421592715
+Epoch 109/150:
+	reg training loss: 1.465555238723755
+	seg training loss: 0.04165233075618744
+Epoch 110/150:
+	reg training loss: 1.5138072729110719
+	seg training loss: 0.0392852783203125
+Epoch 111/150:
+	reg training loss: 1.4285594701766968
+	reg validation loss: 3.0637738704681396
+	seg training loss: 0.04050336182117462
+	seg validation loss: 0.10757420212030411
+Epoch 112/150:
+	reg training loss: 1.4796598553657532
+	seg training loss: 0.04065462350845337
+Epoch 113/150:
+	reg training loss: 1.36372629404068
+	seg training loss: 0.040871036052703855
+Epoch 114/150:
+	reg training loss: 1.4361500144004822
+	seg training loss: 0.04593601524829864
+Epoch 115/150:
+	reg training loss: 1.4456260681152344
+	seg training loss: 0.04071014523506165
+Epoch 116/150:
+	reg training loss: 1.4020459055900574
+	reg validation loss: 3.108996868133545
+	seg training loss: 0.04369308948516846
+	seg validation loss: 0.11938655376434326
+Epoch 117/150:
+	reg training loss: 1.3788525223731996
+	seg training loss: 0.04722652137279511
+Epoch 118/150:
+	reg training loss: 1.3215387344360352
+	seg training loss: 0.04317383766174317
+Epoch 119/150:
+	reg training loss: 1.3698723673820496
+	seg training loss: 0.03398588299751282
+Epoch 120/150:
+	reg training loss: 1.2778821647167207
+	seg training loss: 0.04034335613250732
+Epoch 121/150:
+	reg training loss: 1.3698755979537964
+	reg validation loss: 2.9927785396575928
+	seg training loss: 0.036156189441680905
+	seg validation loss: 0.11336451023817062
+Epoch 122/150:
+	reg training loss: 1.3979350209236145
+	seg training loss: 0.03906717300415039
+Epoch 123/150:
+	reg training loss: 1.2636346697807312
+	seg training loss: 0.04145587384700775
+Epoch 124/150:
+	reg training loss: 1.3199236750602723
+	seg training loss: 0.03506969213485718
+Epoch 125/150:
+	reg training loss: 1.3449559211730957
+	seg training loss: 0.038923582434654234
+Epoch 126/150:
+	reg training loss: 1.339024943113327
+	reg validation loss: 3.245039463043213
+	seg training loss: 0.03790881633758545
+	seg validation loss: 0.1098380908370018
+Epoch 127/150:
+	reg training loss: 1.260996562242508
+	seg training loss: 0.03813325166702271
+Epoch 128/150:
+	reg training loss: 1.3546002149581908
+	seg training loss: 0.03687379956245422
+Epoch 129/150:
+	reg training loss: 1.252830719947815
+	seg training loss: 0.040056157112121585
+Epoch 130/150:
+	reg training loss: 1.1125893533229827
+	seg training loss: 0.0403405487537384
+Epoch 131/150:
+	reg training loss: 1.2271615982055664
+	reg validation loss: 2.9399733543395996
+	seg training loss: 0.03758984208106995
+	seg validation loss: 0.10584234446287155
+Epoch 132/150:
+	reg training loss: 1.3109357595443725
+	seg training loss: 0.046701446175575256
+Epoch 133/150:
+	reg training loss: 1.3082359910011292
+	seg training loss: 0.04108454883098602
+Epoch 134/150:
+	reg training loss: 1.4175715327262879
+	seg training loss: 0.03957531452178955
+Epoch 135/150:
+	reg training loss: 1.2930214643478393
+	seg training loss: 0.036753672361373904
+Epoch 136/150:
+	reg training loss: 1.2290011167526245
+	reg validation loss: 3.009814500808716
+	seg training loss: 0.03787890374660492
+	seg validation loss: 0.11481118947267532
+Epoch 137/150:
+	reg training loss: 1.2510305166244506
+	seg training loss: 0.03525933623313904
+Epoch 138/150:
+	reg training loss: 1.3841961979866029
+	seg training loss: 0.045733338594436644
+Epoch 139/150:
+	reg training loss: 1.1904977083206176
+	seg training loss: 0.041322562098503116
+Epoch 140/150:
+	reg training loss: 1.1987750947475433
+	seg training loss: 0.03969658315181732
+Epoch 141/150:
+	reg training loss: 1.2858553409576416
+	reg validation loss: 3.063588857650757
+	seg training loss: 0.03913751244544983
+	seg validation loss: 0.1053217351436615
+Epoch 142/150:
+	reg training loss: 1.234222173690796
+	seg training loss: 0.04026820361614227
+Epoch 143/150:
+	reg training loss: 1.1718730866909026
+	seg training loss: 0.03998347520828247
+Epoch 144/150:
+	reg training loss: 1.1990990936756134
+	seg training loss: 0.03557175695896149
+Epoch 145/150:
+	reg training loss: 1.157021552324295
+	seg training loss: 0.03615144789218903
+Epoch 146/150:
+	reg training loss: 1.2255614519119262
+	reg validation loss: 3.1661453247070312
+	seg training loss: 0.0391613632440567
+	seg validation loss: 0.13170355558395386
+Epoch 147/150:
+	reg training loss: 1.1338848412036895
+	seg training loss: 0.03860030472278595
+Epoch 148/150:
+	reg training loss: 1.1530435025691985
+	seg training loss: 0.03843391835689545
+Epoch 149/150:
+	reg training loss: 1.19446240067482
+	seg training loss: 0.03256092071533203
+Epoch 150/150:
+	reg training loss: 1.175407838821411
+	seg training loss: 0.03730123043060303
+
+
+Best reg_net validation loss: 2.9399733543395996
+Best seg_net validation loss: 0.1053217351436615

requirements.txt

@@ -0,0 +1,164 @@
+absl-py==1.0.0
+alembic==1.7.7
+antspyx==0.3.2
+argon2-cffi==21.3.0
+argon2-cffi-bindings==21.2.0
+asttokens==2.0.5
+attrs==21.4.0
+autopep8==1.6.0
+backcall==0.2.0
+beautifulsoup4==4.11.1
+bleach==5.0.1
+cachetools==5.1.0
+certifi==2022.5.18.1
+cffi==1.15.1
+charset-normalizer==2.0.12
+chart-studio==1.1.0
+click==8.1.3
+cloudpickle==2.1.0
+cucim==22.4.0
+cycler==0.11.0
+databricks-cli==0.16.6
+debugpy==1.6.0
+decorator==5.1.1
+defusedxml==0.7.1
+docker==5.0.3
+einops==0.4.1
+entrypoints==0.4
+executing==0.8.3
+fastjsonschema==2.16.1
+filelock==3.7.0
+fire==0.4.0
+Flask==2.1.2
+fonttools==4.33.3
+gdown==4.4.0
+gitdb==4.0.9
+GitPython==3.1.27
+google-auth==2.6.6
+google-auth-oauthlib==0.4.6
+greenlet==1.1.2
+grpcio==1.46.3
+gunicorn==20.1.0
+huggingface-hub==0.6.0
+idna==3.3
+imagecodecs==2022.2.22
+imageio==2.19.2
+importlib-metadata==4.11.3
+importlib-resources==5.7.1
+install==1.3.5
+ipykernel==6.13.0
+ipython==8.3.0
+ipython-genutils==0.2.0
+itk==5.2.1.post1
+itk-core==5.2.1.post1
+itk-filtering==5.2.1.post1
+itk-io==5.2.1.post1
+itk-numerics==5.2.1.post1
+itk-registration==5.2.1.post1
+itk-segmentation==5.2.1.post1
+itsdangerous==2.1.2
+jedi==0.18.1
+Jinja2==3.1.2
+joblib==1.1.0
+jsonschema==4.5.1
+jupyter-client==7.3.1
+jupyter-core==4.10.0
+jupyterlab-pygments==0.2.2
+kiwisolver==1.4.2
+lmdb==1.3.0
+Mako==1.2.0
+Markdown==3.3.7
+MarkupSafe==2.1.1
+matplotlib==3.5.2
+matplotlib-inline==0.1.3
+mistune==2.0.3
+mlflow==1.26.0
+-e git+https://github.com/Project-MONAI/MONAI.git@ed233d9b48bd71eb623cf9777ad9b60142c8ad66#egg=monai
+nbclient==0.6.6
+nbconvert==6.5.0
+nbformat==5.4.0
+nest-asyncio==1.5.5
+networkx==2.8.1
+nibabel==3.2.2
+notebook==6.4.12
+numpy==1.22.3
+oauthlib==3.2.0
+openslide-python==1.1.2
+packaging==21.3
+pandas==1.4.2
+pandocfilters==1.5.0
+parso==0.8.3
+patsy==0.5.2
+pexpect==4.8.0
+pickleshare==0.7.5
+Pillow==9.1.1
+plotly==5.8.0
+prometheus-client==0.14.1
+prometheus-flask-exporter==0.20.1
+prompt-toolkit==3.0.29
+protobuf==3.20.1
+psutil==5.9.0
+ptyprocess==0.7.0
+pure-eval==0.2.2
+pyasn1==0.4.8
+pyasn1-modules==0.2.8
+pycodestyle==2.8.0
+pycparser==2.21
+Pygments==2.12.0
+PyJWT==2.4.0
+pynrrd==0.4.3
+pyparsing==3.0.9
+pyrsistent==0.18.1
+PySocks==1.7.1
+python-dateutil==2.8.2
+pytorch-ignite==0.4.8
+pytz==2022.1
+PyWavelets==1.3.0
+PyYAML==6.0
+pyzmq==22.3.0
+querystring-parser==1.2.4
+regex==2022.4.24
+requests==2.27.1
+requests-oauthlib==1.3.1
+retrying==1.3.3
+rsa==4.8
+scikit-image==0.19.2
+scikit-learn==1.1.1
+scipy==1.8.1
+Send2Trash==1.8.0
+six==1.16.0
+slicerio==0.1.3
+smmap==5.0.0
+soupsieve==2.3.2.post1
+SQLAlchemy==1.4.36
+sqlparse==0.4.2
+stack-data==0.2.0
+statsmodels==0.13.2
+tabulate==0.8.9
+tenacity==8.0.1
+tensorboard==2.9.0
+tensorboard-data-server==0.6.1
+tensorboard-plugin-wit==1.8.1
+tensorboardX==2.5
+termcolor==1.1.0
+terminado==0.15.0
+threadpoolctl==3.1.0
+tifffile==2022.5.4
+tinycss2==1.1.1
+tokenizers==0.12.1
+toml==0.10.2
+torch==1.11.0+cu113
+torchaudio==0.11.0+cu113
+torchvision==0.12.0+cu113
+tornado==6.1
+tqdm==4.64.0
+traitlets==5.3.0
+transformers==4.19.2
+typing_extensions==4.2.0
+urllib3==1.26.9
+wcwidth==0.2.5
+webcolors==1.12
+webencodings==0.5.1
+websocket-client==1.3.2
+Werkzeug==2.1.2
+zipp==3.8.0