|
import os |
|
import numpy as np |
|
import multiprocessing |
|
import argparse |
|
from scipy import sparse |
|
from sklearn.model_selection import train_test_split |
|
import json |
|
|
|
from monai.transforms import ( |
|
AddChanneld, |
|
Compose, |
|
LoadImaged, |
|
Orientationd, |
|
) |
|
|
|
def set_parse(): |
|
|
|
parser = argparse.ArgumentParser() |
|
parser.add_argument("-category", default=['liver', 'right kidney', 'spleen', 'pancreas', 'aorta', 'inferior vena cava', 'right adrenal gland', 'left adrenal gland', 'gallbladder', 'esophagus', 'stomach', 'duodenum', 'left kidney'], type=list) |
|
parser.add_argument("-image_dir", type=str, required=True) |
|
parser.add_argument("-label_dir", type=str, required=True) |
|
parser.add_argument("-dataset_code", type=str, required=True) |
|
parser.add_argument("-save_root", type=str, required=True) |
|
parser.add_argument("-test_ratio", type=float, required=True) |
|
|
|
args = parser.parse_args() |
|
return args |
|
|
|
args = set_parse() |
|
|
|
|
|
image_list_all = [item for item in sorted(os.listdir(args.image_dir))] |
|
label_list_all = [item for item in sorted(os.listdir(args.label_dir))] |
|
assert len(image_list_all) == len(label_list_all) |
|
print('dataset size ', len(image_list_all)) |
|
|
|
|
|
data_path_list_all = [] |
|
for idx in range(len(image_list_all)): |
|
img_path = os.path.join(args.image_dir, image_list_all[idx]) |
|
label_path = os.path.join(args.label_dir, label_list_all[idx]) |
|
name = image_list_all[idx].split('.')[0] |
|
info = (idx, name, img_path, label_path) |
|
data_path_list_all.append(info) |
|
|
|
img_loader = Compose( |
|
[ |
|
LoadImaged(keys=['image', 'label']), |
|
AddChanneld(keys=['image', 'label']), |
|
Orientationd(keys=['image', 'label'], axcodes="RAS"), |
|
] |
|
) |
|
|
|
|
|
save_path = os.path.join(args.save_root, args.dataset_code) |
|
ct_save_path = os.path.join(save_path, 'ct') |
|
gt_save_path = os.path.join(save_path, 'gt') |
|
if not os.path.exists(ct_save_path): |
|
os.makedirs(ct_save_path) |
|
if not os.path.exists(gt_save_path): |
|
os.makedirs(gt_save_path) |
|
|
|
|
|
exist_file_list = os.listdir(ct_save_path) |
|
print('exist_file_list ', exist_file_list) |
|
|
|
def normalize(ct_narray): |
|
ct_voxel_ndarray = ct_narray.copy() |
|
ct_voxel_ndarray = ct_voxel_ndarray.flatten() |
|
|
|
thred = np.mean(ct_voxel_ndarray) |
|
voxel_filtered = ct_voxel_ndarray[(ct_voxel_ndarray > thred)] |
|
|
|
upper_bound = np.percentile(voxel_filtered, 99.95) |
|
lower_bound = np.percentile(voxel_filtered, 00.05) |
|
mean = np.mean(voxel_filtered) |
|
std = np.std(voxel_filtered) |
|
|
|
ct_narray = np.clip(ct_narray, lower_bound, upper_bound) |
|
ct_narray = (ct_narray - mean) / max(std, 1e-8) |
|
return ct_narray |
|
|
|
def run(info): |
|
idx, file_name, case_path, label_path = info |
|
item = {} |
|
if file_name + '.npy' in exist_file_list: |
|
print(file_name + '.npy exist, skip') |
|
return |
|
print('process ', idx, '---' ,file_name) |
|
|
|
item_load = { |
|
'image' : case_path, |
|
'label' : label_path, |
|
} |
|
item_load = img_loader(item_load) |
|
ct_voxel_ndarray = item_load['image'] |
|
gt_voxel_ndarray = item_load['label'] |
|
|
|
ct_shape = ct_voxel_ndarray.shape |
|
item['image'] = ct_voxel_ndarray |
|
|
|
|
|
gt_voxel_ndarray = np.array(gt_voxel_ndarray).squeeze() |
|
present_categories = np.unique(gt_voxel_ndarray) |
|
gt_masks = [] |
|
for cls_idx in range(len(args.category)): |
|
cls = cls_idx + 1 |
|
if cls not in present_categories: |
|
gt_voxel_ndarray_category = np.zeros(ct_shape) |
|
gt_masks.append(gt_voxel_ndarray_category) |
|
print('case {} ==> zero category '.format(idx) + args.category[cls_idx]) |
|
print(gt_voxel_ndarray_category.shape) |
|
else: |
|
gt_voxel_ndarray_category = gt_voxel_ndarray.copy() |
|
gt_voxel_ndarray_category[gt_voxel_ndarray != cls] = 0 |
|
gt_voxel_ndarray_category[gt_voxel_ndarray == cls] = 1 |
|
gt_masks.append(gt_voxel_ndarray_category) |
|
gt_voxel_ndarray = np.stack(gt_masks, axis=0) |
|
|
|
assert gt_voxel_ndarray.shape[0] == len(args.category), str(gt_voxel_ndarray.shape[0]) |
|
assert gt_voxel_ndarray.shape[1:] == ct_voxel_ndarray.shape[1:] |
|
item['label'] = gt_voxel_ndarray.astype(np.int32) |
|
print(idx, ' load done!') |
|
|
|
|
|
item['image'] = normalize(item['image']) |
|
print(idx, ' transform done') |
|
|
|
|
|
print(file_name + ' ct gt <--> ', item['image'].shape, item['label'].shape) |
|
np.save(os.path.join(ct_save_path, file_name + '.npy'), item['image']) |
|
allmatrix_sp=sparse.csr_matrix(item['label'].reshape(item['label'].shape[0], -1)) |
|
sparse.save_npz(os.path.join(gt_save_path, file_name + '.' + str(item['label'].shape)), allmatrix_sp) |
|
print(file_name + ' save done!') |
|
|
|
def generate_dataset_json(root_dir, output_file, test_ratio=0.2): |
|
ct_dir = os.path.join(root_dir, 'ct') |
|
gt_dir = os.path.join(root_dir, 'gt') |
|
ct_paths = sorted([os.path.join(ct_dir, f) for f in sorted(os.listdir(ct_dir))]) |
|
gt_paths = sorted([os.path.join(gt_dir, f) for f in sorted(os.listdir(gt_dir))]) |
|
|
|
data = list(zip(ct_paths, gt_paths)) |
|
train_data, val_data = train_test_split(data, test_size=test_ratio) |
|
labels = {} |
|
labels['0'] = 'background' |
|
for idx in range(len(args.category)): |
|
label_name = args.category[idx] |
|
label_id = idx + 1 |
|
labels[str(label_id)] = label_name |
|
dataset = { |
|
'name': f'{args.dataset_code} Dataset', |
|
'description': f'{args.dataset_code} Dataset', |
|
'tensorImageSize': '4D', |
|
'modality': { |
|
'0': 'CT', |
|
}, |
|
'labels': labels, |
|
'numTraining': len(train_data), |
|
'numTest': len(val_data), |
|
'training': [{'image': ct_path, 'label': gt_path} for ct_path, gt_path in train_data], |
|
'validation': [{'image': ct_path, 'label': gt_path} for ct_path, gt_path in val_data] |
|
} |
|
with open(output_file, 'w') as f: |
|
print(f'{output_file} dump') |
|
json.dump(dataset, f, indent=2) |
|
|
|
if __name__ == "__main__": |
|
with multiprocessing.Pool(processes=10) as pool: |
|
pool.map(run, data_path_list_all) |
|
print('Process Finished!') |
|
|
|
generate_dataset_json(root_dir=save_path, |
|
output_file=os.path.join(save_path, f'{args.dataset_code}.json'), |
|
test_ratio=args.test_ratio) |
|
print('Json Split Done!') |
|
|
