Add files using upload-large-folder tool

ATLAS/atlas-train-dataset-1.0.1/CHANGELOG

@@ -0,0 +1,22 @@
+# Changelog
+
+All notable changes to the Atlas Dataset will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [1.0.1] - 2023-06-25
+
+### Updated
+
+- Update metrics.
+
+## [1.0.0] - 2023-04-25
+
+### Added
+
+- Readme with Description, Documentation, and License sections.
+- Initial version of the training dataset with metric scripts for evaluation.
+

ATLAS/atlas-train-dataset-1.0.1/README.md

@@ -0,0 +1,14 @@
+# The Atlas training Dataset
+
+This archive contains the Atlas challenge training dataset as well as the metrics calculation scripts.
+
+
+## Documentation
+
+For more information about the challenge and the dataset, you are invited to visit the [Atlas website](https://atlas-challenge.u-bourgogne.fr).
+
+
+## License
+
+This work is licensed under a [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License](http://creativecommons.org/licenses/by-nc-sa/4.0/).
+

ATLAS/atlas-train-dataset-1.0.1/metric_calculation/README.md

@@ -0,0 +1,14 @@
+## File organisation
+
+calculate_metrics.py is the main file and will allow you to calculate the metrics used in the ATLAS challenge, values per images can be stored in a json file or average values in a csv file. The metrics are defined in the metrics.py file.
+Images from the label file should be named "lbxx.nii.gz" and have a corresponding images in the segmentation file named "imxx.nii.gz".
+
+## Run the code
+
+Install python dependencies
+
+`python -m pip install -r requirements.txt`
+
+Calculate the default metrics and store the output in a json or csv file
+
+`python calculate_metrics.py  --segmentation_folder /path/to/the/model/segmentation/ --label_folder /path/to/the/ground/truth/ --csv_output_file /path/to/the/output/csv/file --json_output_file /path/to/the/output/json/file`

ATLAS/atlas-train-dataset-1.0.1/metric_calculation/calculate_metrics.py

@@ -0,0 +1,60 @@
+import os
+import csv
+import argparse
+from evaluator import aggregate_scores
+
+def calcultate_metrics(segmentation_folder, label_folder, author, status, csv_output_file=None, json_output_file=None, num_threads=8):
+
+    """"
+    param segmentation_folder: folder with the segmentations under nifty format
+    param label_folder: folder with the grond truth images under nifty format
+    param output_file: path to the output csv file with average performances
+    param json_output_file: path to the json output file with performances per image
+    param num_threads: number of cpu threads to parallelize the computations
+    return:
+    """
+    pred_gt_tuples = []
+    for i, p in enumerate(os.listdir(label_folder)):
+        if p.endswith('nii.gz'):
+            file = os.path.join(label_folder, p)
+            pred_gt_tuples.append([os.path.join(segmentation_folder, 'im' + p[2:]),file])
+
+    scores = aggregate_scores(pred_gt_tuples, labels=[[1, 2], 2],
+                         json_output_file=json_output_file, num_threads=num_threads)
+    if csv_output_file != None:
+        evaluation_metrics = {
+            "Authors": author,
+            "Liver ASD (mm³)": round(scores["mean"]["[1, 2]"]["Avg. Symmetric Surface Distance"], 1),
+            "Liver Dice (%)": round(scores["mean"]["[1, 2]"]["Dice"] * 100, 1),
+            "Liver Hausdorff Distance (mm³)": round(scores["mean"]["[1, 2]"]["Hausdorff Distance"], 1),
+            "Liver Surface Dice (%)": round(scores["mean"]["[1, 2]"]["Surface Dice"] * 100, 1),
+            "Tumor ASD (mm³)": round(scores["mean"]["2"]["Avg. Symmetric Surface Distance"], 1),
+            "Tumor Dice (%)": round(scores["mean"]["2"]["Dice"] * 100, 1),
+            "Tumor Hausdorff Distance (mm³)": round(scores["mean"]["2"]["Hausdorff Distance"], 1),
+            "Tumor Surface Dice (%)": round(scores["mean"]["2"]["Surface Dice"] * 100, 1),
+            "RMSE on Tumor Burden (%)": round(scores["mean"]["RMSE on Tumor Burden"] * 100, 1),
+            "Status": status
+                              }
+
+        # Check if file exists, if not, write header
+        if not os.path.isfile(csv_output_file):
+            with open(csv_output_file, 'w') as csvfile:
+                writer = csv.DictWriter(csvfile, fieldnames=evaluation_metrics.keys())
+                writer.writeheader()
+
+        with open(csv_output_file, 'a') as csvfile:
+            writer = csv.DictWriter(csvfile, fieldnames=evaluation_metrics.keys())
+            writer.writerow(evaluation_metrics)
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Metrics calculation')
+    parser.add_argument('--segmentation_folder', default="/path/to/the/segmentation/folder", type=str)
+    parser.add_argument('--label_folder', default="/path/to/the/label/folder/labelsTr", type=str)
+    parser.add_argument('--author', default="Author 1", type=str)
+    parser.add_argument('--status', default="Docker container submitted", type=str)
+    parser.add_argument('--csv_output_file', default="/path/to/the/output/csv/file.csv", type=str)
+    parser.add_argument('--json_output_file', default="/path/to/the/output/json/file.json", type=str)
+    parser.add_argument('--num_threads', default=8, type=int)
+
+    args = parser.parse_args()
+    calcultate_metrics(args.segmentation_folder, args.label_folder, args.author, args.status, csv_output_file=args.csv_output_file, json_output_file=args.json_output_file, num_threads=args.num_threads)

ATLAS/atlas-train-dataset-1.0.1/metric_calculation/evaluator.py

@@ -0,0 +1,430 @@
+#    Copyright 2020 Division of Medical Image Computing, German Cancer Research Center (DKFZ), Heidelberg, Germany
+#
+#    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.
+
+
+import collections
+import inspect
+import json
+import hashlib
+from datetime import datetime
+from multiprocessing.pool import Pool
+import numpy as np
+import pandas as pd
+import SimpleITK as sitk
+from metrics import ConfusionMatrix, ALL_METRICS
+from batchgenerators.utilities.file_and_folder_operations import save_json
+from collections import OrderedDict
+
+
+class Evaluator:
+    """Object that holds test and reference segmentations with label information
+    and computes a number of metrics on the two. 'labels' must either be an
+    iterable of numeric values (or tuples thereof) or a dictionary with string
+    names and numeric values.
+    """
+
+    default_metrics = [
+        "False Positive Rate",
+        "Dice",
+        "Jaccard",
+        "Precision",
+        "Recall",
+        "Accuracy",
+        "False Omission Rate",
+        "Negative Predictive Value",
+        "False Negative Rate",
+        "True Negative Rate",
+        "False Discovery Rate",
+        "Total Positives Test",
+        "Total Positives Reference",
+        "Hausdorff Distance",
+        "Hausdorff Distance 95",
+        "Avg. Surface Distance",
+        "Avg. Symmetric Surface Distance",
+        "Surface Dice"
+    ]
+
+    default_advanced_metrics = []
+
+    def __init__(self,
+                 test=None,
+                 reference=None,
+                 labels=None,
+                 metrics=None,
+                 advanced_metrics=None,
+                 nan_for_nonexisting=False):
+
+        self.test = None
+        self.reference = None
+        self.confusion_matrix = ConfusionMatrix()
+        self.labels = None
+        self.nan_for_nonexisting = nan_for_nonexisting
+        self.result = None
+
+        self.metrics = []
+        if metrics is None:
+            for m in self.default_metrics:
+                self.metrics.append(m)
+        else:
+            for m in metrics:
+                self.metrics.append(m)
+
+        self.advanced_metrics = []
+        if advanced_metrics is None:
+            for m in self.default_advanced_metrics:
+                self.advanced_metrics.append(m)
+        else:
+            for m in advanced_metrics:
+                self.advanced_metrics.append(m)
+
+        self.set_reference(reference)
+        self.set_test(test)
+        if labels is not None:
+            self.set_labels(labels)
+        else:
+            if test is not None and reference is not None:
+                self.construct_labels()
+
+    def set_test(self, test):
+        """Set the test segmentation."""
+
+        self.test = test
+
+    def set_reference(self, reference):
+        """Set the reference segmentation."""
+
+        self.reference = reference
+
+    def set_labels(self, labels):
+        """Set the labels.
+        :param labels= may be a dictionary (int->str), a set (of ints), a tuple (of ints) or a list (of ints). Labels
+        will only have names if you pass a dictionary"""
+
+        if isinstance(labels, dict):
+            self.labels = collections.OrderedDict(labels)
+        elif isinstance(labels, set):
+            self.labels = list(labels)
+        elif isinstance(labels, np.ndarray):
+            self.labels = [i for i in labels]
+        elif isinstance(labels, (list, tuple)):
+            self.labels = labels
+        else:
+            raise TypeError("Can only handle dict, list, tuple, set & numpy array, but input is of type {}".format(type(labels)))
+
+    def construct_labels(self):
+        """Construct label set from unique entries in segmentations."""
+
+        if self.test is None and self.reference is None:
+            raise ValueError("No test or reference segmentations.")
+        elif self.test is None:
+            labels = np.unique(self.reference)
+        else:
+            labels = np.union1d(np.unique(self.test),
+                                np.unique(self.reference))
+        self.labels = list(map(lambda x: int(x), labels))
+
+    def set_metrics(self, metrics):
+        """Set evaluation metrics"""
+
+        if isinstance(metrics, set):
+            self.metrics = list(metrics)
+        elif isinstance(metrics, (list, tuple, np.ndarray)):
+            self.metrics = metrics
+        else:
+            raise TypeError("Can only handle list, tuple, set & numpy array, but input is of type {}".format(type(metrics)))
+
+    def add_metric(self, metric):
+
+        if metric not in self.metrics:
+            self.metrics.append(metric)
+
+    def evaluate(self, test=None, reference=None, advanced=False, **metric_kwargs):
+        """Compute metrics for segmentations."""
+        if test is not None:
+            self.set_test(test)
+
+        if reference is not None:
+            self.set_reference(reference)
+
+        if self.test is None or self.reference is None:
+            raise ValueError("Need both test and reference segmentations.")
+
+        if self.labels is None:
+            self.construct_labels()
+
+        self.metrics.sort()
+
+        # get functions for evaluation
+        # somewhat convoluted, but allows users to define additonal metrics
+        # on the fly, e.g. inside an IPython console
+        _funcs = {m: ALL_METRICS[m] for m in self.metrics + self.advanced_metrics}
+        frames = inspect.getouterframes(inspect.currentframe())
+        for metric in self.metrics:
+            for f in frames:
+                if metric in f[0].f_locals:
+                    _funcs[metric] = f[0].f_locals[metric]
+                    break
+            else:
+                if metric in _funcs:
+                    continue
+                else:
+                    raise NotImplementedError(
+                        "Metric {} not implemented.".format(metric))
+
+        # get results
+        self.result = OrderedDict()
+
+        eval_metrics = self.metrics
+        if advanced:
+            eval_metrics += self.advanced_metrics
+
+        if isinstance(self.labels, dict):
+
+            for label, name in self.labels.items():
+                k = str(name)
+                self.result[k] = OrderedDict()
+                if not hasattr(label, "__iter__"):
+                    self.confusion_matrix.set_test(self.test == label)
+                    self.confusion_matrix.set_reference(self.reference == label)
+                else:
+                    current_test = 0
+                    current_reference = 0
+                    for l in label:
+                        current_test += (self.test == l)
+                        current_reference += (self.reference == l)
+                    self.confusion_matrix.set_test(current_test)
+                    self.confusion_matrix.set_reference(current_reference)
+                for metric in eval_metrics:
+                    self.result[k][metric] = _funcs[metric](confusion_matrix=self.confusion_matrix,
+                                                               nan_for_nonexisting=self.nan_for_nonexisting,
+                                                               **metric_kwargs)
+
+        else:
+
+            for i, l in enumerate(self.labels):
+                k = str(l)
+                self.result[k] = OrderedDict()
+                if isinstance(l, list):
+                    self.confusion_matrix.set_test(np.isin(self.test, l))
+                    self.confusion_matrix.set_reference(np.isin(self.reference, l))
+                else:
+                    self.confusion_matrix.set_test(self.test == l)
+                    self.confusion_matrix.set_reference(self.reference == l)
+
+                for metric in eval_metrics:
+                    self.result[k][metric] = _funcs[metric](confusion_matrix=self.confusion_matrix,
+                                                            nan_for_nonexisting=self.nan_for_nonexisting,
+                                                            **metric_kwargs)
+
+        return self.result
+
+    def to_dict(self):
+
+        if self.result is None:
+            self.evaluate()
+        return self.result
+
+    def to_array(self):
+        """Return result as numpy array (labels x metrics)."""
+
+        if self.result is None:
+            self.evaluate
+
+        result_metrics = sorted(self.result[list(self.result.keys())[0]].keys())
+
+        a = np.zeros((len(self.labels), len(result_metrics)), dtype=np.float32)
+
+        if isinstance(self.labels, dict):
+            for i, label in enumerate(self.labels.keys()):
+                for j, metric in enumerate(result_metrics):
+                    a[i][j] = self.result[self.labels[label]][metric]
+        else:
+            for i, label in enumerate(self.labels):
+                for j, metric in enumerate(result_metrics):
+                    a[i][j] = self.result[label][metric]
+
+        return a
+
+    def to_pandas(self):
+        """Return result as pandas DataFrame."""
+
+        a = self.to_array()
+
+        if isinstance(self.labels, dict):
+            labels = list(self.labels.values())
+        else:
+            labels = self.labels
+
+        result_metrics = sorted(self.result[list(self.result.keys())[0]].keys())
+
+        return pd.DataFrame(a, index=labels, columns=result_metrics)
+
+
+class NiftiEvaluator(Evaluator):
+
+    def __init__(self, *args, **kwargs):
+
+        self.test_nifti = None
+        self.reference_nifti = None
+        super(NiftiEvaluator, self).__init__(*args, **kwargs)
+
+    def set_test(self, test):
+        """Set the test segmentation."""
+
+        if test is not None:
+            self.test_nifti = sitk.ReadImage(test)
+            super(NiftiEvaluator, self).set_test(sitk.GetArrayFromImage(self.test_nifti))
+        else:
+            self.test_nifti = None
+            super(NiftiEvaluator, self).set_test(test)
+
+    def set_reference(self, reference):
+        """Set the reference segmentation."""
+
+        if reference is not None:
+            self.reference_nifti = sitk.ReadImage(reference)
+            super(NiftiEvaluator, self).set_reference(sitk.GetArrayFromImage(self.reference_nifti))
+        else:
+            self.reference_nifti = None
+            super(NiftiEvaluator, self).set_reference(reference)
+
+    def evaluate(self, test=None, reference=None, voxel_spacing=None, **metric_kwargs):
+
+        if voxel_spacing is None:
+            voxel_spacing = np.array(self.test_nifti.GetSpacing())[::-1]
+            metric_kwargs["voxel_spacing"] = voxel_spacing
+
+        return super(NiftiEvaluator, self).evaluate(test, reference, **metric_kwargs)
+
+
+def run_evaluation(args):
+    test, ref, evaluator, metric_kwargs = args
+    # evaluate
+    evaluator.set_test(test)
+    evaluator.set_reference(ref)
+    if evaluator.labels is None:
+        evaluator.construct_labels()
+    current_scores = evaluator.evaluate(**metric_kwargs)
+    if type(test) == str:
+        current_scores["test"] = test
+    if type(ref) == str:
+        current_scores["reference"] = ref
+    return current_scores
+
+
+def aggregate_scores(test_ref_pairs,
+                     evaluator=NiftiEvaluator,
+                     labels=None,
+                     nanmean=True,
+                     json_output_file=None,
+                     json_name="",
+                     json_description="",
+                     json_author="Fabian",
+                     json_task="",
+                     num_threads=2,
+                     do_mean=True,
+                     get_tumor_burden=True,
+                     **metric_kwargs):
+    """
+    test = predicted image
+    :param test_ref_pairs:
+    :param evaluator:
+    :param labels: must be a dict of int-> str or a list of int
+    :param nanmean:
+    :param json_output_file:
+    :param json_name:
+    :param json_description:
+    :param json_author:
+    :param json_task:
+    :param metric_kwargs:
+    :return:
+    """
+
+    if type(evaluator) == type:
+        evaluator = evaluator()
+
+    if labels is not None:
+        evaluator.set_labels(labels)
+
+    all_scores = OrderedDict()
+    all_scores["all"] = []
+    all_scores["mean"] = OrderedDict()
+
+    test = [i[0] for i in test_ref_pairs]
+    ref = [i[1] for i in test_ref_pairs]
+    p = Pool(num_threads)
+    all_res = p.map(run_evaluation, zip(test, ref, [evaluator]*len(ref), [metric_kwargs]*len(ref)))
+
+    p.close()
+    p.join()
+
+    if get_tumor_burden:
+        tumor_burden_segmentation_list = []
+        tumor_burden_reference_list = []
+        for i in range(len(all_res)):
+            liver_label_volume = all_res[i]["[1, 2]"]['Total Positives Reference']
+            liver_seg_volume = all_res[i]["[1, 2]"]['Total Positives Test']
+
+            tumor_label_volume = all_res[i]["2"]['Total Positives Reference']
+            tumor_seg_volume = all_res[i]["2"]['Total Positives Test']
+
+            tumor_burden_reference = tumor_label_volume / liver_label_volume
+            tumor_burden_segmentation = tumor_seg_volume / liver_seg_volume
+
+            tumor_burden_reference_list.append(tumor_burden_reference)
+            tumor_burden_segmentation_list.append(tumor_burden_segmentation)
+
+            all_res[i]["2"]["Tumor Burden Reference"] = tumor_burden_reference
+            all_res[i]["2"]["Tumor Burden Test"] = tumor_burden_segmentation
+        rmse_on_tumor_burden = np.nanmean(np.power(np.subtract(tumor_burden_reference_list, tumor_burden_segmentation_list),2))
+
+    for i in range(len(all_res)):
+        all_scores["all"].append(all_res[i])
+
+        # append score list for mean
+        for label, score_dict in all_res[i].items():
+            if label in ("test", "reference"):
+                continue
+            if label not in all_scores["mean"]:
+                all_scores["mean"][label] = OrderedDict()
+            for score, value in score_dict.items():
+                if score not in all_scores["mean"][label]:
+                    all_scores["mean"][label][score] = []
+                all_scores["mean"][label][score].append(value)
+    if do_mean:
+        for label in all_scores["mean"]:
+            for score in all_scores["mean"][label]:
+                if nanmean:
+                    all_scores["mean"][label][score] = float(np.nanmean(all_scores["mean"][label][score]))
+                else:
+                    all_scores["mean"][label][score] = float(np.mean(all_scores["mean"][label][score]))
+        if get_tumor_burden:
+            all_scores["mean"]["RMSE on Tumor Burden"] = rmse_on_tumor_burden
+
+    # save to file if desired
+    # we create a hopefully unique id by hashing the entire output dictionary
+    if json_output_file is not None:
+        json_dict = OrderedDict()
+        json_dict["name"] = json_name
+        json_dict["description"] = json_description
+        timestamp = datetime.today()
+        json_dict["timestamp"] = str(timestamp)
+        json_dict["task"] = json_task
+        json_dict["author"] = json_author
+        json_dict["results"] = all_scores
+        json_dict["id"] = hashlib.md5(json.dumps(json_dict).encode("utf-8")).hexdigest()[:12]
+        save_json(json_dict, json_output_file)
+
+
+    return all_scores

ATLAS/atlas-train-dataset-1.0.1/metric_calculation/metrics.py

@@ -0,0 +1,442 @@
+#    Copyright 2020 Division of Medical Image Computing, German Cancer Research Center (DKFZ), Heidelberg, Germany
+#
+#    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.
+
+import numpy as np
+from medpy import metric
+
+
+def assert_shape(test, reference):
+
+    assert test.shape == reference.shape, "Shape mismatch: {} and {}".format(
+        test.shape, reference.shape)
+
+
+class ConfusionMatrix:
+
+    def __init__(self, test=None, reference=None):
+
+        self.tp = None
+        self.fp = None
+        self.tn = None
+        self.fn = None
+        self.size = None
+        self.reference_empty = None
+        self.reference_full = None
+        self.test_empty = None
+        self.test_full = None
+        self.set_reference(reference)
+        self.set_test(test)
+
+    def set_test(self, test):
+
+        self.test = test
+        self.reset()
+
+    def set_reference(self, reference):
+
+        self.reference = reference
+        self.reset()
+
+    def reset(self):
+
+        self.tp = None
+        self.fp = None
+        self.tn = None
+        self.fn = None
+        self.size = None
+        self.test_empty = None
+        self.test_full = None
+        self.reference_empty = None
+        self.reference_full = None
+
+    def compute(self):
+
+        if self.test is None or self.reference is None:
+            raise ValueError("'test' and 'reference' must both be set to compute confusion matrix.")
+
+        assert_shape(self.test, self.reference)
+
+        self.tp = int(((self.test != 0) * (self.reference != 0)).sum())
+        self.fp = int(((self.test != 0) * (self.reference == 0)).sum())
+        self.tn = int(((self.test == 0) * (self.reference == 0)).sum())
+        self.fn = int(((self.test == 0) * (self.reference != 0)).sum())
+        self.size = int(np.prod(self.reference.shape, dtype=np.int64))
+        self.test_empty = not np.any(self.test)
+        self.test_full = np.all(self.test)
+        self.reference_empty = not np.any(self.reference)
+        self.reference_full = np.all(self.reference)
+
+    def get_matrix(self):
+
+        for entry in (self.tp, self.fp, self.tn, self.fn):
+            if entry is None:
+                self.compute()
+                break
+
+        return self.tp, self.fp, self.tn, self.fn
+
+    def get_size(self):
+
+        if self.size is None:
+            self.compute()
+        return self.size
+
+    def get_existence(self):
+
+        for case in (self.test_empty, self.test_full, self.reference_empty, self.reference_full):
+            if case is None:
+                self.compute()
+                break
+
+        return self.test_empty, self.test_full, self.reference_empty, self.reference_full
+
+
+def dice(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=False, **kwargs):
+    """2TP / (2TP + FP + FN)"""
+
+    if confusion_matrix is None:
+        confusion_matrix = ConfusionMatrix(test, reference)
+
+    tp, fp, tn, fn = confusion_matrix.get_matrix()
+    test_empty, test_full, reference_empty, reference_full = confusion_matrix.get_existence()
+
+    if test_empty and reference_empty:
+        if nan_for_nonexisting:
+            return float("NaN")
+        else:
+            return 0.
+
+    return float(2. * tp / (2 * tp + fp + fn))
+
+
+def jaccard(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=False, **kwargs):
+    """TP / (TP + FP + FN)"""
+
+    if confusion_matrix is None:
+        confusion_matrix = ConfusionMatrix(test, reference)
+
+    tp, fp, tn, fn = confusion_matrix.get_matrix()
+    test_empty, test_full, reference_empty, reference_full = confusion_matrix.get_existence()
+
+    if test_empty and reference_empty:
+        if nan_for_nonexisting:
+            return float("NaN")
+        else:
+            return 0.
+
+    return float(tp / (tp + fp + fn))
+
+
+def precision(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=False, **kwargs):
+    """TP / (TP + FP)"""
+
+    if confusion_matrix is None:
+        confusion_matrix = ConfusionMatrix(test, reference)
+
+    tp, fp, tn, fn = confusion_matrix.get_matrix()
+    test_empty, test_full, reference_empty, reference_full = confusion_matrix.get_existence()
+
+    if test_empty or tp == fp == 0:
+        if nan_for_nonexisting:
+            return float("NaN")
+        else:
+            return 0.
+
+    return float(tp / (tp + fp))
+
+
+def sensitivity(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=False, **kwargs):
+    """TP / (TP + FN)"""
+
+    if confusion_matrix is None:
+        confusion_matrix = ConfusionMatrix(test, reference)
+
+    tp, fp, tn, fn = confusion_matrix.get_matrix()
+    test_empty, test_full, reference_empty, reference_full = confusion_matrix.get_existence()
+
+    if reference_empty:
+        if nan_for_nonexisting:
+            return float("NaN")
+        else:
+            return 0.
+
+    return float(tp / (tp + fn))
+
+
+def recall(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=False, **kwargs):
+    """TP / (TP + FN)"""
+
+    return sensitivity(test, reference, confusion_matrix, nan_for_nonexisting, **kwargs)
+
+
+def specificity(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=False, **kwargs):
+    """TN / (TN + FP)"""
+
+    if confusion_matrix is None:
+        confusion_matrix = ConfusionMatrix(test, reference)
+
+    tp, fp, tn, fn = confusion_matrix.get_matrix()
+    test_empty, test_full, reference_empty, reference_full = confusion_matrix.get_existence()
+
+    if reference_full:
+        if nan_for_nonexisting:
+            return float("NaN")
+        else:
+            return 0.
+
+    return float(tn / (tn + fp))
+
+
+def accuracy(test=None, reference=None, confusion_matrix=None, **kwargs):
+    """(TP + TN) / (TP + FP + FN + TN)"""
+
+    if confusion_matrix is None:
+        confusion_matrix = ConfusionMatrix(test, reference)
+
+    tp, fp, tn, fn = confusion_matrix.get_matrix()
+
+    return float((tp + tn) / (tp + fp + tn + fn))
+
+
+def fscore(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=False, beta=1., **kwargs):
+    """(1 + b^2) * TP / ((1 + b^2) * TP + b^2 * FN + FP)"""
+
+    precision_ = precision(test, reference, confusion_matrix, nan_for_nonexisting)
+    recall_ = recall(test, reference, confusion_matrix, nan_for_nonexisting)
+
+    return (1 + beta*beta) * precision_ * recall_ /\
+        ((beta*beta * precision_) + recall_)
+
+
+def false_positive_rate(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=False, **kwargs):
+    """FP / (FP + TN)"""
+
+    return 1 - specificity(test, reference, confusion_matrix, nan_for_nonexisting)
+
+
+def false_omission_rate(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=False, **kwargs):
+    """FN / (TN + FN)"""
+
+    if confusion_matrix is None:
+        confusion_matrix = ConfusionMatrix(test, reference)
+
+    tp, fp, tn, fn = confusion_matrix.get_matrix()
+    test_empty, test_full, reference_empty, reference_full = confusion_matrix.get_existence()
+
+    if test_full:
+        if nan_for_nonexisting:
+            return float("NaN")
+        else:
+            return 0.
+
+    return float(fn / (fn + tn))
+
+
+def false_negative_rate(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=False, **kwargs):
+    """FN / (TP + FN)"""
+
+    return 1 - sensitivity(test, reference, confusion_matrix, nan_for_nonexisting)
+
+
+def true_negative_rate(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=False, **kwargs):
+    """TN / (TN + FP)"""
+
+    return specificity(test, reference, confusion_matrix, nan_for_nonexisting)
+
+
+def false_discovery_rate(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=False, **kwargs):
+    """FP / (TP + FP)"""
+
+    return 1 - precision(test, reference, confusion_matrix, nan_for_nonexisting)
+
+
+def negative_predictive_value(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=False, **kwargs):
+    """TN / (TN + FN)"""
+
+    return 1 - false_omission_rate(test, reference, confusion_matrix, nan_for_nonexisting)
+
+
+def total_positives_test(test=None, reference=None, confusion_matrix=None, **kwargs):
+    """TP + FP"""
+
+    if confusion_matrix is None:
+        confusion_matrix = ConfusionMatrix(test, reference)
+
+    tp, fp, tn, fn = confusion_matrix.get_matrix()
+
+    return tp + fp
+
+
+def total_negatives_test(test=None, reference=None, confusion_matrix=None, **kwargs):
+    """TN + FN"""
+
+    if confusion_matrix is None:
+        confusion_matrix = ConfusionMatrix(test, reference)
+
+    tp, fp, tn, fn = confusion_matrix.get_matrix()
+
+    return tn + fn
+
+
+def total_positives_reference(test=None, reference=None, confusion_matrix=None, **kwargs):
+    """TP + FN"""
+
+    if confusion_matrix is None:
+        confusion_matrix = ConfusionMatrix(test, reference)
+
+    tp, fp, tn, fn = confusion_matrix.get_matrix()
+
+    return tp + fn
+
+
+def total_negatives_reference(test=None, reference=None, confusion_matrix=None, **kwargs):
+    """TN + FP"""
+
+    if confusion_matrix is None:
+        confusion_matrix = ConfusionMatrix(test, reference)
+
+    tp, fp, tn, fn = confusion_matrix.get_matrix()
+
+    return tn + fp
+
+def hausdorff_distance(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=True, voxel_spacing=None, connectivity=1, **kwargs):
+
+    if confusion_matrix is None:
+        confusion_matrix = ConfusionMatrix(test, reference)
+
+    test_empty, test_full, reference_empty, reference_full = confusion_matrix.get_existence()
+
+    if test_empty or test_full or reference_empty or reference_full:
+
+
+        if nan_for_nonexisting:
+            return float("NaN")
+        else:
+            confusion_matrix.test = convert_corner_to_true(confusion_matrix.test)
+
+    test, reference = confusion_matrix.test, confusion_matrix.reference
+
+    return metric.hd(test, reference, voxel_spacing, connectivity)
+
+def convert_corner_to_true(segmentation):
+    a, b, c = segmentation.shape
+    segmentation[0, 0, 0] = True
+    segmentation[a - 1, 0, 0] = True
+    segmentation[0, b - 1, 0] = True
+    segmentation[0, 0, c - 1] = True
+
+    segmentation[a - 1, b - 1, 0] = True
+    segmentation[a - 1, b - 1, c - 1] = True
+    segmentation[0, b - 1, c - 1] = True
+    segmentation[a - 1, 0, c - 1] = True
+    return segmentation
+
+
+def hausdorff_distance_95(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=True, voxel_spacing=None, connectivity=1, **kwargs):
+
+    if confusion_matrix is None:
+        confusion_matrix = ConfusionMatrix(test, reference)
+
+    test_empty, test_full, reference_empty, reference_full = confusion_matrix.get_existence()
+
+    if test_empty or test_full or reference_empty or reference_full:
+        if nan_for_nonexisting:
+            return float("NaN")
+        else:
+            return hausdorff_distance(test=test, reference=reference, confusion_matrix=confusion_matrix, nan_for_nonexisting=nan_for_nonexisting, voxel_spacing=voxel_spacing, connectivity=connectivity)
+
+    test, reference = confusion_matrix.test, confusion_matrix.reference
+
+    return metric.hd95(test, reference, voxel_spacing, connectivity)
+
+
+def avg_surface_distance(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=True, voxel_spacing=None, connectivity=1, **kwargs):
+
+    if confusion_matrix is None:
+        confusion_matrix = ConfusionMatrix(test, reference)
+
+    test_empty, test_full, reference_empty, reference_full = confusion_matrix.get_existence()
+
+    if test_empty or test_full or reference_empty or reference_full:
+        if nan_for_nonexisting:
+            return float("NaN")
+        else:
+            return hausdorff_distance(test=test, reference=reference, confusion_matrix=confusion_matrix, nan_for_nonexisting=nan_for_nonexisting, voxel_spacing=voxel_spacing, connectivity=connectivity)
+
+    test, reference = confusion_matrix.test, confusion_matrix.reference
+
+    return metric.asd(test, reference, voxel_spacing, connectivity)
+
+def surface_dice(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=False, voxel_spacing=None, connectivity=1, distance=5, **kwargs):
+
+    if confusion_matrix is None:
+        confusion_matrix = ConfusionMatrix(test, reference)
+
+    test_empty, test_full, reference_empty, reference_full = confusion_matrix.get_existence()
+
+    if test_empty or test_full or reference_empty or reference_full:
+        if nan_for_nonexisting:
+            return float("NaN")
+        else:
+            return 0
+
+    test, reference = confusion_matrix.test, confusion_matrix.reference
+    sds_gt = metric.binary.__surface_distances(test, reference, voxel_spacing, connectivity)
+    sds_pred = metric.binary.__surface_distances(reference, test, voxel_spacing, connectivity)
+    overlap_gt = sum(i < distance for i in sds_gt)
+    overlap_pred = sum(i < distance for i in sds_pred)
+
+    return (overlap_gt + overlap_pred) / (len(sds_gt) + len(sds_pred))
+
+
+def avg_surface_distance_symmetric(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=True, voxel_spacing=None, connectivity=1, **kwargs):
+
+    if confusion_matrix is None:
+        confusion_matrix = ConfusionMatrix(test, reference)
+
+    test_empty, test_full, reference_empty, reference_full = confusion_matrix.get_existence()
+
+    if test_empty or test_full or reference_empty or reference_full:
+        if nan_for_nonexisting:
+            return float("NaN")
+        else:
+            return hausdorff_distance(test=test, reference=reference, confusion_matrix=confusion_matrix, nan_for_nonexisting=nan_for_nonexisting, voxel_spacing=voxel_spacing, connectivity=connectivity)
+
+    test, reference = confusion_matrix.test, confusion_matrix.reference
+
+    return metric.assd(test, reference, voxel_spacing, connectivity)
+
+
+ALL_METRICS = {
+    "False Positive Rate": false_positive_rate,
+    "Dice": dice,
+    "Jaccard": jaccard,
+    "Hausdorff Distance": hausdorff_distance,
+    "Hausdorff Distance 95": hausdorff_distance_95,
+    "Precision": precision,
+    "Recall": recall,
+    "Avg. Symmetric Surface Distance": avg_surface_distance_symmetric,
+    "Avg. Surface Distance": avg_surface_distance,
+    "Accuracy": accuracy,
+    "False Omission Rate": false_omission_rate,
+    "Negative Predictive Value": negative_predictive_value,
+    "False Negative Rate": false_negative_rate,
+    "True Negative Rate": true_negative_rate,
+    "False Discovery Rate": false_discovery_rate,
+    "Total Positives Test": total_positives_test,
+    "Total Negatives Test": total_negatives_test,
+    "Total Positives Reference": total_positives_reference,
+    "total Negatives Reference": total_negatives_reference,
+    "Surface Dice": surface_dice
+}

ATLAS/atlas-train-dataset-1.0.1/metric_calculation/requirements.txt

@@ -0,0 +1,5 @@
+batchgenerators==0.24
+MedPy==0.4.0
+numpy==1.21.5
+pandas==1.5.3
+SimpleITK==2.2.1

ATLAS/atlas-train-dataset-1.0.1/train/dataset.json

@@ -0,0 +1,265 @@
+{
+"description": "ATLAS challenge train dataset",
+"labels": {
+    "0": "background",
+    "1": "liver",
+    "2": "tumour"
+},
+"licence": "CC BY-NC-SA 4.0",
+"modality": {
+    "0": "T1w"
+},
+"name": "cgfl",
+"numTest": 0,
+"numTraining": 60,
+"reference": "Vanderbilt University",
+"release": "14/04/2023",
+"tensorImageSize": "3D",
+"validation": [
+],
+"training": [
+    {
+        "image": "imagesTr/im0.nii.gz",
+        "label": "labelsTr/lb0.nii.gz"
+    },
+    {
+        "image": "imagesTr/im1.nii.gz",
+        "label": "labelsTr/lb1.nii.gz"
+    },
+    {
+        "image": "imagesTr/im2.nii.gz",
+        "label": "labelsTr/lb2.nii.gz"
+    },
+    {
+        "image": "imagesTr/im3.nii.gz",
+        "label": "labelsTr/lb3.nii.gz"
+    },
+    {
+        "image": "imagesTr/im4.nii.gz",
+        "label": "labelsTr/lb4.nii.gz"
+    },  
+    {
+        "image": "imagesTr/im5.nii.gz",
+        "label": "labelsTr/lb5.nii.gz"
+    },
+    {
+        "image": "imagesTr/im6.nii.gz",
+        "label": "labelsTr/lb6.nii.gz"
+    },
+    {
+        "image": "imagesTr/im7.nii.gz",
+        "label": "labelsTr/lb7.nii.gz"
+    },
+    {
+        "image": "imagesTr/im8.nii.gz",
+        "label": "labelsTr/lb8.nii.gz"
+    },
+    {
+        "image": "imagesTr/im9.nii.gz",
+        "label": "labelsTr/lb9.nii.gz"
+    },
+    {
+        "image": "imagesTr/im10.nii.gz",
+        "label": "labelsTr/lb10.nii.gz"
+    },
+    {
+        "image": "imagesTr/im11.nii.gz",
+        "label": "labelsTr/lb11.nii.gz"
+    },
+    {
+        "image": "imagesTr/im12.nii.gz",
+        "label": "labelsTr/lb12.nii.gz"
+    },
+    {
+        "image": "imagesTr/im13.nii.gz",
+        "label": "labelsTr/lb13.nii.gz"
+    },
+    {
+        "image": "imagesTr/im14.nii.gz",
+        "label": "labelsTr/lb14.nii.gz"
+    },
+    {
+        "image": "imagesTr/im15.nii.gz",
+        "label": "labelsTr/lb15.nii.gz"
+    },
+    {
+        "image": "imagesTr/im16.nii.gz",
+        "label": "labelsTr/lb16.nii.gz"
+    },
+    {
+        "image": "imagesTr/im17.nii.gz",
+        "label": "labelsTr/lb17.nii.gz"
+    },
+    {
+        "image": "imagesTr/im18.nii.gz",
+        "label": "labelsTr/lb18.nii.gz"
+    },
+    {
+        "image": "imagesTr/im19.nii.gz",
+        "label": "labelsTr/lb19.nii.gz"
+    },
+    {
+        "image": "imagesTr/im20.nii.gz",
+        "label": "labelsTr/lb20.nii.gz"
+    },
+    {
+        "image": "imagesTr/im21.nii.gz",
+        "label": "labelsTr/lb21.nii.gz"
+    },
+    {
+        "image": "imagesTr/im22.nii.gz",
+        "label": "labelsTr/lb22.nii.gz"
+    },
+    {
+        "image": "imagesTr/im23.nii.gz",
+        "label": "labelsTr/lb23.nii.gz"
+    },
+    {
+        "image": "imagesTr/im24.nii.gz",
+        "label": "labelsTr/lb24.nii.gz"
+    },
+    {
+        "image": "imagesTr/im25.nii.gz",
+        "label": "labelsTr/lb25.nii.gz"
+    },
+    {
+        "image": "imagesTr/im26.nii.gz",
+        "label": "labelsTr/lb26.nii.gz"
+    },
+    {
+        "image": "imagesTr/im27.nii.gz",
+        "label": "labelsTr/lb27.nii.gz"
+    },
+    {
+        "image": "imagesTr/im28.nii.gz",
+        "label": "labelsTr/lb28.nii.gz"
+    },
+    {
+        "image": "imagesTr/im29.nii.gz",
+        "label": "labelsTr/lb29.nii.gz"
+    },
+    {
+        "image": "imagesTr/im30.nii.gz",
+        "label": "labelsTr/lb30.nii.gz"
+    },
+    {
+        "image": "imagesTr/im31.nii.gz",
+        "label": "labelsTr/lb31.nii.gz"
+    },
+    {
+        "image": "imagesTr/im32.nii.gz",
+        "label": "labelsTr/lb32.nii.gz"
+    },
+    {
+        "image": "imagesTr/im33.nii.gz",
+        "label": "labelsTr/lb33.nii.gz"
+    },
+    {
+        "image": "imagesTr/im34.nii.gz",
+        "label": "labelsTr/lb34.nii.gz"
+    },
+    {
+        "image": "imagesTr/im35.nii.gz",
+        "label": "labelsTr/lb35.nii.gz"
+    },
+    {
+        "image": "imagesTr/im36.nii.gz",
+        "label": "labelsTr/lb36.nii.gz"
+    },
+    {
+        "image": "imagesTr/im37.nii.gz",
+        "label": "labelsTr/lb37.nii.gz"
+    },
+    {
+        "image": "imagesTr/im38.nii.gz",
+        "label": "labelsTr/lb38.nii.gz"
+    },
+    {
+        "image": "imagesTr/im39.nii.gz",
+        "label": "labelsTr/lb39.nii.gz"
+    },
+    {
+        "image": "imagesTr/im40.nii.gz",
+        "label": "labelsTr/lb40.nii.gz"
+    },
+    {
+        "image": "imagesTr/im41.nii.gz",
+        "label": "labelsTr/lb41.nii.gz"
+    },
+    {
+        "image": "imagesTr/im42.nii.gz",
+        "label": "labelsTr/lb42.nii.gz"
+    },
+    {
+        "image": "imagesTr/im43.nii.gz",
+        "label": "labelsTr/lb43.nii.gz"
+    },
+    {
+        "image": "imagesTr/im44.nii.gz",
+        "label": "labelsTr/lb44.nii.gz"
+    },
+    {
+        "image": "imagesTr/im45.nii.gz",
+        "label": "labelsTr/lb45.nii.gz"
+    },
+    {
+        "image": "imagesTr/im46.nii.gz",
+        "label": "labelsTr/lb46.nii.gz"
+    },
+    {
+        "image": "imagesTr/im47.nii.gz",
+        "label": "labelsTr/lb47.nii.gz"
+    },
+    {
+        "image": "imagesTr/im48.nii.gz",
+        "label": "labelsTr/lb48.nii.gz"
+    },
+    {
+        "image": "imagesTr/im49.nii.gz",
+        "label": "labelsTr/lb49.nii.gz"
+    },
+    {
+        "image": "imagesTr/im50.nii.gz",
+        "label": "labelsTr/lb50.nii.gz"
+    },
+    {
+        "image": "imagesTr/im51.nii.gz",
+        "label": "labelsTr/lb51.nii.gz"
+    },
+    {
+        "image": "imagesTr/im52.nii.gz",
+        "label": "labelsTr/lb52.nii.gz"
+    },
+    {
+        "image": "imagesTr/im53.nii.gz",
+        "label": "labelsTr/lb53.nii.gz"
+    },
+    {
+        "image": "imagesTr/im54.nii.gz",
+        "label": "labelsTr/lb54.nii.gz"
+    },
+    {
+        "image": "imagesTr/im55.nii.gz",
+        "label": "labelsTr/lb55.nii.gz"
+    },
+    {
+        "image": "imagesTr/im56.nii.gz",
+        "label": "labelsTr/lb56.nii.gz"
+    },
+    {
+        "image": "imagesTr/im57.nii.gz",
+        "label": "labelsTr/lb57.nii.gz"
+    },
+    {
+        "image": "imagesTr/im58.nii.gz",
+        "label": "labelsTr/lb58.nii.gz"
+    },
+    {
+        "image": "imagesTr/im59.nii.gz",
+        "label": "labelsTr/lb59.nii.gz"
+    }
+]
+}
+
+
+

ATLAS/atlas-train-dataset-1.0.1/train/patient_info_train.json

@@ -0,0 +1,662 @@
+{
+    "0": {
+        "machine": "TrioTim",
+        "date": "2014",
+        "sequence": "VIBE",
+        "spacing": {
+            "x": 0.781,
+            "y": 0.781,
+            "z": 2.3
+        },
+        "contrast_phase": "arterial"
+    },
+    "1": {
+        "machine": "Skyra",
+        "date": "2017",
+        "sequence": "VIBE TWIST",
+        "spacing": {
+            "x": 0.938,
+            "y": 0.938,
+            "z": 2.5
+        },
+        "contrast_phase": "arterial"
+    },
+    "2": {
+        "machine": "Skyra",
+        "date": "2017",
+        "sequence": "VIBE",
+        "spacing": {
+            "x": 1.042,
+            "y": 1.042,
+            "z": 3.0
+        },
+        "contrast_phase": "delayed"
+    },
+    "3": {
+        "machine": "Aera",
+        "date": "2012",
+        "sequence": "VIBE",
+        "spacing": {
+            "x": 0.879,
+            "y": 0.879,
+            "z": 4.0
+        },
+        "contrast_phase": "arterial"
+    },
+    "4": {
+        "machine": "TrioTim",
+        "date": "2012",
+        "sequence": "VIBE",
+        "spacing": {
+            "x": 0.742,
+            "y": 0.742,
+            "z": 2.0
+        },
+        "contrast_phase": "arterial"
+    },
+    "5": {
+        "machine": "Aera",
+        "date": "2019",
+        "sequence": "VIBE CAIPIRINHA",
+        "spacing": {
+            "x": 1.25,
+            "y": 1.25,
+            "z": 3.0
+        },
+        "contrast_phase": "arterial"
+    },
+    "6": {
+        "machine": "TrioTim",
+        "date": "2013",
+        "sequence": "VIBE",
+        "spacing": {
+            "x": 0.879,
+            "y": 0.879,
+            "z": 2.5
+        },
+        "contrast_phase": "arterial"
+    },
+    "7": {
+        "machine": "Skyra",
+        "date": "2017",
+        "sequence": "VIBE",
+        "spacing": {
+            "x": 1.136,
+            "y": 1.136,
+            "z": 3.0
+        },
+        "contrast_phase": "arterial"
+    },
+    "8": {
+        "machine": "MAGNETOM Sola",
+        "date": "2019",
+        "sequence": "VIBE CAIPIRINHA",
+        "spacing": {
+            "x": 1.25,
+            "y": 1.25,
+            "z": 3.0
+        },
+        "contrast_phase": "delayed"
+    },
+    "9": {
+        "machine": "Skyra",
+        "date": "2020",
+        "sequence": "VIBE",
+        "spacing": {
+            "x": 1.042,
+            "y": 1.042,
+            "z": 3.0
+        },
+        "contrast_phase": "portal"
+    },
+    "10": {
+        "machine": "TrioTim",
+        "date": "2014",
+        "sequence": "VIBE",
+        "spacing": {
+            "x": 0.82,
+            "y": 0.82,
+            "z": 2.5
+        },
+        "contrast_phase": "unkown"
+    },
+    "11": {
+        "machine": "Aera",
+        "date": "2019",
+        "sequence": "VIBE CAIPIRINHA",
+        "spacing": {
+            "x": 1.25,
+            "y": 1.25,
+            "z": 3.0
+        },
+        "contrast_phase": "arterial"
+    },
+    "12": {
+        "machine": "Signa HDxt",
+        "date": "2017",
+        "sequence": "LAVA FLEX",
+        "spacing": {
+            "x": 0.781,
+            "y": 0.781,
+            "z": 4.6
+        },
+        "contrast_phase": "unkown"
+    },
+    "13": {
+        "machine": "MAGNETOM Sola",
+        "date": "2020",
+        "sequence": "VIBE CAIPIRINHA",
+        "spacing": {
+            "x": 1.188,
+            "y": 1.188,
+            "z": 3.0
+        },
+        "contrast_phase": "portal"
+    },
+    "14": {
+        "machine": "Aera",
+        "date": "2017",
+        "sequence": "VIBE CAIPIRINHA",
+        "spacing": {
+            "x": 1.312,
+            "y": 1.312,
+            "z": 3.0
+        },
+        "contrast_phase": "arterial"
+    },
+    "15": {
+        "machine": "Skyra",
+        "date": "2017",
+        "sequence": "VIBE TWIST",
+        "spacing": {
+            "x": 0.938,
+            "y": 0.938,
+            "z": 2.5
+        },
+        "contrast_phase": "arterial"
+    },
+    "16": {
+        "machine": "Aera",
+        "date": "2017",
+        "sequence": "VIBE CAIPIRINHA",
+        "spacing": {
+            "x": 1.406,
+            "y": 1.406,
+            "z": 3.0
+        },
+        "contrast_phase": "delayed"
+    },
+    "17": {
+        "machine": "Aera",
+        "date": "2015",
+        "sequence": "VIBE CAIPIRINHA",
+        "spacing": {
+            "x": 1.188,
+            "y": 1.188,
+            "z": 3.0
+        },
+        "contrast_phase": "arterial"
+    },
+    "18": {
+        "machine": "Aera",
+        "date": "2019",
+        "sequence": "VIBE",
+        "spacing": {
+            "x": 1.25,
+            "y": 1.25,
+            "z": 3.5
+        },
+        "contrast_phase": "arterial"
+    },
+    "19": {
+        "machine": "SIGNA Explorer",
+        "date": "2016",
+        "sequence": "LAVA",
+        "spacing": {
+            "x": 0.859,
+            "y": 0.859,
+            "z": 4.2
+        },
+        "contrast_phase": "delayed"
+    },
+    "20": {
+        "machine": "Skyra",
+        "date": "2017",
+        "sequence": "VIBE TWIST",
+        "spacing": {
+            "x": 0.938,
+            "y": 0.938,
+            "z": 2.5
+        },
+        "contrast_phase": "arterial"
+    },
+    "21": {
+        "machine": "TrioTim",
+        "date": "2016",
+        "sequence": "VIBE",
+        "spacing": {
+            "x": 0.977,
+            "y": 0.977,
+            "z": 2.1
+        },
+        "contrast_phase": "delayed"
+    },
+    "22": {
+        "machine": "Skyra",
+        "date": "2017",
+        "sequence": "VIBE TWIST",
+        "spacing": {
+            "x": 0.938,
+            "y": 0.938,
+            "z": 2.5
+        },
+        "contrast_phase": "arterial"
+    },
+    "23": {
+        "machine": "Aera",
+        "date": "2015",
+        "sequence": "VIBE CAIPIRINHA",
+        "spacing": {
+            "x": 1.188,
+            "y": 1.188,
+            "z": 3.0
+        },
+        "contrast_phase": "portal"
+    },
+    "24": {
+        "machine": "Signa HDxt",
+        "date": "2017",
+        "sequence": "LAVA FLEX",
+        "spacing": {
+            "x": 0.82,
+            "y": 0.82,
+            "z": 4.4
+        },
+        "contrast_phase": "unkown"
+    },
+    "25": {
+        "machine": "TrioTim",
+        "date": "2013",
+        "sequence": "VIBE",
+        "spacing": {
+            "x": 0.938,
+            "y": 0.938,
+            "z": 2.0
+        },
+        "contrast_phase": "arterial"
+    },
+    "26": {
+        "machine": "Aera",
+        "date": "2013",
+        "sequence": "VIBE",
+        "spacing": {
+            "x": 0.82,
+            "y": 0.82,
+            "z": 4.0
+        },
+        "contrast_phase": "arterial"
+    },
+    "27": {
+        "machine": "TrioTim",
+        "date": "2014",
+        "sequence": "VIBE",
+        "spacing": {
+            "x": 0.684,
+            "y": 0.684,
+            "z": 2.0
+        },
+        "contrast_phase": "portal"
+    },
+    "28": {
+        "machine": "Aera",
+        "date": "2017",
+        "sequence": "VIBE CAIPIRINHA",
+        "spacing": {
+            "x": 1.188,
+            "y": 1.188,
+            "z": 3.0
+        },
+        "contrast_phase": "arterial"
+    },
+    "29": {
+        "machine": "Aera",
+        "date": "2018",
+        "sequence": "VIBE CAIPIRINHA",
+        "spacing": {
+            "x": 1.188,
+            "y": 1.188,
+            "z": 3.0
+        },
+        "contrast_phase": "no contrast agent"
+    },
+    "30": {
+        "machine": "Optima MR450w",
+        "date": "2018",
+        "sequence": "LAVA",
+        "spacing": {
+            "x": 0.84,
+            "y": 0.84,
+            "z": 4.0
+        },
+        "contrast_phase": "unkown"
+    },
+    "31": {
+        "machine": "Aera",
+        "date": "2015",
+        "sequence": "VIBE CAIPIRINHA",
+        "spacing": {
+            "x": 1.188,
+            "y": 1.188,
+            "z": 3.0
+        },
+        "contrast_phase": "delayed"
+    },
+    "32": {
+        "machine": "Skyra",
+        "date": "2018",
+        "sequence": "VIBE TWIST",
+        "spacing": {
+            "x": 0.938,
+            "y": 0.938,
+            "z": 2.5
+        },
+        "contrast_phase": "arterial"
+    },
+    "33": {
+        "machine": "Aera",
+        "date": "2016",
+        "sequence": "VIBE CAIPIRINHA",
+        "spacing": {
+            "x": 1.188,
+            "y": 1.188,
+            "z": 2.6
+        },
+        "contrast_phase": "arterial"
+    },
+    "34": {
+        "machine": "Aera",
+        "date": "2018",
+        "sequence": "VIBE CAIPIRINHA",
+        "spacing": {
+            "x": 1.25,
+            "y": 1.25,
+            "z": 3.0
+        },
+        "contrast_phase": "arterial"
+    },
+    "35": {
+        "machine": "Aera",
+        "date": "2014",
+        "sequence": "VIBE CAIPIRINHA",
+        "spacing": {
+            "x": 1.188,
+            "y": 1.188,
+            "z": 3.0
+        },
+        "contrast_phase": "arterial"
+    },
+    "36": {
+        "machine": "Aera",
+        "date": "2016",
+        "sequence": "VIBE",
+        "spacing": {
+            "x": 1.25,
+            "y": 1.25,
+            "z": 3.5
+        },
+        "contrast_phase": "delayed"
+    },
+    "37": {
+        "machine": "Skyra",
+        "date": "2020",
+        "sequence": "VIBE",
+        "spacing": {
+            "x": 1.172,
+            "y": 1.172,
+            "z": 3.0
+        },
+        "contrast_phase": "portal"
+    },
+    "38": {
+        "machine": "Skyra",
+        "date": "2019",
+        "sequence": "VIBE",
+        "spacing": {
+            "x": 1.042,
+            "y": 1.042,
+            "z": 3.0
+        },
+        "contrast_phase": "portal"
+    },
+    "39": {
+        "machine": "TrioTim",
+        "date": "2014",
+        "sequence": "VIBE",
+        "spacing": {
+            "x": 0.762,
+            "y": 0.762,
+            "z": 2.0
+        },
+        "contrast_phase": "arterial"
+    },
+    "40": {
+        "machine": "Skyra",
+        "date": "2017",
+        "sequence": "VIBE TWIST",
+        "spacing": {
+            "x": 0.938,
+            "y": 0.938,
+            "z": 2.5
+        },
+        "contrast_phase": "arterial"
+    },
+    "41": {
+        "machine": "Aera",
+        "date": "2013",
+        "sequence": "VIBE CAIPIRINHA",
+        "spacing": {
+            "x": 1.25,
+            "y": 1.25,
+            "z": 3.5
+        },
+        "contrast_phase": "portal"
+    },
+    "42": {
+        "machine": "Skyra",
+        "date": "2017",
+        "sequence": "VIBE TWIST",
+        "spacing": {
+            "x": 0.938,
+            "y": 0.938,
+            "z": 2.5
+        },
+        "contrast_phase": "arterial"
+    },
+    "43": {
+        "machine": "MAGNETOM Sola",
+        "date": "2020",
+        "sequence": "VIBE",
+        "spacing": {
+            "x": 0.938,
+            "y": 0.938,
+            "z": 3.0
+        },
+        "contrast_phase": "arterial"
+    },
+    "44": {
+        "machine": "Aera",
+        "date": "2017",
+        "sequence": "VIBE CAIPIRINHA",
+        "spacing": {
+            "x": 1.188,
+            "y": 1.188,
+            "z": 3.0
+        },
+        "contrast_phase": "arterial"
+    },
+    "45": {
+        "machine": "MAGNETOM Sola",
+        "date": "2020",
+        "sequence": "VIBE",
+        "spacing": {
+            "x": 0.938,
+            "y": 0.938,
+            "z": 3.0
+        },
+        "contrast_phase": "arterial"
+    },
+    "46": {
+        "machine": "Aera",
+        "date": "2018",
+        "sequence": "VIBE CAIPIRINHA",
+        "spacing": {
+            "x": 1.188,
+            "y": 1.188,
+            "z": 3.0
+        },
+        "contrast_phase": "portal"
+    },
+    "47": {
+        "machine": "OPTIMA MR360",
+        "date": "2015",
+        "sequence": "LAVA",
+        "spacing": {
+            "x": 0.859,
+            "y": 0.859,
+            "z": 4.4
+        },
+        "contrast_phase": "unkown"
+    },
+    "48": {
+        "machine": "Aera",
+        "date": "2016",
+        "sequence": "VIBE CAIPIRINHA",
+        "spacing": {
+            "x": 1.312,
+            "y": 1.312,
+            "z": 3.0
+        },
+        "contrast_phase": "arterial"
+    },
+    "49": {
+        "machine": "Aera",
+        "date": "2020",
+        "sequence": "VIBE CAIPIRINHA",
+        "spacing": {
+            "x": 1.188,
+            "y": 1.188,
+            "z": 3.0
+        },
+        "contrast_phase": "arterial"
+    },
+    "50": {
+        "machine": "SIGNA Explorer",
+        "date": "2016",
+        "sequence": "LAVA",
+        "spacing": {
+            "x": 0.859,
+            "y": 0.859,
+            "z": 4.6
+        },
+        "contrast_phase": "unkown"
+    },
+    "51": {
+        "machine": "Skyra",
+        "date": "2019",
+        "sequence": "VIBE",
+        "spacing": {
+            "x": 1.042,
+            "y": 1.042,
+            "z": 3.0
+        },
+        "contrast_phase": "portal"
+    },
+    "52": {
+        "machine": "Aera",
+        "date": "2014",
+        "sequence": "VIBE",
+        "spacing": {
+            "x": 1.188,
+            "y": 1.188,
+            "z": 3.0
+        },
+        "contrast_phase": "no contrast agent"
+    },
+    "53": {
+        "machine": "Aera",
+        "date": "2019",
+        "sequence": "VIBE CAIPIRINHA",
+        "spacing": {
+            "x": 1.188,
+            "y": 1.188,
+            "z": 3.0
+        },
+        "contrast_phase": "arterial"
+    },
+    "54": {
+        "machine": "TrioTim",
+        "date": "2016",
+        "sequence": "VIBE",
+        "spacing": {
+            "x": 0.918,
+            "y": 0.918,
+            "z": 2.0
+        },
+        "contrast_phase": "arterial"
+    },
+    "55": {
+        "machine": "SIGNA Voyager",
+        "date": "2017",
+        "sequence": "LAVA",
+        "spacing": {
+            "x": 0.898,
+            "y": 0.898,
+            "z": 4.4
+        },
+        "contrast_phase": "unkown"
+    },
+    "56": {
+        "machine": "Aera",
+        "date": "2020",
+        "sequence": "VIBE CAIPIRINHA",
+        "spacing": {
+            "x": 1.375,
+            "y": 1.375,
+            "z": 3.0
+        },
+        "contrast_phase": "portal"
+    },
+    "57": {
+        "machine": "Aera",
+        "date": "2019",
+        "sequence": "VIBE",
+        "spacing": {
+            "x": 1.25,
+            "y": 1.25,
+            "z": 3.5
+        },
+        "contrast_phase": "delayed"
+    },
+    "58": {
+        "machine": "Aera",
+        "date": "2013",
+        "sequence": "VIBE",
+        "spacing": {
+            "x": 1.146,
+            "y": 1.146,
+            "z": 3.0
+        },
+        "contrast_phase": "arterial"
+    },
+    "59": {
+        "machine": "Aera",
+        "date": "2018",
+        "sequence": "VIBE CAIPIRINHA",
+        "spacing": {
+            "x": 1.312,
+            "y": 1.312,
+            "z": 3.0
+        },
+        "contrast_phase": "arterial"
+    }
+}

amos/amos22/dataset.json

@@ -0,0 +1 @@
+{"name": "AMOS", "description": "Amos: A large-scale abdominal multi-organ benchmark for versatile medical image segmentation", "author": "Yuanfeng Ji", "reference": "SRIDB x CUHKSZ x HKU x LGCHSZ x LGPHSZ", "licence": "CC-BY-SA 4.0", "release": "1.0 01/05/2022", "contact": "[email protected]", "tensorImageSize": "3D", "modality": {"0": "CT"}, "labels": {"0": "background", "1": "spleen", "2": "right kidney", "3": "left kidney", "4": "gall bladder", "5": "esophagus", "6": "liver", "7": "stomach", "8": "arota", "9": "postcava", "10": "pancreas", "11": "right adrenal gland", "12": "left adrenal gland", "13": "duodenum", "14": "bladder", "15": "prostate/uterus"}, "numTraining": 240, "numValidation": 120, "numTest": 240, "training": [{"image": "./imagesTr/amos_0001.nii.gz", "label": "./labelsTr/amos_0001.nii.gz"}, {"image": "./imagesTr/amos_0004.nii.gz", "label": "./labelsTr/amos_0004.nii.gz"}, {"image": "./imagesTr/amos_0005.nii.gz", "label": "./labelsTr/amos_0005.nii.gz"}, {"image": "./imagesTr/amos_0006.nii.gz", "label": "./labelsTr/amos_0006.nii.gz"}, {"image": "./imagesTr/amos_0007.nii.gz", "label": "./labelsTr/amos_0007.nii.gz"}, {"image": "./imagesTr/amos_0009.nii.gz", "label": "./labelsTr/amos_0009.nii.gz"}, {"image": "./imagesTr/amos_0010.nii.gz", "label": "./labelsTr/amos_0010.nii.gz"}, {"image": "./imagesTr/amos_0011.nii.gz", "label": "./labelsTr/amos_0011.nii.gz"}, {"image": "./imagesTr/amos_0014.nii.gz", "label": "./labelsTr/amos_0014.nii.gz"}, {"image": "./imagesTr/amos_0015.nii.gz", "label": "./labelsTr/amos_0015.nii.gz"}, {"image": "./imagesTr/amos_0016.nii.gz", "label": "./labelsTr/amos_0016.nii.gz"}, {"image": "./imagesTr/amos_0017.nii.gz", "label": "./labelsTr/amos_0017.nii.gz"}, {"image": "./imagesTr/amos_0019.nii.gz", "label": "./labelsTr/amos_0019.nii.gz"}, {"image": "./imagesTr/amos_0021.nii.gz", "label": "./labelsTr/amos_0021.nii.gz"}, {"image": "./imagesTr/amos_0023.nii.gz", "label": "./labelsTr/amos_0023.nii.gz"}, {"image": "./imagesTr/amos_0024.nii.gz", "label": "./labelsTr/amos_0024.nii.gz"}, {"image": "./imagesTr/amos_0025.nii.gz", "label": "./labelsTr/amos_0025.nii.gz"}, {"image": "./imagesTr/amos_0027.nii.gz", "label": "./labelsTr/amos_0027.nii.gz"}, {"image": "./imagesTr/amos_0030.nii.gz", "label": "./labelsTr/amos_0030.nii.gz"}, {"image": "./imagesTr/amos_0033.nii.gz", "label": "./labelsTr/amos_0033.nii.gz"}, {"image": "./imagesTr/amos_0035.nii.gz", "label": "./labelsTr/amos_0035.nii.gz"}, {"image": "./imagesTr/amos_0036.nii.gz", "label": "./labelsTr/amos_0036.nii.gz"}, {"image": "./imagesTr/amos_0038.nii.gz", "label": "./labelsTr/amos_0038.nii.gz"}, {"image": "./imagesTr/amos_0042.nii.gz", "label": "./labelsTr/amos_0042.nii.gz"}, {"image": "./imagesTr/amos_0043.nii.gz", "label": "./labelsTr/amos_0043.nii.gz"}, {"image": "./imagesTr/amos_0044.nii.gz", "label": "./labelsTr/amos_0044.nii.gz"}, {"image": "./imagesTr/amos_0045.nii.gz", "label": "./labelsTr/amos_0045.nii.gz"}, {"image": "./imagesTr/amos_0047.nii.gz", "label": "./labelsTr/amos_0047.nii.gz"}, {"image": "./imagesTr/amos_0048.nii.gz", "label": "./labelsTr/amos_0048.nii.gz"}, {"image": "./imagesTr/amos_0049.nii.gz", "label": "./labelsTr/amos_0049.nii.gz"}, {"image": "./imagesTr/amos_0050.nii.gz", "label": "./labelsTr/amos_0050.nii.gz"}, {"image": "./imagesTr/amos_0052.nii.gz", "label": "./labelsTr/amos_0052.nii.gz"}, {"image": "./imagesTr/amos_0054.nii.gz", "label": "./labelsTr/amos_0054.nii.gz"}, {"image": "./imagesTr/amos_0057.nii.gz", "label": "./labelsTr/amos_0057.nii.gz"}, {"image": "./imagesTr/amos_0058.nii.gz", "label": "./labelsTr/amos_0058.nii.gz"}, {"image": "./imagesTr/amos_0059.nii.gz", "label": "./labelsTr/amos_0059.nii.gz"}, {"image": "./imagesTr/amos_0060.nii.gz", "label": "./labelsTr/amos_0060.nii.gz"}, {"image": "./imagesTr/amos_0064.nii.gz", "label": "./labelsTr/amos_0064.nii.gz"}, {"image": "./imagesTr/amos_0066.nii.gz", "label": "./labelsTr/amos_0066.nii.gz"}, {"image": "./imagesTr/amos_0067.nii.gz", "label": "./labelsTr/amos_0067.nii.gz"}, {"image": "./imagesTr/amos_0069.nii.gz", "label": "./labelsTr/amos_0069.nii.gz"}, {"image": "./imagesTr/amos_0071.nii.gz", "label": "./labelsTr/amos_0071.nii.gz"}, {"image": "./imagesTr/amos_0072.nii.gz", "label": "./labelsTr/amos_0072.nii.gz"}, {"image": "./imagesTr/amos_0075.nii.gz", "label": "./labelsTr/amos_0075.nii.gz"}, {"image": "./imagesTr/amos_0076.nii.gz", "label": "./labelsTr/amos_0076.nii.gz"}, {"image": "./imagesTr/amos_0077.nii.gz", "label": "./labelsTr/amos_0077.nii.gz"}, {"image": "./imagesTr/amos_0078.nii.gz", "label": "./labelsTr/amos_0078.nii.gz"}, {"image": "./imagesTr/amos_0079.nii.gz", "label": "./labelsTr/amos_0079.nii.gz"}, {"image": "./imagesTr/amos_0081.nii.gz", "label": "./labelsTr/amos_0081.nii.gz"}, {"image": "./imagesTr/amos_0083.nii.gz", "label": "./labelsTr/amos_0083.nii.gz"}, {"image": "./imagesTr/amos_0084.nii.gz", "label": "./labelsTr/amos_0084.nii.gz"}, {"image": "./imagesTr/amos_0086.nii.gz", "label": "./labelsTr/amos_0086.nii.gz"}, {"image": "./imagesTr/amos_0088.nii.gz", "label": "./labelsTr/amos_0088.nii.gz"}, {"image": "./imagesTr/amos_0089.nii.gz", "label": "./labelsTr/amos_0089.nii.gz"}, {"image": "./imagesTr/amos_0092.nii.gz", "label": "./labelsTr/amos_0092.nii.gz"}, {"image": "./imagesTr/amos_0094.nii.gz", "label": "./labelsTr/amos_0094.nii.gz"}, {"image": "./imagesTr/amos_0097.nii.gz", "label": "./labelsTr/amos_0097.nii.gz"}, {"image": "./imagesTr/amos_0098.nii.gz", "label": "./labelsTr/amos_0098.nii.gz"}, {"image": "./imagesTr/amos_0099.nii.gz", "label": "./labelsTr/amos_0099.nii.gz"}, {"image": "./imagesTr/amos_0102.nii.gz", "label": "./labelsTr/amos_0102.nii.gz"}, {"image": "./imagesTr/amos_0103.nii.gz", "label": "./labelsTr/amos_0103.nii.gz"}, {"image": "./imagesTr/amos_0104.nii.gz", "label": "./labelsTr/amos_0104.nii.gz"}, {"image": "./imagesTr/amos_0105.nii.gz", "label": "./labelsTr/amos_0105.nii.gz"}, {"image": "./imagesTr/amos_0109.nii.gz", "label": "./labelsTr/amos_0109.nii.gz"}, {"image": "./imagesTr/amos_0110.nii.gz", "label": "./labelsTr/amos_0110.nii.gz"}, {"image": "./imagesTr/amos_0111.nii.gz", "label": "./labelsTr/amos_0111.nii.gz"}, {"image": "./imagesTr/amos_0113.nii.gz", "label": "./labelsTr/amos_0113.nii.gz"}, {"image": "./imagesTr/amos_0115.nii.gz", "label": "./labelsTr/amos_0115.nii.gz"}, {"image": "./imagesTr/amos_0116.nii.gz", "label": "./labelsTr/amos_0116.nii.gz"}, {"image": "./imagesTr/amos_0118.nii.gz", "label": "./labelsTr/amos_0118.nii.gz"}, {"image": "./imagesTr/amos_0119.nii.gz", "label": "./labelsTr/amos_0119.nii.gz"}, {"image": "./imagesTr/amos_0121.nii.gz", "label": "./labelsTr/amos_0121.nii.gz"}, {"image": "./imagesTr/amos_0124.nii.gz", "label": "./labelsTr/amos_0124.nii.gz"}, {"image": "./imagesTr/amos_0125.nii.gz", "label": "./labelsTr/amos_0125.nii.gz"}, {"image": "./imagesTr/amos_0126.nii.gz", "label": "./labelsTr/amos_0126.nii.gz"}, {"image": "./imagesTr/amos_0127.nii.gz", "label": "./labelsTr/amos_0127.nii.gz"}, {"image": "./imagesTr/amos_0129.nii.gz", "label": "./labelsTr/amos_0129.nii.gz"}, {"image": "./imagesTr/amos_0131.nii.gz", "label": "./labelsTr/amos_0131.nii.gz"}, {"image": "./imagesTr/amos_0133.nii.gz", "label": "./labelsTr/amos_0133.nii.gz"}, {"image": "./imagesTr/amos_0134.nii.gz", "label": "./labelsTr/amos_0134.nii.gz"}, {"image": "./imagesTr/amos_0135.nii.gz", "label": "./labelsTr/amos_0135.nii.gz"}, {"image": "./imagesTr/amos_0137.nii.gz", "label": "./labelsTr/amos_0137.nii.gz"}, {"image": "./imagesTr/amos_0138.nii.gz", "label": "./labelsTr/amos_0138.nii.gz"}, {"image": "./imagesTr/amos_0141.nii.gz", "label": "./labelsTr/amos_0141.nii.gz"}, {"image": "./imagesTr/amos_0142.nii.gz", "label": "./labelsTr/amos_0142.nii.gz"}, {"image": "./imagesTr/amos_0143.nii.gz", "label": "./labelsTr/amos_0143.nii.gz"}, {"image": "./imagesTr/amos_0147.nii.gz", "label": "./labelsTr/amos_0147.nii.gz"}, {"image": "./imagesTr/amos_0149.nii.gz", "label": "./labelsTr/amos_0149.nii.gz"}, {"image": "./imagesTr/amos_0152.nii.gz", "label": "./labelsTr/amos_0152.nii.gz"}, {"image": "./imagesTr/amos_0153.nii.gz", "label": "./labelsTr/amos_0153.nii.gz"}, {"image": "./imagesTr/amos_0154.nii.gz", "label": "./labelsTr/amos_0154.nii.gz"}, {"image": "./imagesTr/amos_0156.nii.gz", "label": "./labelsTr/amos_0156.nii.gz"}, {"image": "./imagesTr/amos_0158.nii.gz", "label": "./labelsTr/amos_0158.nii.gz"}, {"image": "./imagesTr/amos_0159.nii.gz", "label": "./labelsTr/amos_0159.nii.gz"}, {"image": "./imagesTr/amos_0160.nii.gz", "label": "./labelsTr/amos_0160.nii.gz"}, {"image": "./imagesTr/amos_0161.nii.gz", "label": "./labelsTr/amos_0161.nii.gz"}, {"image": "./imagesTr/amos_0162.nii.gz", "label": "./labelsTr/amos_0162.nii.gz"}, {"image": "./imagesTr/amos_0166.nii.gz", "label": "./labelsTr/amos_0166.nii.gz"}, {"image": "./imagesTr/amos_0170.nii.gz", "label": "./labelsTr/amos_0170.nii.gz"}, {"image": "./imagesTr/amos_0171.nii.gz", "label": "./labelsTr/amos_0171.nii.gz"}, {"image": "./imagesTr/amos_0172.nii.gz", "label": "./labelsTr/amos_0172.nii.gz"}, {"image": "./imagesTr/amos_0173.nii.gz", "label": "./labelsTr/amos_0173.nii.gz"}, {"image": "./imagesTr/amos_0175.nii.gz", "label": "./labelsTr/amos_0175.nii.gz"}, {"image": "./imagesTr/amos_0177.nii.gz", "label": "./labelsTr/amos_0177.nii.gz"}, {"image": "./imagesTr/amos_0179.nii.gz", "label": "./labelsTr/amos_0179.nii.gz"}, {"image": "./imagesTr/amos_0180.nii.gz", "label": "./labelsTr/amos_0180.nii.gz"}, {"image": "./imagesTr/amos_0181.nii.gz", "label": "./labelsTr/amos_0181.nii.gz"}, {"image": "./imagesTr/amos_0184.nii.gz", "label": "./labelsTr/amos_0184.nii.gz"}, {"image": "./imagesTr/amos_0185.nii.gz", "label": "./labelsTr/amos_0185.nii.gz"}, {"image": "./imagesTr/amos_0186.nii.gz", "label": "./labelsTr/amos_0186.nii.gz"}, {"image": "./imagesTr/amos_0188.nii.gz", "label": "./labelsTr/amos_0188.nii.gz"}, {"image": "./imagesTr/amos_0190.nii.gz", "label": "./labelsTr/amos_0190.nii.gz"}, {"image": "./imagesTr/amos_0192.nii.gz", "label": "./labelsTr/amos_0192.nii.gz"}, {"image": "./imagesTr/amos_0193.nii.gz", "label": "./labelsTr/amos_0193.nii.gz"}, {"image": "./imagesTr/amos_0195.nii.gz", "label": "./labelsTr/amos_0195.nii.gz"}, {"image": "./imagesTr/amos_0196.nii.gz", "label": "./labelsTr/amos_0196.nii.gz"}, {"image": "./imagesTr/amos_0197.nii.gz", "label": "./labelsTr/amos_0197.nii.gz"}, {"image": "./imagesTr/amos_0198.nii.gz", "label": "./labelsTr/amos_0198.nii.gz"}, {"image": "./imagesTr/amos_0199.nii.gz", "label": "./labelsTr/amos_0199.nii.gz"}, {"image": "./imagesTr/amos_0212.nii.gz", "label": "./labelsTr/amos_0212.nii.gz"}, {"image": "./imagesTr/amos_0214.nii.gz", "label": "./labelsTr/amos_0214.nii.gz"}, {"image": "./imagesTr/amos_0215.nii.gz", "label": "./labelsTr/amos_0215.nii.gz"}, {"image": "./imagesTr/amos_0217.nii.gz", "label": "./labelsTr/amos_0217.nii.gz"}, {"image": "./imagesTr/amos_0224.nii.gz", "label": "./labelsTr/amos_0224.nii.gz"}, {"image": "./imagesTr/amos_0225.nii.gz", "label": "./labelsTr/amos_0225.nii.gz"}, {"image": "./imagesTr/amos_0226.nii.gz", "label": "./labelsTr/amos_0226.nii.gz"}, {"image": "./imagesTr/amos_0230.nii.gz", "label": "./labelsTr/amos_0230.nii.gz"}, {"image": "./imagesTr/amos_0231.nii.gz", "label": "./labelsTr/amos_0231.nii.gz"}, {"image": "./imagesTr/amos_0235.nii.gz", "label": "./labelsTr/amos_0235.nii.gz"}, {"image": "./imagesTr/amos_0237.nii.gz", "label": "./labelsTr/amos_0237.nii.gz"}, {"image": "./imagesTr/amos_0239.nii.gz", "label": "./labelsTr/amos_0239.nii.gz"}, {"image": "./imagesTr/amos_0242.nii.gz", "label": "./labelsTr/amos_0242.nii.gz"}, {"image": "./imagesTr/amos_0245.nii.gz", "label": "./labelsTr/amos_0245.nii.gz"}, {"image": "./imagesTr/amos_0248.nii.gz", "label": "./labelsTr/amos_0248.nii.gz"}, {"image": "./imagesTr/amos_0249.nii.gz", "label": "./labelsTr/amos_0249.nii.gz"}, {"image": "./imagesTr/amos_0254.nii.gz", "label": "./labelsTr/amos_0254.nii.gz"}, {"image": "./imagesTr/amos_0259.nii.gz", "label": "./labelsTr/amos_0259.nii.gz"}, {"image": "./imagesTr/amos_0263.nii.gz", "label": "./labelsTr/amos_0263.nii.gz"}, {"image": "./imagesTr/amos_0264.nii.gz", "label": "./labelsTr/amos_0264.nii.gz"}, {"image": "./imagesTr/amos_0268.nii.gz", "label": "./labelsTr/amos_0268.nii.gz"}, {"image": "./imagesTr/amos_0272.nii.gz", "label": "./labelsTr/amos_0272.nii.gz"}, {"image": "./imagesTr/amos_0273.nii.gz", "label": "./labelsTr/amos_0273.nii.gz"}, {"image": "./imagesTr/amos_0274.nii.gz", "label": "./labelsTr/amos_0274.nii.gz"}, {"image": "./imagesTr/amos_0276.nii.gz", "label": "./labelsTr/amos_0276.nii.gz"}, {"image": "./imagesTr/amos_0279.nii.gz", "label": "./labelsTr/amos_0279.nii.gz"}, {"image": "./imagesTr/amos_0281.nii.gz", "label": "./labelsTr/amos_0281.nii.gz"}, {"image": "./imagesTr/amos_0282.nii.gz", "label": "./labelsTr/amos_0282.nii.gz"}, {"image": "./imagesTr/amos_0288.nii.gz", "label": "./labelsTr/amos_0288.nii.gz"}, {"image": "./imagesTr/amos_0294.nii.gz", "label": "./labelsTr/amos_0294.nii.gz"}, {"image": "./imagesTr/amos_0296.nii.gz", "label": "./labelsTr/amos_0296.nii.gz"}, {"image": "./imagesTr/amos_0297.nii.gz", "label": "./labelsTr/amos_0297.nii.gz"}, {"image": "./imagesTr/amos_0299.nii.gz", "label": "./labelsTr/amos_0299.nii.gz"}, {"image": "./imagesTr/amos_0301.nii.gz", "label": "./labelsTr/amos_0301.nii.gz"}, {"image": "./imagesTr/amos_0302.nii.gz", "label": "./labelsTr/amos_0302.nii.gz"}, {"image": "./imagesTr/amos_0307.nii.gz", "label": "./labelsTr/amos_0307.nii.gz"}, {"image": "./imagesTr/amos_0317.nii.gz", "label": "./labelsTr/amos_0317.nii.gz"}, {"image": "./imagesTr/amos_0320.nii.gz", "label": "./labelsTr/amos_0320.nii.gz"}, {"image": "./imagesTr/amos_0321.nii.gz", "label": "./labelsTr/amos_0321.nii.gz"}, {"image": "./imagesTr/amos_0330.nii.gz", "label": "./labelsTr/amos_0330.nii.gz"}, {"image": "./imagesTr/amos_0332.nii.gz", "label": "./labelsTr/amos_0332.nii.gz"}, {"image": "./imagesTr/amos_0336.nii.gz", "label": "./labelsTr/amos_0336.nii.gz"}, {"image": "./imagesTr/amos_0337.nii.gz", "label": "./labelsTr/amos_0337.nii.gz"}, {"image": "./imagesTr/amos_0341.nii.gz", "label": "./labelsTr/amos_0341.nii.gz"}, {"image": "./imagesTr/amos_0348.nii.gz", "label": "./labelsTr/amos_0348.nii.gz"}, {"image": "./imagesTr/amos_0349.nii.gz", "label": "./labelsTr/amos_0349.nii.gz"}, {"image": "./imagesTr/amos_0350.nii.gz", "label": "./labelsTr/amos_0350.nii.gz"}, {"image": "./imagesTr/amos_0351.nii.gz", "label": "./labelsTr/amos_0351.nii.gz"}, {"image": "./imagesTr/amos_0353.nii.gz", "label": "./labelsTr/amos_0353.nii.gz"}, {"image": "./imagesTr/amos_0358.nii.gz", "label": "./labelsTr/amos_0358.nii.gz"}, {"image": "./imagesTr/amos_0361.nii.gz", "label": "./labelsTr/amos_0361.nii.gz"}, {"image": "./imagesTr/amos_0362.nii.gz", "label": "./labelsTr/amos_0362.nii.gz"}, {"image": "./imagesTr/amos_0366.nii.gz", "label": "./labelsTr/amos_0366.nii.gz"}, {"image": "./imagesTr/amos_0367.nii.gz", "label": "./labelsTr/amos_0367.nii.gz"}, {"image": "./imagesTr/amos_0370.nii.gz", "label": "./labelsTr/amos_0370.nii.gz"}, {"image": "./imagesTr/amos_0371.nii.gz", "label": "./labelsTr/amos_0371.nii.gz"}, {"image": "./imagesTr/amos_0374.nii.gz", "label": "./labelsTr/amos_0374.nii.gz"}, {"image": "./imagesTr/amos_0376.nii.gz", "label": "./labelsTr/amos_0376.nii.gz"}, {"image": "./imagesTr/amos_0378.nii.gz", "label": "./labelsTr/amos_0378.nii.gz"}, {"image": "./imagesTr/amos_0379.nii.gz", "label": "./labelsTr/amos_0379.nii.gz"}, {"image": "./imagesTr/amos_0380.nii.gz", "label": "./labelsTr/amos_0380.nii.gz"}, {"image": "./imagesTr/amos_0381.nii.gz", "label": "./labelsTr/amos_0381.nii.gz"}, {"image": "./imagesTr/amos_0383.nii.gz", "label": "./labelsTr/amos_0383.nii.gz"}, {"image": "./imagesTr/amos_0384.nii.gz", "label": "./labelsTr/amos_0384.nii.gz"}, {"image": "./imagesTr/amos_0387.nii.gz", "label": "./labelsTr/amos_0387.nii.gz"}, {"image": "./imagesTr/amos_0388.nii.gz", "label": "./labelsTr/amos_0388.nii.gz"}, {"image": "./imagesTr/amos_0390.nii.gz", "label": "./labelsTr/amos_0390.nii.gz"}, {"image": "./imagesTr/amos_0391.nii.gz", "label": "./labelsTr/amos_0391.nii.gz"}, {"image": "./imagesTr/amos_0392.nii.gz", "label": "./labelsTr/amos_0392.nii.gz"}, {"image": "./imagesTr/amos_0395.nii.gz", "label": "./labelsTr/amos_0395.nii.gz"}, {"image": "./imagesTr/amos_0396.nii.gz", "label": "./labelsTr/amos_0396.nii.gz"}, {"image": "./imagesTr/amos_0398.nii.gz", "label": "./labelsTr/amos_0398.nii.gz"}, {"image": "./imagesTr/amos_0400.nii.gz", "label": "./labelsTr/amos_0400.nii.gz"}, {"image": "./imagesTr/amos_0401.nii.gz", "label": "./labelsTr/amos_0401.nii.gz"}, {"image": "./imagesTr/amos_0402.nii.gz", "label": "./labelsTr/amos_0402.nii.gz"}, {"image": "./imagesTr/amos_0403.nii.gz", "label": "./labelsTr/amos_0403.nii.gz"}, {"image": "./imagesTr/amos_0404.nii.gz", "label": "./labelsTr/amos_0404.nii.gz"}, {"image": "./imagesTr/amos_0405.nii.gz", "label": "./labelsTr/amos_0405.nii.gz"}, {"image": "./imagesTr/amos_0406.nii.gz", "label": "./labelsTr/amos_0406.nii.gz"}, {"image": "./imagesTr/amos_0408.nii.gz", "label": "./labelsTr/amos_0408.nii.gz"}, {"image": "./imagesTr/amos_0410.nii.gz", "label": "./labelsTr/amos_0410.nii.gz"}, {"image": "./imagesTr/amos_0507.nii.gz", "label": "./labelsTr/amos_0507.nii.gz"}, {"image": "./imagesTr/amos_0508.nii.gz", "label": "./labelsTr/amos_0508.nii.gz"}, {"image": "./imagesTr/amos_0510.nii.gz", "label": "./labelsTr/amos_0510.nii.gz"}, {"image": "./imagesTr/amos_0514.nii.gz", "label": "./labelsTr/amos_0514.nii.gz"}, {"image": "./imagesTr/amos_0517.nii.gz", "label": "./labelsTr/amos_0517.nii.gz"}, {"image": "./imagesTr/amos_0518.nii.gz", "label": "./labelsTr/amos_0518.nii.gz"}, {"image": "./imagesTr/amos_0522.nii.gz", "label": "./labelsTr/amos_0522.nii.gz"}, {"image": "./imagesTr/amos_0530.nii.gz", "label": "./labelsTr/amos_0530.nii.gz"}, {"image": "./imagesTr/amos_0532.nii.gz", "label": "./labelsTr/amos_0532.nii.gz"}, {"image": "./imagesTr/amos_0538.nii.gz", "label": "./labelsTr/amos_0538.nii.gz"}, {"image": "./imagesTr/amos_0540.nii.gz", "label": "./labelsTr/amos_0540.nii.gz"}, {"image": "./imagesTr/amos_0541.nii.gz", "label": "./labelsTr/amos_0541.nii.gz"}, {"image": "./imagesTr/amos_0548.nii.gz", "label": "./labelsTr/amos_0548.nii.gz"}, {"image": "./imagesTr/amos_0551.nii.gz", "label": "./labelsTr/amos_0551.nii.gz"}, {"image": "./imagesTr/amos_0554.nii.gz", "label": "./labelsTr/amos_0554.nii.gz"}, {"image": "./imagesTr/amos_0555.nii.gz", "label": "./labelsTr/amos_0555.nii.gz"}, {"image": "./imagesTr/amos_0557.nii.gz", "label": "./labelsTr/amos_0557.nii.gz"}, {"image": "./imagesTr/amos_0558.nii.gz", "label": "./labelsTr/amos_0558.nii.gz"}, {"image": "./imagesTr/amos_0570.nii.gz", "label": "./labelsTr/amos_0570.nii.gz"}, {"image": "./imagesTr/amos_0571.nii.gz", "label": "./labelsTr/amos_0571.nii.gz"}, {"image": "./imagesTr/amos_0578.nii.gz", "label": "./labelsTr/amos_0578.nii.gz"}, {"image": "./imagesTr/amos_0580.nii.gz", "label": "./labelsTr/amos_0580.nii.gz"}, {"image": "./imagesTr/amos_0582.nii.gz", "label": "./labelsTr/amos_0582.nii.gz"}, {"image": "./imagesTr/amos_0583.nii.gz", "label": "./labelsTr/amos_0583.nii.gz"}, {"image": "./imagesTr/amos_0584.nii.gz", "label": "./labelsTr/amos_0584.nii.gz"}, {"image": "./imagesTr/amos_0585.nii.gz", "label": "./labelsTr/amos_0585.nii.gz"}, {"image": "./imagesTr/amos_0586.nii.gz", "label": "./labelsTr/amos_0586.nii.gz"}, {"image": "./imagesTr/amos_0587.nii.gz", "label": "./labelsTr/amos_0587.nii.gz"}, {"image": "./imagesTr/amos_0588.nii.gz", "label": "./labelsTr/amos_0588.nii.gz"}, {"image": "./imagesTr/amos_0589.nii.gz", "label": "./labelsTr/amos_0589.nii.gz"}, {"image": "./imagesTr/amos_0590.nii.gz", "label": "./labelsTr/amos_0590.nii.gz"}, {"image": "./imagesTr/amos_0591.nii.gz", "label": "./labelsTr/amos_0591.nii.gz"}, {"image": "./imagesTr/amos_0592.nii.gz", "label": "./labelsTr/amos_0592.nii.gz"}, {"image": "./imagesTr/amos_0593.nii.gz", "label": "./labelsTr/amos_0593.nii.gz"}, {"image": "./imagesTr/amos_0594.nii.gz", "label": "./labelsTr/amos_0594.nii.gz"}, {"image": "./imagesTr/amos_0595.nii.gz", "label": "./labelsTr/amos_0595.nii.gz"}, {"image": "./imagesTr/amos_0596.nii.gz", "label": "./labelsTr/amos_0596.nii.gz"}, {"image": "./imagesTr/amos_0597.nii.gz", "label": "./labelsTr/amos_0597.nii.gz"}, {"image": "./imagesTr/amos_0599.nii.gz", "label": "./labelsTr/amos_0599.nii.gz"}, {"image": "./imagesTr/amos_0600.nii.gz", "label": "./labelsTr/amos_0600.nii.gz"}], "validation": [{"image": "./imagesVa/amos_0008.nii.gz", "label": "./labelsVa/amos_0008.nii.gz"}, {"image": "./imagesVa/amos_0013.nii.gz", "label": "./labelsVa/amos_0013.nii.gz"}, {"image": "./imagesVa/amos_0018.nii.gz", "label": "./labelsVa/amos_0018.nii.gz"}, {"image": "./imagesVa/amos_0022.nii.gz", "label": "./labelsVa/amos_0022.nii.gz"}, {"image": "./imagesVa/amos_0029.nii.gz", "label": "./labelsVa/amos_0029.nii.gz"}, {"image": "./imagesVa/amos_0032.nii.gz", "label": "./labelsVa/amos_0032.nii.gz"}, {"image": "./imagesVa/amos_0034.nii.gz", "label": "./labelsVa/amos_0034.nii.gz"}, {"image": "./imagesVa/amos_0040.nii.gz", "label": "./labelsVa/amos_0040.nii.gz"}, {"image": "./imagesVa/amos_0041.nii.gz", "label": "./labelsVa/amos_0041.nii.gz"}, {"image": "./imagesVa/amos_0051.nii.gz", "label": "./labelsVa/amos_0051.nii.gz"}, {"image": "./imagesVa/amos_0056.nii.gz", "label": "./labelsVa/amos_0056.nii.gz"}, {"image": "./imagesVa/amos_0061.nii.gz", "label": "./labelsVa/amos_0061.nii.gz"}, {"image": "./imagesVa/amos_0063.nii.gz", "label": "./labelsVa/amos_0063.nii.gz"}, {"image": "./imagesVa/amos_0070.nii.gz", "label": "./labelsVa/amos_0070.nii.gz"}, {"image": "./imagesVa/amos_0073.nii.gz", "label": "./labelsVa/amos_0073.nii.gz"}, {"image": "./imagesVa/amos_0085.nii.gz", "label": "./labelsVa/amos_0085.nii.gz"}, {"image": "./imagesVa/amos_0087.nii.gz", "label": "./labelsVa/amos_0087.nii.gz"}, {"image": "./imagesVa/amos_0090.nii.gz", "label": "./labelsVa/amos_0090.nii.gz"}, {"image": "./imagesVa/amos_0106.nii.gz", "label": "./labelsVa/amos_0106.nii.gz"}, {"image": "./imagesVa/amos_0108.nii.gz", "label": "./labelsVa/amos_0108.nii.gz"}, {"image": "./imagesVa/amos_0112.nii.gz", "label": "./labelsVa/amos_0112.nii.gz"}, {"image": "./imagesVa/amos_0117.nii.gz", "label": "./labelsVa/amos_0117.nii.gz"}, {"image": "./imagesVa/amos_0120.nii.gz", "label": "./labelsVa/amos_0120.nii.gz"}, {"image": "./imagesVa/amos_0123.nii.gz", "label": "./labelsVa/amos_0123.nii.gz"}, {"image": "./imagesVa/amos_0128.nii.gz", "label": "./labelsVa/amos_0128.nii.gz"}, {"image": "./imagesVa/amos_0132.nii.gz", "label": "./labelsVa/amos_0132.nii.gz"}, {"image": "./imagesVa/amos_0136.nii.gz", "label": "./labelsVa/amos_0136.nii.gz"}, {"image": "./imagesVa/amos_0140.nii.gz", "label": "./labelsVa/amos_0140.nii.gz"}, {"image": "./imagesVa/amos_0144.nii.gz", "label": "./labelsVa/amos_0144.nii.gz"}, {"image": "./imagesVa/amos_0150.nii.gz", "label": "./labelsVa/amos_0150.nii.gz"}, {"image": "./imagesVa/amos_0155.nii.gz", "label": "./labelsVa/amos_0155.nii.gz"}, {"image": "./imagesVa/amos_0157.nii.gz", "label": "./labelsVa/amos_0157.nii.gz"}, {"image": "./imagesVa/amos_0167.nii.gz", "label": "./labelsVa/amos_0167.nii.gz"}, {"image": "./imagesVa/amos_0174.nii.gz", "label": "./labelsVa/amos_0174.nii.gz"}, {"image": "./imagesVa/amos_0176.nii.gz", "label": "./labelsVa/amos_0176.nii.gz"}, {"image": "./imagesVa/amos_0189.nii.gz", "label": "./labelsVa/amos_0189.nii.gz"}, {"image": "./imagesVa/amos_0191.nii.gz", "label": "./labelsVa/amos_0191.nii.gz"}, {"image": "./imagesVa/amos_0194.nii.gz", "label": "./labelsVa/amos_0194.nii.gz"}, {"image": "./imagesVa/amos_0200.nii.gz", "label": "./labelsVa/amos_0200.nii.gz"}, {"image": "./imagesVa/amos_0202.nii.gz", "label": "./labelsVa/amos_0202.nii.gz"}, {"image": "./imagesVa/amos_0203.nii.gz", "label": "./labelsVa/amos_0203.nii.gz"}, {"image": "./imagesVa/amos_0204.nii.gz", "label": "./labelsVa/amos_0204.nii.gz"}, {"image": "./imagesVa/amos_0206.nii.gz", "label": "./labelsVa/amos_0206.nii.gz"}, {"image": "./imagesVa/amos_0207.nii.gz", "label": "./labelsVa/amos_0207.nii.gz"}, {"image": "./imagesVa/amos_0208.nii.gz", "label": "./labelsVa/amos_0208.nii.gz"}, {"image": "./imagesVa/amos_0216.nii.gz", "label": "./labelsVa/amos_0216.nii.gz"}, {"image": "./imagesVa/amos_0218.nii.gz", "label": "./labelsVa/amos_0218.nii.gz"}, {"image": "./imagesVa/amos_0219.nii.gz", "label": "./labelsVa/amos_0219.nii.gz"}, {"image": "./imagesVa/amos_0223.nii.gz", "label": "./labelsVa/amos_0223.nii.gz"}, {"image": "./imagesVa/amos_0228.nii.gz", "label": "./labelsVa/amos_0228.nii.gz"}, {"image": "./imagesVa/amos_0233.nii.gz", "label": "./labelsVa/amos_0233.nii.gz"}, {"image": "./imagesVa/amos_0238.nii.gz", "label": "./labelsVa/amos_0238.nii.gz"}, {"image": "./imagesVa/amos_0244.nii.gz", "label": "./labelsVa/amos_0244.nii.gz"}, {"image": "./imagesVa/amos_0247.nii.gz", "label": "./labelsVa/amos_0247.nii.gz"}, {"image": "./imagesVa/amos_0250.nii.gz", "label": "./labelsVa/amos_0250.nii.gz"}, {"image": "./imagesVa/amos_0255.nii.gz", "label": "./labelsVa/amos_0255.nii.gz"}, {"image": "./imagesVa/amos_0257.nii.gz", "label": "./labelsVa/amos_0257.nii.gz"}, {"image": "./imagesVa/amos_0258.nii.gz", "label": "./labelsVa/amos_0258.nii.gz"}, {"image": "./imagesVa/amos_0278.nii.gz", "label": "./labelsVa/amos_0278.nii.gz"}, {"image": "./imagesVa/amos_0280.nii.gz", "label": "./labelsVa/amos_0280.nii.gz"}, {"image": "./imagesVa/amos_0283.nii.gz", "label": "./labelsVa/amos_0283.nii.gz"}, {"image": "./imagesVa/amos_0284.nii.gz", "label": "./labelsVa/amos_0284.nii.gz"}, {"image": "./imagesVa/amos_0286.nii.gz", "label": "./labelsVa/amos_0286.nii.gz"}, {"image": "./imagesVa/amos_0287.nii.gz", "label": "./labelsVa/amos_0287.nii.gz"}, {"image": "./imagesVa/amos_0289.nii.gz", "label": "./labelsVa/amos_0289.nii.gz"}, {"image": "./imagesVa/amos_0290.nii.gz", "label": "./labelsVa/amos_0290.nii.gz"}, {"image": "./imagesVa/amos_0292.nii.gz", "label": "./labelsVa/amos_0292.nii.gz"}, {"image": "./imagesVa/amos_0293.nii.gz", "label": "./labelsVa/amos_0293.nii.gz"}, {"image": "./imagesVa/amos_0304.nii.gz", "label": "./labelsVa/amos_0304.nii.gz"}, {"image": "./imagesVa/amos_0308.nii.gz", "label": "./labelsVa/amos_0308.nii.gz"}, {"image": "./imagesVa/amos_0309.nii.gz", "label": "./labelsVa/amos_0309.nii.gz"}, {"image": "./imagesVa/amos_0310.nii.gz", "label": "./labelsVa/amos_0310.nii.gz"}, {"image": "./imagesVa/amos_0311.nii.gz", "label": "./labelsVa/amos_0311.nii.gz"}, {"image": "./imagesVa/amos_0313.nii.gz", "label": "./labelsVa/amos_0313.nii.gz"}, {"image": "./imagesVa/amos_0316.nii.gz", "label": "./labelsVa/amos_0316.nii.gz"}, {"image": "./imagesVa/amos_0318.nii.gz", "label": "./labelsVa/amos_0318.nii.gz"}, {"image": "./imagesVa/amos_0323.nii.gz", "label": "./labelsVa/amos_0323.nii.gz"}, {"image": "./imagesVa/amos_0325.nii.gz", "label": "./labelsVa/amos_0325.nii.gz"}, {"image": "./imagesVa/amos_0326.nii.gz", "label": "./labelsVa/amos_0326.nii.gz"}, {"image": "./imagesVa/amos_0328.nii.gz", "label": "./labelsVa/amos_0328.nii.gz"}, {"image": "./imagesVa/amos_0333.nii.gz", "label": "./labelsVa/amos_0333.nii.gz"}, {"image": "./imagesVa/amos_0334.nii.gz", "label": "./labelsVa/amos_0334.nii.gz"}, {"image": "./imagesVa/amos_0339.nii.gz", "label": "./labelsVa/amos_0339.nii.gz"}, {"image": "./imagesVa/amos_0342.nii.gz", "label": "./labelsVa/amos_0342.nii.gz"}, {"image": "./imagesVa/amos_0344.nii.gz", "label": "./labelsVa/amos_0344.nii.gz"}, {"image": "./imagesVa/amos_0346.nii.gz", "label": "./labelsVa/amos_0346.nii.gz"}, {"image": "./imagesVa/amos_0352.nii.gz", "label": "./labelsVa/amos_0352.nii.gz"}, {"image": "./imagesVa/amos_0356.nii.gz", "label": "./labelsVa/amos_0356.nii.gz"}, {"image": "./imagesVa/amos_0357.nii.gz", "label": "./labelsVa/amos_0357.nii.gz"}, {"image": "./imagesVa/amos_0363.nii.gz", "label": "./labelsVa/amos_0363.nii.gz"}, {"image": "./imagesVa/amos_0364.nii.gz", "label": "./labelsVa/amos_0364.nii.gz"}, {"image": "./imagesVa/amos_0365.nii.gz", "label": "./labelsVa/amos_0365.nii.gz"}, {"image": "./imagesVa/amos_0368.nii.gz", "label": "./labelsVa/amos_0368.nii.gz"}, {"image": "./imagesVa/amos_0372.nii.gz", "label": "./labelsVa/amos_0372.nii.gz"}, {"image": "./imagesVa/amos_0373.nii.gz", "label": "./labelsVa/amos_0373.nii.gz"}, {"image": "./imagesVa/amos_0377.nii.gz", "label": "./labelsVa/amos_0377.nii.gz"}, {"image": "./imagesVa/amos_0385.nii.gz", "label": "./labelsVa/amos_0385.nii.gz"}, {"image": "./imagesVa/amos_0397.nii.gz", "label": "./labelsVa/amos_0397.nii.gz"}, {"image": "./imagesVa/amos_0399.nii.gz", "label": "./labelsVa/amos_0399.nii.gz"}, {"image": "./imagesVa/amos_0409.nii.gz", "label": "./labelsVa/amos_0409.nii.gz"}, {"image": "./imagesVa/amos_0544.nii.gz", "label": "./labelsVa/amos_0544.nii.gz"}, {"image": "./imagesVa/amos_0545.nii.gz", "label": "./labelsVa/amos_0545.nii.gz"}, {"image": "./imagesVa/amos_0546.nii.gz", "label": "./labelsVa/amos_0546.nii.gz"}, {"image": "./imagesVa/amos_0547.nii.gz", "label": "./labelsVa/amos_0547.nii.gz"}, {"image": "./imagesVa/amos_0549.nii.gz", "label": "./labelsVa/amos_0549.nii.gz"}, {"image": "./imagesVa/amos_0550.nii.gz", "label": "./labelsVa/amos_0550.nii.gz"}, {"image": "./imagesVa/amos_0552.nii.gz", "label": "./labelsVa/amos_0552.nii.gz"}, {"image": "./imagesVa/amos_0553.nii.gz", "label": "./labelsVa/amos_0553.nii.gz"}, {"image": "./imagesVa/amos_0556.nii.gz", "label": "./labelsVa/amos_0556.nii.gz"}, {"image": "./imagesVa/amos_0559.nii.gz", "label": "./labelsVa/amos_0559.nii.gz"}, {"image": "./imagesVa/amos_0561.nii.gz", "label": "./labelsVa/amos_0561.nii.gz"}, {"image": "./imagesVa/amos_0562.nii.gz", "label": "./labelsVa/amos_0562.nii.gz"}, {"image": "./imagesVa/amos_0563.nii.gz", "label": "./labelsVa/amos_0563.nii.gz"}, {"image": "./imagesVa/amos_0568.nii.gz", "label": "./labelsVa/amos_0568.nii.gz"}, {"image": "./imagesVa/amos_0572.nii.gz", "label": "./labelsVa/amos_0572.nii.gz"}, {"image": "./imagesVa/amos_0573.nii.gz", "label": "./labelsVa/amos_0573.nii.gz"}, {"image": "./imagesVa/amos_0575.nii.gz", "label": "./labelsVa/amos_0575.nii.gz"}, {"image": "./imagesVa/amos_0576.nii.gz", "label": "./labelsVa/amos_0576.nii.gz"}, {"image": "./imagesVa/amos_0581.nii.gz", "label": "./labelsVa/amos_0581.nii.gz"}, {"image": "./imagesVa/amos_0598.nii.gz", "label": "./labelsVa/amos_0598.nii.gz"}], "test": [{"image": "./imagesTs/amos_0002.nii.gz"}, {"image": "./imagesTs/amos_0003.nii.gz"}, {"image": "./imagesTs/amos_0012.nii.gz"}, {"image": "./imagesTs/amos_0020.nii.gz"}, {"image": "./imagesTs/amos_0026.nii.gz"}, {"image": "./imagesTs/amos_0028.nii.gz"}, {"image": "./imagesTs/amos_0031.nii.gz"}, {"image": "./imagesTs/amos_0037.nii.gz"}, {"image": "./imagesTs/amos_0039.nii.gz"}, {"image": "./imagesTs/amos_0046.nii.gz"}, {"image": "./imagesTs/amos_0053.nii.gz"}, {"image": "./imagesTs/amos_0055.nii.gz"}, {"image": "./imagesTs/amos_0062.nii.gz"}, {"image": "./imagesTs/amos_0065.nii.gz"}, {"image": "./imagesTs/amos_0068.nii.gz"}, {"image": "./imagesTs/amos_0074.nii.gz"}, {"image": "./imagesTs/amos_0080.nii.gz"}, {"image": "./imagesTs/amos_0082.nii.gz"}, {"image": "./imagesTs/amos_0091.nii.gz"}, {"image": "./imagesTs/amos_0093.nii.gz"}, {"image": "./imagesTs/amos_0095.nii.gz"}, {"image": "./imagesTs/amos_0096.nii.gz"}, {"image": "./imagesTs/amos_0100.nii.gz"}, {"image": "./imagesTs/amos_0101.nii.gz"}, {"image": "./imagesTs/amos_0107.nii.gz"}, {"image": "./imagesTs/amos_0114.nii.gz"}, {"image": "./imagesTs/amos_0122.nii.gz"}, {"image": "./imagesTs/amos_0130.nii.gz"}, {"image": "./imagesTs/amos_0139.nii.gz"}, {"image": "./imagesTs/amos_0145.nii.gz"}, {"image": "./imagesTs/amos_0146.nii.gz"}, {"image": "./imagesTs/amos_0148.nii.gz"}, {"image": "./imagesTs/amos_0151.nii.gz"}, {"image": "./imagesTs/amos_0163.nii.gz"}, {"image": "./imagesTs/amos_0164.nii.gz"}, {"image": "./imagesTs/amos_0165.nii.gz"}, {"image": "./imagesTs/amos_0168.nii.gz"}, {"image": "./imagesTs/amos_0169.nii.gz"}, {"image": "./imagesTs/amos_0178.nii.gz"}, {"image": "./imagesTs/amos_0182.nii.gz"}, {"image": "./imagesTs/amos_0183.nii.gz"}, {"image": "./imagesTs/amos_0187.nii.gz"}, {"image": "./imagesTs/amos_0201.nii.gz"}, {"image": "./imagesTs/amos_0205.nii.gz"}, {"image": "./imagesTs/amos_0209.nii.gz"}, {"image": "./imagesTs/amos_0210.nii.gz"}, {"image": "./imagesTs/amos_0211.nii.gz"}, {"image": "./imagesTs/amos_0213.nii.gz"}, {"image": "./imagesTs/amos_0220.nii.gz"}, {"image": "./imagesTs/amos_0221.nii.gz"}, {"image": "./imagesTs/amos_0222.nii.gz"}, {"image": "./imagesTs/amos_0227.nii.gz"}, {"image": "./imagesTs/amos_0229.nii.gz"}, {"image": "./imagesTs/amos_0232.nii.gz"}, {"image": "./imagesTs/amos_0234.nii.gz"}, {"image": "./imagesTs/amos_0236.nii.gz"}, {"image": "./imagesTs/amos_0240.nii.gz"}, {"image": "./imagesTs/amos_0241.nii.gz"}, {"image": "./imagesTs/amos_0243.nii.gz"}, {"image": "./imagesTs/amos_0246.nii.gz"}, {"image": "./imagesTs/amos_0251.nii.gz"}, {"image": "./imagesTs/amos_0252.nii.gz"}, {"image": "./imagesTs/amos_0253.nii.gz"}, {"image": "./imagesTs/amos_0256.nii.gz"}, {"image": "./imagesTs/amos_0260.nii.gz"}, {"image": "./imagesTs/amos_0261.nii.gz"}, {"image": "./imagesTs/amos_0262.nii.gz"}, {"image": "./imagesTs/amos_0265.nii.gz"}, {"image": "./imagesTs/amos_0266.nii.gz"}, {"image": "./imagesTs/amos_0267.nii.gz"}, {"image": "./imagesTs/amos_0269.nii.gz"}, {"image": "./imagesTs/amos_0270.nii.gz"}, {"image": "./imagesTs/amos_0271.nii.gz"}, {"image": "./imagesTs/amos_0275.nii.gz"}, {"image": "./imagesTs/amos_0277.nii.gz"}, {"image": "./imagesTs/amos_0285.nii.gz"}, {"image": "./imagesTs/amos_0291.nii.gz"}, {"image": "./imagesTs/amos_0295.nii.gz"}, {"image": "./imagesTs/amos_0298.nii.gz"}, {"image": "./imagesTs/amos_0300.nii.gz"}, {"image": "./imagesTs/amos_0303.nii.gz"}, {"image": "./imagesTs/amos_0305.nii.gz"}, {"image": "./imagesTs/amos_0306.nii.gz"}, {"image": "./imagesTs/amos_0312.nii.gz"}, {"image": "./imagesTs/amos_0314.nii.gz"}, {"image": "./imagesTs/amos_0315.nii.gz"}, {"image": "./imagesTs/amos_0319.nii.gz"}, {"image": "./imagesTs/amos_0322.nii.gz"}, {"image": "./imagesTs/amos_0324.nii.gz"}, {"image": "./imagesTs/amos_0327.nii.gz"}, {"image": "./imagesTs/amos_0329.nii.gz"}, {"image": "./imagesTs/amos_0331.nii.gz"}, {"image": "./imagesTs/amos_0335.nii.gz"}, {"image": "./imagesTs/amos_0338.nii.gz"}, {"image": "./imagesTs/amos_0340.nii.gz"}, {"image": "./imagesTs/amos_0343.nii.gz"}, {"image": "./imagesTs/amos_0345.nii.gz"}, {"image": "./imagesTs/amos_0347.nii.gz"}, {"image": "./imagesTs/amos_0354.nii.gz"}, {"image": "./imagesTs/amos_0355.nii.gz"}, {"image": "./imagesTs/amos_0359.nii.gz"}, {"image": "./imagesTs/amos_0360.nii.gz"}, {"image": "./imagesTs/amos_0369.nii.gz"}, {"image": "./imagesTs/amos_0375.nii.gz"}, {"image": "./imagesTs/amos_0382.nii.gz"}, {"image": "./imagesTs/amos_0386.nii.gz"}, {"image": "./imagesTs/amos_0389.nii.gz"}, {"image": "./imagesTs/amos_0393.nii.gz"}, {"image": "./imagesTs/amos_0394.nii.gz"}, {"image": "./imagesTs/amos_0407.nii.gz"}, {"image": "./imagesTs/amos_0411.nii.gz"}, {"image": "./imagesTs/amos_0412.nii.gz"}, {"image": "./imagesTs/amos_0413.nii.gz"}, {"image": "./imagesTs/amos_0414.nii.gz"}, {"image": "./imagesTs/amos_0415.nii.gz"}, {"image": "./imagesTs/amos_0416.nii.gz"}, {"image": "./imagesTs/amos_0417.nii.gz"}, {"image": "./imagesTs/amos_0418.nii.gz"}, {"image": "./imagesTs/amos_0419.nii.gz"}, {"image": "./imagesTs/amos_0420.nii.gz"}, {"image": "./imagesTs/amos_0421.nii.gz"}, {"image": "./imagesTs/amos_0422.nii.gz"}, {"image": "./imagesTs/amos_0423.nii.gz"}, {"image": "./imagesTs/amos_0424.nii.gz"}, {"image": "./imagesTs/amos_0425.nii.gz"}, {"image": "./imagesTs/amos_0426.nii.gz"}, {"image": "./imagesTs/amos_0427.nii.gz"}, {"image": "./imagesTs/amos_0428.nii.gz"}, {"image": "./imagesTs/amos_0429.nii.gz"}, {"image": "./imagesTs/amos_0430.nii.gz"}, {"image": "./imagesTs/amos_0431.nii.gz"}, {"image": "./imagesTs/amos_0432.nii.gz"}, {"image": "./imagesTs/amos_0433.nii.gz"}, {"image": "./imagesTs/amos_0434.nii.gz"}, {"image": "./imagesTs/amos_0435.nii.gz"}, {"image": "./imagesTs/amos_0436.nii.gz"}, {"image": "./imagesTs/amos_0437.nii.gz"}, {"image": "./imagesTs/amos_0438.nii.gz"}, {"image": "./imagesTs/amos_0439.nii.gz"}, {"image": "./imagesTs/amos_0440.nii.gz"}, {"image": "./imagesTs/amos_0441.nii.gz"}, {"image": "./imagesTs/amos_0442.nii.gz"}, {"image": "./imagesTs/amos_0443.nii.gz"}, {"image": "./imagesTs/amos_0444.nii.gz"}, {"image": "./imagesTs/amos_0445.nii.gz"}, {"image": "./imagesTs/amos_0446.nii.gz"}, {"image": "./imagesTs/amos_0447.nii.gz"}, {"image": "./imagesTs/amos_0448.nii.gz"}, {"image": "./imagesTs/amos_0449.nii.gz"}, {"image": "./imagesTs/amos_0450.nii.gz"}, {"image": "./imagesTs/amos_0451.nii.gz"}, {"image": "./imagesTs/amos_0452.nii.gz"}, {"image": "./imagesTs/amos_0453.nii.gz"}, {"image": "./imagesTs/amos_0454.nii.gz"}, {"image": "./imagesTs/amos_0455.nii.gz"}, {"image": "./imagesTs/amos_0456.nii.gz"}, {"image": "./imagesTs/amos_0457.nii.gz"}, {"image": "./imagesTs/amos_0458.nii.gz"}, {"image": "./imagesTs/amos_0459.nii.gz"}, {"image": "./imagesTs/amos_0460.nii.gz"}, {"image": "./imagesTs/amos_0461.nii.gz"}, {"image": "./imagesTs/amos_0462.nii.gz"}, {"image": "./imagesTs/amos_0463.nii.gz"}, {"image": "./imagesTs/amos_0464.nii.gz"}, {"image": "./imagesTs/amos_0465.nii.gz"}, {"image": "./imagesTs/amos_0466.nii.gz"}, {"image": "./imagesTs/amos_0467.nii.gz"}, {"image": "./imagesTs/amos_0468.nii.gz"}, {"image": "./imagesTs/amos_0469.nii.gz"}, {"image": "./imagesTs/amos_0470.nii.gz"}, {"image": "./imagesTs/amos_0471.nii.gz"}, {"image": "./imagesTs/amos_0472.nii.gz"}, {"image": "./imagesTs/amos_0473.nii.gz"}, {"image": "./imagesTs/amos_0474.nii.gz"}, {"image": "./imagesTs/amos_0475.nii.gz"}, {"image": "./imagesTs/amos_0476.nii.gz"}, {"image": "./imagesTs/amos_0477.nii.gz"}, {"image": "./imagesTs/amos_0478.nii.gz"}, {"image": "./imagesTs/amos_0479.nii.gz"}, {"image": "./imagesTs/amos_0480.nii.gz"}, {"image": "./imagesTs/amos_0481.nii.gz"}, {"image": "./imagesTs/amos_0482.nii.gz"}, {"image": "./imagesTs/amos_0483.nii.gz"}, {"image": "./imagesTs/amos_0484.nii.gz"}, {"image": "./imagesTs/amos_0485.nii.gz"}, {"image": "./imagesTs/amos_0486.nii.gz"}, {"image": "./imagesTs/amos_0487.nii.gz"}, {"image": "./imagesTs/amos_0488.nii.gz"}, {"image": "./imagesTs/amos_0489.nii.gz"}, {"image": "./imagesTs/amos_0490.nii.gz"}, {"image": "./imagesTs/amos_0491.nii.gz"}, {"image": "./imagesTs/amos_0492.nii.gz"}, {"image": "./imagesTs/amos_0493.nii.gz"}, {"image": "./imagesTs/amos_0494.nii.gz"}, {"image": "./imagesTs/amos_0495.nii.gz"}, {"image": "./imagesTs/amos_0496.nii.gz"}, {"image": "./imagesTs/amos_0497.nii.gz"}, {"image": "./imagesTs/amos_0498.nii.gz"}, {"image": "./imagesTs/amos_0499.nii.gz"}, {"image": "./imagesTs/amos_0500.nii.gz"}, {"image": "./imagesTs/amos_0501.nii.gz"}, {"image": "./imagesTs/amos_0502.nii.gz"}, {"image": "./imagesTs/amos_0503.nii.gz"}, {"image": "./imagesTs/amos_0504.nii.gz"}, {"image": "./imagesTs/amos_0505.nii.gz"}, {"image": "./imagesTs/amos_0506.nii.gz"}, {"image": "./imagesTs/amos_0509.nii.gz"}, {"image": "./imagesTs/amos_0511.nii.gz"}, {"image": "./imagesTs/amos_0512.nii.gz"}, {"image": "./imagesTs/amos_0513.nii.gz"}, {"image": "./imagesTs/amos_0515.nii.gz"}, {"image": "./imagesTs/amos_0516.nii.gz"}, {"image": "./imagesTs/amos_0519.nii.gz"}, {"image": "./imagesTs/amos_0520.nii.gz"}, {"image": "./imagesTs/amos_0521.nii.gz"}, {"image": "./imagesTs/amos_0523.nii.gz"}, {"image": "./imagesTs/amos_0524.nii.gz"}, {"image": "./imagesTs/amos_0525.nii.gz"}, {"image": "./imagesTs/amos_0526.nii.gz"}, {"image": "./imagesTs/amos_0527.nii.gz"}, {"image": "./imagesTs/amos_0528.nii.gz"}, {"image": "./imagesTs/amos_0529.nii.gz"}, {"image": "./imagesTs/amos_0531.nii.gz"}, {"image": "./imagesTs/amos_0533.nii.gz"}, {"image": "./imagesTs/amos_0534.nii.gz"}, {"image": "./imagesTs/amos_0535.nii.gz"}, {"image": "./imagesTs/amos_0536.nii.gz"}, {"image": "./imagesTs/amos_0537.nii.gz"}, {"image": "./imagesTs/amos_0539.nii.gz"}, {"image": "./imagesTs/amos_0542.nii.gz"}, {"image": "./imagesTs/amos_0543.nii.gz"}, {"image": "./imagesTs/amos_0560.nii.gz"}, {"image": "./imagesTs/amos_0564.nii.gz"}, {"image": "./imagesTs/amos_0565.nii.gz"}, {"image": "./imagesTs/amos_0566.nii.gz"}, {"image": "./imagesTs/amos_0567.nii.gz"}, {"image": "./imagesTs/amos_0569.nii.gz"}, {"image": "./imagesTs/amos_0574.nii.gz"}, {"image": "./imagesTs/amos_0577.nii.gz"}, {"image": "./imagesTs/amos_0579.nii.gz"}]}

amos/amos22/readme.md

@@ -0,0 +1,39 @@
+### Overview
+
+Despite the considerable progress in automatic abdominal multi-organ segmentation from CT/MRI scans in recent years, a comprehensive evaluation of the models' capabilities is hampered by the lack of a large-scale benchmark from diverse clinical scenarios. Constraint by the high cost of collecting and labeling 3D medical data, most of the deep learning models to date are driven by datasets with a limited number of organs of interest or samples, which still limits the power of modern deep models and makes it difficult to provide a fully comprehensive and fair estimate of various methods. To mitigate the limitations, we present AMOS, a large-scale, diverse, clinical dataset for abdominal organ segmentation. <u>AMOS provides 500 CT and 100 MRI scans collected from multi-center, multi-vendor, multi-modality, multi-phase, multi-disease patients, each with voxel-level annotations of 15 abdominal organs, providing challenging examples and test-bed for studying robust segmentation algorithms</u> under diverse targets and scenarios. We further benchmark several state-of-the-art medical segmentation models to evaluate the status of the existing methods on this new challenging dataset. We have made our datasets, benchmark servers, and baselines publicly available, and hope to inspire future research.  For more details, please refer to our paper "https://arxiv.org/pdf/2206.08023.pdf" as well as homepage "https://jiyuanfeng.github.io/AMOS/".
+
+### Structure
+
+AMOS provides the following content. imagesTr and labelsTr provide 240 scans (200 CT and 40 MRI), imagesVa and labelsVa provide 120 scans for model selection (100 CT and 20 MRI), and imagesTs provide 120 test data (please submit your predictions from https://amos22.grand-challenge.org/evaluation/challenge/submissions to get a score). Please note that id numbers less than 500 belong to CT data, otherwise they belong to MRI data.
+
+```bash
+amos
+│   readme.md
+│   dataset.json
+└───imagesTr
+│   │   amos_xxxx.nii.gz
+│   │   ...
+└───imagesVa
+└───imagesTs
+└───labelsTr
+└───labelsVa
+└───labelsTs
+
+```
+
+### Citation
+
+if you found this dataset useful for your research, please cite:
+
+```
+@article{ji2022amos,
+  title={AMOS: A Large-Scale Abdominal Multi-Organ Benchmark for Versatile Medical Image Segmentation},
+  author={Ji, Yuanfeng and Bai, Haotian and Yang, Jie and Ge, Chongjian and Zhu, Ye and Zhang, Ruimao and Li, Zhen and Zhang, Lingyan and Ma, Wanling and Wan, Xiang and others},
+  journal={arXiv preprint arXiv:2206.08023},
+  year={2022}
+  }
+```
+
+### Upcoming
+
+We will publish more meta information and corresponding APIs in October, while more unlabeled data will be used to support more learning scenarios

kits21/kits21/kits21/annotation/import.py

@@ -0,0 +1,342 @@
+import argparse
+import shutil
+from pathlib import Path
+import json
+
+import nibabel as nib
+import numpy as np
+
+from kits21.annotation.postprocessing import delineation_to_seg, load_json, write_json
+from kits21.configuration.labels import KITS_LABEL_NAMES, LABEL_AGGREGATION_ORDER
+from kits21.configuration.paths import SRC_DIR, TRAINING_DIR, TESTING_DIR, CACHE_FILE
+
+
+def get_case_dir(case):
+    assert SRC_DIR is not None, "SRC_DIR was none, this is most likely due to KITS21_SERVER_DATA not being in your " \
+                                "environment variables. This functionality is intended to be used only by the " \
+                                "KiTS organizers."
+    # TODO remove hardcoding -- test both to find it
+    page = int(case // 50)
+    tst = "training_data"
+    if case >= 300:
+        tst = "testing_data"
+    return (SRC_DIR / tst / "cases_{:05d}".format(page) / "case_{:05d}".format(case)).resolve(strict=True)
+
+
+def get_all_case_dirs():
+    # TODO set this number dynamically
+    return [get_case_dir(i) for i in range(400)]
+
+
+def get_region_dir(case_dir, region):
+    return (case_dir / region).resolve(strict=True)
+
+
+def get_all_region_dirs(case_dir):
+    return [r for r in case_dir.glob("*")]
+
+
+def get_instance_dir(region_dir, instance):
+    return (region_dir / "{:02d}".format(instance)).resolve(strict=True)
+
+
+def get_all_instance_dirs(region_dir):
+    return [i for i in region_dir.glob("*")]
+
+
+def get_existing_instances(region_dir):
+    case_id = region_dir.parent.name
+    base_dir = Path(__file__).resolve().parent.parent / "data"
+    if int(case_id.split("_")[-1]) >= 300:
+        base_dir = TESTING_DIR
+    seg_dir = base_dir / case_id / "segmentations"
+    return [x for x in seg_dir.glob("*{}*".format(region_dir.name))]
+
+
+def get_delineation(instance_dir, delineation):
+    return (instance_dir / "delineation{}".format(delineation)).resolve(strict=True)
+
+
+def get_all_delineations(instance_dir):
+    return [d for d in instance_dir.glob("delineation*")]
+
+
+def get_most_recent_save(parent_dir):
+    # Get latest file and list of remainder
+    try:
+        srt_files = sorted([s for s in parent_dir.glob("*")])
+        latest = srt_files[-1]
+    except Exception as e:
+        print()
+        print("Error finding most recent save in", str(parent_dir))
+        raise(e)
+
+    return latest
+
+
+def update_raw(delineation_path, case_id, in_test_set):
+    # Get parent directory (create if necessary)
+    destination_parent = TRAINING_DIR / case_id
+    if in_test_set:
+        destination_parent = TESTING_DIR / case_id
+    if not destination_parent.exists():
+        destination_parent.mkdir()
+    destination_parent = destination_parent / "raw"
+    if not destination_parent.exists():
+        destination_parent.mkdir()
+
+    custom_hilums = None
+    if (destination_parent / "meta.json").exists():
+        with (destination_parent / "meta.json").open() as f:
+            old_meta = json.loads(f.read())
+            if "custom_hilums" in old_meta:
+                custom_hilums = old_meta["custom_hilums"]
+
+    # Get source directory
+    src = delineation_path.parent.parent.parent.parent
+
+    # Copy all annotation files to destination
+    shutil.copytree(str(src), str(destination_parent), dirs_exist_ok=True)
+
+    if custom_hilums is not None:
+        with (destination_parent / "meta.json").open() as f:
+            new_meta = json.loads(f.read())
+        with (destination_parent / "meta.json").open('w') as f:
+            new_meta["custom_hilums"] = custom_hilums
+            f.write(json.dumps(new_meta, indent=2))
+
+
+def get_localization(delineation_path):
+    return get_most_recent_save(delineation_path.parent.parent / "localization")
+
+
+def get_artery_localization(delineation_path):
+    pth = delineation_path.parent.parent.parent.parent / "artery" / "00" / "localization"
+    if not pth.exists():
+        return None
+    return get_most_recent_save(pth)
+
+
+def get_image_path(case_id, in_test_set):
+    if in_test_set:
+        return (TESTING_DIR / case_id / "imaging.nii.gz").resolve(strict=True)
+    else:
+        return (TRAINING_DIR / case_id / "imaging.nii.gz").resolve(strict=True)
+
+
+def save_segmentation(case_id, region_type, delineation_path, n1img, in_test_set):
+    # Create name of destination file
+    annotation_num = int(delineation_path.parent.name[-1])
+    instance_num = int(delineation_path.parent.parent.name)
+    filename = "{}_instance-{}_annotation-{}.nii.gz".format(region_type, instance_num+1, annotation_num)
+
+    # Get parent directory (create if necessary)
+    destination_parent = TRAINING_DIR / case_id
+    if in_test_set:
+        destination_parent = TESTING_DIR / case_id
+    if not destination_parent.exists():
+        destination_parent.mkdir()
+    destination_parent = destination_parent / "segmentations"
+    if not destination_parent.exists():
+        destination_parent.mkdir()
+    destination = destination_parent / filename
+
+    # Save file
+    nib.save(n1img, str(destination))
+
+
+def run_import(delineation_path):
+    # Useful values
+    region_type = delineation_path.parent.parent.parent.name
+    case_id = delineation_path.parent.parent.parent.parent.name
+    in_test_set = False
+    if delineation_path.parent.parent.parent.parent.parent.parent.name == "testing_data":
+        in_test_set = True
+
+    # Copy updated raw data
+    update_raw(delineation_path, case_id, in_test_set)
+
+    # Kidneys require hilum information from the localization
+    localization = None
+    if region_type == "kidney":
+        localization = get_localization(delineation_path)
+
+    # Path to underlying CT scan stored as .nii.gz
+    image_path = get_image_path(case_id, in_test_set)
+
+    meta_path = image_path.parent / "raw" / "meta.json"
+    meta = load_json(meta_path)
+
+    # Compute and save segmentation based on delineation
+    seg_nib = delineation_to_seg(region_type, image_path, delineation_path, meta, localization)
+    save_segmentation(case_id, region_type, delineation_path, seg_nib, in_test_set)
+
+
+def aggregate(parent, region, idnum, agg, affine, agtype="maj"):
+
+    seg_files = [x for x in parent.glob("{}*.nii.gz".format(region))]
+    instances = [int(x.stem.split("_")[1].split("-")[1]) for x in seg_files]
+    unq_insts = sorted(list(set(instances)))
+
+    reg_agg = None
+    for inst in unq_insts:
+        inst_agg = None
+        n_anns = 0
+        for tins, tfnm in zip(instances, seg_files):
+            if tins != inst:
+                continue
+            seg_nib = nib.load(str(tfnm))
+            n_anns += 1
+            if inst_agg is None:
+                inst_agg = np.asanyarray(seg_nib.dataobj)
+                affine = seg_nib.affine
+            else:
+                inst_agg = inst_agg + np.asanyarray(seg_nib.dataobj)
+
+        if agtype == "maj":
+            inst = np.greater(inst_agg, n_anns/2).astype(inst_agg.dtype)
+        elif agtype == "or":
+            inst = np.greater(inst_agg, 0).astype(inst_agg.dtype)
+        elif agtype == "and":
+            inst = np.equal(inst_agg, n_anns).astype(inst_agg.dtype)
+
+        if reg_agg is None:
+            reg_agg = np.copy(inst)
+        else:
+            reg_agg = np.logical_or(reg_agg, inst).astype(reg_agg.dtype)
+
+    # If no info here, just return what we started with
+    if reg_agg is None:
+        return agg, affine
+
+    if agg is None:
+        agg = idnum*reg_agg
+    else:
+        agg = np.where(np.logical_not(np.equal(reg_agg, 0)), idnum*reg_agg, agg)
+
+    return agg, affine
+
+
+def aggregate_case(case_id):
+    base_dir = Path(__file__).resolve().parent.parent / "data"
+    if int(case_id.split("_")[-1]) >= 300:
+        base_dir = TESTING_DIR
+
+    segs =  base_dir / case_id / "segmentations"
+
+    affine = None
+    agg = None
+    for label_id in LABEL_AGGREGATION_ORDER:
+        agg, affine = aggregate(segs, KITS_LABEL_NAMES[label_id], label_id, agg, affine, agtype="or")
+    if agg is not None:
+        nib.save(
+            nib.Nifti1Image(agg.astype(np.int32), affine),
+            str(base_dir / case_id / "aggregated_OR_seg.nii.gz")
+        )
+
+    affine = None
+    agg = None
+    for label_id in LABEL_AGGREGATION_ORDER:
+        agg, affine = aggregate(segs, KITS_LABEL_NAMES[label_id], label_id, agg, affine, agtype="and")
+    if agg is not None:
+        nib.save(
+            nib.Nifti1Image(agg.astype(np.int32), affine),
+            str(base_dir / case_id / "aggregated_AND_seg.nii.gz")
+        )
+
+    affine = None
+    agg = None
+    for label_id in LABEL_AGGREGATION_ORDER:
+        agg, affine = aggregate(segs, KITS_LABEL_NAMES[label_id], label_id, agg, affine, agtype="maj")
+    if agg is not None:
+        nib.save(
+            nib.Nifti1Image(agg.astype(np.int32), affine),
+            str(base_dir / case_id / "aggregated_MAJ_seg.nii.gz")
+        )
+
+
+def cleanup(case_dir):
+    base_dir = Path(__file__).resolve().parent.parent / "data"
+    if int(case_dir.name.split("_")[-1]) >= 300:
+        base_dir = TESTING_DIR
+    case_dir = base_dir / case_dir.name / "raw"
+    region_dirs = get_all_region_dirs(case_dir)
+    for region_dir in region_dirs:
+        instance_dirs = get_all_instance_dirs(region_dir)
+        for instance_dir in instance_dirs:
+            sessions = [x for x in instance_dir.glob("*")]
+            for sess in sessions:
+                srt_files = sorted([s for s in sess.glob("*")])
+                for f in srt_files[:-1]:
+                    f.unlink()
+
+
+def main(args):
+    cache = load_json(CACHE_FILE)
+    cli = True
+    if args.case is not None:
+        case_dirs = [get_case_dir(args.case)]
+    else:
+        cli = False
+        case_dirs = get_all_case_dirs()
+
+    for case_dir in case_dirs:
+        print(case_dir.name)
+        reaggregate = args.reaggregate
+        if cli and args.region is not None:
+            region_dirs = [get_region_dir(case_dir, args.region)]
+        else:
+            cli = False
+            region_dirs = get_all_region_dirs(case_dir)
+
+        for region_dir in region_dirs:
+            # Skip regions no longer being used
+            if region_dir.name in ["artery", "vein", "ureter"]:
+                continue
+            if cli and args.instance is not None:
+                instance_dirs = [get_instance_dir(region_dir, args.instance - 1)]
+            else:
+                cli = False
+                instance_dirs = get_all_instance_dirs(region_dir)
+
+            for instance_dir in instance_dirs:
+                if cli and args.delineation is not None:
+                    delineations = [get_delineation(instance_dir, args.delineation)]
+                else:
+                    delineations = get_all_delineations(instance_dir)
+
+                for delineation in delineations:
+                    dln_file = get_most_recent_save(delineation)
+                    cache_key = str(delineation.relative_to(delineation.parent.parent.parent.parent))
+                    if args.regenerate or cache_key not in cache or cache[cache_key] != dln_file.name:
+                        run_import(dln_file)
+                        cache[cache_key] = dln_file.name
+                        write_json(CACHE_FILE, cache)
+                        reaggregate = True
+
+            # Delete any instances that were generated before but don't exist anymore
+            generated_instances = get_existing_instances(region_dir)
+            for gi in generated_instances:
+                if int(gi.stem.split("instance-")[1][0]) not in [int(x.name)+1 for x in instance_dirs]:
+                    print("Deleting legacy file:", str(gi.name))
+                    gi.unlink()
+                    reaggregate = True
+
+        if reaggregate:
+            aggregate_case(case_dir.name, )
+        
+        # Clean up all unused raw files
+        cleanup(case_dir)
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-c", "--case", help="The index of the case to import", type=int)
+    parser.add_argument("-r", "--region", help="The type of region to import", type=str)
+    parser.add_argument("-i", "--instance", help="The index of the instance of that region to import", type=int)
+    parser.add_argument("-d", "--delineation", help="The index of the delineation of that instance to import (1, 2, or 3)", type=int)
+    parser.add_argument("--regenerate", help="Regenerate segmentations regardless of cached values", action="store_true")
+    parser.add_argument("--reaggregate", help="Reaggregate segmentations regardless of whether it was changed", action="store_true")
+    if __name__ == "__main__":
+        cl_args = parser.parse_args()
+        main(cl_args)

kits21/kits21/kits21/annotation/postprocessing.py

@@ -0,0 +1,749 @@
+"""Code for turning user delineations into dense segmentations."""
+import json
+
+import numpy as np
+import nibabel as nib
+from PIL import Image, ImageDraw
+from numpy.core.fromnumeric import cumsum
+import torch
+import torch.nn.functional
+from scipy import signal
+from skimage import measure
+import cv2
+
+#pylint: disable=no-member
+
+
+def load_json(json_path):
+    with json_path.open() as f:
+        return json.loads(f.read())
+
+
+def write_json(json_path, data):
+    with json_path.open("w") as f:
+        return f.write(json.dumps(data, indent=2))
+
+
+def get_containing_box(dln, shape):
+    annotated_frames = set([])
+    maxs = [0, 0]
+    mins = [np.inf, np.inf]
+    max_sz = 0
+    for ann in dln["annotations"]:
+        annotated_frames.add(ann["frame"])
+        for pt in ann["spatial_payload"]:
+            if pt[0] > maxs[0]:
+                maxs[0] = pt[0]
+            if pt[1] > maxs[1]:
+                maxs[1] = pt[1]
+            if pt[0] < mins[0]:
+                mins[0] = pt[0]
+            if pt[1] < mins[1]:
+                mins[1] = pt[1]
+        if ann["line_size"] > max_sz:
+            max_sz = ann["line_size"]
+
+    afrms = sorted(list(annotated_frames))
+    last = afrms[0]
+    min_step = np.inf
+    for afrm in afrms[1:]:
+        if afrm - last < min_step:
+            min_step = afrm - last
+        last = afrm
+
+    abs_zmin = 0
+    abs_zmax = shape[0] - 1
+    return {
+        "xmin": max(0, int(np.floor(mins[0] - max_sz))),
+        "xmax": min(shape[2] - 1, int(np.ceil(maxs[0] + max_sz))),
+        "ymin": max(0, int(np.floor(mins[1] - max_sz))),
+        "ymax": min(shape[1] - 1, int(np.ceil(maxs[1] + max_sz))),
+        "zmin": max(abs_zmin, min(afrms) - min_step),
+        "zmax": min(abs_zmax, max(afrms) + min_step),
+        "step": min_step,
+        "xdim": shape[2],
+        "ydim": shape[1],
+        "zdim": shape[0]
+    }
+
+
+def get_cropped_scan(cbox, img_nib):
+    return img_nib.get_fdata()[
+        cbox["zmin"]:cbox["zmax"] + 1,
+        cbox["ymin"]:cbox["ymax"] + 1,
+        cbox["xmin"]:cbox["xmax"] + 1
+    ]
+
+
+def generate_cropped_drawing_interior(cbox, dln):
+    ret = np.zeros((
+        cbox["zmax"] - cbox["zmin"] + 1,
+        cbox["ymax"] - cbox["ymin"] + 1,
+        cbox["xmax"] - cbox["xmin"] + 1
+    ), dtype=np.int)
+
+    for i in range(ret.shape[0]):
+        with Image.new("L", (ret.shape[2]*10, ret.shape[1]*10)) as im:
+            draw = ImageDraw.Draw(im)
+            drew = False
+            for stroke in dln["annotations"]:
+                if stroke["deprecated"]:
+                    continue
+                if i + cbox["zmin"] == stroke["frame"]:
+                    drew = True
+                    draw.line(
+                        [
+                            (
+                                int(round((x[0] - cbox["xmin"])*10)),
+                                int(round((x[1] - cbox["ymin"])*10))
+                            ) 
+                            for x in stroke["spatial_payload"]
+                        ],
+                        fill=128,
+                        width=int(round(stroke["line_size"]*10))+4,
+                        joint="curve"
+                    )
+                    srt = stroke["spatial_payload"][0]
+                    draw.ellipse(
+                        [
+                            (
+                                int(round((srt[0] - cbox["xmin"] - stroke["line_size"]/2)*10))-2,
+                                int(round((srt[1] - cbox["ymin"] - stroke["line_size"]/2)*10))-2
+                            ),
+                            (
+                                int(round((srt[0] - cbox["xmin"] + stroke["line_size"]/2)*10))+2,
+                                int(round((srt[1] - cbox["ymin"] + stroke["line_size"]/2)*10))+2
+                            )
+                        ],
+                        fill=128
+                    )
+                    end = stroke["spatial_payload"][-1]
+                    draw.ellipse(
+                        [
+                            (
+                                int(round((end[0] - cbox["xmin"] - stroke["line_size"]/2)*10))-2,
+                                int(round((end[1] - cbox["ymin"] - stroke["line_size"]/2)*10))-2
+                            ),
+                            (
+                                int(round((end[0] - cbox["xmin"] + stroke["line_size"]/2)*10))+2,
+                                int(round((end[1] - cbox["ymin"] + stroke["line_size"]/2)*10))+2
+                            )
+                        ],
+                        fill=128
+                    )
+            if drew:
+                ImageDraw.floodfill(im, (0,0), 128, thresh=63.5)
+                rszd = im.resize((ret.shape[2], ret.shape[1]), Image.BILINEAR)
+                ret[i,:,:] = np.less(np.array(rszd), 63.9).astype(np.int)
+
+    return ret
+
+
+def get_contour(bin_seg):
+    if bin_seg is None:
+        return None
+    contours, hierarchy = cv2.findContours(bin_seg.astype(np.uint8)*255, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
+    return contours[0]
+
+
+def distance(p1, p2):
+    return (p1[0][0] - p2[0][0])*(p1[0][0] - p2[0][0]) + (p1[0][1] - p2[0][1])*(p1[0][1] - p2[0][1])
+
+
+def find_nearest_neighbors_slow_v2(lg_cntr, sm_cntr):
+    matches = np.zeros_like(lg_cntr)
+    step = sm_cntr.shape[0]/lg_cntr.shape[0]
+    mini = None
+    mind = np.inf
+    for i in range(lg_cntr.shape[0]):
+        candidate_matches = np.zeros_like(lg_cntr)
+        offset = i*step
+        for j in range(lg_cntr.shape[0]):
+            candidate_matches[j] = sm_cntr[int(np.round(offset + j*step)) % sm_cntr.shape[0]]
+
+        dist = np.square(lg_cntr - candidate_matches).sum()
+        if dist < mind:
+            mini = i
+            matches = candidate_matches.copy()
+            mind = dist
+            
+    return matches
+
+
+def draw_filled_contour(ind, bef_i, aft_i, drw_c, bef_bin, aft_bin, float_contour):
+    blown_up = np.zeros((drw_c.shape[1]*10, drw_c.shape[2]*10), dtype=np.uint8)
+    points = np.round(float_contour*10).astype(np.int32) + 1
+    cv2.fillPoly(blown_up, pts=[points], color=128)
+    drw_c[ind,:,:] = np.logical_or(
+        drw_c[ind,:,:],
+        np.logical_or(
+            np.greater(cv2.resize(blown_up, (drw_c.shape[2], drw_c.shape[1]), cv2.INTER_LINEAR), 32),
+            np.multiply(bef_bin, aft_bin)
+        )
+    )
+
+
+def get_group(istr, bef_to_aft, aft_to_bef):
+    bef_grp = set([istr])
+    aft_grp = set([])
+    bef_ln = len(bef_grp)
+    aft_ln = len(aft_grp)
+    while True:
+        for ai in aft_grp:
+            for atb in aft_to_bef[ai]:
+                if atb["ovr_sz"] > 0:
+                    bef_grp.add(str(atb["ind"]))
+        for bi in bef_grp:
+            for bta in bef_to_aft[bi]:
+                if bta["ovr_sz"] > 0:
+                    aft_grp.add(str(bta["ind"]))
+        if len(bef_grp) != bef_ln or len(aft_grp) != aft_ln:
+            bef_ln = len(bef_grp)
+            aft_ln = len(aft_grp)
+        else:
+            break
+    return list(bef_grp), list(aft_grp)
+
+
+def splice_contour(spliced, stretches, cntr, cur_sz, ctr_ind):
+    # Get nearest pair
+    mini = None
+    minj = None
+    mind = np.inf
+    for i in range(cur_sz):
+        for j in range(cntr.shape[0]):
+            dst = distance(spliced[i], cntr[j])
+            if dst < mind:
+                mini = i
+                minj = j
+                mind = dst
+                                
+    ret_sp = spliced.copy()
+    ret_sp[mini+1:mini+cntr.shape[0]+1] = cntr
+    ret_sp[mini+cntr.shape[0]+1:cur_sz+cntr.shape[0]] = spliced[mini+1:cur_sz]
+
+    ret_st = stretches.copy()
+    ret_st[mini+1:mini+cntr.shape[0]+1] = ctr_ind*np.ones((cntr.shape[0], 1))
+    ret_st[mini+cntr.shape[0]+1:cur_sz+cntr.shape[0]] = stretches[mini+1:cur_sz]
+    
+    return ret_sp, ret_st
+    
+
+def splice_contours(cntrs):
+    lengths = [cr.shape[0] for cr in cntrs]
+    stretches = -1*np.ones(
+        (sum(lengths),1),
+        dtype=np.int32
+    )
+    
+    spliced = np.zeros(
+        (sum(lengths),) + cntrs[0].shape[1:],
+        dtype=cntrs[0].dtype
+    )
+    spliced[0:cntrs[0].shape[0]] = cntrs[0].copy()
+    stretches[0:cntrs[0].shape[0]] = np.zeros((cntrs[0].shape[0], 1))
+    for i in range(1, len(cntrs)):
+        spliced, stretches = splice_contour(spliced, stretches, cntrs[i], sum(lengths[:i]), i)
+
+    return spliced, stretches
+
+
+def slice_matches(matches, splice_inds):
+    ret = []
+    for i in range(np.max(splice_inds)+1):
+        ret += [matches[splice_inds == i,:].reshape((-1,1,2))]
+    
+    return ret 
+
+
+def interpolate_merge_association(bef_grp, aft_grp, bef_lbl, aft_lbl, drw_c, bef_i, aft_i, step):
+    # Get composites for each
+    tot_bef_bin = np.zeros_like(bef_lbl)
+    for lbl in bef_grp:
+        tot_bef_bin = np.logical_or(
+            tot_bef_bin,
+            np.equal(bef_lbl, int(lbl))
+        )
+    tot_aft_bin = np.zeros_like(aft_lbl)
+    for lbl in aft_grp:
+        tot_aft_bin = np.logical_or(
+            tot_aft_bin,
+            np.equal(aft_lbl, int(lbl))
+        )
+        
+    # Get individual values
+    bef_bins = [
+        np.equal(bef_lbl, int(x))
+        for x in bef_grp
+    ]
+    aft_bins = [
+        np.equal(aft_lbl, int(x))
+        for x in aft_grp
+    ]
+    bef_cntrs = [
+        get_contour(bef_bin)
+        for bef_bin in bef_bins
+    ]
+    aft_cntrs = [
+        get_contour(aft_bin)
+        for aft_bin in aft_bins
+    ]
+    if len(bef_grp) > len(aft_grp):
+        nonref_cntrs = bef_cntrs
+        spliced_nonref, splice_inds = splice_contours(bef_cntrs)
+        ref_cntrs = aft_cntrs
+        start = aft_i
+        inc = -1
+    else:
+        nonref_cntrs = aft_cntrs
+        spliced_nonref, splice_inds = splice_contours(aft_cntrs)
+        ref_cntrs = bef_cntrs
+        start = bef_i
+        inc = 1
+
+    for ref_cntr in ref_cntrs:
+        matches = find_nearest_neighbors_slow_v2(ref_cntr, spliced_nonref)
+        rev_matches = find_nearest_neighbors_slow_v2(spliced_nonref, ref_cntr)
+        sliced_matches = slice_matches(rev_matches, splice_inds)
+        for i in range(1, int(np.ceil((aft_i - bef_i)/2))):
+            draw_filled_contour(
+                start + i*inc, bef_i, aft_i,
+                drw_c, tot_bef_bin, tot_aft_bin,
+                i/step*matches + (step - i)/step*ref_cntr
+            )
+        for nonref_frag, ref_frag in zip(nonref_cntrs, sliced_matches):
+            for i in range(int(np.ceil((aft_i - bef_i)/2)), aft_i - bef_i):
+                draw_filled_contour(
+                    start + i*inc, bef_i, aft_i,
+                    drw_c, tot_bef_bin, tot_aft_bin,
+                    i/step*nonref_frag + (step - i)/step*ref_frag
+                )
+
+
+def interpolate_simple_association(bef_bin, aft_bin, drw_c, bef_i, aft_i, bef_cnt, aft_cnt, step):
+    # cnt <- center
+    # cntr <- contour
+    bef_cntr = get_contour(bef_bin)
+    aft_cntr = get_contour(aft_bin)
+    if bef_cntr is None:
+        start = bef_i
+        inc = 1
+        ref = bef_cntr
+        bef_cntr = np.array([
+            [bef_cnt]
+        ])
+        bef_bin = np.zeros_like(aft_bin)
+    elif aft_cntr is None:
+        start = aft_i
+        inc = -1
+        ref = aft_cntr
+        aft_cntr = np.array([
+            [aft_cnt]
+        ])
+        aft_bin = np.zeros_like(bef_bin)
+    if bef_cntr.shape[0] > aft_cntr.shape[0]:
+        start = bef_i
+        inc = 1
+        ref = bef_cntr
+        matches = find_nearest_neighbors_slow_v2(bef_cntr, aft_cntr)
+    else:
+        start = aft_i
+        inc = -1
+        ref = aft_cntr
+        matches = find_nearest_neighbors_slow_v2(aft_cntr, bef_cntr)
+
+    for i in range(1, aft_i - bef_i):
+        draw_filled_contour(
+            start + i*inc, bef_i, aft_i,
+            drw_c, bef_bin, aft_bin,
+            i/step*matches + (step - i)/step*ref
+        )
+
+
+def interpolate_step(bef_i, aft_i, drw_c, step):
+    # Label connected components in each
+    bef_lbl = measure.label(drw_c[bef_i, :, :], background=0)
+    aft_lbl = measure.label(drw_c[aft_i, :, :], background=0)
+
+    # Associate connected components based on proximity and overlap
+    num_bef = np.max(bef_lbl)
+    num_aft = np.max(aft_lbl)
+
+    aft_cvg = [False for _ in range(num_aft)]
+
+    bef_to_aft = {}
+    aft_to_bef = {}
+
+    # Iterate over all pairs of blobs
+    for i in range(1, num_bef+1):
+        bef_bin = np.equal(bef_lbl, i).astype(np.int)
+        bef_cnt_x, bef_cnt_y = np.argwhere(bef_bin == 1).sum(0)/bef_bin.sum()
+        bef_covered = False
+        istr = "{}".format(i)
+        for j in range(1, num_aft+1):
+            aft_bin = np.equal(aft_lbl, j).astype(np.int)
+
+            # Get size of overlap
+            ovr_sz = np.multiply(bef_bin, aft_bin).sum()
+
+            # Get metrics describing blob proximity
+            aft_cnt_x, aft_cnt_y = np.argwhere(aft_bin == 1).sum(0)/aft_bin.sum()
+            cnt_dsp = [aft_cnt_y - bef_cnt_y, aft_cnt_x - bef_cnt_x]
+            cnt_dst_sq = cnt_dsp[0]**2 + cnt_dsp[1]**2
+
+            if ovr_sz > 0 or cnt_dst_sq < 5**2:
+                jstr = "{}".format(j)
+                if istr not in bef_to_aft:
+                    bef_to_aft[istr] = []
+                bef_to_aft[istr] += [{
+                    "ind": j,
+                    "ovr_sz": int(ovr_sz),
+                    "cnt_dst_sq": cnt_dst_sq
+                }]
+                if jstr not in aft_to_bef:
+                    aft_to_bef[jstr] = []
+                aft_to_bef[jstr] += [{
+                    "ind": i,
+                    "ovr_sz": int(ovr_sz),
+                    "cnt_dst_sq": cnt_dst_sq
+                }]
+                bef_covered = True
+                aft_cvg[j-1] = True
+
+        if not bef_covered:
+            interpolate_simple_association(
+                bef_bin, None, drw_c, bef_i, aft_i,
+                [bef_cnt_y, bef_cnt_x], [bef_cnt_y, bef_cnt_x], step
+            )
+
+    for j, ac in enumerate(aft_cvg):
+        if not ac:
+            aft_bin = np.equal(aft_lbl, j+1).astype(np.int)
+            aft_cnt_x, aft_cnt_y = np.argwhere(aft_bin == 1).sum(0)/aft_bin.sum()
+            interpolate_simple_association(
+                None, aft_bin, drw_c, bef_i, aft_i,
+                [aft_cnt_y, aft_cnt_x], [aft_cnt_y, aft_cnt_x], step
+            )
+
+    # If each only has one candidate, that's easy
+    for istr in bef_to_aft:
+        if len(bef_to_aft[istr]) == 1 and len(aft_to_bef[str(bef_to_aft[istr][0]["ind"])]) == 1:
+            bef_bin = np.equal(bef_lbl, int(istr)).astype(np.int)
+            aft_bin = np.equal(aft_lbl, bef_to_aft[istr][0]["ind"]).astype(np.int)
+            aft_cnt_x, aft_cnt_y = np.argwhere(aft_bin == 1).sum(0)/aft_bin.sum()
+            bef_cnt_x, bef_cnt_y = np.argwhere(bef_bin == 1).sum(0)/bef_bin.sum()
+            interpolate_simple_association(
+                bef_bin, aft_bin, drw_c, bef_i, aft_i,
+                [bef_cnt_y, bef_cnt_x], [aft_cnt_y, aft_cnt_x], step
+            )
+        else: # More complex decision...
+            strict_bta = [x for x in bef_to_aft[istr] if x["ovr_sz"] > 0]
+            strict_atb = []
+            for k in range(len(strict_bta)):
+                strict_atb += [
+                    x for x in aft_to_bef[str(strict_bta[k]["ind"])] 
+                    if x["ovr_sz"] > 0
+                ]
+            handled = False
+            if len(strict_bta) == 1:
+                if len(strict_atb) == 1:
+                    handled = True
+                    bef_bin = np.equal(bef_lbl, int(istr)).astype(np.int)
+                    aft_bin = np.equal(aft_lbl, strict_bta[0]["ind"]).astype(np.int)
+                    aft_cnt_x, aft_cnt_y = np.argwhere(aft_bin == 1).sum(0)/aft_bin.sum()
+                    bef_cnt_x, bef_cnt_y = np.argwhere(bef_bin == 1).sum(0)/bef_bin.sum()
+                    interpolate_simple_association(
+                        bef_bin, aft_bin, drw_c, bef_i, aft_i,
+                        [bef_cnt_y, bef_cnt_x], [aft_cnt_y, aft_cnt_x], step
+                    )
+            if not handled: # Need to do a group merge
+                bef_grp, aft_grp = get_group(istr, bef_to_aft, aft_to_bef)
+                interpolate_merge_association(
+                    bef_grp, aft_grp, bef_lbl, aft_lbl, drw_c, bef_i, aft_i, step
+                )
+
+    return drw_c
+
+
+def interpolate_drawings(drw_c, step, arb_bdry=False):
+    # Get inclusive start and end frames
+    start = 0
+    while start < drw_c.shape[0]:
+        if np.sum(drw_c[start]) > 0:
+            break
+        else:
+            start += 1
+    end = drw_c.shape[0] - 1
+    while end > start:
+        if np.sum(drw_c[end]) > 0:
+            break
+        else:
+            end -= 1
+
+
+    if arb_bdry:
+        start += step
+        end -= step
+
+    while start < end + step + 1:
+        drw_c = interpolate_step(max(start - step, 0), min(start, drw_c.shape[0] - 1), drw_c, step)
+        start += step
+
+    return drw_c
+
+
+def get_blur_kernel_d(affine):
+    kerx = signal.gaussian(5, std=1/np.abs(affine[0,2])).reshape(5, 1)
+    kerxy = np.outer(kerx, kerx).reshape(1, 5, 5)
+    kerz = signal.gaussian(5, std=1/np.abs(affine[2,0])).reshape(5, 1, 1)
+    kerxyz = np.outer(kerz, kerxy)
+    kerxyz /= np.sum(kerxyz)
+    return torch.from_numpy(kerxyz.reshape(1,1,5,5,5)).to("cuda:0")
+
+
+def get_threshold(region_type):
+    # This seems to work -- no need to adjust based on region now that ureter is gone
+    return -30
+
+
+def find_hilum_in_slice(thresh, side):
+    # TODO use custom if available
+    thresh = thresh.astype(np.uint8)
+    (
+        nb_components, output, stats, centroids
+    ) = cv2.connectedComponentsWithStats(thresh, connectivity=4)
+    sizes = stats[:, -1]
+
+    max_label = 0
+    max_size = 0
+    for i in range(1, nb_components):
+        if sizes[i] > max_size:
+            max_label = i
+            max_size = sizes[i]
+
+    thresh[output != max_label] = 0
+    centroid = np.array(tuple(centroids[max_label]))
+
+    contours, _ = cv2.findContours(
+        thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE
+    )
+
+    if len(contours) == 0:
+        return None
+
+    primary_contour = contours[0]
+    hull = cv2.convexHull(primary_contour, returnPoints=False)
+    defects = cv2.convexityDefects(primary_contour, hull)
+
+    # Choose from defects
+    distances = []
+    scores = []
+    criteria = []
+    depths = []
+
+    if defects is None:
+        return None
+
+    for i in range(defects.shape[0]):
+        s, e, f, d = defects[i, 0]
+        start = np.array(tuple(primary_contour[s][0]))
+        end = np.array(tuple(primary_contour[e][0]))
+        furthest = np.array(tuple(primary_contour[f][0]))
+        defect_center = (start + end)/2
+        depth = np.linalg.norm(furthest - defect_center)
+        centroid_offset = centroid - defect_center
+        distance = np.linalg.norm(start - end, ord=2)
+        # print(centroid, defect_center, centroid_offset, distance)
+        if side == "left":
+            score = 1*centroid_offset[0] + centroid_offset[1]
+        elif side == "right":
+            score = -1*centroid_offset[0] + centroid_offset[1]
+        distance = np.linalg.norm(start - end, ord=2)
+        scores = scores + [score]
+        distances = distances + [distance]
+        depths = depths + [depth]
+        criteria = criteria + [int(score>0)*(distance+3*depth)]
+
+    if np.sum(criteria) > 1e-2:
+        winner = np.argmax(criteria)
+        s, e, f, d = defects[winner, 0]
+        start = tuple(primary_contour[s][0])
+        end = tuple(primary_contour[e][0])
+        hlm = [start, end]
+    else:
+        hlm = None
+
+    return hlm
+
+
+def apply_hilum_to_slice(thresholded_c, blur_c, threshold, ind, hlm):
+    if hlm is None:
+        return
+
+    cv2.line(thresholded_c[ind], hlm[0], hlm[1], 1, 2)
+    abuse_slc = thresholded_c[ind].copy()
+    mask = np.zeros((thresholded_c.shape[1]+2, thresholded_c.shape[2]+2), np.uint8)
+    cv2.floodFill(abuse_slc, mask, (0,0), 1)
+    thresholded_c[ind] = np.logical_and(
+        (np.equal(abuse_slc, 0) | thresholded_c[ind]).astype(thresholded_c[ind].dtype),
+        np.greater(blur_c[ind], threshold)
+    )
+
+
+# TODO allow for custom hilums to be specified in dln
+# Polygons will be allowed for logged-in users
+def add_renal_hilum(thresholded_c, blr_c, threshold, lzn, side, cbox, custom_hilums):
+    first_hilum_slice = None
+    last_hilum_slice = None
+    for ann in lzn["annotations"]:
+        if ann["spatial_type"] == "whole-image" and not ann["deprecated"]:
+            bound = None
+            for cp in ann["classification_payloads"]:
+                if cp["confidence"] > 0.5:
+                    if cp["class_id"] == 7:
+                        bound = "sup"
+                    elif cp["class_id"] == 8:
+                        bound = "inf"
+            if bound is None:
+                continue
+            frame = int(ann["frame"])
+            if bound == "sup":
+                if first_hilum_slice is None or frame < first_hilum_slice:
+                    first_hilum_slice = frame - cbox["zmin"]
+            elif bound == "inf":
+                if last_hilum_slice is None or frame > last_hilum_slice:
+                    last_hilum_slice = frame - cbox["zmin"]
+
+    for ind in range(thresholded_c.shape[0]):
+        if "slice_{}".format(ind) in custom_hilums:
+            for hlm in custom_hilums["slice_{}".format(ind)]:
+                apply_hilum_to_slice(thresholded_c, blr_c, threshold, ind, hlm)
+        elif (
+            (
+                first_hilum_slice is not None and ind >= first_hilum_slice
+            ) and (
+                last_hilum_slice is not None and ind <= last_hilum_slice
+            )
+        ):
+            # TODO send dln here and use custom hilum if possible
+            hlm = find_hilum_in_slice(thresholded_c[ind].copy(), side)
+            apply_hilum_to_slice(thresholded_c, blr_c, threshold, ind, hlm)
+    else:
+        if first_hilum_slice is None:
+            print("First hilum slice could not be determined")
+        if last_hilum_slice is None:
+            print("Last hilum slice could not be determined")
+
+    return thresholded_c
+
+
+def get_side(cbox):
+    if cbox["xmin"] + cbox["xmax"] > cbox["xdim"]:
+        return "left"
+    return "right"
+
+
+def generate_segmentation(region_type, cropped_img, cropped_drw, step=1, affine=None, lzn=None, cbox=None, custom_hilums={}):
+    # Interpolate drawings
+    cropped_drw = interpolate_drawings(cropped_drw, step)
+
+    # Send tensors to GPU
+    img_d = torch.from_numpy(cropped_img).to("cuda:0")
+    drw_d = torch.from_numpy(cropped_drw).to("cuda:0")
+
+    # Apply a 3d blur convolution
+    blur_kernel_d = get_blur_kernel_d(affine)
+    blr_d = torch.nn.functional.conv3d(
+        img_d.reshape((1,1)+cropped_img.shape),
+        blur_kernel_d, stride=1, padding=2
+    ).reshape(cropped_img.shape)
+
+    # Apply threshold
+    threshold = get_threshold(region_type)
+    thresholded_d = torch.logical_and(
+        torch.greater(blr_d, threshold),
+        torch.greater(drw_d, 0)
+    ).int()
+
+    # If region is kidney, add hilum, redraw, and get new threshold
+    thresholded_c = thresholded_d.to("cpu").numpy()
+    blr_c = blr_d.to("cpu").numpy()
+    if region_type == "kidney":
+        side = get_side(cbox)
+        thresholded_c = add_renal_hilum(thresholded_c, blr_c, threshold, lzn, side, cbox, custom_hilums)
+
+    # Bring result back to cpu memory
+    return thresholded_c
+
+
+def inflate_seg_to_image_size(cbox, cropped_seg):
+    seg_np = np.zeros((cbox["zdim"], cbox["ydim"], cbox["xdim"]), dtype=np.int)
+    seg_np[
+        cbox["zmin"]:cbox["zmax"] + 1,
+        cbox["ymin"]:cbox["ymax"] + 1,
+        cbox["xmin"]:cbox["xmax"] + 1,
+    ] = cropped_seg
+    return seg_np
+
+
+def get_custom_hilums(meta, cbox):
+    ret = {}
+    if "custom_hilums" not in meta:
+        return ret
+
+    for ch in meta["custom_hilums"]:
+        if ch["slice_index"] < cbox["zmin"] or ch["slice_index"] > cbox["zmax"]:
+            continue
+
+        dct_key = "slice_{}".format(ch["slice_index"] - cbox["zmin"])
+        if dct_key not in ret:
+            ret[dct_key] = []
+
+        for hlm in ch["hilums"]:
+            ret[dct_key] += [
+                [
+                    (
+                        hlm[0][0] - cbox["xmin"],
+                        hlm[0][1] - cbox["ymin"]
+                    ),
+                    (
+                        hlm[1][0] - cbox["xmin"],
+                        hlm[1][1] - cbox["ymin"]
+                    )
+                ]
+            ]
+
+    return ret
+
+
+def delineation_to_seg(region_type, image_path, delineation_path, meta, localization_path=None):
+    # Read and parse delination and (maybe) localization from file
+    lzn = None
+    if region_type == "kidney":
+        assert localization_path is not None
+        lzn = load_json(localization_path)
+    dln = load_json(delineation_path)
+
+    # Read CT scan
+    img_nib = nib.load(str(image_path))
+
+    # Crop image to the smallest possible box for memory/computational efficiency
+    cbox = get_containing_box(dln, img_nib.shape)
+    cropped_img = get_cropped_scan(cbox, img_nib)
+
+    # Generate the drawing made by the annotator
+    cropped_drw = generate_cropped_drawing_interior(cbox, dln)
+
+    # Get any custom hilums within the containing box
+    custom_hilums = get_custom_hilums(meta, cbox)
+
+    # Apply heuristics to infer segmentation based on drawing and image
+    cropped_seg = generate_segmentation(
+        region_type, cropped_img, cropped_drw, cbox["step"], img_nib.affine, lzn, cbox, custom_hilums
+    )
+
+    # Undo cropping to get final segmentation
+    seg = inflate_seg_to_image_size(cbox, cropped_seg)
+
+    # Return the seg in nifti format
+    return nib.Nifti1Image(seg.astype(np.uint8), img_nib.affine)

kits21/kits21/kits21/annotation/sample_segmentations.py

@@ -0,0 +1,158 @@
+import shutil
+from multiprocessing import Pool
+
+import SimpleITK as sitk
+import numpy as np
+from batchgenerators.utilities.file_and_folder_operations import *
+
+from kits21.configuration.labels import LABEL_AGGREGATION_ORDER, NUMBER_OF_GROUPS
+from kits21.configuration.paths import TRAINING_DIR, TESTING_DIR
+
+
+def get_number_of_instances(segmentations_folder: str, label_name: str = 'kidney'):
+    nii_files = subfiles(segmentations_folder, suffix='.nii.gz', prefix=label_name, join=False)
+    instance_strings = [i.split('_')[1] for i in nii_files]
+    instance_idx = [int(i.split('-')[-1]) for i in instance_strings]
+    return list(np.unique(instance_idx))
+
+
+def get_annotations(segmentations_folder: str, label_name: str = 'kidney', instance_idx: int = 1):
+    nii_files = subfiles(segmentations_folder, suffix='.nii.gz', prefix=label_name + '_instance-%s' % instance_idx, join=False)
+    annotation_strings = [i.split('_')[-1][:-7] for i in nii_files]
+    annotation_idx = [int(i.split('-')[-1]) for i in annotation_strings]
+    return list(np.unique(annotation_idx))
+
+
+def build_segmentation(kidney_files, tumor_files, cyst_files, output_file: str) -> None:
+    labelid_files_mapping = {
+        i: j if j is not None else list() for i, j in {
+            1: kidney_files,
+            2: tumor_files,
+            3: cyst_files,
+        }.items()}
+
+    seg = None
+    seg_itk = None
+
+    for current_label in LABEL_AGGREGATION_ORDER:
+        files = labelid_files_mapping[current_label]
+        for f in files:
+            if seg is None:
+                seg_itk = sitk.ReadImage(f)
+                seg = sitk.GetArrayFromImage(seg_itk).astype(np.uint8)
+                seg[seg == 1] = current_label
+            else:
+                new_seg = sitk.GetArrayFromImage(sitk.ReadImage(f)).astype(np.uint8)
+                seg[new_seg == 1] = current_label
+
+    seg = seg.astype(np.uint8)
+    seg = sitk.GetImageFromArray(seg)
+    seg.CopyInformation(seg_itk)
+    sitk.WriteImage(seg, output_file)
+
+
+def generate_samples(segmentations_folder: str, samples_output_folder: str, num_groups=3, seed=1234):
+    """
+    We do this the stupid way, because the smart way is above my head right now.
+
+    Why groups? We can only determine the inter-rater disagreement within each group because otherwise we might see the
+    same annotation more than once. So we compute the inter-rater disagreement within each group, then average across
+    groups
+
+    :param segmentations_folder:
+    :param samples_output_folder:
+    :return:
+    """
+    instances_kidney = get_number_of_instances(segmentations_folder, 'kidney')
+    instances_cyst = get_number_of_instances(segmentations_folder, 'cyst')
+    instances_tumor = get_number_of_instances(segmentations_folder, 'tumor')
+
+    anno_kidney = [get_annotations(segmentations_folder, 'kidney', i) for i in instances_kidney]
+    anno_cyst = [get_annotations(segmentations_folder, 'cyst', i) for i in instances_cyst]
+    anno_tumor = [get_annotations(segmentations_folder, 'tumor', i) for i in instances_tumor]
+
+    num_kidney_seg_per_group = min([len(i) for i in anno_kidney]) if len(anno_kidney) > 0 else np.nan
+    num_cyst_seg_per_group = min([len(i) for i in anno_cyst]) if len(anno_cyst) > 0 else np.nan
+    num_tumor_seg_per_group = min([len(i) for i in anno_tumor]) if len(anno_tumor) > 0 else np.nan
+
+    n_seg_per_group = int(np.nanmin((num_kidney_seg_per_group, num_cyst_seg_per_group, num_tumor_seg_per_group)))
+
+    rs = np.random.RandomState(seed)
+    for n in range(num_groups):
+        output_folder = join(samples_output_folder, 'group_%s' % str(n))
+        maybe_mkdir_p(output_folder)
+
+        random_offsets_kidney = [rs.randint(0, len(i)) for i in anno_kidney]
+        random_offsets_tumor = [rs.randint(0, len(i)) for i in anno_tumor]
+        random_offsets_cyst = [rs.randint(0, len(i)) for i in anno_cyst]
+
+        for i in range(n_seg_per_group):
+            output_filename = 'kidney'
+            kidney_files = []
+            for ik, inst_k in enumerate(instances_kidney):
+                anno = anno_kidney[ik][(random_offsets_kidney[ik] + i) % len(anno_kidney[ik])]
+                kidney_files.append(join(segmentations_folder, 'kidney_instance-%s_annotation-%s.nii.gz' % (inst_k, anno)))
+                output_filename += "_i%sa%s" % (inst_k, anno)
+
+            output_filename += '_cyst'
+            cyst_files = []
+            for ic, inst_c in enumerate(instances_cyst):
+                anno = anno_cyst[ic][(random_offsets_cyst[ic] + i) % len(anno_cyst[ic])]
+                cyst_files.append(join(segmentations_folder, 'cyst_instance-%s_annotation-%s.nii.gz' % (inst_c, anno)))
+                output_filename += "_i%sa%s" % (inst_c, anno)
+
+            output_filename += '_tumor'
+            tumor_files = []
+            for it, inst_t in enumerate(instances_tumor):
+                anno = anno_tumor[it][(random_offsets_tumor[it] + i) % len(anno_tumor[it])]
+                tumor_files.append(join(segmentations_folder, 'tumor_instance-%s_annotation-%s.nii.gz' % (inst_t, anno)))
+                output_filename += "_i%sa%s" % (inst_t, anno)
+
+            output_filename += ".nii.gz"
+            build_segmentation(kidney_files, tumor_files, cyst_files, join(output_folder, output_filename))
+
+
+def generate_samples_for_all_cases(num_processes: int, num_groups_per_case: int = 5, testing: bool = True) -> None:
+    """
+    THIS WILL DELETE PREVIOUSLY EXISTING SAMPLES! BEWARE!
+
+    :param num_processes:
+    :param num_groups_per_case:
+    :return:
+    """
+    source_dir = TRAINING_DIR
+    if testing:
+        source_dir = TESTING_DIR
+
+    cases = subfolders(source_dir, prefix='case_', join=False)
+    case_ids = [int(i.split('_')[-1]) for i in cases]
+    p = Pool(num_processes)
+    res = []
+    for case, caseid in zip(cases, case_ids):
+        if isdir(join(source_dir, case, 'segmentations')) and \
+                len(subfiles(join(source_dir, case, 'segmentations'), suffix='.nii.gz')) > 0:
+            if isdir(join(source_dir, case, 'segmentation_samples')):
+                shutil.rmtree(join(source_dir, case, 'segmentation_samples'))
+            if isfile(join(source_dir, case, 'inter_rater_disagreement.json')):
+                os.remove(join(source_dir, case, 'inter_rater_disagreement.json'))
+            if isfile(join(source_dir, case, 'tolerances.json')):
+                os.remove(join(source_dir, case, 'tolerances.json'))
+            res.append(p.starmap_async(
+                generate_samples, ((join(source_dir, case, 'segmentations'),
+                                    join(source_dir, case, 'segmentation_samples'),
+                                    num_groups_per_case,
+                                    caseid), )
+            ))
+    _ = [i.get() for i in res]
+    p.close()
+    p.join()
+
+
+if __name__ == '__main__':
+    if __name__ == '__main__':
+        import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-num_processes', required=False, default=12, type=int)
+    parser.add_argument('-testing', required=False, default=False, type=bool)
+    args = parser.parse_args()
+    generate_samples_for_all_cases(args.num_processes, NUMBER_OF_GROUPS, args.testing)