def __call__(self, img, lbl):
if random.random() < self.p:
img = F.vflip(img)
lbl = F.vflip(lbl)
return img, lbl
def __getitem__(self, index):
"""Reads an image from a file and preprocesses it and returns."""
image_path = self.image_paths[index]
filename = image_path.split('_')[-1][:-len(".jpg")]
GT_path = self.GT_paths + 'ISIC_' + filename + '_segmentation.png'
image = Image.open(image_path)
GT = Image.open(GT_path)
# 宽高比
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)
GT = Transform(GT)
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))
GT = GT.crop(box=(ShiftRange_left, ShiftRange_upper,
ShiftRange_right, ShiftRange_lower))
if random.random() < 0.5:
image = F.hflip(image)
GT = F.hflip(GT)
if random.random() < 0.5:
image = F.vflip(image)
GT = F.vflip(GT)
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)
GT = Transform(GT)
Norm_ = T.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
image = Norm_(image)
return image, GT
def __call__(self, imgs):
if isinstance(imgs, Image.Image):
imgs = [imgs]
assert len(imgs) >= 1
size = None
for img_no, img in enumerate(imgs):
assert isinstance(img, Image.Image)
# if img_no == 0:
# size = img.size
# else:
# assert size == img.size
trans_imgs = copy.deepcopy(imgs)
for trans in self.transformation_list:
if isinstance(trans, transforms.RandomRotation):
angle = trans.get_params(trans.degrees)
for img_no, trans_img in enumerate(trans_imgs):
trans_imgs[img_no] = F.rotate(trans_img, angle,
trans.resample, trans.expand,
trans.center)
elif isinstance(trans, transforms.RandomCrop):
i, j, th, tw = trans.get_params(trans_imgs[0], trans.size)
for img_no, trans_img in enumerate(trans_imgs):
trans_imgs[img_no] = F.crop(trans_img, i, j, th, tw)
elif isinstance(trans, transforms.RandomResizedCrop):
i, j, h, w = trans.get_params(trans_imgs[0], trans.scale,
trans.ratio)
for img_no, trans_img in enumerate(trans_imgs):
trans_imgs[img_no] = F.resized_crop(
trans_img, i, j, h, w, trans.size, trans.interpolation)
elif isinstance(trans, transforms.ColorJitter):
color_transform = trans.get_params(trans.brightness,
trans.contrast,
trans.saturation, trans.hue)
for img_no, trans_img in enumerate(trans_imgs):
trans_imgs[img_no] = color_transform(trans_img)
elif isinstance(trans, transforms.RandomHorizontalFlip):
random_value = random.random()
if random_value < trans.p:
for img_no, trans_img in enumerate(trans_imgs):
trans_imgs[img_no] = F.hflip(trans_img)
elif isinstance(trans, transforms.RandomVerticalFlip):
random_value = random.random()
if random_value < trans.p:
for img_no, trans_img in enumerate(trans_imgs):
trans_imgs[img_no] = F.vflip(trans_img)
elif isinstance(trans,
(transforms.Resize, transforms.CenterCrop,
transforms.ToTensor, transforms.Normalize)):
for img_no, trans_img in enumerate(trans_imgs):
trans_imgs[img_no] = trans(trans_img)
else:
print(trans)
raise NotImplementedError()
if len(imgs) == 1:
trans_imgs = trans_imgs[0]
return trans_imgs
def __call__(self, image, target):
if random.random() < self.prob:
image = F.vflip(image)
target = target.transpose(1)
return image, target
def transform_triplets(self, img, gt1, gt2):
# resize image and covert to tensor
img = TF.to_pil_image(img)
img = TF.resize(img, [self.img_size, self.img_size])
gt1 = TF.to_pil_image(gt1)
gt1 = TF.resize(gt1, [self.img_size, self.img_size])
gt2 = TF.to_pil_image(gt2)
gt2 = TF.resize(gt2, [self.img_size, self.img_size])
if self.with_random_hflip and random.random() > 0.5:
img = TF.hflip(img)
gt1 = TF.hflip(gt1)
gt2 = TF.hflip(gt2)
if self.with_random_vflip and random.random() > 0.5:
img = TF.vflip(img)
gt1 = TF.vflip(gt1)
gt2 = TF.vflip(gt2)
if self.with_random_rot90 and random.random() > 0.5:
img = TF.rotate(img, 90)
gt1 = TF.rotate(gt1, 90)
gt2 = TF.rotate(gt2, 90)
if self.with_random_rot180 and random.random() > 0.5:
img = TF.rotate(img, 180)
gt1 = TF.rotate(gt1, 180)
gt2 = TF.rotate(gt2, 180)
if self.with_random_rot270 and random.random() > 0.5:
img = TF.rotate(img, 270)
gt1 = TF.rotate(gt1, 270)
gt2 = TF.rotate(gt2, 270)
if self.with_color_jittering and random.random() > 0.5:
img = TF.adjust_hue(img, hue_factor=random.random() * 0.5 -
0.25) # -0.25 ~ +0.25
img = TF.adjust_saturation(
img,
saturation_factor=random.random() * 0.8 + 0.8) # 0.8 ~ +1.6
gt1 = TF.adjust_hue(gt1, hue_factor=random.random() * 0.5 -
0.25) # -0.25 ~ +0.25
gt1 = TF.adjust_saturation(
gt1,
saturation_factor=random.random() * 0.8 + 0.8) # 0.8 ~ +1.6
gt2 = TF.adjust_hue(gt2, hue_factor=random.random() * 0.5 -
0.25) # -0.25 ~ +0.25
gt2 = TF.adjust_saturation(
gt2,
saturation_factor=random.random() * 0.8 + 0.8) # 0.8 ~ +1.6
if self.with_random_crop and random.random() > 0.5:
i, j, h, w = transforms.RandomResizedCrop(size=self.img_size). \
get_params(img=img, scale=(0.5, 1.0), ratio=self.crop_ratio)
img = TF.resized_crop(img,
i,
j,
h,
w,
size=(self.img_size, self.img_size))
gt1 = TF.resized_crop(gt1,
i,
j,
h,
w,
size=(self.img_size, self.img_size))
gt2 = TF.resized_crop(gt2,
i,
j,
h,
w,
size=(self.img_size, self.img_size))
# to tensor
img = TF.to_tensor(img)
gt1 = TF.to_tensor(gt1)
gt2 = TF.to_tensor(gt2)
return img, gt1, gt2
def __call__(self, image):
if random.random() < self.prob:
image = F.vflip(image)
return image
def __getitem__(self, idx, seed=None):
path = self.paths[idx]
scanner = np.load(path)
scan, mask = scanner["scan"], scanner["mask"]
if self.train_test == "train":
random.seed(seed)
v_flip = random.random() < self.flip_proba
h_flip = random.random() < self.flip_proba
if self.mode == 'concatenate':
scans = []
masks = []
to_pil = Convert()
to_tens = T.ToTensor()
for img, msk in zip(scan, mask):
img, msk = to_pil(img), to_pil(np.uint8(msk))
if v_flip:
img = TF.hflip(img)
msk = TF.hflip(msk)
if h_flip:
img = TF.vflip(img)
msk = TF.vflip(msk)
img, msk = to_tens(img).unsqueeze(0).float(), to_tens(
msk).unsqueeze(0).float()
if self.noise_magnitude is not None:
noise = torch.randn_like(img)
img += noise
scans.append(img)
masks.append(msk)
scans = torch.cat(scans, dim=1)
masks = torch.cat(masks, dim=1)
output = torch.cat([scans, masks], dim=0)
elif self.mode == 'mask':
output = np.expand_dims(mask, axis=1)
output = torch.cat([self.transform(x) for x in output], dim=0)
elif self.mode == 'scan':
output = np.expand_dims(scan, axis=1)
output = torch.cat([self.transform(x) for x in output], dim=0)
else:
if self.mode == 'mask':
output = torch.Tensor(mask).unsqueeze(1).float()
elif self.mode == 'scan':
output = torch.Tensor(scan).unsqueeze(1).float()
elif self.mode == 'concatenate':
scan = torch.Tensor(scan).unsqueeze(0).float()
mask = torch.Tensor(mask).unsqueeze(0).float()
output = torch.cat([scan, mask], dim=0)
output = {"images": output}
patient_id = int(get_id_from_path(path))
if self.csv_dir:
patient_info = self.ground_truth.loc[self.ground_truth.PatientID ==
patient_id]
output['y'] = self.scaler.transform([[patient_info.iloc[0, 1]]])[0]
output['info'] = np.array(
[patient_id, int(patient_info.iloc[0, 2])])
else:
output['info'] = np.array([patient_id, 1.])
return output
def _verticalFlip(img, segMask=None):
img = F.vflip(img)
if segMask is not None:
segMask = F.vflip(segMask)
return img, segMask
def vflip(self, x):
return F.vflip(x)
def __call__(self, image, segmentation):
if random.random() < 0.5:
image = TF.vflip(image)
segmentation = TF.vflip(segmentation)
return image, segmentation
def transform_image(self, image):
return F.vflip(image)
def apply_randomTransform(image_left, image_right, size=(224, 224)):
# Resize
resize = transforms.Resize(size=size)
image_left = resize(image_left)
image_right = resize(image_right)
# Random crop
#if random.random() > 0.5:
# i, j, h, w = transforms.RandomCrop.get_params(image_left, output_size=(224, 224))
# image_left = TF.crop(image_left, i, j, h, w)
# image_right = TF.crop(image_right, i, j, h, w)
# Random horizontal flipping
if random.random() > 0.5:
image_left = TF.hflip(image_left)
image_right = TF.hflip(image_right)
# Random vertical flipping
if random.random() > 0.5:
image_left = TF.vflip(image_left)
image_right = TF.vflip(image_right)
# Random rotation
if random.random() > 0.5:
angle = random.randint(0, 360)
image_left = TF.rotate(image_left, angle)
image_right = TF.rotate(image_right, angle)
# Random grayscale
# if random.random() > 0.5:
# image_left = TF.to_grayscale(image_left, 3)
# image_right = TF.to_grayscale(image_right, 3)
# Random scale
if random.random() > 0.5:
scale = random.uniform(0.2, 2)
image_left = TF.affine(image_left,
angle=0,
translate=(0, 0),
scale=scale,
shear=0)
image_right = TF.affine(image_right,
angle=0,
translate=(0, 0),
scale=scale,
shear=0)
# Random shear
if random.random() > 0.5:
shear = random.randint(-180, 180)
image_left = TF.affine(image_left,
angle=0,
translate=(0, 0),
scale=1,
shear=shear)
image_right = TF.affine(image_right,
angle=0,
translate=(0, 0),
scale=1,
shear=shear)
return image_left, image_right
def transform(self, img1, img2):
# resize image and covert to tensor
img1 = TF.to_pil_image(img1)
img1 = TF.resize(img1, [self.img_size, self.img_size], interpolation=3)
img2 = TF.to_pil_image(img2)
img2 = TF.resize(img2, [self.img_size, self.img_size], interpolation=3)
if self.with_random_hflip and random.random() > 0.5:
img1 = TF.hflip(img1)
img2 = TF.hflip(img2)
if self.with_random_vflip and random.random() > 0.5:
img1 = TF.vflip(img1)
img2 = TF.vflip(img2)
if self.with_random_rot90 and random.random() > 0.5:
img1 = TF.rotate(img1, 90)
img2 = TF.rotate(img2, 90)
if self.with_random_rot180 and random.random() > 0.5:
img1 = TF.rotate(img1, 180)
img2 = TF.rotate(img2, 180)
if self.with_random_rot270 and random.random() > 0.5:
img1 = TF.rotate(img1, 270)
img2 = TF.rotate(img2, 270)
if self.with_random_crop and random.random() > 0.5:
i, j, h, w = transforms.RandomResizedCrop(size=self.img_size). \
get_params(img=img1, scale=(0.5, 1.0), ratio=(0.9, 1.1))
img1 = TF.resized_crop(img1,
i,
j,
h,
w,
size=(self.img_size, self.img_size))
img2 = TF.resized_crop(img2,
i,
j,
h,
w,
size=(self.img_size, self.img_size))
if self.with_random_patch:
i, j, h, w = transforms.RandomResizedCrop(size=self.img_size). \
get_params(img=img1, scale=(1/16.0, 1/9.0), ratio=(0.9, 1.1))
img1 = TF.resized_crop(img1,
i,
j,
h,
w,
size=(self.img_size, self.img_size))
img2 = TF.resized_crop(img2,
i,
j,
h,
w,
size=(self.img_size, self.img_size))
# to tensor
img1 = TF.to_tensor(img1)
img2 = TF.to_tensor(img2)
return img1, img2
def __call__(self, img, mask):
if random.random() < self.p:
return F.vflip(img), F.vflip(mask)
return img, mask
def __call__(self, imglist):
assert len(imglist) <= 2
if random.random() < self.p:
return [TF.vflip(img) for img in imglist]
return imglist
def __call__(self,imgs):
if random.random() < self.p:
return [tvF.vflip(img) for img in imgs]
return imgs
def __call__(self, image, mask):
if random.random() < self.prob:
image = F.vflip(image)
mask = F.vflip(mask)
return image, mask
def torchvision_transform(self, img):
return torchvision.vflip(img)
def randomVflip(self, img):
return F.vflip(img)
def __call__(self, sample):
sample['image'] = tff.vflip(sample['image'])
sample['target'] = tff.vflip(sample['target'])
return sample
def _verticalFlip(img, bboxes=None, labels=None):
img = F.vflip(img)
if bboxes is not None and len(labels):
bboxes[:,1] = img.size[1] - (bboxes[:,1] + bboxes[:,3])
return img, bboxes, labels
def __call__(self, img, anns):
if random.random() < self.p:
img = VF.vflip(img)
anns = HF.vflip(anns, img.size)
return img, anns
return img, anns
def data_argument(self, img, seed1, seed2):
if seed1 > 0.5: img = TF.vflip(img)
if seed2 > 0.5: img = TF.hflip(img)
return img
def __getitem__(self, idx):
if self.phase == 'val':
idx = idx + self.total_data_num * 4
elif self.phase == 'test':
idx = idx + self.total_data_num * 5
imidx = self.imgs[idx].split("_")[1].replace(".png", "")
# print("the image index is: ",imidx)
img_path = os.path.join(self.root_dir, self.imgs[idx])
# print(img_path)
# depth_path = os.path.join(self.root_dir, imidx+".npy")
depth_path = os.path.join(self.root_dir, self.d_imgs[idx])
# print(depth_path)
img_rgb = Image.open(img_path)
depth_npy = np.load(depth_path)
# print(depth_npy)
depth_npy[np.isnan(depth_npy)] = max_d = np.nanmax(depth_npy)
# print(depth_npy.shape)
############ edited by wei change to float, can not run
# img_depth = Image.fromarray(depth_npy, mode='F')
img_depth = Image.fromarray(depth_npy)
# print(img_depth)
transform = T.Compose([T.ToTensor()])
if self.phase == 'test':
if self.use_transform:
img_rgb = transform(img_rgb)
img_depth = transform(img_depth)
# mask = transform(mask)
img_depth = normalize(img_depth)
sample = {'rgb': img_rgb, 'X': img_depth}
#### train and val datasets
else:
corners_label = Image.open(
os.path.join(self.root_dir, imidx + '_labels_orange.png'))
edges_label = Image.open(
os.path.join(self.root_dir, imidx + '_labels_yellow.png'))
inner_edges_label = Image.open(
os.path.join(self.root_dir, imidx + '_labels_green.png'))
if self.use_transform:
if random.random() > 0.5:
# vertical flip
img_rgb = tf.hflip(img_rgb)
img_depth = tf.hflip(img_depth)
corners_label = tf.hflip(corners_label)
edges_label = tf.hflip(edges_label)
inner_edges_label = tf.hflip(inner_edges_label)
# horizontal flip
if random.random() > 0.5:
img_rgb = tf.vflip(img_rgb)
img_depth = tf.vflip(img_depth)
corners_label = tf.vflip(corners_label)
edges_label = tf.vflip(edges_label)
inner_edges_label = tf.vflip(inner_edges_label)
# rotation
if random.random() > 0.9:
angle = T.RandomRotation.get_params([-30, 30])
img_rgb = tf.rotate(img_rgb, angle, resample=Image.NEAREST)
img_depth = tf.rotate(img_depth,
angle,
resample=Image.NEAREST)
corners_label = tf.rotate(corners_label,
angle,
resample=Image.NEAREST)
edges_label = tf.rotate(edges_label,
angle,
resample=Image.NEAREST)
inner_edges_label = tf.rotate(inner_edges_label,
angle,
resample=Image.NEAREST)
img_rgb = transform(img_rgb)
img_depth = transform(img_depth)
corners_label = transform(corners_label)
edges_label = transform(edges_label)
inner_edges_label = transform(inner_edges_label)
##### concatenate the label to 3 * 480 * 640
##### three channel GT with each channel a detected colors
label = torch.cat((corners_label, edges_label, inner_edges_label),
0)
img_depth = normalize(img_depth)
sample = {'rgb': img_rgb, 'X': img_depth, 'Y': label}
return sample
def data_aug_func(self,
scene=None,
current_scene_image=None,
obs_traj=None,
pred_traj=None,
obs_traj_rel=None,
pred_traj_rel=None,
walls=None):
# seed = torch.utils.data.get_worker_info().seed
# print("Working seed {}".format( seed))
# torch.manual_seed(seed)
img = current_scene_image["scaled_image"]
k = obs_traj.size(0)
xy = torch.cat((obs_traj, pred_traj), dim=1)
if self.format == "pixel":
scale2orig = 1 / current_scene_image["scale_factor"]
elif self.format == "meter":
scale2orig = self.img_scaling
else:
assert False, " Not valid format '{}': 'meters' or 'pixel'".format(
self.format)
alpha = torch.rand(1) * 2 * np.pi
center = torch.tensor(img.size) / 2.
corners = torch.tensor([[0, 0], [0, img.height],
[img.width, img.height], [img.width, 0]])
rand_num = torch.randint(0, 3, (1, ))
if rand_num != 0:
if rand_num == 1:
img = TF.hflip(img)
xy[:, :, 0] = img.width * scale2orig - xy[:, :, 0]
if self.wall_available:
for i in range(len(walls)):
walls[i][:,
0] = img.width * scale2orig - walls[i][:, 0]
elif rand_num == 2:
img = TF.vflip(img)
xy[:, :, 1] = img.height * scale2orig - xy[:, :, 1]
# transform wall
if self.wall_available:
for i in range(len(walls)):
walls[i][:,
1] = img.height * scale2orig - walls[i][:, 1]
img = TF.rotate(img, alpha / np.pi * 180, expand=True)
corners_trans = rotate(corners, center, alpha)
offset = corners_trans.min(axis=0)[0]
corners_trans -= offset
if self.wall_available:
wall_points = []
for wall in walls.copy():
wall_points.append(
(rotate(torch.from_numpy(wall), center * scale2orig, alpha)
- offset * scale2orig).numpy())
walls = wall_points
else:
walls = False
xy = xy.reshape(k * self.seq_len, -1)
xy = rotate(xy, center * scale2orig, alpha) - offset * scale2orig
xy = xy.reshape(k, self.seq_len, -1)
scaling_factor_global = self.img_scaling / self.scaling_global
scaling_factor_local = self.img_scaling / self.scaling_local
global_image = img.resize(
(int(round(img.width * scaling_factor_global)),
int(round(img.height * scaling_factor_global))), Image.ANTIALIAS)
local_image = img.resize(
(int(round(img.width * scaling_factor_local)),
int(round(img.height * scaling_factor_local))), Image.ANTIALIAS)
scene_image = {
"ratio": self.images[scene]["ratio"],
"scene": scene,
"scaled_image": copy.copy(img),
"global_image": copy.copy(global_image),
"local_image": copy.copy(local_image)
}
dxdy = xy[:, 1:] - xy[:, :-1]
obs_traj = xy[:, :self.obs_len]
pred_traj = xy[:, self.obs_len:]
feature_list = []
cropped_img_list = []
prob_mask_list = []
for idx in np.arange(0, k):
features_id, prob_mask = self.gen_global_patches(
scene_image, obs_traj[idx], pred_traj[idx])
feature_list.append(features_id)
prob_mask_list.append(prob_mask)
global_patch = torch.cat(feature_list)
prob_mask_tensor = torch.cat(prob_mask_list)
feature_list = []
for idx in np.arange(0, k):
feature_pred = []
for time in range(self.pred_len):
feature_pred.append(
self.gen_local_patches(scene_image,
xy[idx, self.obs_len - 1 + time],
xy[idx, time + self.obs_len]))
feature_pred = torch.cat(feature_pred)
feature_list.append(feature_pred)
local_patch = torch.stack(feature_list, dim=0)
scene_image = (k) * [scene_image]
return obs_traj, pred_traj, dxdy[:, :self.obs_len -
1], dxdy[:, self.obs_len -
1:], scene_image, global_patch, prob_mask_tensor, walls, local_patch
def __call__(self, sample):
if random.random() < self.p:
sample['input'] = [F.vflip(input) for input in sample['input']]
sample['gt'] = [F.vflip(gt) for gt in sample['gt']]
return sample
def torchvision(self, img):
return torchvision.vflip(img)
def __call__(self, image):
return F.vflip(image)
def __getitem__(self, index):
"""Reads an image from a file and preprocesses it and returns."""
# Random factor extraction
def random_factor(factor):
assert factor > 0
return_factor = factor * np.random.randn() + 1
if return_factor < 1 - factor:
return_factor = 1 - factor
if return_factor > 1 + factor:
return_factor = 1 + factor
return return_factor
# Load image and mask files
image_path, mask_path = self.data_paths[index] # Random index
image = Image.open(image_path)
mask = Image.open(mask_path) if mask_path is not None else None
# Data augmentation
image = np.array(image).astype(np.float32) / 255.0
if self.phase != "test":
# Random brightness & contrast & gamma adjustment (linear and nonlinear intensity transform)
brightness_factor = random_factor(0.12)
contrast_factor = random_factor(0.20)
gamma_factor = random_factor(0.45)
image = np.array(image).astype(np.float32)
image = (brightness_factor - 1.0) + image
image = 0.5 + contrast_factor * (image - 0.5)
image = np.clip(image, 0.0, 1.0)
image = image**gamma_factor
# Image standard deviation normalization
image = image / np.std(image)
image = F.to_pil_image(image, mode="F")
# Random cropping
i, j, h, w = T.RandomCrop.get_params(image,
output_size=self.patch_size)
image = F.crop(image, i, j, h, w)
mask = F.crop(mask, i, j, h, w)
# Random horizontal flipping
if random.random() < 0.5:
image = F.hflip(image)
mask = F.hflip(mask)
# Random vertical flipping
if random.random() < 0.5:
image = F.vflip(image)
mask = F.vflip(mask)
# # Random shearing (takes too long time...)
# if random.random() < 0.5:
# shear = 4 * random.random() - 2
# image = F.affine(image, angle=0, translate=(0, 0), scale=1, shear=shear, resample=Image.NEAREST)
# mask = F.affine(mask, angle=0, translate=(0, 0), scale=1, shear=shear, resample=Image.NEAREST)
# # Random noise addition (white & speckle)
# image0 = image
# image0[image0 < 0] = 0
# speckle_level = np.abs(0.1 * np.random.randn())
# white_level = np.abs(0.05 * np.random.randn())
# speckle = speckle_level * (np.random.exponential(scale=image0).astype(np.float32) - image)
# white_noise = white_level * np.random.randn(image.shape[0], image.shape[1]).astype(np.float32)
# image = image + white_noise + speckle
else:
image = image / np.std(image)
# ToTensor
transform = list()
transform.append(
T.ToTensor()) # ToTensor should be included before returning.
transform = T.Compose(transform)
image = transform(image)
# fig, axes = plt.subplots(1, 2)
# axes[0].imshow(image0, vmax=1.0, vmin=0.0)
# axes[1].imshow(image[0, :, :].numpy(), vmax=1.0, vmin=0.0)
# plt.title("%.2f %.2f %.2f" % (brightness_factor, contrast_factor, gamma_factor))
# plt.show()
# Mask labeling & Weight
if mask is not None:
mask = (np.array(mask) / 255).astype(np.float32)
weight = np.zeros(mask.shape, dtype=np.float32)
if self.sample_weight is None:
self.sample_weight = (1.0, ) * self.num_classes
# mask_label = np.ndarray(mask.shape + (self.num_classes,), dtype=np.float32)
# for c in range(self.num_classes):
# mask_label[:, :, c] = (mask == c).astype(np.float32)
# weight += (mask == c).astype(np.float32) * self.sample_weight[c]
transform = list()
transform.append(
T.ToTensor()) # ToTensor should be included before returning.
transform = T.Compose(transform)
# mask = transform(mask_label)
mask = transform(mask)
weight = transform(weight)
return image, mask, weight
else:
return image
def torchvision(self, img):
return torchvision.vflip(img)
def __call__(self, images, target):
if random.random() < self.prob:
images = [F.vflip(image) for image in images]
target = target.transpose(1)
return images, target
