Delete preprocess_3D_to_2D

preprocess_3D_to_2D/README.md

@@ -1,21 +0,0 @@
-*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

@@ -1,114 +0,0 @@
-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

@@ -1,141 +0,0 @@
-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/label_base.json

@@ -1,245 +0,0 @@
-{
-  "0": {
-    "name": "background"
-  },
-  "1": {
-    "name": "liver",
-    "parent": "organ"
-  },
-  "2": {
-    "name": "lung",
-    "parent": "organ",
-    "child": [
-      "left lung",
-      "right lung",
-      "left lower lung lobe",
-      "left upper lung lobe",
-      "right lower lung lobe",
-      "right upper lung lobe",
-      "left middle lung lobe",
-      "right middle lung lobe",
-      "lower lung lobe",
-      "upper lung lobe",
-      "middle lung lobe",
-      "Fibrotic Lung Disease",
-      "pulmonary embolism",
-      "lung tumor",
-      "Pulmonary Artery"
-    ]
-  },
-  "3": {
-    "name": "kidney",
-    "parent": "organ",
-    "child": [
-      "left kidney",
-      "right kidney",
-      "tumor"
-    ]
-  },
-  "4": {
-    "name": "pancreas",
-    "parent": "organ"
-  },
-  "5": {
-    "name": "heart anatomies",
-    "parent": "organ",
-    "child": [
-      "left heart atrium",
-      "right heart atrium",
-      "left heart ventricle",
-      "right heart ventricle",
-      "myocardium",
-      "heart",
-      "Coronary Arteries"
-    ]
-  },
-
-  "6": {
-    "name": "brain anatomies",
-    "parent": "organ",
-    "child": [
-      "brain ventricles",
-      "cerebellum",
-      "hippocampus",
-      "anterior hippocampus",
-      "posterior hippocampus"
-    ]
-  },
-  "7": {
-    "name": "eye anatomies",
-    "parent": "organ",
-    "child": [
-      "optic disc",
-      "optic cup"
-    ]
-  },
-  "8": {
-    "name": "vessel",
-    "parent": "organ",
-    "child": [
-      "aorta",
-      "postcava",
-      "hepatic vessel",
-      "retinal vessel"
-    ]
-  },
-  "9": {
-    "name": "other organ",
-    "parent": "organ",
-    "child": [
-      "spleen",
-      "gallbladder",
-      "left adrenal gland",
-      "right adrenal gland",
-      "adrenal gland",
-      "esophagus",
-      "uterus",
-      "prostate",
-      "prostate peripheral zone",
-      "prostate transitional zone",
-      "stomach",
-      "bladder",
-      "duodenum",
-      "lymph node",
-      "colon",
-      "Head of femur Left",
-      "Head of femur Right",
-      "adrenal"
-    ]
-  },
-  "10": {
-    "name": "tumor",
-    "parent": "abnormality",
-    "child": [
-      "enhancing tumor",
-      "non-enhancing tumor",
-      "benign tumor",
-      "malignant tumor",
-      "tumor core",
-      "whole tumor",
-      "kidney tumor",
-      "lower-grade glioma"
-    ]
-  },
-  "11": {
-    "name": "infection",
-    "parent": "abnormality",
-    "child": [
-      "COVID-19 infection",
-      "viral pneumonia",
-      "lung opacity"
-    ]
-  },
-  "12": {
-    "name": "lesion",
-    "parent": "abnormality",
-    "child": [
-      "nodule",
-      "kidney cyst",
-      "left kidney cyst",
-      "right kidney cyst",
-      "polyp",
-      "neoplastic polyp",
-      "non-neoplastic polyp",
-      "melanoma"
-    ]
-  },
-  "13": {
-    "name": "fluid disturbance",
-    "parent": "abnormality",
-    "child": [
-      "edema",
-      "pleural effusion"
-    ]
-  },
-  "14": {
-    "name": "other abnormality",
-    "parent": "abnormality",
-    "child": [
-      "pneumothorax",
-      "pulmonary embolism"
-    ]
-  },
-  "15": {
-    "name": "histology structure",
-    "parent": "histology",
-    "child": [
-      "glandular structure",
-      "nuclei",
-      "cancer cells",
-      "benign cancer cells",
-      "malignant cancer cells",
-      "neoplastic cells",
-      "inflammatory cells",
-      "connective tissue cells", 
-      "dead cells", 
-      "epithelial cells"
-    ]
-  },
-  "16": {
-    "name": "other",
-    "child": [
-      "surgical tool",
-      "public symphysis",
-      "fetal head"
-    ]
-  },
-  "17": {
-    "name": "abdomen",
-    "child": ["spleen", "veins", "pancreas", "right adrenal gland", "left adrenal gland",
-      "liver tumor", "pancreas tumor", "kidney tumor", "covid", "colon", "colon cancer",
-      "right kidney", "lung cancer", "left kidney", "gallbladder",
-      "eso", "liver", "stomach", "aorta", "inferior vena cava","intestine","rectum", "kidney"
-    ]
-  },
-  "18": {
-    "name": "thoracic",
-    "child": ["Heart",
-      "Trachea",
-      "Aorta",
-      "Esophagus"]
-  },
-  "19": {
-    "name": "Brain Hemorrhage",
-    "parent": "organ",
-    "child": [
-      "extradural hemorrhage",
-      "subdural hemorrhage",
-      "subarachnoid hemorrhage",
-      "intraparenchymal hemorrhage",
-      "intraventricular hemorrhage"
-    ]
-  },
-  "20": {
-    "name": "Pancreas",
-    "parent": "organ",
-    "child": [
-      "PDAC lesion",
-        "Veins",
-        "Arteries",
-        "Pancreas parenchyma",
-        "Pancreatic duct",
-        "Common bile duct"
-    ]
-  },
-  "21": {
-    "name": "kidney",
-    "parent": "organ",
-    "child": [
-      "Renal vein",
-        "kidney",
-        "Renal artery",
-        "kidney tumor"
-    ]
-  },
-  "22": {
-    "name": "radgenome",
-    "parent": "organ",
-    "child": [
-      "left lung lower lobe",
-      "right lung lower lobe",
-      "left lung upper lobe",
-      "right lung upper lobe"
-    ]
-  }
-}

preprocess_3D_to_2D/normalize_CT.py

@@ -1,178 +0,0 @@
-# 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

@@ -1,171 +0,0 @@
-# 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

@@ -1,206 +0,0 @@
-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)