def custom_transform(self, image, segmentation): # 0.5 probability of performing one transformation if random.random() > 0.5: p = random.random() # Rotate if p < 0.3: angle = random.randint(-30, 30) image = TF.rotate(image, angle) segmentation = TF.rotate(segmentation, angle) # Horizontal flip elif p < 0.6: TF.hflip(image) TF.hflip(segmentation) # Vertical flip elif p < 0.9: TF.vflip(image) TF.vflip(segmentation) # Colours else: TF.adjust_brightness(image, 1.4) TF.adjust_hue(image, 0.3) TF.adjust_contrast(image, 1.3) TF.adjust_saturation(image, 0.7) return image, segmentation
def __call__(self, seq_blur, seq_clear): seq_blur = [Image.fromarray(np.uint8(img)) for img in seq_blur] seq_clear = [Image.fromarray(np.uint8(img)) for img in seq_clear] if self.brightness > 0: brightness_factor = np.random.uniform(max(0, 1 - self.brightness), 1 + self.brightness) seq_blur = [F.adjust_brightness(img, brightness_factor) for img in seq_blur] seq_clear = [F.adjust_brightness(img, brightness_factor) for img in seq_clear] if self.contrast > 0: contrast_factor = np.random.uniform(max(0, 1 - self.contrast), 1 + self.contrast) seq_blur = [F.adjust_contrast(img, contrast_factor) for img in seq_blur] seq_clear = [F.adjust_contrast(img, contrast_factor) for img in seq_clear] if self.saturation > 0: saturation_factor = np.random.uniform(max(0, 1 - self.saturation), 1 + self.saturation) seq_blur = [F.adjust_saturation(img, saturation_factor) for img in seq_blur] seq_clear = [F.adjust_saturation(img, saturation_factor) for img in seq_clear] if self.hue > 0: hue_factor = np.random.uniform(-self.hue, self.hue) seq_blur = [F.adjust_hue(img, hue_factor) for img in seq_blur] seq_clear = [F.adjust_hue(img, hue_factor) for img in seq_clear] seq_blur = [np.asarray(img) for img in seq_blur] seq_clear = [np.asarray(img) for img in seq_clear] seq_blur = [img.clip(0,255) for img in seq_blur] seq_clear = [img.clip(0,255) for img in seq_clear] return seq_blur, seq_clear
def CustomTransform(LR, HR, adjust_brightness, adjust_contrast, adjust_saturation, adjust_hue, adjust_gamma, rotate, hflip, vflip): """ to execute data augmentation. except :param LR and :param HR, all other params accept bool args. """ if adjust_brightness: brightness_factor = random.gauss(1, 0.05) while brightness_factor > 2 or brightness_factor < 0: brightness_factor = random.gauss(1, 0.05) HR = f.adjust_brightness(HR, brightness_factor) LR = f.adjust_brightness(LR, brightness_factor) if adjust_contrast: contrast_factor = random.gauss(1, 0.05) while contrast_factor > 2 or contrast_factor < 0: contrast_factor = random.gauss(1, 0.05) HR = f.adjust_contrast(HR, contrast_factor) LR = f.adjust_contrast(LR, contrast_factor) if adjust_saturation: saturation_factor = random.gauss(1, 0.05) while saturation_factor > 2 or saturation_factor < 0: saturation_factor = random.gauss(1, 0.05) HR = f.adjust_saturation(HR, saturation_factor) LR = f.adjust_saturation(LR, saturation_factor) if adjust_hue: hue_factor = random.gauss(0, 0.025) while hue_factor > 0.5 or hue_factor < -0.5: hue_factor = random.gauss(0, 0.025) HR = f.adjust_hue(HR, hue_factor) LR = f.adjust_hue(LR, hue_factor) if adjust_gamma: gamma = random.gauss(1, 0.025) while gamma > 0.5 or gamma < -0.5: gamma = random.gauss(0, 0.025) HR = f.adjust_gamma(HR, gamma) LR = f.adjust_gamma(LR, gamma) if rotate: angle = random.choice([-90, 0, 90]) HR = f.rotate(HR, angle) LR = f.rotate(LR, angle) if hflip: flip = random.choice([True, False]) if flip: HR = f.hflip(HR) LR = f.hflip(LR) if vflip: flip = random.choice([True, False]) if flip: HR = f.vflip(HR) LR = f.vflip(LR) return LR, HR
def image_change_contrast(img, contrast=0, use_random=False): """Given the image, change the contrast of the image. Param: - contrast: In F.adjust_contrast, the value of contrast will give the followig result: 0 will give a solid gray image 1 will give the original image 2 will increase the contrast of the image by the factor of 2 - random: determine whether we need to randomly generate a contrast factor in the valid range. Return: - image in BGR order """ if contrast > 0: # convert opencv image to PIL image pil_img = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB)) if use_random: contrast = random.uniform(max(0, 1 - contrast), 1 + contrast) pil_img = F.adjust_contrast(pil_img, contrast) else: pil_img = F.adjust_contrast(pil_img, contrast) img = cv2.cvtColor(np.array(pil_img), cv2.COLOR_RGB2BGR) return img
def __call__(self, sample): if np.random.random() < 0.5: contrast_factor = np.random.uniform(0.8, 1.2) sample['left'] = F.adjust_contrast(sample['left'], contrast_factor) sample['right'] = F.adjust_contrast(sample['right'], contrast_factor) return sample
def __call__(self, img: Image.Image, boxes: Optional[torch.Tensor] = None, labels: Optional[torch.Tensor] = None): if random() < self._prob: brightness_factor = uniform(self._min, self._max_brightness_factor) img = F.adjust_brightness(img, brightness_factor) contrast_factor = uniform(self._min, self._max_contrast_factor) hue_factor = uniform(-self._min, self._max_hue_factor) saturation_factor = uniform(self._min, self._max_saturation_factor) # 50% chance applying contrast followed by hue and saturation or vice versa if random() < 0.5: if random() < self._prob: img = F.adjust_contrast(img, contrast_factor) if random() < self._prob: img = img.convert("HSV") img = F.adjust_hue(img, hue_factor) img = img.convert("RGB") img = F.adjust_saturation(img, saturation_factor) else: if random() < self._prob: img = img.convert("HSV") img = F.adjust_hue(img, hue_factor) img = img.convert("RGB") img = F.adjust_saturation(img, saturation_factor) if random() < self._prob: img = F.adjust_contrast(img, contrast_factor) return img, boxes, labels
def train_transform(lr: PIL.BmpImagePlugin.BmpImageFile, hr: PIL.BmpImagePlugin.BmpImageFile): r"""Unified transformation of training dataset.""" # Rotate the image by angle. angle = transforms.RandomRotation.get_params([-180, 180]) lr = lr.rotate(angle) hr = hr.rotate(angle) # Horizontally flip the given image randomly with a given probability. p = random.random() if p > 0.5: lr = F.hflip(lr) lr = F.vflip(lr) hr = F.hflip(hr) hr = F.vflip(hr) # Randomly change the brightness, contrast, saturation and hue of an image. lr = F.adjust_brightness(lr, brightness_factor=p) lr = F.adjust_contrast(lr, contrast_factor=p) lr = F.adjust_saturation(lr, saturation_factor=p) hr = F.adjust_brightness(hr, brightness_factor=p) hr = F.adjust_contrast(hr, contrast_factor=p) hr = F.adjust_saturation(hr, saturation_factor=p) # PIL to tensor. lr = F.to_tensor(lr) hr = F.to_tensor(hr) return lr, hr
def data_augmentation(x, y, mode='train'): """ x, y: np array, [B, C, H, W] """ x_list = list() y_list = list() for i in range(x.shape[0]): # gamma correction xi = skimage.exposure.adjust_gamma(x[i, ...], 0.4) yi = skimage.exposure.adjust_gamma(y[i, ...], 0.4) # color transfer if mode == 'train': xi = color_transform(xi, T) yi = color_transform(yi, T) xi = Image.fromarray(xi) yi = Image.fromarray(yi) if mode == 'train': pick = random.randint(0, 4) if pick == 0: # random brightness brightness_factor = 1.0 + random.uniform(0, 0.3) xi = ttf.adjust_brightness(xi, brightness_factor) yi = ttf.adjust_brightness(yi, brightness_factor) elif pick == 1: # random saturation saturation_factor = 1.0 + random.uniform(-0.2, 0.5) xi = ttf.adjust_saturation(xi, saturation_factor) yi = ttf.adjust_saturation(yi, saturation_factor) elif pick == 2: # random hue hue_factor = random.uniform(-0.2, 0.2) xi = ttf.adjust_hue(xi, hue_factor) yi = ttf.adjust_hue(yi, hue_factor) elif pick == 3: # random contrast contrast_factor = 1.0 + random.uniform(-0.2, 0.4) xi = ttf.adjust_contrast(xi, contrast_factor) yi = ttf.adjust_contrast(yi, contrast_factor) elif pick == 4: # random swap color channel permute = np.random.permutation(3) xi = np.array(xi) yi = np.array(yi) xi = xi[..., permute] yi = yi[..., permute] xi = np.clip(np.array(xi) / 255.0, 0, 1.0) yi = np.clip(np.array(yi) / 255.0, 0, 1.0) x_list.append(xi) y_list.append(yi) x_ret = torch.tensor(np.stack(x_list, axis=0), dtype=torch.float) y_ret = torch.tensor(np.stack(y_list, axis=0), dtype=torch.float) x_ret = normalize_lf(x_ret) y_ret = normalize_lf(y_ret) return x_ret.to(device), y_ret.to(device)
def selective_color_distort(self, image, mask): # make skin mask using face, neck, and ear segments skin = mask[0] + mask[16] + mask[6] + mask[7] # ensure there's no clipping skin[skin > 1] = 1 skin = skin.repeat((3, 1, 1)) # torch transforms only work on PIL images, so first # the image tensors must be converted to PIL images background = TF.to_pil_image(image) face = TF.to_pil_image(image) # generate parameters for color jitter # taken from https://arxiv.org/pdf/2002.05709.pdf page 12 jitter_params = torch.rand(4) * torch.tensor([.8, .8, .8, .2]) if torch.rand(1).item() > .2: # apply transforms to background background = TF.adjust_brightness(background, .2 + jitter_params[0] * 2) background = TF.adjust_contrast(background, .2 + jitter_params[1] * 2) background = TF.adjust_saturation(background, .2 + jitter_params[2] * 2) background = TF.adjust_hue(background, jitter_params[3] * 2 - .2) # apply identical brightness/contrast/saturation transform to face face = TF.adjust_brightness(face, .2 + jitter_params[0] * 2) face = TF.adjust_saturation(face, .2 + jitter_params[2] * 2) # only apply 50% of the contrast transform to the face face = TF.adjust_contrast(face, .4 + jitter_params[1]) # only apply 25% of the hue transform to the face face = TF.adjust_hue(face, jitter_params[3] * .5 - .05) # note: the possibility of neither color jitter or grayscale or both # color jitter and grayscale is intended behavior. the random # draws are meant to be different for these two if statements if torch.rand(1).item() > .8: background = TF.to_grayscale(background, num_output_channels=3) face = TF.to_grayscale(face, num_output_channels=3) # convert PIL images back to tensors background = TF.to_tensor(background) face = TF.to_tensor(face) # construct final image as convex combination of face pixels # and mask pixels. where the mask has higher confidence (closer # to 1), the face image will be used distorted = (1 - skin) * background + skin * face return distorted.type(torch.float32)
def wrapper(img): nonlocal aug_params if aug_target == 'batch' or aug_target == 'test-batch': pass # nothing to do # Deciding transform parameters elif aug_target == 'sample': aug_params['rotate']['angle'] = get_random_rotate_angle( aug_params['rotate']['train_range']) aug_params['bright']['factor'] = get_random_factor( aug_params['bright']['train_range']) aug_params['contrast']['factor'] = get_random_factor( aug_params['contrast']['train_range']) elif aug_target == 'test-sample': aug_params['rotate']['angle'] = get_random_rotate_angle( aug_params['rotate']['test_range']) aug_params['bright']['factor'] = get_random_factor( aug_params['bright']['test_range']) aug_params['contrast']['factor'] = get_random_factor( aug_params['contrast']['test_range']) else: raise ValueError('Invalid aug_target: %s' % (aug_target)) # Process the image if aug_type == 'rotate': img = TF.rotate(img, aug_params['rotate']['angle']) # print('rotate angle:', aug_params['rotate']['angle']) elif aug_type == 'bright': img = TF.adjust_brightness(img, aug_params['bright']['factor']) # print('bright factor:', aug_params['bright']['factor']) elif aug_type == 'contrast': img = TF.adjust_contrast(img, aug_params['contrast']['factor']) # print('contrast factor:', aug_params['contrast']['factor']) elif aug_type == 'mix': img = TF.adjust_contrast(img, aug_params['contrast']['factor']) img = TF.adjust_brightness(img, aug_params['bright']['factor']) img = TF.rotate(img, aug_params['rotate']['angle']) else: raise ValueError('Invalid aug_type: %s' % (aug_type)) return img
def random_adjust_contrast(lr: Any, hr: Any) -> list[Any, Any]: """Set ``PIL.Image`` to randomly adjust the image contrast. Args: lr: Low-resolution image data read by ``PIL.Image``. hr: High-resolution image data read by ``PIL.Image``. Returns: Low-resolution image and high-resolution image with randomly adjusted contrast. """ # Randomly adjust the contrast gain range. factor = random.uniform(0.5, 2) lr = F.adjust_contrast(lr, factor) hr = F.adjust_contrast(hr, factor) return lr, hr
def augmentation(image, seg, hand=None, p=.5): if hand: if random.random() < p: angle = random.randint(-45, 45) image = TF.rotate(image, angle) hand = TF.rotate(hand, angle, fill=0.) seg = TF.rotate( seg, angle, fill=2 ) #if rotation leaves edges black fill value with 2 to ignore if random.random() < p: image = TF.hflip(image) hand = TF.hflip(hand) seg = TF.hflip(seg) if random.random() < p: image = TF.vflip(image) hand = TF.vflip(hand) seg = TF.vflip(seg) if random.random() < p: image = TF.adjust_saturation(image, random.uniform( .5, 3)) #only applicable to image if random.random() < p: image = TF.adjust_contrast(image, random.uniform( .5, 3)) #only applicable to image image = TF.to_tensor(image) hand = TF.to_tensor(hand) segmentation = TF.to_tensor(seg) imageHand = torch.cat([image, hand], dim=0) imageHand = TF.normalize(imageHand, mean=mean, std=std) return imageHand, segmentation else: if random.random() < p: angle = random.randint(-45, 45) image = TF.rotate(image, angle) seg = TF.rotate(seg, angle, fill=2) if random.random() < p: image = TF.hflip(image) seg = TF.hflip(seg) if random.random() < p: image = TF.vflip(image) seg = TF.vflip(seg) if random.random() < p: image = TF.adjust_saturation(image, random.uniform(.5, 3)) if random.random() < p: image = TF.adjust_contrast(image, random.uniform(.5, 3)) image = TF.to_tensor(image) segmentation = TF.to_tensor(seg) image = TF.normalize(image, mean=imgNetMean, std=imgNetStd) return image, segmentation
def __getitem__(self, index): left = self.left[index] right = self.right[index] disp_L = self.disp_L[index] left_img = self.loader(left) right_img = self.loader(right) dataL = self.dploader(disp_L) dataL = np.clip(dataL, 0, 192) stddev = np.random.uniform(5,10) factor = 1. + random.uniform(-0.5, 0.5) left_img = adjust_brightness(left_img, factor) right_img = adjust_brightness(right_img, factor) factor = 1. + random.uniform(-0.5, 0.5) left_img = adjust_contrast(left_img, factor) right_img = adjust_contrast(right_img, factor) left_img = np.asarray(left_img) right_img = np.asarray(right_img) noise = np.random.normal(0, stddev, left_img.shape) left_img = np.clip(left_img + noise, 0, 255) noise = np.random.normal(0, stddev, left_img.shape) right_img = np.clip(right_img + noise, 0, 255) left_img = motion_blur(left_img) right_img = motion_blur(right_img) left_img = Image.fromarray(np.uint8(left_img)) right_img = Image.fromarray(np.uint8(right_img)) dataL = np.ascontiguousarray(dataL, dtype=np.float32) processed = preprocess.get_transform( augment=False, normalize=self.normalize) left_img = processed(left_img) right_img = processed(right_img) return left_img, right_img, dataL
def __call__(self, input, target): #Horizontal flip if h_flip: flip = random.random() < 0.5 if flip: input=input.transpose(Image.FLIP_LEFT_RIGHT) target = target.transpose(Image.FLIP_LEFT_RIGHT) #Vertical flip if v_flip: flip = random.random() < 0.5 if flip: input = input.transpose(Image.FLIP_TOP_BOTTOM) target = target.transpose(Image.FLIP_TOP_BOTTOM) #RandomCrop if Random_crop: i, j, h, w = transforms.RandomCrop.get_params(input, output_size=(224, 224)) input = TF.crop(input, i, j, h, w) target = TF.crop(target, i, j, h, w) #RandomRotation i = transforms.RandomRotation.get_params(angle) input = TF.rotate(input, i) target = TF.rotate(target, i) #ColorJitter b,c,s,h=transforms.ColorJitter.get_params(ColorJitter[0],ColorJitter[1],ColorJitter[2],ColorJitter[3]) input=TF.adjust_brightness(input,b) input=TF.adjust_contrast(input,c) input = TF.adjust_saturation(input, s) input = TF.adjust_hue(input, h) target=TF.adjust_brightness(target,b) target=TF.adjust_contrast(target,c) target = TF.adjust_saturation(target, s) target = TF.adjust_hue(target, h) return input, target
def forward(self, img): """ Args: img (PIL Image or Tensor): Input image. Returns: PIL Image or Tensor: Color jittered image. """ #Check if image is bright enough #code form https://stackoverflow.com/questions/3490727/what-are-some-methods-to-analyze-image-brightness-using-python im = img.convert('L') stat = ImageStat.Stat(im) #print(stat.rms[0]) fn_idx, brightness_factor, contrast_factor, saturation_factor, hue_factor = \ self.get_params(self.brightness, self.contrast, self.saturation, self.hue) for fn_id in fn_idx: if fn_id == 0 and brightness_factor is not None and ( stat.rms[0] >= 50 or brightness_factor >= 1): img = functional.adjust_brightness(img, brightness_factor) elif fn_id == 1 and contrast_factor is not None and ( stat.rms[0] >= 50 or contrast_factor >= 1): img = functional.adjust_contrast(img, contrast_factor) elif fn_id == 2 and saturation_factor is not None: img = functional.adjust_saturation(img, saturation_factor) elif fn_id == 3 and hue_factor is not None: img = functional.adjust_hue(img, hue_factor) return img
def randomize_parameters(self): self.p = random.random() brightness_factor = random.uniform(self.brightness[0], self.brightness[1]) contrast_factor = random.uniform(self.contrast[0], self.contrast[1]) saturation_factor = random.uniform(self.saturation[0], self.saturation[1]) hue_factor = random.uniform(self.hue[0], self.hue[1]) transforms = [] transforms.append( torchvision.transforms.Lambda( lambda img: F.adjust_brightness(img, brightness_factor))) transforms.append( torchvision.transforms.Lambda( lambda img: F.adjust_contrast(img, contrast_factor))) transforms.append( torchvision.transforms.Lambda( lambda img: F.adjust_saturation(img, saturation_factor))) transforms.append( torchvision.transforms.Lambda( lambda img: F.adjust_hue(img, hue_factor))) random.shuffle(transforms) self.transform = torchvision.transforms.Compose(transforms)
def augmentations(img): crop_h = 32 crop_w = 128 i = torch.randint(height - crop_h + 1, size=(1, )).item() j = torch.randint(width - crop_w + 1, size=(1, )).item() img = F2.crop(img, i, j, crop_h, crop_w) img = F2.resize(img, (height, width)) fn_idx = torch.randperm(4) for fn_id in fn_idx: if fn_id == 0 and torch.rand(1) < 0.2: brg = float(torch.empty(1).uniform_(0.6, 2)) img = F2.adjust_brightness(img, brg) elif fn_id == 1 and torch.rand(1) < 0.2: con = float(torch.empty(1).uniform_(0.6, 2)) img = F2.adjust_contrast(img, con) elif fn_id == 2 and torch.rand(1) < 0.2: sat = float(torch.empty(1).uniform_(0.6, 2)) img = F2.adjust_saturation(img, sat) elif fn_id == 3 and torch.rand(1) < 0.2: hue = float(torch.empty(1).uniform_(-0.5, 0.5)) img = F2.adjust_hue(img, hue) if torch.rand(1) < 0.2: img = F2.hflip(img) if torch.rand(1) < 0.2: img = F2.vflip(img) return img
def get_params(brightness, contrast, saturation, hue): """Get a randomized transform to be applied on image. Arguments are same as that of __init__. Returns: Transform which randomly adjusts brightness, contrast and saturation in a random order. """ transforms = [] if brightness > 0: brightness_factor = random.uniform(max(0, 1 - brightness), 1 + brightness) transforms.append(Lambda(lambda img: F.adjust_brightness(img, brightness_factor))) if contrast > 0: contrast_factor = random.uniform(max(0, 1 - contrast), 1 + contrast) transforms.append(Lambda(lambda img: F.adjust_contrast(img, contrast_factor))) if saturation > 0: saturation_factor = random.uniform(max(0, 1 - saturation), 1 + saturation) transforms.append(Lambda(lambda img: F.adjust_saturation(img, saturation_factor))) if hue > 0: hue_factor = random.uniform(-hue, hue) transforms.append(Lambda(lambda img: F.adjust_hue(img, hue_factor))) random.shuffle(transforms) transform = Compose(transforms) return transform
def randomize_parameters(self): transforms = [] if self.brightness is not None: brightness_factor = random.uniform(self.brightness[0], self.brightness[1]) transforms.append( Lambda( lambda img: F.adjust_brightness(img, brightness_factor))) if self.contrast is not None: contrast_factor = random.uniform(self.contrast[0], self.contrast[1]) transforms.append( Lambda(lambda img: F.adjust_contrast(img, contrast_factor))) if self.saturation is not None: saturation_factor = random.uniform(self.saturation[0], self.saturation[1]) transforms.append( Lambda( lambda img: F.adjust_saturation(img, saturation_factor))) if self.hue is not None: hue_factor = random.uniform(self.hue[0], self.hue[1]) transforms.append( Lambda(lambda img: F.adjust_hue(img, hue_factor))) random.shuffle(transforms) self.transform = Compose(transforms)
def adjust_contrast(self, img, do, prob, cf): if do: if random.random() < prob: c = random.uniform(1 - cf, 1 + cf) # -7,7 img = tff.adjust_contrast(img, contrast_factor=c) return img
def __call__(self, image, target): if self.prob == 0: return image, target if random.random() < self.prob: factor = np.random.uniform(0.25, 0.75) image = F.adjust_contrast(image, factor) return image, target
def forward(self, img, mask): """ Args: img (PIL Image or Tensor): Input image. Returns: PIL Image or Tensor: Color jittered image. """ fn_idx = torch.randperm(4) for fn_id in fn_idx: if fn_id == 0 and self.brightness is not None: brightness = self.brightness brightness_factor = torch.tensor(1.0).uniform_( brightness[0], brightness[1]).item() img = F.adjust_brightness(img, brightness_factor) if fn_id == 1 and self.contrast is not None: contrast = self.contrast contrast_factor = torch.tensor(1.0).uniform_( contrast[0], contrast[1]).item() img = F.adjust_contrast(img, contrast_factor) if fn_id == 2 and self.saturation is not None: saturation = self.saturation saturation_factor = torch.tensor(1.0).uniform_( saturation[0], saturation[1]).item() img = F.adjust_saturation(img, saturation_factor) if fn_id == 3 and self.hue is not None: hue = self.hue hue_factor = torch.tensor(1.0).uniform_(hue[0], hue[1]).item() img = F.adjust_hue(img, hue_factor) return img, mask
def get_params(brightness, contrast, saturation, hue): """Get a randomized transform to be applied on image. Arguments are same as that of __init__. Returns: Transform which randomly adjusts brightness, contrast and saturation in a random order. """ transforms = [] if brightness is not None: brightness_factor = random.uniform(brightness[0], brightness[1]) transforms.append(torchvision.transforms.Lambda(lambda img: F.adjust_brightness(img, brightness_factor))) if contrast is not None: contrast_factor = random.uniform(contrast[0], contrast[1]) transforms.append(torchvision.transforms.Lambda(lambda img: F.adjust_contrast(img, contrast_factor))) if saturation is not None: saturation_factor = random.uniform(saturation[0], saturation[1]) transforms.append(torchvision.transforms.Lambda(lambda img: F.adjust_saturation(img, saturation_factor))) if hue is not None: hue_factor = random.uniform(hue[0], hue[1]) transforms.append(torchvision.transforms.Lambda(lambda img: F.adjust_hue(img, hue_factor))) random.shuffle(transforms) transform = torchvision.transforms.Compose(transforms) return transform
def forward(self, img): brightness_factor, contrast_factor, saturation_factor, hue_factor = 0, 0, 0, 0 fn_idx = torch.randperm(4) for fn_id in fn_idx: if fn_id == 0 and self.brightness is not None: brightness = self.brightness brightness_factor = torch.tensor(1.0).uniform_(brightness[0], brightness[1]).item() img = F.adjust_brightness(img, brightness_factor) if fn_id == 1 and self.contrast is not None: contrast = self.contrast contrast_factor = torch.tensor(1.0).uniform_(contrast[0], contrast[1]).item() img = F.adjust_contrast(img, contrast_factor) if fn_id == 2 and self.saturation is not None: saturation = self.saturation saturation_factor = torch.tensor(1.0).uniform_(saturation[0], saturation[1]).item() img = F.adjust_saturation(img, saturation_factor) if fn_id == 3 and self.hue is not None: hue = self.hue hue_factor = torch.tensor(1.0).uniform_(hue[0], hue[1]).item() img = F.adjust_hue(img, hue_factor) return img, [brightness_factor, contrast_factor, saturation_factor, hue_factor]
def __call__(self, x, params=None): """ Args: x (numpy.ndarray or list): Image (H x W x C) or pose (3) or bounding box (4) Returns: numpy.ndarray or list: Transformed images. """ if params is None: params = self.get_params(self.brightness, self.contrast, self.saturation, self.hue) fn_idx, brightness_factor, contrast_factor, saturation_factor, hue_factor = params if is_img(x): # x is an image x = Image.fromarray(x) for fn_id in fn_idx: if fn_id == 0 and brightness_factor is not None: x = F.adjust_brightness(x, brightness_factor) elif fn_id == 1 and contrast_factor is not None: x = F.adjust_contrast(x, contrast_factor) elif fn_id == 2 and saturation_factor is not None: x = F.adjust_saturation(x, saturation_factor) elif fn_id == 3 and hue_factor is not None: x = F.adjust_hue(x, hue_factor) return np.array(x) elif isinstance(x, (list, tuple)): return [self.__call__(a, None if self.randomize_per_image else params) for a in x] return x
def augment_PIL(self, img, labels): if np.random.rand() > 0.4: img = tvf.adjust_brightness(img, uniform(0.3, 1.5)) if np.random.rand() > 0.7: factor = 2**uniform(-1, 1) img = tvf.adjust_contrast(img, factor) # 0.5 ~ 2 if np.random.rand() > 0.7: img = tvf.adjust_hue(img, uniform(-0.1, 0.1)) if np.random.rand() > 0.6: factor = uniform(0, 2) if factor > 1: factor = 1 + uniform(0, 2) img = tvf.adjust_saturation(img, factor) # 0 ~ 3 if np.random.rand() > 0.5: img = tvf.adjust_gamma(img, uniform(0.5, 3)) # horizontal flip if np.random.rand() > 0.5: img, labels = augUtils.hflip(img, labels) # vertical flip if np.random.rand() > 0.5: img, labels = augUtils.vflip(img, labels) # # random rotation rand_degree = np.random.rand() * 360 if self.coco: img, labels = augUtils.rotate(img, rand_degree, labels, expand=True) else: img, labels = augUtils.rotate(img, rand_degree, labels, expand=False) return img, labels
def get_params(brightness, contrast, saturation): """Get a randomized transform to be applied on image. Arguments are same as that of __init__. Returns: Transform which randomly adjusts brightness, contrast and saturation in a random order. """ transforms = [] if brightness is not None: brightness_factor = random.gauss(brightness[0], brightness[1]) transforms.append( Lambda(lambda img: adjust_brightness(img, brightness_factor))) if contrast is not None: contrast_factor = random.gauss(contrast[0], contrast[1]) transforms.append( Lambda(lambda img: adjust_contrast(img, contrast_factor))) if saturation is not None: saturation_factor = random.gauss(saturation[0], saturation[1]) transforms.append( Lambda(lambda img: adjust_saturation(img, saturation_factor))) random.shuffle(transforms) transform = Compose(transforms) print(brightness_factor) return transform
def __call__(self, img): contrast_factor = np.random.uniform(self.low, self.high) if not isinstance(img, Image.Image): img = np.clip(img * 255, 0, 255).astype(np.uint8) img = Image.fromarray(img) img = functional.adjust_contrast(img, contrast_factor) return img
def recolor(im, recolor_net, aug=False): N = im.shape[0] if aug: im_ = [] for i in range(N): im_i = im[i] brightness_factor = float(torch.Tensor(1).uniform_(0.8, 1.2)) contrast_factor = float(torch.Tensor(1).uniform_(0.8, 1.2)) gamma = float(torch.Tensor(1).uniform_(0.8, 1.2)) hue_factor = float(torch.Tensor(1).uniform_(-0.1, 0.1)) im_i = Ft.adjust_brightness(im_i, brightness_factor) im_i = Ft.adjust_contrast(im_i, contrast_factor) im_i = Ft.to_tensor( Ft.adjust_gamma(Ft.to_pil_image(im_i.cpu()), gamma)).cuda() im_i = Ft.to_tensor( Ft.adjust_hue(Ft.to_pil_image(im_i.cpu()), hue_factor)).cuda() im_.append(im_i) im = torch.stack(im_, dim=0) imout = recolor_net(im - 0.5) + im - 0.5 imout = F.sigmoid(imout * 5) return imout
def adjustContrast(self, image, mask): factor = transforms.RandomRotation.get_params([0, 10]) # 这里调增广后的数据的对比度 image = tf.adjust_contrast(image, factor) # mask = tf.adjust_contrast(mask,factor) image = tf.to_tensor(image) mask = tf.to_tensor(mask) return image, mask
def test_adjusts_L_mode(self): x_shape = [2, 2, 3] x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape) x_rgb = Image.fromarray(x_np, mode='RGB') x_l = x_rgb.convert('L') assert F.adjust_brightness(x_l, 2).mode == 'L' assert F.adjust_saturation(x_l, 2).mode == 'L' assert F.adjust_contrast(x_l, 2).mode == 'L' assert F.adjust_hue(x_l, 0.4).mode == 'L' assert F.adjust_gamma(x_l, 0.5).mode == 'L'
def test_adjust_contrast(self): x_shape = [2, 2, 3] x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape) x_pil = Image.fromarray(x_np, mode='RGB') # test 0 y_pil = F.adjust_contrast(x_pil, 1) y_np = np.array(y_pil) assert np.allclose(y_np, x_np) # test 1 y_pil = F.adjust_contrast(x_pil, 0.5) y_np = np.array(y_pil) y_ans = [43, 45, 49, 70, 110, 156, 61, 47, 160, 88, 170, 43] y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) assert np.allclose(y_np, y_ans) # test 2 y_pil = F.adjust_contrast(x_pil, 2) y_np = np.array(y_pil) y_ans = [0, 0, 0, 22, 184, 255, 0, 0, 255, 94, 255, 0] y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) assert np.allclose(y_np, y_ans)