""" code is from https://github.com/bowang-lab/MedSAM/blob/main/pre_MR.py. """ import numpy as np import SimpleITK as sitk import os join = os.path.join from skimage import transform, io, segmentation from tqdm import tqdm import torch from desam import sam_model_registry from desam.utils.transforms import ResizeLongestSide import argparse # set up the parser parser = argparse.ArgumentParser(description='preprocess non-CT images') parser.add_argument('-w', '--work_dir', type=str, default='E:/DeSAMData', help='path to the work dir') parser.add_argument('--image_size', type=int, default=256, help='image size') parser.add_argument('--img_name_suffix', type=str, default='_0000.nii.gz', help='image name suffix') parser.add_argument('--label_id', type=int, default=1, help='label id') parser.add_argument('--model_type', type=str, default='vit_h', help='model type') parser.add_argument('--device', type=str, default='cuda:0', help='device') # seed parser.add_argument('--seed', type=int, default=2023, help='random seed') args = parser.parse_args() work_dir = args.work_dir nii_path = join(work_dir, 'raw_data', 'imagesTr') gt_path = join(work_dir, 'raw_data', 'labelsTr') npz_path = join(work_dir, 'image_embeddings', 'npz_files_{}'.format(args.model_type)) png_path = join(work_dir, 'image_embeddings', 'png_files_{}'.format(args.model_type)) os.makedirs(npz_path, exist_ok=True) os.makedirs(png_path, exist_ok=True) model_zoo = { 'vit_h': os.path.join(work_dir, 'checkpoint/sam_vit_h_4b8939.pth'), 'vit_l': os.path.join(work_dir, 'checkpoint/sam_vit_l_0b3195.pth'), 'vit_b': os.path.join(work_dir, 'checkpoint/sam_vit_b_01ec64.pth'), } checkpoint = model_zoo[args.model_type] names = sorted(os.listdir(gt_path)) names = [name for name in names if os.path.exists(join(nii_path, name.split('.nii.gz')[0] + args.img_name_suffix))] # split names into training and testing np.random.seed(args.seed) np.random.shuffle(names) train_names = sorted(names) # def preprocessing function def preprocess_nonct(gt_path, nii_path, gt_name, image_name, label_id, image_size, sam_model, device): gt_sitk = sitk.ReadImage(join(gt_path, gt_name)) gt_data = sitk.GetArrayFromImage(gt_sitk) # gt_data = np.uint8(gt_data==label_id) gt_data = np.uint8(gt_data==label_id) if np.sum(gt_data)>0: imgs = [] gts = [] img_embeddings = [] assert np.max(gt_data)==1 and np.unique(gt_data).shape[0]==2, 'ground truth should be binary' img_sitk = sitk.ReadImage(join(nii_path, image_name)) image_data = sitk.GetArrayFromImage(img_sitk) # nii preprocess start lower_bound, upper_bound = np.percentile(image_data, 0.5), np.percentile(image_data, 99.5) image_data_pre = np.clip(image_data, lower_bound, upper_bound) image_data_pre = (image_data_pre - np.min(image_data_pre))/(np.max(image_data_pre)-np.min(image_data_pre))*255.0 image_data_pre[image_data==0] = 0 image_data_pre = np.uint8(image_data_pre) z_index, _, _ = np.where(gt_data>0) z_min, z_max = np.min(z_index), np.max(z_index) for i in range(z_min, z_max): gt_slice_i = gt_data[i,:,:] gt_slice_i = transform.resize(gt_slice_i, (image_size, image_size), order=0, preserve_range=True, mode='constant', anti_aliasing=True) if np.sum(gt_slice_i)>0: # resize img_slice_i to 256x256 img_slice_i = transform.resize(image_data_pre[i,:,:], (image_size, image_size), order=3, preserve_range=True, mode='constant', anti_aliasing=True) # convert to three channels img_slice_i = np.uint8(np.repeat(img_slice_i[:,:,None], 3, axis=-1)) assert len(img_slice_i.shape)==3 and img_slice_i.shape[2]==3, 'image should be 3 channels' assert img_slice_i.shape[0]==gt_slice_i.shape[0] and img_slice_i.shape[1]==gt_slice_i.shape[1], 'image and ground truth should have the same size' imgs.append(img_slice_i) gts.append(gt_slice_i) if sam_model is not None: sam_transform = ResizeLongestSide(sam_model.image_encoder.img_size) resize_img = sam_transform.apply_image(img_slice_i) # resized_shapes.append(resize_img.shape[:2]) resize_img_tensor = torch.as_tensor(resize_img.transpose(2, 0, 1)).to(device) # model input: (1, 3, 1024, 1024) input_image = sam_model.preprocess(resize_img_tensor[None,:,:,:]) # (1, 3, 1024, 1024) assert input_image.shape == (1, 3, sam_model.image_encoder.img_size, sam_model.image_encoder.img_size), 'input image should be resized to 1024*1024' # input_imgs.append(input_image.cpu().numpy()[0]) with torch.no_grad(): embedding = sam_model.image_encoder(input_image) img_embeddings.append([x.cpu().numpy()[0] for x in embedding]) # img_embeddings.append(embedding[-1][0].cpu().numpy()) if sam_model is not None: return imgs, gts, img_embeddings else: return imgs, gts # prepare the save path save_path_tr = npz_path os.makedirs(save_path_tr, exist_ok=True) # set up the model sam_model = sam_model_registry[args.model_type](checkpoint=checkpoint).to(args.device) for name in tqdm(train_names): image_name = name.split('.nii.gz')[0] + args.img_name_suffix gt_name = name imgs, gts, img_embeddings = preprocess_nonct(gt_path, nii_path, gt_name, image_name, args.label_id, args.image_size, sam_model, args.device) # save to npz file # stack the list to array for idx in range(len(imgs)): # imgs = np.stack(imgs, axis=0) # (n, 256, 256, 3) # gts = np.stack(gts, axis=0) # (n, 256, 256) # img_embeddings = np.stack(img_embeddings, axis=0) # (n, 1, 256, 64, 64) np.savez_compressed( join(save_path_tr, gt_name.split('.nii.gz')[0]+'_'+str(idx).zfill(2)+'.npz'), imgs=imgs[idx], gts=gts[idx], img_embeddings=img_embeddings[idx] ) # save an example image for sanity check img_idx = imgs[idx] gt_idx = gts[idx] bd = segmentation.find_boundaries(gt_idx, mode='inner') img_idx[bd, :] = [255, 0, 0] io.imsave(join(png_path, gt_name.split('.nii.gz')[0]+'_'+str(idx).zfill(2)+'.png'), img_idx, check_contrast=False)