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(): # %% set up parser 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() # get ct> dir 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)) # build dataset 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 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: 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() # for all data thred = np.mean(ct_voxel_ndarray) voxel_filtered = ct_voxel_ndarray[(ct_voxel_ndarray > thred)] # for foreground data 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) ### transform ### 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) # generate ct_voxel_ndarray 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 # generate gt_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!')