def __getitem__(self, idx): img_path = os.path.join(self.image_dir, self.ids[idx]) img = Image.open(img_path + '.png').convert("RGB") width, height = img.size mask = rle2mask(self.rles[idx], width, height) mask = mask.T label = self.labels[idx] if self.augs is not None: augmented = self.augs(image=np.array(img), mask=np.array(mask)) img = augmented['image'] mask = augmented['mask'] img = cv2.resize(img, (config.size, config.size)) mask = cv2.resize(mask, (config.size, config.size)) # mask = cv2.resize(mask, (int(Size/4), int(Size/4))) # ********* the output of network is image_size/4 *************************** mask = torch.as_tensor(mask, dtype=torch.float) img = transforms.ToTensor()(img) # img = transforms.Normalize(mean=[0.491, 0.491, 0.491], # std=[0.249, 0.249, 0.249])(img) return img, mask, label, self.ids[idx]
def cal_dice(thres_seg, size_seg, thres_after = 0.2): ipos = 0 dice = 0.0 for pred, true_rle in zip(preds, trues): # post process true = rle2mask(true_rle, self.args.width, self.args.height) pred = post_process_segment(pred, thres_seg, size_seg, thres_after) ipos += 1 dice += dice_metric(true, pred) return dice/len(preds)
def get_masks(self, encoded_masks): masks = np.zeros((4, self.shape[0], self.shape[1]), dtype=np.float32) for idx, label in enumerate(encoded_masks.values): if label is not np.nan: mask = utils.rle2mask(label, self.shape) masks[idx, :, :] = mask resized_masks = np.zeros((4, 350, 525), dtype=np.float32) for idx in range(4): resized_masks[idx, :, :] = resize(masks[idx, :, :], (525, 350)) return torch.as_tensor(resized_masks, dtype=torch.float32)
def main(): train = pd.read_csv(os.path.join('..', 'input', 'preprocessed_train.csv')) mask_list = [] for (_, row) in tqdm(train.iterrows()): mask = np.zeros((256, 1600, 4)) for i in range(0, 4): mask[:, :, i] = rle2mask(row[f'{i+1}'], (256, 1600)) with open( os.path.join('..', 'input', 'train_masks', row['ImageId'].replace('jpg', 'pkl')), 'wb') as f: pickle.dump(mask, f)
def plot_mask_on_img(old_img): tdf = pd.read_csv('mask_test.csv', index_col=0) tdf = tdf.fillna('') plt.figure(figsize=[25, 20]) types = '' for index, row in tdf.iterrows(): img = cv2.imread(old_img) img = cv2.resize(img, (525, 350)) mask_rle = row['EncodedPixels'] plt.subplot(2, 2, index + 1) plt.imshow(img) if mask_rle != '': types = types + ', ' + row['Image_Label'].split('_')[-1] plt.imshow(utils.rle2mask(mask_rle, img.shape), alpha=0.5, cmap='gray') plt.title(row['Image_Label'].split('_')[-1], fontsize=25) plt.axis('off') types_all = types[2:] after_mask = ''.join(str(uuid.uuid4()).split('-')) + '.png' plt.savefig('static/upload/' + after_mask) plt.close() imgId = str(random.randint(22200, 24200)) + '.jpg' print(imgId) for i in types_all.split(', '): query = """INSERT INTO `project_id.project_satellite.report` (int64_field_0 , ImageId, Label, exist, Frequent, types ) VALUES (2, @d, @a, 1, @b, @c)""" query_params = [ bigquery.ScalarQueryParameter("d", "STRING", imgId), bigquery.ScalarQueryParameter("a", "STRING", i), bigquery.ScalarQueryParameter("b", "STRING", types_all), bigquery.ScalarQueryParameter("c", "INT64", len(types_all.split(', '))), ] job_config = bigquery.QueryJobConfig() job_config.query_parameters = query_params client.query( query, # Location must match that of the dataset(s) referenced in the query. location="US", job_config=job_config, ) return after_mask
def _PS_data_preprocess_np(fns, df, TARGET_COLUMN, im_height, im_width, im_chan): X_train = np.zeros((len(fns), im_height, im_width, im_chan), dtype=np.uint8) Y_train = np.zeros((len(fns), im_height, im_width, 1), dtype=np.uint8) print("Getting train images and masks ... ") # sys.stdout.flush() for n, _id in tqdm(enumerate(fns), total=len(fns)): dataset = pydicom.read_file(_id) _id_keystr = _id.split("/")[-1][:-4] X_train[n] = np.expand_dims(dataset.pixel_array, axis=2) try: mask_data = df.loc[_id_keystr, TARGET_COLUMN] if "-1" in mask_data: Y_train[n] = np.zeros((1024, 1024, 1)) else: if type(mask_data) == str: Y_train[n] = np.expand_dims( utils.rle2mask(df.loc[_id_keystr, TARGET_COLUMN], 1024, 1024).T, axis=2, ) else: Y_train[n] = np.zeros((1024, 1024, 1)) for x in mask_data: Y_train[n] = Y_train[n] + np.expand_dims( utils.rle2mask(x, 1024, 1024).T, axis=2) except KeyError: print( f"Key {_id.split('/')[-1][:-4]} without mask, assuming healthy patient." ) # Assume missing masks are empty masks. Y_train[n] = np.zeros((1024, 1024, 1)) print("Done data preprocessing as numpy array!") return X_train, Y_train
def __getitem__(self, idx): img_path = self.image_info[idx]["image_path"] img = Image.open(img_path + ".png").convert( "RGB") # here it is converted to 3 channels width, height = img.size img = img.resize((self.width, self.height), resample=Image.BILINEAR) info = self.image_info[idx] mask = utils.rle2mask(info["annotations"], width, height) if mask is None: raise ValueError("mask is None!!!!!!!!") mask = Image.fromarray(mask.T) mask = mask.resize((self.width, self.height), resample=Image.BILINEAR) img, mask = self.functional_transforms( img, mask) # pay attention need after mask.T mask = np.expand_dims(mask, axis=0) if sum(mask.flatten()) == 0: xmax = 0 xmin = 0 ymax = 0 ymin = 0 else: pos = np.where(np.array(mask)[0, :, :]) xmin = np.min(pos[1]) xmax = np.max(pos[1]) ymin = np.min(pos[0]) ymax = np.max(pos[0]) boxes = torch.as_tensor([[xmin, ymin, xmax, ymax]], dtype=torch.float32) labels = torch.ones((1, ), dtype=torch.int64) masks = torch.as_tensor(mask, dtype=torch.uint8) image_id = torch.tensor([idx]) area = (boxes[:, 3] - boxes[:, 1]) * (boxes[:, 2] - boxes[:, 0]) iscrowd = torch.zeros((1, ), dtype=torch.int64) target = {} target["boxes"] = boxes target["labels"] = labels target["masks"] = masks target["image_id"] = image_id target["area"] = area target["iscrowd"] = iscrowd img = self.to_tensor_transformer(img) return img, target
def __getitem__(self, index): fn, class_id_str = self.df['ImageId_ClassId'].iloc[index].rsplit( '_', -1) img = Image.open(self.data_path + fn) img = self.transform(img) if self.subset == 'train' or self.subset == 'valid': mask = rle2mask(self.df['EncodedPixels'].iloc[index], (256, 1600)) mask = transforms.ToPILImage()(mask) mask = self.transform(mask) != 0 # ensure tensor is either 0 or 1 mask = mask.float() return img, mask, int(class_id_str) else: mask = None return img
def save_segmentation(cam, weights, num, path, thresholds = [0.8,0.5,0.7,0.7]): th = thresholds for img_idx in test_df.index: img_name = IMG_PATH + img_idx + ".jpg" # while IMG_LIST[k].split(".")[0] not in test_df.index: k = np.random.randint(0, len(IMG_LIST)) img = cv2.resize(cv2.imread(img_name), (512, 352)) for label_idx in [0,1,2,3]: mask_pred, probs = get_rle_probs(cam, weights, img_name, label_idx) label = LABELS[label_idx] rle_true = data_df.loc[img_idx.split('.')[0], "rle_" + label] rle_pred = mask2rle((mask_pred > th[label_idx]).astype(int)) mask_true = rle2mask(rle_true)[::4,::4] skimage.io.imsave(path + img_idx + "_pred_" + label + ".jpg", (mask_pred > th[label_idx]).astype("uint8")*100) skimage.io.imsave(path + img_idx + "_heat_" + label + ".jpg", (mask_pred*100).astype("uint8")) skimage.io.imsave(path + img_idx + "_true_" + label + ".jpg", mask_true*100) dice = dice_coef(rle_true, rle_pred, probs, th[label_idx]) print("Dice = " + str(np.round(dice,3)))
def get_segmentation_masks(map_size, gaze_sequences): # load seg dict seg_dict_pth = "/media/pneumothorax/rle_dict.pkl" with open(seg_dict_pth, "rb") as pkl_f: rle_dict = pickle.load(pkl_f) ret_rle = {} for gaze_id, val in tqdm(gaze_sequences.items(), total=len(gaze_sequences.keys())): img_path = gaze_id.split("/")[-1].split(".dcm")[0] rle = rle_dict[img_path] if rle != " -1": segmask_org = rle2mask(rle, 1024, 1024).T segmask = binarize_seg_mask(segmask_org, map_size) ret_rle[img_path] = segmask else: ret_rle[img_path] = rle return ret_rle
def cal_dice(thres_seg, size_seg, thres_after, thres_oth=-float('inf'), size_oth=0): ipos = 0 dice = 0.0 if self.args.use_weight: nnormal = self.nweight else: nnormal = len(self.dataloader.dataset) for pred, other, true_rle in zip(preds, others, trues): # post process true = rle2mask(true_rle, self.args.width, self.args.height) pred = post_process_single(pred, other, thres_seg, size_seg, thres_after, thres_oth, size_oth) if self.args.use_weight: dice += dice_metric(true, pred)*self.weight[ipos] else: dice += dice_metric(true, pred) ipos += 1 return dice/nnormal
def __getitem__(self, index): """Generates one batch of data at position 'index'. Note: index=0 for batch 1, 2 for batch 2 and so on.. Arguments: index (int): position of the batch in the Sequence. Returns: A batch. X (ndarray): array containing the image 4D array of size: batch_size x img_size[0] x img_size[1] x 3 (RGB) Y (ndarray): array containing the masks for corresponding images in X 4D array of size: batch_size x img_size[0] x img_size[1] x 4 (number of defect classes) Note: If subset =' train', both the images along with its masks is returned. This is essentially the information contained in the train.csv file. If subset = 'test', only the images in the test_images folder is returned """ # (batch size, image height, image width, number of channels (RGB=3)) X = np.zeros((self.batch_size, self.img_size[0], self.img_size[1], 3), dtype=np.float32) # (batch size, image height, image width, number of (defect) classes = 4 (one hot coded) ) Y = np.zeros((self.batch_size, self.img_size[0], self.img_size[1], 4), dtype=np.int8) # Generate indexes of the batch indexes = self.indexes[index * self.batch_size:(index + 1) * self.batch_size] for idx, (imgID, masks) in enumerate(self.data[indexes]): self.info[index * self.batch_size + idx] = imgID X[idx, ] = plt.imread(self.data_path + imgID)[::2, ::2] if self.subset == 'train': defectsIDs = masks['defectIDs'] masks = masks['masks'] for m in range(len(defectsIDs)): Y[idx, :, :, defectsIDs[m]] = rle2mask(masks[m])[::2, ::2] if self.preprocess != None: X = self.preprocess(X) if self.subset == 'train': return X, Y else: return X
def __getitem__(self, idx): 'get one image along with its masks on four categories' fpath = self.fpaths[idx] fname = fpath.split('/')[-1] # get the image image = cv2.imread(fpath) mask = np.zeros((self.height, self.width, self.category)) # if this is for training if self.mask_df is not None: # get the masks for classid in range(self.category): rle = self.mask_df.loc[fname + '_{:d}'.format(classid + 1), 'EncodedPixels'] mask[:,:,classid] = rle2mask(rle, self.width, self.height) image, mask = np.uint8(image), np.uint8(mask) # if there is augmentation if self.augment is not None: augmented = self.augment(image = image, mask = mask) image, mask = augmented['image'], augmented['mask'] # do additional augmentations for training data set if self.augTag: if not self.args.conservative: image, mask = random_crop_shift_pad(image, mask) else: image, mask = random_crop_shift_pad_old(image, mask) # do simple normalization else: image, mask = image/255, mask # do regression task if self.args.output == 1: area = np.array([self.stat_mask(mask[:,:,j]) for j in range(self.category)]).astype(np.float32) return image.astype(np.float32), mask.astype(np.float32), area # do classification task elif self.args.output == 2: area = np.array([self.stat_mask(mask[:,:,j])>0 for j in range(self.category)]).astype(np.float32) return image.astype(np.float32), mask.astype(np.float32), area # vanilla version (0,3) else: return image.astype(np.float32), mask.astype(np.float32)
def __getitem__(self, idx): img_path = self.image_info[idx]["image_path"] img = Image.open(img_path + '.png').convert("RGB") width, height = img.size info = self.image_info[idx] mask = rle2mask(info['annotations'], width, height) mask = mask.T # mask = np.expand_dims(mask, axis=0) # mask = mask.T*255 # kernel = np.ones((6,6), np.uint8) # dilation_mask = cv2.dilate(mask.astype(np.uint8), kernel, iterations=2) / 255 # # mask = Image.fromarray(dilation_mask/255) if self.augs is not None: img = np.array(img) mask = np.array(mask) # size = random.randint(512,1024) # img = cv2.resize(img, (config.size, config.size)) # mask = cv2.resize(mask, (config.size, config.size)) augmented = self.augs(image=img, mask=mask) img = augmented['image'] mask = augmented['mask'] img = cv2.resize(img, (config.size, config.size)) mask = cv2.resize(mask, (config.size, config.size)) mask = torch.as_tensor(mask, dtype=torch.float) img = transforms.ToTensor()(img) # img = transforms.Normalize(mean=[0.491, 0.491, 0.491], # std=[0.249, 0.249, 0.249])(img) return img, mask
augment_test = Compose([ Normalize(mean=(test_mean, test_mean, test_mean), std=(test_std, test_std, test_std)), ToFloat(max_value=1.) ], p=1) ######################################################################## # do some simple checking if args.test_run: # check rle2mask and mask2rle mask_df = pd.read_csv(TRAIN_MASKS).set_index(['ImageId_ClassId' ]).fillna('-1') for i, pixel in enumerate(mask_df['EncodedPixels']): if pixel != '-1': rle_pass = mask2rle(rle2mask(pixel, 1600, 256)) if rle_pass != pixel: print(i) # check dataloader steel_ds = SteelDataset(TRAIN_FILES, args, mask_df=mask_df) steel_ds_train = SteelDataset(TRAIN_FILES, args, mask_df=mask_df, augment=augment_train) steel_ds_valid = SteelDataset(VALID_FILES, args, mask_df=mask_df, augment=augment_valid) res = steel_ds_train[1] image, mask = res[0], res[1]
df['ImageId'] = df['ImageId_ClassId'].map(lambda x: x.split("_")[0]) df['ClassId'] = df[['ImageId_ClassId', 'EncodedPixels']].apply(lambda x: x[0].split("_")[1] if x[1] is not np.nan else '0', axis=1) df.drop(columns='ImageId_ClassId', inplace=True) df.drop_duplicates(inplace=True) # drop row with label 0 which exist label != 0 max_class_df = df.groupby("ImageId")['ClassId'].max().reset_index() max_class_df = max_class_df[max_class_df['ClassId'] != '0'] df = df[~((df['ImageId'].isin(max_class_df['ImageId'].values)) & (df['ClassId'] == '0'))] # split to train and validation # Didn't use # tv_df = df.groupby("ImageId")['ClassId'].sum().reset_index() # train_images, val_images = train_test_split(tv_df['ImageId'].values, stratify=tv_df['ClassId'].values, test_size=0.2) images = df['ImageId'].unique() for image in tqdm(images): temp_df = df[df['ImageId'] == image] mask = np.zeros((4, 256, 1600), dtype=np.uint8) for row in temp_df.values: if row[0] is not np.nan: mask[int(row[2]) - 1] = rle2mask(row[0]) mask = np.moveaxis(mask, 0, -1) cv2.imwrite( os.path.join(config['path_to_data'], 'train_masks', image.replace('.jpg', '.png')), mask)
import os import numpy as np import pandas as pd from tqdm import tqdm from utils import mask2rle, rle2mask import matplotlib.pyplot as plt original_size = (1400, 2100) new_size = (350, 525) # ResNet dataset_dir = './satellite_dataset/' processed_dataset_dir = './satellite_dataset/preprocess_images' df = pd.read_csv(os.path.join(dataset_dir, '350_525_train.csv')) for idx, row in tqdm(df.iterrows()): encoded_pixels = row[1] names = row[0].split('_') # i.g) 021401240.jpg, Flower filename = names[1] + '_' + names[0] if encoded_pixels is not np.nan: mask = rle2mask(encoded_pixels, new_size[::-1]) plt.imsave(os.path.join(processed_dataset_dir + '/gt_train_images', filename), mask, cmap='gray')
def __getitem__(self, idx): """ Fetch index idx image and label from dataset. Args: idx: (int) index in [0, 1, ..., size_of_dataset-1] Returns: image: (Tensor) transformed image label: (int) corresponding label of image """ img_id, label = self.file_markers[idx] subclass_label = 0 if self.source == "cxr_a": img_pth = os.path.join(self.data_dir, f"cxr_ibm/dicom_images/{img_id}") elif self.source == "cxr_p": img_pth = os.path.join(self.data_dir, f"pneumothorax/dicom_images/{img_id}") if self.args.machine == "meteor": tube_path = '/media/pneumothorax/cxr_tube_dict.pkl' elif self.args.machine == "gemini": tube_path = '/media/nvme_data/jupinder_cxr_robustness_results/cxr_tube_dict.pkl' else: raise ValueError("Machine type not known") with open(tube_path, 'rb') as f: cxr_tube_dict = pickle.load(f) image_name = img_id.split("/")[-1].split(".dcm")[0] if self.subclass: subclass_label = 1 if cxr_tube_dict[image_name] is True else 0 else: img_pth = img_id if self.ood: img = Image.open(img_pth) else: ds = pydicom.dcmread(img_pth) img = ds.pixel_array img = Image.fromarray(np.uint8(img)) img = self.transform(img) if not self.gan: if img.shape[0] == 1: img = torch.cat([img, img, img]) if img.shape[0] >= 4: img = img[:3] if self.gan: return img, label if self.split_type in ['train', 'val']: gaze_attribute = self.gaze_features[img_id][0] if self.gaze_task == "data_augment": gaze_map = gaze_attribute.reshape(4, 4) gaze_binary_mask = torch.zeros(224, 224) divisor = int(224 / 4) for i in range(4): for j in range(4): if gaze_map[i, j] != 0: gaze_binary_mask[(divisor) * (i):(divisor) * (i + 1), (divisor) * (j):(divisor) * (j + 1)] = torch.ones( divisor, divisor) gaze_binary_mask = gaze_binary_mask.unsqueeze(0) gaze_binary_mask = torch.cat( [gaze_binary_mask, gaze_binary_mask, gaze_binary_mask]) img = img * gaze_binary_mask if self.gaze_task == "cam_reg_convex": gaze_attribute_dict = { "gaze_attribute": gaze_attribute, "average_hm": self.average_heatmap } return img, label, gaze_attribute_dict ### neet to return regular image, label, and masked image if self.gaze_task == "actdiff": rle = self.rle_dict[img_id.split("/")[-1].split(".dcm")[0]] y_true = rle != " -1" ### use the segmentation mask if y_true: # extract segmask segmask_org = rle2mask(rle, 1024, 1024).T if self.args.actdiff_segmask_size != self.IMG_SIZE: segmask_int = nn.functional.max_pool2d( torch.tensor(segmask_org).unsqueeze(0), int(1024 / self.args.actdiff_segmask_size) ).squeeze().numpy() segmask_int = (segmask_int > 0) * 1 segmask = resize(segmask_int, (self.IMG_SIZE, self.IMG_SIZE)) segmask = (segmask > 0) * 1 else: segmask = resize(segmask_org, (self.IMG_SIZE, self.IMG_SIZE)) segmask = (segmask > 0) * 1 segmask = torch.from_numpy(segmask) segmask = torch.where(segmask > 0, torch.ones(segmask.shape), torch.zeros(segmask.shape)).long() img_masked = create_masked_image(img, segmask) return img, label, img_masked ## we don't have a segmentation mask for the image, as in actdiff set segmentation mask to all 1 else: segmask = torch.ones((self.IMG_SIZE, self.IMG_SIZE)).long() img_masked = create_masked_image(img, segmask) return img, label, img_masked ### need to return regular image, label, and masked image from the gaze heatmap if self.gaze_task == "actdiff_gaze": ### obtain 7 x 7 gaze heatmap gaze_map = gaze_attribute.reshape( self.args.actdiff_gazemap_size, self.args.actdiff_gazemap_size) gaze_map = (gaze_map > self.args.actdiff_gaze_threshold) * 1.0 ### resize up to 224 x 224 gaze_map = resize( gaze_map, (self.IMG_SIZE, self.IMG_SIZE)) ### change to change_map_size gaze_map = torch.from_numpy(gaze_map) gaze_map = torch.where(gaze_map > 0, torch.ones(gaze_map.shape), torch.zeros(gaze_map.shape)).long() ### get masked image, img_masked = create_masked_image(img, gaze_map) return img, label, img_masked ### neet to return regular image, label, and masked image if self.gaze_task == "actdiff_lungmask": if self.args.actdiff_segmentation_classes == 'positive': ## we have lungmasks for these right now if label == 1: img_name = img_id.replace("/", "_").split(".dcm")[0] lung_mask = np.load( f"./lung_segmentations/annotations/{img_name}_lungmask.npy" ) lung_mask = np.where(lung_mask > 0, np.ones(lung_mask.shape), np.zeros(lung_mask.shape)) if self.args.actdiff_lungmask_size != self.IMG_SIZE: lung_mask_int = nn.functional.max_pool2d( torch.tensor(lung_mask).unsqueeze(0), int(224 / self.args.actdiff_lungmask_size) ).squeeze().numpy() lung_mask_int = (lung_mask_int > 0) * 1 lung_mask = resize(lung_mask_int, (self.IMG_SIZE, self.IMG_SIZE)) lung_mask = (lung_mask > 0) * 1 lung_mask = torch.from_numpy(lung_mask) lung_mask = torch.where(lung_mask > 0, torch.ones(lung_mask.shape), torch.zeros( lung_mask.shape)).long() img_masked = create_masked_image_advanced_augmentations( img, lung_mask, augmentation=self.args.actdiff_augmentation_type, masked_normalization_vals=self. masked_normalization_values, seed=self.seed) return img, label, img_masked else: segmask = torch.ones( (self.IMG_SIZE, self.IMG_SIZE)).long() img_masked = create_masked_image_advanced_augmentations( img, segmask, augmentation='normal', masked_normalization_vals=self. masked_normalization_values, seed=self.seed) return img, label, img_masked elif self.args.actdiff_segmentation_classes == 'all': img_name = img_id.replace("/", "_").split(".dcm")[0] lung_mask = np.load( f"./lung_segmentations/annotations/{img_name}_lungmask.npy" ) lung_mask = np.where(lung_mask > 0, np.ones(lung_mask.shape), np.zeros(lung_mask.shape)) if self.args.actdiff_lungmask_size != self.IMG_SIZE: lung_mask_int = nn.functional.max_pool2d( torch.tensor(lung_mask).unsqueeze(0), int(224 / self.args.actdiff_lungmask_size) ).squeeze().numpy() lung_mask_int = (lung_mask_int > 0) * 1 lung_mask = resize(lung_mask_int, (self.IMG_SIZE, self.IMG_SIZE)) lung_mask = (lung_mask > 0) * 1 lung_mask = torch.from_numpy(lung_mask) lung_mask = torch.where(lung_mask > 0, torch.ones(lung_mask.shape), torch.zeros( lung_mask.shape)).long() img_masked = create_masked_image_advanced_augmentations( img, lung_mask, augmentation=self.args.actdiff_augmentation_type, masked_normalization_vals=self. masked_normalization_values, seed=self.seed) return img, label, img_masked if self.gaze_task == "segmentation_reg": rle = self.rle_dict[img_id.split("/")[-1].split(".dcm")[0]] y_true = rle != " -1" if y_true: # extract segmask segmask_org = rle2mask(rle, 1024, 1024).T segmask = resize(segmask_org, (7, 7)) segmask = torch.FloatTensor(segmask) return img, label, segmask else: segmask = -1 * torch.ones((7, 7)) return img, label, segmask if self.gaze_task is None: return img, label, 0 return img, label, gaze_attribute else: if self.gaze_task == 'cam_error_analysis': return img, label, img_id return img, label, subclass_label
def __getitem__(self, idx): img_path = self.image_info[idx]["image_path"] img = Image.open(img_path + '.png').convert("RGB") width, height = img.size image = img.resize((self.width, self.height), resample=Image.BILINEAR) info = self.image_info[idx] mask = rle2mask(info['annotations'], width, height) mask = Image.fromarray(mask.T) mask = mask.resize((self.width, self.height), resample=Image.BILINEAR) mask = np.expand_dims(mask, axis=0) image_id = torch.tensor([idx]) aspect_ratio = image.size[1] / image.size[0] Transform = [] ResizeRange = random.randint(300, 320) Transform.append( T.Resize((int(ResizeRange * aspect_ratio), ResizeRange))) p_transform = random.random() if (self.mode == 'train') and p_transform <= self.augmentation_prob: RotationDegree = random.randint(0, 3) RotationDegree = self.RotationDegree[RotationDegree] if (RotationDegree == 90) or (RotationDegree == 270): aspect_ratio = 1 / aspect_ratio Transform.append(T.RandomRotation( (RotationDegree, RotationDegree))) RotationRange = random.randint(-10, 10) Transform.append(T.RandomRotation((RotationRange, RotationRange))) CropRange = random.randint(250, 270) Transform.append( T.CenterCrop((int(CropRange * aspect_ratio), CropRange))) Transform = T.Compose(Transform) image = Transform(image) mask = Transform(mask) ShiftRange_left = random.randint(0, 20) ShiftRange_upper = random.randint(0, 20) ShiftRange_right = image.size[0] - random.randint(0, 20) ShiftRange_lower = image.size[1] - random.randint(0, 20) image = image.crop(box=(ShiftRange_left, ShiftRange_upper, ShiftRange_right, ShiftRange_lower)) mask = mask.crop(box=(ShiftRange_left, ShiftRange_upper, ShiftRange_right, ShiftRange_lower)) if random.random() < 0.5: image = F.hflip(image) mask = F.hflip(mask) if random.random() < 0.5: image = F.vflip(image) mask = F.vflip(mask) Transform = T.ColorJitter(brightness=0.2, contrast=0.2, hue=0.02) image = Transform(image) Transform = [] Transform.append( T.Resize( (int(256 * aspect_ratio) - int(256 * aspect_ratio) % 16, 256))) Transform.append(T.ToTensor()) Transform = T.Compose(Transform) image = Transform(image) mask = Transform(mask) Norm_ = T.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) image = Norm_(image) return image, mask
def __getitem__(self, idx): # load images ad masks img_path = os.path.join(self.root, "train_images", self.imgs[idx]) mask_path = os.path.join(self.root, "train_mask", self.masks[idx]) img = cv2.imread(img_path) # note that we haven't converted the mask to RGB, # because each color corresponds to a different instance # with 0 being background #mask = Image.open(mask_path) with open(mask_path, 'r') as f: mask = json.load(f) f.close() # convert the PIL Image into a numpy array #mask = np.array(mask) # instances are encoded as different colors obj_ids = len(mask) # first id is the background, so remove it #obj_ids = obj_ids[1:] # split the color-encoded mask into a set # of binary masks masks = [] #masks = mask == obj_ids[:, None, None] for i in range(0, obj_ids): masks.append(rle2mask(mask[i]['mask'], img.shape)) # get bounding box coordinates for each mask num_objs = obj_ids boxes = [] for i in range(0, num_objs): pos = np.where(masks[i] == 1) xmin = np.min(pos[1]) xmax = np.max(pos[1]) ymin = np.min(pos[0]) ymax = np.max(pos[0]) boxes.append([xmin, ymin, xmax, ymax]) # convert everything into a torch.Tensor boxes = torch.as_tensor(boxes, dtype=torch.float32) # there is only one class #labels = torch.ones((num_objs,), dtype=torch.int64) labels = [x['id'] for x in mask] labels = torch.as_tensor((labels), dtype=torch.int64) masks = torch.as_tensor(masks, dtype=torch.uint8) image_id = torch.tensor([idx]) area = (boxes[:, 3] - boxes[:, 1]) * (boxes[:, 2] - boxes[:, 0]) # suppose all instances are not crowd iscrowd = torch.zeros((num_objs, ), dtype=torch.int64) target = {} target["boxes"] = boxes target["labels"] = labels target["masks"] = masks target["image_id"] = image_id target["area"] = area target["iscrowd"] = iscrowd if self.transforms is not None: img, target = self.transforms(img, target) return img, target
def get_mask(self, encode, width, height): if encode ==[] or encode == ' -1': return rle2mask(' -1',width,height) else : return rle2mask(encode[0],width,height) # Isnt it just returning one of the mask not all.
df = pd.read_csv(os.path.join(config['path_to_data'], 'train.csv')) df['ImageId'] = df['Image_Label'].map(lambda x: x.split("_")[0]) df['ClassId'] = df[['Image_Label', 'EncodedPixels']].apply(lambda x: x[0].split("_")[1] if x[1] is not np.nan else '0', axis=1) df.drop(columns='Image_Label', inplace=True) df.drop_duplicates(inplace=True) # drop row with label 0 which exist label != 0 max_class_df = df.groupby("ImageId")['ClassId'].max().reset_index() max_class_df = max_class_df[max_class_df['ClassId'] != '0'] df = df[~((df['ImageId'].isin(max_class_df['ImageId'].values)) & (df['ClassId'] == '0'))] print(df.columns) images = df['ImageId'].unique() for image in tqdm(images): temp_df = df[df['ImageId'] == image] mask = np.zeros( (config['n_classes'], config['height'], config['width']), dtype=np.uint8) for row in temp_df.values: if row[0] is not np.nan: mask[mapping[row[2]]] = rle2mask(row[0], shape=(config['width'], config['height'])) mask = np.moveaxis(mask, 0, -1) cv2.imwrite( os.path.join(config['path_to_data'], 'train_masks', image.replace('.jpg', '.png')), mask)
def preproc(input_img, input_csv, limit=-1): input_glob = input_img + "*/*/*.dcm" train_fns = sorted(glob.glob(input_glob))[:limit] df_full = pd.read_csv(input_csv, index_col='ImageId') im_height = 1024 im_width = 1024 im_chan = 1 # Get train images and masks X_train = np.zeros((len(train_fns), im_height, im_width, im_chan), dtype=np.uint8) Y_train = np.zeros((len(train_fns), im_height, im_width, 1), dtype=np.bool) print('Getting train images and masks ... ') sys.stdout.flush() strCount, arrCount, noMaskCount, minus1Count = 0, 0, 0, 0 # iterate every training dicom file for n, _id in tqdm(enumerate(train_fns), total=len(train_fns)): # read image from this dicom file dataset = pydicom.read_file(_id) # expand the image pixel vector into image pixel matrix X_train[n] = np.expand_dims(dataset.pixel_array, axis=2) try: # retrieve the encoded pixels by: df_full.loc[_id.split('/')[-1][:-4],' EncodedPixels'] tempRle = df_full.loc[_id.split('/')[-1][:-4], ' EncodedPixels'] if '-1' in tempRle: # if a -1 is marked in training rle set for this image # need to mark every pixel as 1 Y_train[n] = np.zeros((1024, 1024, 1)) minus1Count += 1 else: if type(tempRle) == str: Y_train[n] = np.expand_dims(rle2mask(tempRle, 1024, 1024), axis=2) strCount += 1 else: Y_train[n] = np.zeros((1024, 1024, 1)) for x in tempRle: Y_train[n] = Y_train[n] + \ np.expand_dims(rle2mask(x, 1024, 1024), axis=2) arrCount += 1 # print(_id) except KeyError: print( f"Key {_id.split('/')[-1][:-4]} without mask, assuming healthy patient." ) # Assume missing masks are empty masks. Y_train[n] = np.zeros((1024, 1024, 1)) noMaskCount += 1 print('Done!') print('strCount:' + str(strCount)) print('arrCount:' + str(arrCount)) print('noMaskCount:' + str(noMaskCount)) print('minus1Count:' + str(minus1Count)) im_height = 128 im_width = 128 X_train = X_train.reshape((-1, im_height, im_width, 1)) Y_train = Y_train.reshape((-1, im_height, im_width, 1)) return X_train, Y_train
mask = ui.rle2mask(df.loc[0].EncodedPixels) img[mask==1] = 255 fig = plt.figure(figsize=(8,50)) ax = fig.add_subplot(1,1,1) plt.imshow(img, cmap='gray') ax.set_xticks(np.arange(0, 1601, 64), minor=True) ax.set_yticks(np.arange(0, 257, 64), minor=True) ax.grid(which='minor', alpha=1) size = 64 x = img.shape[0] // size y = img.shape[1] // size subImg = np.zeros((size,size))
test_size=0.1) print(len(df_train), len(df_valid)) if plot_beginning_images: columns = 1 rows = 4 fig = plt.figure(figsize=(20, columns * rows + 6)) for i in range(1, columns * rows + 1): fn, class_id_str = df_train['ImageId_ClassId'].iloc[i].rsplit( '_', -1) class_id = int(class_id_str) fig.add_subplot(rows, columns, i).set_title(fn) img = cv2.imread(path + 'train_images/' + fn) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) mask = rle2mask(df_train['EncodedPixels'].iloc[i], (256, 1600)) # different color codings for different classes if class_id == 1: img[mask == 1, 0] = 255 elif class_id == 2: img[mask == 1, 1] = 255 elif class_id == 3: img[mask == 1, 2] = 255 else: img[mask == 1, 0:2] = 255 plt.imshow(img) plt.show() # Define transformation(if needed augmentation can be applied here)
PATH = '/Users/nikita/Programming/SIIM/SIIM/train-rle.csv' # "../../data/ibespalov/SIIM_ACR/train-rle.csv" PATH_TO_SAVE = '/Users/nikita/Programming/SIIM/SIIM/train.csv' # "../../data/ibespalov/SIIM_ACR/train.csv" mask = pd.read_csv(PATH) k = mask.groupby('ImageId').count()[" EncodedPixels"] list_ImageId = k.index[k > 1] for i in tqdm(range(len(list_ImageId))): tmp = mask.loc[mask['ImageId'] == list_ImageId[i]] final_mask = np.zeros((1024, 1024)) for index, row in tmp.iterrows(): RLE_mask = row[" EncodedPixels"] if RLE_mask.strip() != str(-1): rle_mask = rle2mask(RLE_mask[1:], 1024, 1024).T else: rle_mask = np.zeros((1024, 1024)) final_mask[np.where(rle_mask)] = 1 final_rle = mask_to_rle(final_mask.T, 1024, 1024) new_csv['ImageId'].append(list_ImageId[i]) new_csv[' EncodedPixels'].append(final_rle) k = mask.groupby('ImageId').count()[" EncodedPixels"] list_ImageId = k.index[k == 1] for i in tqdm(range(len(list_ImageId))): new_csv['ImageId'].append(list_ImageId[i]) new_csv[' EncodedPixels'].append(mask.loc[ mask['ImageId'] == list_ImageId[i]][" EncodedPixels"].values[0])
''' (height, width) ''' original_size = (1400, 2100) new_size = (350, 525) # ResNet interpolation = cv2.INTER_CUBIC df = pd.read_csv(os.path.join(dataset_dir, 'train.csv')) print('update train.csv ...') # masking 영역을 ratio 맞게 resize 하기 for idx, row in tqdm(df.iterrows()): encoded_pixels = row[1] if encoded_pixels is not np.nan: mask = rle2mask(encoded_pixels, shape=original_size[::-1]) mask = cv2.resize(mask, new_size[::-1], interpolation=interpolation) rle = mask2rle(mask) df.at[idx, 'EncodedPixels'] = rle df.to_csv(os.path.join(dataset_dir, '350_525_train.csv'), index=False) # Resizing Train and Test Images train_images_dir = os.path.join(dataset_dir, 'train_images') train_image_files = os.listdir(train_images_dir) test_images_dir = os.path.join(dataset_dir, 'test_images') test_image_files = os.listdir(test_images_dir)