Upload 6 files

preprocess_3D_to_2D/README.md

@@ -0,0 +1,21 @@
+*Step 1: Normalization 3D images*
+
+CT, [-175, 250] for abdomen, [-1000, 500] for chest:
+
+```
+python normalize_CT.py --test_data_path $YOUR_3D_IMAGE_PATH --save_path $YOUR_PATH_SAVE_NORMALIZE_DATA --a_min -175 --a_max 250
+```
+
+MRI:
+
+```
+python normalize_MRI.py --test_data_path $YOUR_3D_IMAGE_PATH --save_path $YOUR_PATH_SAVE_NORMALIZE_DATA
+```
+
+*Step 2: pre_process slices*
+
+You need to modify the your own label keys in preprocess_2D_slices.py
+
+```
+python preprocess_2D_slices.py
+```

preprocess_3D_to_2D/create_annotations.py

@@ -0,0 +1,114 @@
+from PIL import Image                                      # (pip install Pillow)
+import numpy as np                                         # (pip install numpy)
+from skimage import measure                                # (pip install scikit-image)
+#from shapely.geometry import Polygon, MultiPolygon         # (pip install Shapely)
+import os
+import json
+
+def create_sub_masks(mask_image, width, height):
+    # Initialize a dictionary of sub-masks indexed by RGB colors
+    sub_masks = {}
+    for x in range(width):
+        for y in range(height):
+            # Get the RGB values of the pixel
+            pixel = mask_image.getpixel((x,y))[:3]
+
+            # Check to see if we have created a sub-mask...
+            pixel_str = str(pixel)
+            sub_mask = sub_masks.get(pixel_str)
+            if sub_mask is None:
+               # Create a sub-mask (one bit per pixel) and add to the dictionary
+                # Note: we add 1 pixel of padding in each direction
+                # because the contours module doesn"t handle cases
+                # where pixels bleed to the edge of the image
+                sub_masks[pixel_str] = Image.new("1", (width+2, height+2))
+
+            # Set the pixel value to 1 (default is 0), accounting for padding
+            sub_masks[pixel_str].putpixel((x+1, y+1), 1)
+
+    return sub_masks
+
+# def create_sub_mask_annotation(sub_mask):
+#     # Find contours (boundary lines) around each sub-mask
+#     # Note: there could be multiple contours if the object
+#     # is partially occluded. (E.g. an elephant behind a tree)
+#     contours = measure.find_contours(np.array(sub_mask), 0.5, positive_orientation="low")
+
+#     polygons = []
+#     segmentations = []
+#     for contour in contours:
+#         # Flip from (row, col) representation to (x, y)
+#         # and subtract the padding pixel
+#         for i in range(len(contour)):
+#             row, col = contour[i]
+#             contour[i] = (col - 1, row - 1)
+
+#         # Make a polygon and simplify it
+#         poly = Polygon(contour)
+#         if poly.length > 100:
+#             poly = poly.simplify(0.5, preserve_topology=True)
+        
+#         if(poly.is_empty):
+#             # Go to next iteration, dont save empty values in list
+#             continue
+
+#         polygons.append(poly)
+
+#         segmentation = np.array(poly.exterior.coords).ravel().tolist()
+#         segmentations.append(segmentation)
+    
+#     return polygons, segmentations
+
+def create_category_annotation(category_dict):
+    category_list = []
+
+    for key, value in category_dict.items():
+        category = {
+            "supercategory": key,
+            "id": value,
+            "name": key
+        }
+        category_list.append(category)
+
+    return category_list
+
+def create_image_annotation(file_name, width, height, image_id):
+    images = {
+        "file_name": file_name,
+        "height": height,
+        "width": width,
+        "id": image_id
+    }
+
+    return images
+
+def create_annotation_format(polygon, segmentation, image_id, category_id, annotation_id):
+    min_x, min_y, max_x, max_y = polygon.bounds
+    width = max_x - min_x
+    height = max_y - min_y
+    bbox = (min_x, min_y, width, height)
+    area = polygon.area
+
+    annotation = {
+        "segmentation": segmentation,
+        "area": area,
+        "iscrowd": 0,
+        "image_id": image_id,
+        "bbox": bbox,
+        "category_id": category_id,
+        "id": annotation_id
+    }
+
+    return annotation
+
+def get_coco_json_format():
+    # Standard COCO format 
+    coco_format = {
+        "info": {},
+        "licenses": [],
+        "images": [{}],
+        "categories": [{}],
+        "annotations": [{}]
+    }
+
+    return coco_format

preprocess_3D_to_2D/create_customer_datasets.py

@@ -0,0 +1,141 @@
+import glob
+from tqdm import tqdm
+import pandas as pd
+
+from create_annotations import *
+
+
+# provide the path to the dataset. There should be train, train_mask, test, test_mask under this folder
+
+image_size = 1024
+
+
+### Load Biomed Label Base
+# provide path to predefined label base
+with open('label_base.json', 'r') as f:
+    label_base = json.load(f)
+    
+
+# get parent class for the names
+parent_class = {}
+for i in label_base:
+    subnames = [label_base[i]['name']] + label_base[i].get('child', [])
+    for label in subnames:
+        parent_class[label] = int(i)
+    
+# Label ids of the dataset
+category_ids = {label_base[i]['name']: int(i) for i in label_base if 'name' in label_base[i]}
+
+# Get "images" and "annotations" info 
+def images_annotations_info(maskpath, keyword):
+    
+    imagepath = maskpath.replace('_mask', '')
+    # This id will be automatically increased as we go
+    annotation_id = 0
+    
+    sent_id = 0
+    ref_id = 0
+    
+    annotations = []
+    images = []
+    image_to_id = {}
+    n_total = len(glob.glob(maskpath + "*.png"))
+    n_errors = 0
+    
+    def extra_annotation(ann, file_name, target):
+        nonlocal sent_id, ref_id
+        ann['file_name'] = file_name
+        ann['split'] = keyword
+        
+        ### modality
+        mod = file_name.split('.')[0].split('_')[-2]
+        ### site
+        site = file_name.split('.')[0].split('_')[-1]
+        
+        task = {'target': target, 'modality': mod, 'site': site}
+        if 'T1' in mod or 'T2' in mod or 'FLAIR' in mod or 'ADC' in mod:
+            task['modality'] = 'MRI'
+            if 'MRI' not in mod:
+                task['sequence'] = mod
+            else:
+                task['sequence'] = mod[4:]
+            
+        prompts = [f'{target} in {site} {mod}']
+        
+        ann['sentences'] = []
+        for p in prompts:
+            ann['sentences'].append({'raw': p, 'sent': p, 'sent_id': sent_id})
+            sent_id += 1
+        ann['sent_ids'] = [s['sent_id'] for s in ann['sentences']]
+        
+        ann['ann_id'] = ann['id']
+        ann['ref_id'] = ref_id
+        ref_id += 1
+        
+        return ann
+    
+    for mask_image in tqdm(glob.glob(maskpath + "*.png")):
+        # The mask image is *.png but the original image is *.jpg.
+        # We make a reference to the original file in the COCO JSON file
+        filename_parsed = os.path.basename(mask_image).split("_")
+        target_name = filename_parsed[-1].split(".")[0].replace("+", " ")
+        
+        original_file_name = "_".join(filename_parsed[:-1]) + ".png"
+        
+        if original_file_name not in os.listdir(imagepath):
+            print("Original file not found: {}".format(original_file_name))
+            n_errors += 1
+            print(n_errors)
+            continue
+        
+        if original_file_name not in image_to_id:
+            image_to_id[original_file_name] = len(image_to_id)
+
+            # "images" info 
+            image_id = image_to_id[original_file_name]
+            image = create_image_annotation(original_file_name, image_size, image_size, image_id)
+            images.append(image)
+            
+        
+        annotation = {
+            "mask_file": os.path.basename(mask_image),
+            "iscrowd": 0,
+            "image_id": image_to_id[original_file_name],
+            "category_id": parent_class[target_name],
+            "id": annotation_id,
+        }
+
+        annotation = extra_annotation(annotation, original_file_name, target_name)
+                
+        annotations.append(annotation)
+        annotation_id += 1
+            
+    #print(f"Number of errors in conversion: {n_errors}/{n_total}")
+    return images, annotations, annotation_id
+
+
+def create(targetpath):
+    # Get the standard COCO JSON format
+    coco_format = get_coco_json_format()
+
+    for keyword in ['train', 'test']:
+        mask_path = os.path.join(targetpath, "{}_mask/".format(keyword))
+        
+        # Create category section
+        coco_format["categories"] = create_category_annotation(category_ids)
+    
+        # Create images and annotations sections
+        coco_format["images"], coco_format["annotations"], annotation_cnt = images_annotations_info(mask_path, keyword)
+
+        # post-process file
+        images_with_ann = set()
+        for ann in coco_format['annotations']:
+            images_with_ann.add(ann['file_name'])
+        for im in coco_format['images']:
+            if im["file_name"] not in images_with_ann:
+                coco_format['images'].remove(im)
+
+        with open(os.path.join(targetpath, "{}.json".format(keyword)),"w") as outfile:
+            json.dump(coco_format, outfile)
+        
+        print("Created %d annotations for %d images in folder: %s" % (annotation_cnt, len(coco_format['images']), mask_path))

preprocess_3D_to_2D/normalize_CT.py

@@ -0,0 +1,178 @@
+# Copyright 2020 - 2022 MONAI Consortium
+# 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 argparse
+import os
+from functools import partial
+import nibabel as nib
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch.cuda.amp import GradScaler, autocast
+import SimpleITK as sitk
+from monai.inferers import sliding_window_inference
+# from monai.data import decollate_batch
+from monai.losses import DiceCELoss
+from monai.metrics import DiceMetric
+from monai.networks.nets import SwinUNETR
+from monai.transforms import *
+from monai.utils.enums import MetricReduction
+from monai.handlers import StatsHandler, from_engine
+import matplotlib.pyplot as plt
+from PIL import Image
+from monai import data, transforms
+from monai.data import *
+import resource
+
+rlimit = resource.getrlimit(resource.RLIMIT_NOFILE)
+resource.setrlimit(resource.RLIMIT_NOFILE, (8192, rlimit[1]))
+print('Setting resource limit:', str(resource.getrlimit(resource.RLIMIT_NOFILE)))
+
+os.environ['MASTER_ADDR'] = 'localhost'
+os.environ['MASTER_PORT'] = '28890'
+
+parser = argparse.ArgumentParser(description="process 3d to 2d")
+parser.add_argument(
+    "--test_data_path", default="/data/imagesTr/", type=str,
+    help="The path to 3d image")
+
+parser.add_argument(
+    "--save_path", default="/data/YOUR_DATASET_NAME/process_image/", type=str,
+    help="The path to save 2d image")
+
+roi = 96
+parser.add_argument("--use_normal_dataset", default=True, help="use monai Dataset class")
+parser.add_argument("--feature_size", default=48, type=int, help="feature size")
+parser.add_argument("--batch_size", default=1, type=int, help="number of batch size")
+parser.add_argument("--sw_batch_size", default=1, type=int, help="number of sliding window batch size")
+parser.add_argument("--infer_overlap", default=0.75, type=float, help="sliding window inference overlap")
+parser.add_argument("--in_channels", default=1, type=int, help="number of input channels")
+parser.add_argument("--out_channels", default=7, type=int, help="number of output channels")
+parser.add_argument("--a_min", default=-175.0, type=float, help="a_min in ScaleIntensityRanged")
+parser.add_argument("--a_max", default=250.0, type=float, help="a_max in ScaleIntensityRanged")
+parser.add_argument("--b_min", default=0.0, type=float, help="b_min in ScaleIntensityRanged")
+parser.add_argument("--b_max", default=1.0, type=float, help="b_max in ScaleIntensityRanged")
+parser.add_argument("--space_x", default=1.5, type=float, help="spacing in x direction")
+parser.add_argument("--space_y", default=1.5, type=float, help="spacing in y direction")
+parser.add_argument("--space_z", default=1.5, type=float, help="spacing in z direction")
+parser.add_argument("--roi_x", default=roi, type=int, help="roi size in x direction")
+parser.add_argument("--roi_y", default=roi, type=int, help="roi size in y direction")
+parser.add_argument("--roi_z", default=roi, type=int, help="roi size in z direction")
+parser.add_argument("--dropout_rate", default=0.0, type=float, help="dropout rate")
+parser.add_argument("--distributed", action="store_true", help="start distributed training")
+parser.add_argument("--workers", default=4, type=int, help="number of workers")
+parser.add_argument("--spatial_dims", default=3, type=int, help="spatial dimension of input data")
+parser.add_argument("--use_checkpoint", default=True, help="use gradient checkpointing to save memory")
+parser.add_argument("--rank", default=0, type=int, help="node rank for distributed training")
+
+
+def check_dir(dir):
+    if not os.path.exists(dir):
+        os.makedirs(dir)
+
+
+def get_test_loader(args):
+    """
+    Creates training transforms, constructs a dataset, and returns a dataloader.
+
+    Args:
+        args: Command line arguments containing dataset paths and hyperparameters.
+    """
+    test_transforms = transforms.Compose([
+        LoadImaged(keys=["image"]),
+        EnsureChannelFirstd(keys=["image"]),
+        Orientationd(keys=["image"], axcodes="RAS"),
+        Spacingd(keys=["image"], pixdim=(args.space_x, args.space_y, args.space_z),
+                 mode=("bilinear")),
+        ScaleIntensityRanged(
+            keys=["image"],
+            a_min=args.a_min,
+            a_max=args.a_max,
+            b_min=0.0,
+            b_max=1.0,
+            clip=True,
+        ),
+        CropForegroundd(keys=["image"], source_key="image"),
+        SpatialPadd(keys=["image"], spatial_size=(args.roi_x, args.roi_y, args.roi_z),
+                    mode='constant'),
+    ])
+
+    # constructing training dataset
+    test_img = []
+    test_name = []
+
+    dataset_list = os.listdir(args.test_data_path)
+
+    check_dir(args.save_path)
+    already_exist_list = os.listdir(args.save_path)
+    new_list = []
+
+    for item in dataset_list:
+        if item not in already_exist_list:
+            new_list.append(item)
+
+    for item in new_list:
+        name = item
+        print(name)
+        test_img_path = os.path.join(args.test_data_path, name)
+
+        test_img.append(test_img_path)
+        test_name.append(name)
+
+    data_dicts_test = [{'image': image, 'name': name}
+                       for image, name in zip(test_img, test_name)]
+
+    print('test len {}'.format(len(data_dicts_test)))
+
+    test_ds = Dataset(data=data_dicts_test, transform=test_transforms)
+    test_loader = DataLoader(
+        test_ds, batch_size=1, shuffle=False, num_workers=args.workers, sampler=None, pin_memory=True
+    )
+    return test_loader, test_transforms
+
+
+def main():
+    args = parser.parse_args()
+
+    test_loader, test_transforms = get_test_loader(args)
+
+    post_ori_transforms = Compose([EnsureTyped(keys=["image"]),
+                                   Invertd(keys=["image"],
+                                           transform=test_transforms,
+                                           orig_keys="image",
+                                           meta_keys="image_meta_dict",
+                                           orig_meta_keys="image_meta_dict",
+                                           meta_key_postfix="meta_dict",
+                                           nearest_interp=True,
+                                           to_tensor=True),
+                                   SaveImaged(keys="image", meta_keys="img_meta_dict",
+                                              output_dir=args.save_path,
+                                              separate_folder=False, folder_layout=None,
+                                              resample=False),
+                                   ])
+
+    num = 0
+    with torch.no_grad():
+        for idx, batch_data in enumerate(test_loader):
+            img = batch_data["image"]
+
+            name = batch_data['name'][0]
+            with autocast(enabled=True):
+
+                for i in decollate_batch(batch_data):
+                    post_ori_transforms(i)
+
+                os.rename(os.path.join(args.save_path, name.split('/')[-1][:-7] + '_trans.nii.gz'),
+                          os.path.join(args.save_path, name.split('/')[-1][:-7] + '.nii.gz'))
+
+
+if __name__ == "__main__":
+    main()

preprocess_3D_to_2D/normalize_MRI.py

@@ -0,0 +1,171 @@
+# Copyright 2020 - 2022 MONAI Consortium
+# 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 argparse
+import os
+from functools import partial
+import nibabel as nib
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch.cuda.amp import GradScaler, autocast
+import SimpleITK as sitk
+from monai.inferers import sliding_window_inference
+# from monai.data import decollate_batch
+from monai.losses import DiceCELoss
+from monai.metrics import DiceMetric
+from monai.networks.nets import SwinUNETR
+from monai.transforms import *
+from monai.utils.enums import MetricReduction
+from monai.handlers import StatsHandler, from_engine
+import matplotlib.pyplot as plt
+from PIL import Image
+from monai import data, transforms
+from monai.data import *
+import resource
+
+rlimit = resource.getrlimit(resource.RLIMIT_NOFILE)
+resource.setrlimit(resource.RLIMIT_NOFILE, (8192, rlimit[1]))
+print('Setting resource limit:', str(resource.getrlimit(resource.RLIMIT_NOFILE)))
+
+os.environ['MASTER_ADDR'] = 'localhost'
+os.environ['MASTER_PORT'] = '28890'
+
+parser = argparse.ArgumentParser(description="process 3d to 2d")
+parser.add_argument(
+    "--test_data_path", default="/data/imagesTr/", type=str,
+    help="The path to 3d image")
+
+parser.add_argument(
+    "--save_path", default="/data/YOUR_DATASET_NAME/process_image/", type=str,
+    help="The path to save 2d image")
+
+roi = 96
+parser.add_argument("--use_normal_dataset", default=True, help="use monai Dataset class")
+parser.add_argument("--feature_size", default=48, type=int, help="feature size")
+parser.add_argument("--batch_size", default=1, type=int, help="number of batch size")
+parser.add_argument("--sw_batch_size", default=1, type=int, help="number of sliding window batch size")
+parser.add_argument("--infer_overlap", default=0.75, type=float, help="sliding window inference overlap")
+parser.add_argument("--in_channels", default=1, type=int, help="number of input channels")
+parser.add_argument("--out_channels", default=7, type=int, help="number of output channels")
+parser.add_argument("--a_min", default=-175.0, type=float, help="a_min in ScaleIntensityRanged")
+parser.add_argument("--a_max", default=250.0, type=float, help="a_max in ScaleIntensityRanged")
+parser.add_argument("--b_min", default=0.0, type=float, help="b_min in ScaleIntensityRanged")
+parser.add_argument("--b_max", default=1.0, type=float, help="b_max in ScaleIntensityRanged")
+parser.add_argument("--space_x", default=1.5, type=float, help="spacing in x direction")
+parser.add_argument("--space_y", default=1.5, type=float, help="spacing in y direction")
+parser.add_argument("--space_z", default=1.5, type=float, help="spacing in z direction")
+parser.add_argument("--roi_x", default=roi, type=int, help="roi size in x direction")
+parser.add_argument("--roi_y", default=roi, type=int, help="roi size in y direction")
+parser.add_argument("--roi_z", default=roi, type=int, help="roi size in z direction")
+parser.add_argument("--dropout_rate", default=0.0, type=float, help="dropout rate")
+parser.add_argument("--distributed", action="store_true", help="start distributed training")
+parser.add_argument("--workers", default=4, type=int, help="number of workers")
+parser.add_argument("--spatial_dims", default=3, type=int, help="spatial dimension of input data")
+parser.add_argument("--use_checkpoint", default=True, help="use gradient checkpointing to save memory")
+parser.add_argument("--rank", default=0, type=int, help="node rank for distributed training")
+
+
+def check_dir(dir):
+    if not os.path.exists(dir):
+        os.makedirs(dir)
+
+
+def get_test_loader(args):
+    """
+    Creates training transforms, constructs a dataset, and returns a dataloader.
+
+    Args:
+        args: Command line arguments containing dataset paths and hyperparameters.
+    """
+    test_transforms = transforms.Compose([
+        LoadImaged(keys=["image"]),
+        EnsureChannelFirstd(keys=["image"]),
+        Orientationd(keys=["image"], axcodes="RAS"),
+        Spacingd(keys=["image"], pixdim=(args.space_x, args.space_y, args.space_z),
+                 mode=("bilinear")),
+        NormalizeIntensityd(keys="image", nonzero=True, channel_wise=True),
+        CropForegroundd(keys=["image"], source_key="image"),
+        SpatialPadd(keys=["image"], spatial_size=(args.roi_x, args.roi_y, args.roi_z),
+                    mode='constant'),
+    ])
+
+    # constructing training dataset
+    test_img = []
+    test_name = []
+
+    dataset_list = os.listdir(args.test_data_path)
+
+    check_dir(args.save_path)
+    already_exist_list = os.listdir(args.save_path)
+    new_list = []
+
+    for item in dataset_list:
+        if item not in already_exist_list:
+            new_list.append(item)
+
+    for item in new_list:
+        name = item
+        print(name)
+        test_img_path = os.path.join(args.test_data_path, name)
+
+        test_img.append(test_img_path)
+        test_name.append(name)
+
+    data_dicts_test = [{'image': image, 'name': name}
+                       for image, name in zip(test_img, test_name)]
+
+    print('test len {}'.format(len(data_dicts_test)))
+
+    test_ds = Dataset(data=data_dicts_test, transform=test_transforms)
+    test_loader = DataLoader(
+        test_ds, batch_size=1, shuffle=False, num_workers=args.workers, sampler=None, pin_memory=True
+    )
+    return test_loader, test_transforms
+
+
+def main():
+    args = parser.parse_args()
+
+    test_loader, test_transforms = get_test_loader(args)
+
+    post_ori_transforms = Compose([EnsureTyped(keys=["image"]),
+                                   Invertd(keys=["image"],
+                                           transform=test_transforms,
+                                           orig_keys="image",
+                                           meta_keys="image_meta_dict",
+                                           orig_meta_keys="image_meta_dict",
+                                           meta_key_postfix="meta_dict",
+                                           nearest_interp=True,
+                                           to_tensor=True),
+                                   SaveImaged(keys="image", meta_keys="img_meta_dict",
+                                              output_dir=args.save_path,
+                                              separate_folder=False, folder_layout=None,
+                                              resample=False),
+                                   ])
+
+    num = 0
+    with torch.no_grad():
+        for idx, batch_data in enumerate(test_loader):
+            img = batch_data["image"]
+
+            name = batch_data['name'][0]
+            with autocast(enabled=True):
+
+                for i in decollate_batch(batch_data):
+                    post_ori_transforms(i)
+
+                os.rename(os.path.join(args.save_path, name.split('/')[-1][:-7] + '_trans.nii.gz'),
+                          os.path.join(args.save_path, name.split('/')[-1][:-7] + '.nii.gz'))
+
+
+if __name__ == "__main__":
+    main()

preprocess_3D_to_2D/preprocess_2D_slices.py

@@ -0,0 +1,206 @@
+import os
+import shutil
+import numpy as np
+import SimpleITK as sitk
+from PIL import Image
+
+dataset_name = 'YOUR_DATASET_NAME'
+root = '/data/YOUR_DATASET_NAME/'
+
+path_3d = root + 'process_image'
+path_2d = root + 'process_image_2d'
+
+path_3d_label = root + 'labelsTr'
+path_2d_label = root + 'process_label_2d'
+
+suffix = '_CT_abdomen.png'
+
+target_path = '/data/'
+
+# define your label dict, for example
+label_dict = {'liver': 1, 'esophagus': 10, 'stomach': 11, 'duodenum': 12, 'left+kidney': 13, 'right+kidney': 2,
+              'spleen': 3, 'pancreas': 4, 'aorta': 5, 'inferior+vena+cava': 6,
+              'right+adrenal+gland': 7, 'left+adrenal+gland': 8, 'gallbladder': 9}
+
+
+def read(img, transpose=False):
+    img = sitk.ReadImage(img)
+    direction = img.GetDirection()
+    origin = img.GetOrigin()
+    Spacing = img.GetSpacing()
+
+    img = sitk.GetArrayFromImage(img)
+    if transpose:
+        img = img.transpose(1, 2, 0)
+
+    return img, direction, origin, Spacing
+
+
+def check_dir(dir):
+    if not os.path.exists(dir):
+        os.makedirs(dir)
+
+
+def find_index(path, target):
+    lst = os.listdir(path)
+    lst.sort()
+
+    try:
+        index = lst.index(target)
+        return index
+    except ValueError:
+        return f"Element {target} not found in the list."
+
+
+def exe_each_image(i):
+    ct = os.path.join(path_3d, i)
+    ct = read(ct, True)[0]
+    ct = (ct * 255).astype(np.uint8)
+    print(ct.shape)
+
+    h, w, c = ct.shape
+
+    idx = find_index(path_3d, i)
+    name = dataset_name + '-' + str(idx) + '-'
+
+    for j in range(c):
+        img = ct[:, :, j]
+
+        img = Image.fromarray(img)
+        image_name = name + str(j) + suffix
+        img.save(os.path.join(path_2d, image_name))
+
+
+def trans_3d_to_2d_image():
+    check_dir(path_2d)
+
+    ls = os.listdir(path_3d)
+    ls.sort()
+
+    import multiprocessing
+    with multiprocessing.Pool(5) as pool:
+        pool.map(exe_each_image, ls, 1)
+
+
+def exe_each_label(i):
+    old_lab = os.path.join(path_3d_label, i)
+    old_lab = read(old_lab, True)[0].astype(np.uint8)
+
+    label_keys = label_dict.keys()
+    for label_key in label_keys:
+        label_value = label_dict[label_key]
+
+        lab = old_lab.copy()
+
+        lab[old_lab > 0] = 0
+        lab[old_lab == label_value] = 1
+
+        suffix_class = suffix[:-4] + '_' + label_key + '.png'
+
+        lab = (lab*255).astype(np.uint8)
+        print(lab.shape)
+
+        h, w, c = lab.shape
+        idx = find_index(path_3d_label, i)
+        name = dataset_name + '-' + str(idx) + '-'
+
+        for j in range(c):
+            la = lab[:, :, j]
+
+            if la.sum() > 0:
+                la = Image.fromarray(la)
+                la_name = name + str(j) + suffix_class
+                la.save(os.path.join(path_2d_label, la_name))
+
+
+def trans_3d_to_2d_label():
+    check_dir(path_2d_label)
+
+    ls = os.listdir(path_3d_label)
+    ls.sort()
+
+    import multiprocessing
+    with multiprocessing.Pool(5) as pool:
+        pool.map(exe_each_label, ls, 1)
+
+
+def shuffle_to_get_test():
+
+    train_path = os.path.join(target_path+dataset_name, 'train')
+    train_mask_path = os.path.join(target_path+dataset_name, 'train_mask')
+
+    test_path = os.path.join(target_path+dataset_name, 'test')
+    test_mask_path = os.path.join(target_path+dataset_name, 'test_mask')
+
+    check_dir(test_path), check_dir(test_mask_path)
+
+    ls = os.listdir(train_path)
+    ls.sort()
+
+    prefix = dataset_name + '-'
+
+    new_ls = []
+    for i in ls:
+        name = i[len(prefix):].split('-')[0]
+        new_ls.append(name)
+
+    new_ls.sort()
+    new_ls = list(np.unique(new_ls))
+    print(new_ls)
+    import random
+    random.shuffle(new_ls)
+
+    to_test_ls = []
+
+    for j in new_ls[:len(new_ls)//5]:
+        to_test_ls.append(j)
+
+    print(len(to_test_ls))
+
+    # move
+    train_img_ls = os.listdir(train_path)
+    train_mask_ls = os.listdir(train_mask_path)
+
+    for train_img_name in train_img_ls:
+        if str(train_img_name[len(prefix):].split('-')[0]) in to_test_ls:
+            print('move img:', train_img_name)
+            shutil.move(os.path.join(train_path, train_img_name), os.path.join(test_path, train_img_name))
+
+    for train_mask_name in train_mask_ls:
+        if train_mask_name[len(prefix):].split('-')[0] in to_test_ls:
+            print('move mask:', train_mask_name)
+            shutil.move(os.path.join(train_mask_path, train_mask_name), os.path.join(test_mask_path, train_mask_name))
+
+
+def exe_resize(name):
+
+    original_image = Image.open(name)
+    resized_image = original_image.resize((1024, 1024))
+    resized_image.save(name)
+
+
+def resize_images_in_directory(input_dir):
+    ls = os.listdir(input_dir)
+
+    new_ls = [os.path.join(input_dir, i) for i in ls]
+
+    import multiprocessing
+    with multiprocessing.Pool(10) as pool:
+        pool.map(exe_resize, new_ls, 1)
+
+
+if __name__ == "__main__":
+
+    trans_3d_to_2d_image()
+    trans_3d_to_2d_label()
+
+    resize_images_in_directory(path_2d)
+    resize_images_in_directory(path_2d_label)
+
+    shutil.copytree(path_2d, os.path.join(target_path+dataset_name, 'train'))
+    shutil.copytree(path_2d_label, os.path.join(target_path + dataset_name, 'train_mask'))
+
+    shuffle_to_get_test()
+
+    from create_customer_datasets import create
+    create(target_path+dataset_name)