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_brightness(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_brightness(x_pil, 1) y_np = np.array(y_pil) assert np.allclose(y_np, x_np) # test 1 y_pil = F.adjust_brightness(x_pil, 0.5) y_np = np.array(y_pil) y_ans = [0, 2, 6, 27, 67, 113, 18, 4, 117, 45, 127, 0] 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_brightness(x_pil, 2) y_np = np.array(y_pil) y_ans = [0, 10, 26, 108, 255, 255, 74, 16, 255, 180, 255, 2] y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) assert np.allclose(y_np, y_ans)
def __call__(self, img, mask): assert img.size == mask.size return tf.adjust_brightness(img, random.uniform(1 - self.bf, 1 + self.bf)), mask
def __call__(self, x): x = TF.adjust_gamma(x, gamma=1) x = TF.adjust_saturation(x, self.saturation_factor) x = TF.adjust_brightness(x, self.brightness_factor) x = TF.adjust_contrast(x, self.contrast_factor) return x
def __call__(self, inputs): img1 = inputs[0] img2 = inputs[1] depth = inputs[2] phase = inputs[3] fb = inputs[4] h = img1.height w = img1.width w0 = w if self.size == [-1]: divisor = 32.0 h = int(math.ceil(h / divisor) * divisor) w = int(math.ceil(w / divisor) * divisor) self.size = (h, w) scale_transform = transforms.Compose( [transforms.Resize(self.size, Image.BICUBIC)]) img1 = scale_transform(img1) if img2 is not None: img2 = scale_transform(img2) if fb is not None: scale = float(self.size[1]) / float(w0) fb = fb * scale if phase == 'test': return img1, img2, depth, fb if depth is not None: scale_transform_d = transforms.Compose( [transforms.Resize(self.size, Image.BICUBIC)]) depth = scale_transform_d(depth) if not self.size == 0: if depth is not None: arr_depth = np.array(depth, dtype=np.float32) arr_depth /= 65535.0 # cm->m, /10 arr_depth[arr_depth < 0.0] = 0.0 depth = Image.fromarray(arr_depth, 'F') if self.flip and not (img2 is not None and depth is not None): flip_prob = random.random() flip_transform = transforms.Compose( [RandomHorizontalFlip(flip_prob)]) if img2 is None: img1 = flip_transform(img1) else: if flip_prob < 0.5: img1_ = img1 img2_ = img2 img1 = flip_transform(img2_) img2 = flip_transform(img1_) if depth is not None: depth = flip_transform(depth) if self.rotation and not (img2 is not None and depth is not None): if random.random() < 0.5: degree = random.randrange(-500, 500) / 100 img1 = F.rotate(img1, degree, Image.BICUBIC) if depth is not None: depth = F.rotate(depth, degree, Image.BILINEAR) if img2 is not None: img2 = F.rotate(img2, degree, Image.BICUBIC) if depth is not None: depth = np.array(depth, dtype=np.float32) depth = depth * 2.0 depth -= 1.0 if self.augment: if random.random() < 0.5: brightness = random.uniform(0.8, 1.0) contrast = random.uniform(0.8, 1.0) saturation = random.uniform(0.8, 1.0) img1 = F.adjust_brightness(img1, brightness) img1 = F.adjust_contrast(img1, contrast) img1 = F.adjust_saturation(img1, saturation) if img2 is not None: img2 = F.adjust_brightness(img2, brightness) img2 = F.adjust_contrast(img2, contrast) img2 = F.adjust_saturation(img2, saturation) return img1, img2, depth, fb
def apply_data_augmentation(img, da_config): applied_da = list() # Convert to PIL Image img = img[:, :, 0] if img.shape[2] == 1 else img img = Image.fromarray(img) # Apply data augmentation if "dpi" in da_config.keys( ) and np.random.rand() < da_config["dpi"]["proba"]: valid_factor = False while not valid_factor: factor = np.random.uniform(da_config["dpi"]["min_factor"], da_config["dpi"]["max_factor"]) valid_factor = True if ("max_width" in da_config["dpi"].keys() and factor*img.size[0] > da_config["dpi"]["max_width"]) or \ ("max_height" in da_config["dpi"].keys() and factor * img.size[1] > da_config["dpi"]["max_height"]): valid_factor = False if ("min_width" in da_config["dpi"].keys() and factor*img.size[0] < da_config["dpi"]["min_width"]) or \ ("min_height" in da_config["dpi"].keys() and factor * img.size[1] < da_config["dpi"]["min_height"]): valid_factor = False img = DPIAdjusting(factor)(img) applied_da.append("dpi: factor {}".format(factor)) if "perspective" in da_config.keys( ) and np.random.rand() < da_config["perspective"]["proba"]: scale = np.random.uniform(da_config["perspective"]["min_factor"], da_config["perspective"]["max_factor"]) img = RandomPerspective(distortion_scale=scale, p=1, interpolation=Image.BILINEAR, fill=255)(img) applied_da.append("perspective: scale {}".format(scale)) elif "elastic_distortion" in da_config.keys( ) and np.random.rand() < da_config["elastic_distortion"]["proba"]: magnitude = np.random.randint( 1, da_config["elastic_distortion"]["max_magnitude"] + 1) kernel = np.random.randint( 1, da_config["elastic_distortion"]["max_kernel"] + 1) magnitude_w, magnitude_h = ( magnitude, 1) if np.random.randint(2) == 0 else (1, magnitude) img = ElasticDistortion(grid=(kernel, kernel), magnitude=(magnitude_w, magnitude_h), min_sep=(1, 1))(img) applied_da.append( "elastic_distortion: magnitude ({}, {}) - kernel ({}, {})".format( magnitude_w, magnitude_h, kernel, kernel)) elif "random_transform" in da_config.keys( ) and np.random.rand() < da_config["random_transform"]["proba"]: img = RandomTransform(da_config["random_transform"]["max_val"])(img) applied_da.append("random_transform") if "dilation_erosion" in da_config.keys( ) and np.random.rand() < da_config["dilation_erosion"]["proba"]: kernel_h = np.random.randint( da_config["dilation_erosion"]["min_kernel"], da_config["dilation_erosion"]["max_kernel"] + 1) kernel_w = np.random.randint( da_config["dilation_erosion"]["min_kernel"], da_config["dilation_erosion"]["max_kernel"] + 1) if np.random.randint(2) == 0: img = Erosion((kernel_w, kernel_h), da_config["dilation_erosion"]["iterations"])(img) applied_da.append("erosion: kernel ({}, {})".format( kernel_w, kernel_h)) else: img = Dilation((kernel_w, kernel_h), da_config["dilation_erosion"]["iterations"])(img) applied_da.append("dilation: kernel ({}, {})".format( kernel_w, kernel_h)) if "contrast" in da_config.keys( ) and np.random.rand() < da_config["contrast"]["proba"]: factor = np.random.uniform(da_config["contrast"]["min_factor"], da_config["contrast"]["max_factor"]) img = adjust_contrast(img, factor) applied_da.append("contrast: factor {}".format(factor)) if "brightness" in da_config.keys( ) and np.random.rand() < da_config["brightness"]["proba"]: factor = np.random.uniform(da_config["brightness"]["min_factor"], da_config["brightness"]["max_factor"]) img = adjust_brightness(img, factor) applied_da.append("brightness: factor {}".format(factor)) if "color_jittering" in da_config.keys( ) and np.random.rand() < da_config["color_jittering"]["proba"]: img = ColorJitter( contrast=da_config["color_jittering"]["factor_contrast"], brightness=da_config["color_jittering"]["factor_brightness"], saturation=da_config["color_jittering"]["factor_saturation"], hue=da_config["color_jittering"]["factor_hue"], )(img) applied_da.append("jittering") if "sign_flipping" in da_config.keys( ) and np.random.rand() < da_config["sign_flipping"]["proba"]: img = SignFlipping()(img) applied_da.append("sign_flipping") if "crop" in da_config.keys( ) and np.random.rand() < da_config["crop"]["proba"]: new_w, new_h = [int(t * da_config["crop"]["ratio"]) for t in img.size] img = RandomCrop((new_h, new_w))(img) applied_da.append("random_crop") elif "fixed_crop" in da_config.keys( ) and np.random.rand() < da_config["fixed_crop"]["proba"]: img = RandomCrop( (da_config["fixed_crop"]["h"], da_config["fixed_crop"]["w"]))(img) applied_da.append("fixed_crop") # convert to numpy array img = np.array(img) img = np.expand_dims(img, axis=2) if len(img.shape) == 2 else img return img, applied_da
def torchvision(self, img): img = torchvision.adjust_brightness(img, brightness_factor=1.5) img = torchvision.adjust_contrast(img, contrast_factor=1.5) return img
def __getitem__(self, index): ' Get sample' # Load image id = self.ids[index] if self.coco: image = self.coco.loadImgs(id)[0]['file_name'] im = Image.open('{}/{}'.format(self.path, image)).convert("RGB") # Randomly sample scale for resize during training resize = self.resize if isinstance(resize, list): resize = random.randint(self.resize[0], self.resize[-1]) ratio = resize / min(im.size) if ratio * max(im.size) > self.max_size: ratio = self.max_size / max(im.size) im = im.resize((int(ratio * d) for d in im.size), Image.BILINEAR) if self.training: # Get annotations boxes, categories = self._get_target(id) boxes *= ratio # Random rotation, if self.rotate_augment random_angle = random.randint(0, 3) * 90 if self.rotate_augment and random_angle != 0: # rotate by random_angle degrees. im = im.rotate(random_angle) x, y, w, h = boxes[:, 0].clone(), boxes[:, 1].clone( ), boxes[:, 2].clone(), boxes[:, 3].clone() if random_angle == 90: boxes[:, 0] = y boxes[:, 1] = im.size[1] - x - w boxes[:, 2] = h boxes[:, 3] = w elif random_angle == 180: boxes[:, 0] = im.size[0] - x - w boxes[:, 1] = im.size[1] - y - h elif random_angle == 270: boxes[:, 0] = im.size[0] - y - h boxes[:, 1] = x boxes[:, 2] = h boxes[:, 3] = w # Random horizontal flip if random.randint(0, 1): im = im.transpose(Image.FLIP_LEFT_RIGHT) boxes[:, 0] = im.size[0] - boxes[:, 0] - boxes[:, 2] # Apply image brightness, contrast etc augmentation if self.augment_brightness: brightness_factor = random.normalvariate( 1, self.augment_brightness) brightness_factor = max(0, brightness_factor) im = adjust_brightness(im, brightness_factor) if self.augment_contrast: contrast_factor = random.normalvariate(1, self.augment_contrast) contrast_factor = max(0, contrast_factor) im = adjust_contrast(im, contrast_factor) if self.augment_hue: hue_factor = random.normalvariate(0, self.augment_hue) hue_factor = max(-0.5, hue_factor) hue_factor = min(0.5, hue_factor) im = adjust_hue(im, hue_factor) if self.augment_saturation: saturation_factor = random.normalvariate( 1, self.augment_saturation) saturation_factor = max(0, saturation_factor) im = adjust_saturation(im, saturation_factor) target = torch.cat([boxes, categories], dim=1) # Convert to tensor and normalize data = torch.ByteTensor(torch.ByteStorage.from_buffer(im.tobytes())) data = data.float().div(255).view(*im.size[::-1], len(im.mode)) data = data.permute(2, 0, 1) for t, mean, std in zip(data, self.mean, self.std): t.sub_(mean).div_(std) # Apply padding pw, ph = ((self.stride - d % self.stride) % self.stride for d in im.size) data = F.pad(data, (0, pw, 0, ph)) if self.training: return data, target return data, id, ratio
def __call__(self, input: Tensor) -> Tensor: return TF.adjust_brightness(input, self.brightness_factor)
def Adjust_brightness(image): return F.adjust_brightness(image, 1.9)
def __call__(self, imgs): return [ F.adjust_brightness(img=img, brightness_factor=self.bright_factor) for img in imgs ]
def __call__(self, sample): image, target = sample['image'], sample['target'] # 0 gives a black image, 1 gives the original image while 2 increases the brightness by a factor of 2. ratio = random.randint(8, 12) / 10 image = tf.adjust_brightness(image, ratio) return {'image': image, 'target': target}
def __getitem__(self, index): if self.test: g = self.X_test.get_group(self.keys[index]) cont_gaze = [] for i, row in g.iterrows(): path = row['path'] x_min = row['bbox_x_min'] y_min = row['bbox_y_min'] x_max = row['bbox_x_max'] y_max = row['bbox_y_max'] eye_x = row['eye_x'] eye_y = row['eye_y'] gaze_x = row['gaze_x'] gaze_y = row['gaze_y'] cont_gaze.append([gaze_x, gaze_y ]) # all ground truth gaze are stacked up for j in range(len(cont_gaze), 20): cont_gaze.append( [-1, -1]) # pad dummy gaze to match size for batch processing cont_gaze = torch.FloatTensor(cont_gaze) gaze_inside = True # always consider test samples as inside else: path = self.X_train.iloc[index] x_min, y_min, x_max, y_max, eye_x, eye_y, gaze_x, gaze_y, inout = self.y_train.iloc[ index] gaze_inside = bool(inout) # expand face bbox a bit k = 0.1 x_min -= k * abs(x_max - x_min) y_min -= k * abs(y_max - y_min) x_max += k * abs(x_max - x_min) y_max += k * abs(y_max - y_min) img = Image.open(os.path.join(self.data_dir, path)) img = img.convert('RGB') width, height = img.size x_min, y_min, x_max, y_max = map(float, [x_min, y_min, x_max, y_max]) if self.imshow: img.save("origin_img.jpg") if self.test: imsize = torch.IntTensor([width, height]) else: ## data augmentation # Jitter (expansion-only) bounding box size if np.random.random_sample() <= 0.5: k = np.random.random_sample() * 0.2 x_min -= k * abs(x_max - x_min) y_min -= k * abs(y_max - y_min) x_max += k * abs(x_max - x_min) y_max += k * abs(y_max - y_min) # Random Crop if np.random.random_sample() <= 0.5: # Calculate the minimum valid range of the crop that doesn't exclude the face and the gaze target crop_x_min = np.min([gaze_x * width, x_min, x_max]) crop_y_min = np.min([gaze_y * height, y_min, y_max]) crop_x_max = np.max([gaze_x * width, x_min, x_max]) crop_y_max = np.max([gaze_y * height, y_min, y_max]) # Randomly select a random top left corner if crop_x_min >= 0: crop_x_min = np.random.uniform(0, crop_x_min) if crop_y_min >= 0: crop_y_min = np.random.uniform(0, crop_y_min) # Find the range of valid crop width and height starting from the (crop_x_min, crop_y_min) crop_width_min = crop_x_max - crop_x_min crop_height_min = crop_y_max - crop_y_min crop_width_max = width - crop_x_min crop_height_max = height - crop_y_min # Randomly select a width and a height crop_width = np.random.uniform(crop_width_min, crop_width_max) crop_height = np.random.uniform(crop_height_min, crop_height_max) # Crop it img = TF.crop(img, crop_y_min, crop_x_min, crop_height, crop_width) # Record the crop's (x, y) offset offset_x, offset_y = crop_x_min, crop_y_min # convert coordinates into the cropped frame x_min, y_min, x_max, y_max = x_min - offset_x, y_min - offset_y, x_max - offset_x, y_max - offset_y # if gaze_inside: gaze_x, gaze_y = (gaze_x * width - offset_x) / float(crop_width), \ (gaze_y * height - offset_y) / float(crop_height) # else: # gaze_x = -1; gaze_y = -1 width, height = crop_width, crop_height # Random flip if np.random.random_sample() <= 0.5: img = img.transpose(Image.FLIP_LEFT_RIGHT) x_max_2 = width - x_min x_min_2 = width - x_max x_max = x_max_2 x_min = x_min_2 gaze_x = 1 - gaze_x # Random color change if np.random.random_sample() <= 0.5: img = TF.adjust_brightness(img, brightness_factor=np.random.uniform( 0.5, 1.5)) img = TF.adjust_contrast(img, contrast_factor=np.random.uniform( 0.5, 1.5)) img = TF.adjust_saturation(img, saturation_factor=np.random.uniform( 0, 1.5)) head_channel = imutils.get_head_box_channel( x_min, y_min, x_max, y_max, width, height, resolution=self.input_size, coordconv=False).unsqueeze(0) # Crop the face face = img.crop((int(x_min), int(y_min), int(x_max), int(y_max))) if self.imshow: img.save("img_aug.jpg") face.save('face_aug.jpg') if self.transform is not None: img = self.transform(img) face = self.transform(face) # generate the heat map used for deconv prediction gaze_heatmap = torch.zeros( self.output_size, self.output_size) # set the size of the output if self.test: # aggregated heatmap num_valid = 0 for gaze_x, gaze_y in cont_gaze: if gaze_x != -1: num_valid += 1 gaze_heatmap = imutils.draw_labelmap( gaze_heatmap, [gaze_x * self.output_size, gaze_y * self.output_size], 3, type='Gaussian') gaze_heatmap /= num_valid else: # if gaze_inside: gaze_heatmap = imutils.draw_labelmap( gaze_heatmap, [gaze_x * self.output_size, gaze_y * self.output_size], 3, type='Gaussian') if self.imshow: fig = plt.figure(111) img = 255 - imutils.unnorm(img.numpy()) * 255 img = np.clip(img, 0, 255) plt.imshow(np.transpose(img, (1, 2, 0))) plt.imshow(imresize(gaze_heatmap, (self.input_size, self.input_size)), cmap='jet', alpha=0.3) plt.imshow(imresize(1 - head_channel.squeeze(0), (self.input_size, self.input_size)), alpha=0.2) plt.savefig('viz_aug.png') if self.test: return img, face, head_channel, gaze_heatmap, cont_gaze, imsize, path else: return img, face, head_channel, gaze_heatmap, path, gaze_inside
def __getitem__(self, index): sequence_path = self.all_sequence_paths[index] df = pd.read_csv( sequence_path, header=None, index_col=False, names=['path', 'xmin', 'ymin', 'xmax', 'ymax', 'gazex', 'gazey']) show_name = sequence_path.split('/')[-3] clip = sequence_path.split('/')[-2] seq_len = len(df.index) # moving-avg smoothing window_size = 11 # should be odd number df['xmin'] = myutils.smooth_by_conv(window_size, df, 'xmin') df['ymin'] = myutils.smooth_by_conv(window_size, df, 'ymin') df['xmax'] = myutils.smooth_by_conv(window_size, df, 'xmax') df['ymax'] = myutils.smooth_by_conv(window_size, df, 'ymax') if not self.test: # cond for data augmentation cond_jitter = np.random.random_sample() cond_flip = np.random.random_sample() cond_color = np.random.random_sample() if cond_color < 0.5: n1 = np.random.uniform(0.5, 1.5) n2 = np.random.uniform(0.5, 1.5) n3 = np.random.uniform(0.5, 1.5) cond_crop = np.random.random_sample() # if longer than seq_len_limit, cut it down to the limit with the init index randomly sampled if seq_len > self.seq_len_limit: sampled_ind = np.random.randint(0, seq_len - self.seq_len_limit) seq_len = self.seq_len_limit else: sampled_ind = 0 if cond_crop < 0.5: sliced_x_min = df['xmin'].iloc[sampled_ind:sampled_ind + seq_len] sliced_x_max = df['xmax'].iloc[sampled_ind:sampled_ind + seq_len] sliced_y_min = df['ymin'].iloc[sampled_ind:sampled_ind + seq_len] sliced_y_max = df['ymax'].iloc[sampled_ind:sampled_ind + seq_len] sliced_gaze_x = df['gazex'].iloc[sampled_ind:sampled_ind + seq_len] sliced_gaze_y = df['gazey'].iloc[sampled_ind:sampled_ind + seq_len] check_sum = sliced_gaze_x.sum() + sliced_gaze_y.sum() all_outside = check_sum == -2 * seq_len # Calculate the minimum valid range of the crop that doesn't exclude the face and the gaze target if all_outside: crop_x_min = np.min( [sliced_x_min.min(), sliced_x_max.min()]) crop_y_min = np.min( [sliced_y_min.min(), sliced_y_max.min()]) crop_x_max = np.max( [sliced_x_min.max(), sliced_x_max.max()]) crop_y_max = np.max( [sliced_y_min.max(), sliced_y_max.max()]) else: crop_x_min = np.min([ sliced_gaze_x.min(), sliced_x_min.min(), sliced_x_max.min() ]) crop_y_min = np.min([ sliced_gaze_y.min(), sliced_y_min.min(), sliced_y_max.min() ]) crop_x_max = np.max([ sliced_gaze_x.max(), sliced_x_min.max(), sliced_x_max.max() ]) crop_y_max = np.max([ sliced_gaze_y.max(), sliced_y_min.max(), sliced_y_max.max() ]) # Randomly select a random top left corner if crop_x_min >= 0: crop_x_min = np.random.uniform(0, crop_x_min) if crop_y_min >= 0: crop_y_min = np.random.uniform(0, crop_y_min) # Get image size path = os.path.join(self.data_dir, show_name, clip, df['path'].iloc[0]) img = Image.open(path) img = img.convert('RGB') width, height = img.size # Find the range of valid crop width and height starting from the (crop_x_min, crop_y_min) crop_width_min = crop_x_max - crop_x_min crop_height_min = crop_y_max - crop_y_min crop_width_max = width - crop_x_min crop_height_max = height - crop_y_min # Randomly select a width and a height crop_width = np.random.uniform(crop_width_min, crop_width_max) crop_height = np.random.uniform(crop_height_min, crop_height_max) else: sampled_ind = 0 faces, images, head_channels, heatmaps, paths, gazes, imsizes, gaze_inouts = [], [], [], [], [], [], [], [] index_tracker = -1 for i, row in df.iterrows(): index_tracker = index_tracker + 1 if not self.test: if index_tracker < sampled_ind or index_tracker >= ( sampled_ind + self.seq_len_limit): continue face_x1 = row['xmin'] # note: Already in image coordinates face_y1 = row['ymin'] # note: Already in image coordinates face_x2 = row['xmax'] # note: Already in image coordinates face_y2 = row['ymax'] # note: Already in image coordinates gaze_x = row['gazex'] # note: Already in image coordinates gaze_y = row['gazey'] # note: Already in image coordinates impath = os.path.join(self.data_dir, show_name, clip, row['path']) img = Image.open(impath) img = img.convert('RGB') width, height = img.size imsize = torch.FloatTensor([width, height]) # imsizes.append(imsize) face_x1, face_y1, face_x2, face_y2 = map( float, [face_x1, face_y1, face_x2, face_y2]) gaze_x, gaze_y = map(float, [gaze_x, gaze_y]) if gaze_x == -1 and gaze_y == -1: gaze_inside = False else: if gaze_x < 0: # move gaze point that was sliglty outside the image back in gaze_x = 0 if gaze_y < 0: gaze_y = 0 gaze_inside = True if not self.test: ## data augmentation # Jitter (expansion-only) bounding box size. if cond_jitter < 0.5: k = cond_jitter * 0.1 face_x1 -= k * abs(face_x2 - face_x1) face_y1 -= k * abs(face_y2 - face_y1) face_x2 += k * abs(face_x2 - face_x1) face_y2 += k * abs(face_y2 - face_y1) face_x1 = np.clip(face_x1, 0, width) face_x2 = np.clip(face_x2, 0, width) face_y1 = np.clip(face_y1, 0, height) face_y2 = np.clip(face_y2, 0, height) # Random Crop if cond_crop < 0.5: # Crop it img = TF.crop(img, crop_y_min, crop_x_min, crop_height, crop_width) # Record the crop's (x, y) offset offset_x, offset_y = crop_x_min, crop_y_min # convert coordinates into the cropped frame face_x1, face_y1, face_x2, face_y2 = face_x1 - offset_x, face_y1 - offset_y, face_x2 - offset_x, face_y2 - offset_y if gaze_inside: gaze_x, gaze_y = (gaze_x- offset_x), \ (gaze_y - offset_y) else: gaze_x = -1 gaze_y = -1 width, height = crop_width, crop_height # Flip? if cond_flip < 0.5: img = img.transpose(Image.FLIP_LEFT_RIGHT) x_max_2 = width - face_x1 x_min_2 = width - face_x2 face_x2 = x_max_2 face_x1 = x_min_2 if gaze_x != -1 and gaze_y != -1: gaze_x = width - gaze_x # Random color change if cond_color < 0.5: img = TF.adjust_brightness(img, brightness_factor=n1) img = TF.adjust_contrast(img, contrast_factor=n2) img = TF.adjust_saturation(img, saturation_factor=n3) # Face crop face = img.copy().crop( (int(face_x1), int(face_y1), int(face_x2), int(face_y2))) # Head channel image head_channel = imutils.get_head_box_channel( face_x1, face_y1, face_x2, face_y2, width, height, resolution=self.input_size, coordconv=False).unsqueeze(0) if self.transform is not None: img = self.transform(img) face = self.transform(face) # Deconv output if gaze_inside: gaze_x /= float(width) # fractional gaze gaze_y /= float(height) gaze_heatmap = torch.zeros( self.output_size, self.output_size) # set the size of the output gaze_map = imutils.draw_labelmap( gaze_heatmap, [gaze_x * self.output_size, gaze_y * self.output_size], 3, type='Gaussian') gazes.append(torch.FloatTensor([gaze_x, gaze_y])) else: gaze_map = torch.zeros(self.output_size, self.output_size) gazes.append(torch.FloatTensor([-1, -1])) faces.append(face) images.append(img) head_channels.append(head_channel) heatmaps.append(gaze_map) gaze_inouts.append(torch.FloatTensor([int(gaze_inside)])) if self.imshow: for i in range(len(faces)): fig = plt.figure(111) img = 255 - imutils.unnorm(images[i].numpy()) * 255 img = np.clip(img, 0, 255) plt.imshow(np.transpose(img, (1, 2, 0))) plt.imshow(imresize(heatmaps[i], (self.input_size, self.input_size)), cmap='jet', alpha=0.3) plt.imshow(imresize(1 - head_channels[i].squeeze(0), (self.input_size, self.input_size)), alpha=0.2) plt.savefig( os.path.join('debug', 'viz_%d_inout=%d.png' % (i, gaze_inouts[i]))) plt.close('all') faces = torch.stack(faces) images = torch.stack(images) head_channels = torch.stack(head_channels) heatmaps = torch.stack(heatmaps) gazes = torch.stack(gazes) gaze_inouts = torch.stack(gaze_inouts) # imsizes = torch.stack(imsizes) # print(faces.shape, images.shape, head_channels.shape, heatmaps.shape) if self.test: return images, faces, head_channels, heatmaps, gazes, gaze_inouts else: # train return images, faces, head_channels, heatmaps, gaze_inouts
def adjustBrightness(self, x): return F.adjust_brightness(x, self.brightness_factor)
def torchvision(self, img): return torchvision.adjust_brightness(img, brightness_factor=1.5)
def __call__(self, img, masks): return tf.adjust_brightness(img, random.uniform(1 - self.bf, 1 + self.bf)), masks
def __getitem__(self, index): data_path = self.data_list[index % self.total] xml_path = self.label_list[index % self.total] xml_tree = ET.parse(xml_path) xml_root = xml_tree.getroot() filename = xml_root.find('filename').text hwc = np.array([ int(xml_root.find('size').find('height').text), int(xml_root.find('size').find('width').text), int(xml_root.find('size').find('depth').text) ]) labels = [] bboxes = [] for obj in xml_root.findall('object'): labels.append(VOC_LABELS[obj.find('name').text][0]) bbox = [] bbox.append(float(obj.find('bndbox').find('xmin').text)) bbox.append(float(obj.find('bndbox').find('ymin').text)) bbox.append(float(obj.find('bndbox').find('xmax').text)) bbox.append(float(obj.find('bndbox').find('ymax').text)) bboxes.append(bbox) labels = np.array(labels).astype(np.int) bboxes = np.array(bboxes).astype(np.int) # -------------------------------------------------------------- rand_scale = np.random.uniform(0.85, 1.0) crop_size = int(np.min([hwc[0], hwc[1]]) * rand_scale) rand_i = np.random.randint(0, hwc[0] - crop_size) if hwc[0] > crop_size else 0 rand_j = np.random.randint(0, hwc[1] - crop_size) if hwc[1] > crop_size else 0 rand_hue = np.random.uniform(-0.3, 0.3) rand_num = [np.random.uniform(0.6, 1.5) for i in range(4)] img = Image.open(data_path) img = fn.resized_crop(img, rand_i, rand_j, crop_size, crop_size, (self.img_size, self.img_size), interpolation=2) ratio = self.img_size / crop_size bboxes = np.concatenate([ np.maximum(bboxes[:, 0:1], rand_j) - rand_j, np.maximum(bboxes[:, 1:2], rand_i) - rand_i, np.minimum(bboxes[:, 2:3], rand_j + crop_size) - rand_j, np.minimum(bboxes[:, 3:], rand_i + crop_size) - rand_i ], axis=-1) * ratio if self.train: img = fn.adjust_hue(img, rand_hue) img = fn.adjust_contrast(img, rand_num[0]) img = fn.adjust_brightness(img, rand_num[1]) img = fn.adjust_saturation(img, rand_num[2]) if rand_num[3] > 1.05: img = fn.hflip(img) bboxes = np.concatenate( [(bboxes[:, 2:3] - self.img_size) * (-1), bboxes[:, 1:2], (bboxes[:, 0:1] - self.img_size) * (-1), bboxes[:, 3:]], axis=-1) img = np.array(img).transpose(2, 0, 1) bboxes = bboxes.astype(np.int) return img, filename, hwc, labels, bboxes
def torchvision(self, img): return torchvision.adjust_brightness(img, brightness_factor=1.5)
def bright(self, O, B): brightness_factor = self.rand_state.uniform(0.3, 1.7) O = TF.adjust_brightness(img=O, brightness_factor=brightness_factor) B = TF.adjust_brightness(img=B, brightness_factor=brightness_factor) return O, B
def torchvision(self, img): img = torchvision.adjust_hue(img, hue_factor=0.1) img = torchvision.adjust_saturation(img, saturation_factor=1.2) img = torchvision.adjust_brightness(img, brightness_factor=1.2) return img
def makeAgumentedTest(test, test_labels): num_image = test.shape[0] translatedImages = [] brightenedImages = [] darkenedImages = [] hContrasted = [] lContrasted = [] flippedImages = [] invertedImages = [] for i in range(num_image): img = test[i, :, :, :] img = Image.fromarray(img) # Do Translation translatedIMG = transforms.affine(img, angle=0, translate=(50, 50), scale=1, shear=0) # Do Brigthened brightenedIMG = transforms.adjust_brightness(img, 1.5) # Do Darkened darkenedIMG = transforms.adjust_brightness(img, 0.75) # Do High Contrast highContrastIMG = transforms.adjust_contrast(img, 1.5) # Do Low Contrast lowContrastIMG = transforms.adjust_contrast(img, 0.75) # Flipped Upside Down flippedIMG = transforms.hflip(img) # Colors Inverted invertedIMG = ImageOps.invert(img) translatedImages.append(np.expand_dims(np.array(translatedIMG), axis=0)) brightenedImages.append(np.expand_dims(np.array(brightenedIMG), axis=0)) darkenedImages.append(np.expand_dims(np.array(darkenedIMG), axis=0)) hContrasted.append(np.expand_dims(np.array(highContrastIMG), axis=0)) lContrasted.append(np.expand_dims(np.array(lowContrastIMG), axis=0)) flippedImages.append(np.expand_dims(np.array(flippedIMG), axis=0)) invertedImages.append(np.expand_dims(np.array(invertedIMG), axis=0)) translatedImages = np.vstack(translatedImages) brightenedImages = np.vstack(brightenedImages) darkenedImages = np.vstack(darkenedImages) hContrasted = np.vstack(hContrasted) lContrasted = np.vstack(lContrasted) flippedImages = np.vstack(flippedImages) invertedImages = np.vstack(invertedImages) augmentedTest = { 'translated': translatedImages, 'brightened': brightenedImages, 'darkened': darkenedImages, 'high_contrast': hContrasted, 'low_contrast': lContrasted, 'flipped': flippedImages, 'inverted': invertedImages, 'labels': test_labels } with open('augmented_test.pkl', 'wb') as outfile: pickle.dump(augmentedTest, outfile) print('Done!')
def __call__(self, img): out = F.adjust_brightness(img, self.brightness) out = F.adjust_contrast(out, self.contrast) out = F.adjust_hue(out, self.hue) return out
def ColorAdjust(image, factor): image = F.adjust_brightness(image, factor) image = F.adjust_contrast(image, factor) image = F.adjust_saturation(image, factor) return F.to_tensor(image)
def __call__(self, image, target): if random.random() < self.prob: brightness_factor = random.uniform(0.5, 2) image = F.adjust_brightness(image, brightness_factor) return image, target
def data_augment(self, images, edges, imgh, imgw): images = Image.fromarray(np.uint8(np.asarray(images)), mode="RGB") mask = Image.fromarray(np.uint8(np.ones_like(edges))) edges = Image.fromarray(np.uint8(edges)) if np.random.binomial(1, 0.8) > 0: brightness_factor = np.random.uniform(0.8, 1.2) images = F.adjust_brightness(images, brightness_factor) if np.random.binomial(1, 0.8) > 0: contrast_factor = np.random.uniform(0.5, 2) images = F.adjust_contrast(images, contrast_factor) if np.random.binomial(1, 0.8) > 0: hue_factor = np.random.uniform(-0.2, 0.2) images = F.adjust_hue(images, hue_factor) if np.random.binomial(1, 0.8) > 0: saturation_factor = np.random.uniform(0.8, 1.2) images = F.adjust_saturation(images, saturation_factor) if np.random.binomial(1, 0.8) > 0: angle = random.randint(-2, 2) translate = (random.randint(-int(imgw * 0.1), int(imgw * 0.1)), random.randint(-int(imgh * 0.1), int(imgh * 0.1))) scale = np.random.uniform(0.9, 1.1) if scale < 1: # scale:[0.9,1.1] scale = scale / 2 + 0.5 shear = random.randint(-2, 2) images = F.affine(images, angle, translate, scale, shear, resample=Image.BICUBIC) edges = F.affine(edges, angle, translate, scale, shear, resample=Image.BICUBIC) mask = F.affine(mask, angle, translate, scale, shear, resample=Image.BICUBIC) if np.random.binomial(1, 0.5) > 0: images = F.hflip(images) edges = F.hflip(edges) mask = F.hflip(mask) if np.random.binomial(1, 0.5) > 0: images = F.vflip(images) edges = F.vflip(edges) mask = F.vflip(mask) images = np.asarray(images) edges = np.asarray(edges) mask = np.asarray(mask) # https://github.com/mdbloice/Augmentor images = [[images, edges, mask]] p = Augmentor.DataPipeline(images) p.random_distortion(1, 10, 10, 10) g = p.generator(batch_size=1) augmented_images = next(g) images = augmented_images[0][0] edges = augmented_images[0][1] mask = augmented_images[0][2] edges = edges.copy() edges[edges < 128] = 0 edges[edges >= 128] = 1 edges = (morphology.skeletonize(edges)).astype(np.uint8) edges[edges == 1] = 255 edges = self.resize(edges, imgh, imgw) mask = self.resize(mask, imgh, imgw) # 1.not thin edge truth edges[edges > 0] = 255 # 2.thin edge truth # edges[edges>0]=1 # edges = (morphology.skeletonize(edges)).astype(np.uint8) # edges[edges==1] = 255 edges = (255 - edges) * mask return images, edges, mask * 255
def __call__(self, img, target): factor = random.uniform(-self.factor, self.factor) img = F.adjust_brightness(img, 1 + factor) return img, target
def __call__(self, image): factor = np.random.uniform(self.low, self.high) return TF.adjust_brightness(image, factor)
def __getitem__(self, index): squeen = self.sequeueslists[index] image_filenames = [ join(squeen, x) for x in listdir(squeen) if is_image_file(x) ] randi = 0 cropsize = self.crop_size hr_scale = Resize((cropsize, cropsize), interpolation=Image.BICUBIC) # first image of seq imgname = join(squeen, str(randi + 1) + '.jpg') hr_image = Image.open(imgname) w, h = hr_image.size ragey = random.randint(0, h - cropsize) rangx = random.randint(0, w - cropsize) ################################ hr_image = self.seq_randomcrop(hr_image, ragey, rangx, cropsize, cropsize) hfp = random.random() if hfp < 0.5: hr_image = self.randomHflip(hr_image) vfp = random.random() if vfp < 0.5: hr_image = self.randomVflip(hr_image) brightness = 0.2 contrast = 0.2 saturation = 0.1 hue = 0.1 transforms = [] brightness_factor = np.random.uniform(max(0, 1 - brightness), 1 + brightness) transforms.append( Lambda(lambda img: F.adjust_brightness(img, brightness_factor))) contrast_factor = np.random.uniform(max(0, 1 - contrast), 1 + contrast) transforms.append( Lambda(lambda img: F.adjust_contrast(img, contrast_factor))) saturation_factor = np.random.uniform(max(0, 1 - saturation), 1 + saturation) transforms.append( Lambda(lambda img: F.adjust_saturation(img, saturation_factor))) hue_factor = np.random.uniform(-hue, hue) transforms.append(Lambda(lambda img: F.adjust_hue(img, hue_factor))) np.random.shuffle(transforms) color_transform = Compose(transforms) hr_image = color_transform(hr_image) ################################ hr_image = ToTensor()(hr_image) lr_image = self.lr_transform(hr_image) # Y channel hr_image = torch.unsqueeze(hr_image, dim=0) bic_hr = torch.unsqueeze(ToTensor()(hr_scale(lr_image)), dim=0) lr_image = torch.unsqueeze(ToTensor()(lr_image), dim=0) t0 = lr_image t1 = bic_hr t2 = hr_image for i in range(randi + 1, randi + self.relation): imgname = join(squeen, str(i + 1) + '.jpg') hr_image = Image.open(imgname) # data argument hr_image = self.seq_randomcrop(hr_image, rangx, ragey, cropsize, cropsize) if hfp < 0.5: hr_image = self.randomHflip(hr_image) if vfp < 0.5: hr_image = self.randomVflip(hr_image) hr_image = color_transform(hr_image) hr_image = ToTensor()(hr_image) lr_image = self.lr_transform(hr_image) # Y channel hr_image = torch.unsqueeze(hr_image, dim=0) bic_hr = torch.unsqueeze(ToTensor()(hr_scale(lr_image)), dim=0) lr_image = torch.unsqueeze(ToTensor()(lr_image), dim=0) t0 = torch.cat((t0, lr_image), 0) t1 = torch.cat((t1, bic_hr), 0) t2 = torch.cat((t2, hr_image), 0) return t0, t1, t2
def colorop(img, bright, contrast): _img = TF.adjust_brightness(img, bright) _img = TF.adjust_contrast(_img, contrast) return _img
def __getitem__(self, idx): rgb, depth, gt, confidence, K = self._load_data(idx) if self.augment and self.mode == 'train': # Top crop if needed if self.args.top_crop > 0: width, height = rgb.size rgb = TF.crop(rgb, self.args.top_crop, 0, height - self.args.top_crop, width) depth = TF.crop(depth, self.args.top_crop, 0, height - self.args.top_crop, width) confidence = TF.crop(confidence, self.args.top_crop, 0, height - self.args.top_crop, width) gt = TF.crop(gt, self.args.top_crop, 0, height - self.args.top_crop, width) K[3] = K[3] - self.args.top_crop width, height = rgb.size _scale = np.random.uniform(1.0, 1.5) scale = np.int(height * _scale) degree = np.random.uniform(-5.0, 5.0) flip = np.random.uniform(0.0, 1.0) # Horizontal flip if flip > 0.5: rgb = TF.hflip(rgb) depth = TF.hflip(depth) confidence = TF.hflip(confidence) gt = TF.hflip(gt) K[2] = width - K[2] # Rotation rgb = TF.rotate(rgb, angle=degree, resample=Image.BICUBIC) depth = TF.rotate(depth, angle=degree, resample=Image.NEAREST) confidence = TF.rotate(confidence, angle=degree, resample=Image.NEAREST) gt = TF.rotate(gt, angle=degree, resample=Image.NEAREST) # Color jitter brightness = np.random.uniform(0.6, 1.4) contrast = np.random.uniform(0.6, 1.4) saturation = np.random.uniform(0.6, 1.4) rgb = TF.adjust_brightness(rgb, brightness) rgb = TF.adjust_contrast(rgb, contrast) rgb = TF.adjust_saturation(rgb, saturation) # Resize rgb = TF.resize(rgb, scale, Image.BICUBIC) depth = TF.resize(depth, scale, Image.NEAREST) confidence = TF.resize(confidence, scale, Image.NEAREST) gt = TF.resize(gt, scale, Image.NEAREST) K[0] = K[0] * _scale K[1] = K[1] * _scale K[2] = K[2] * _scale K[3] = K[3] * _scale # Crop width, height = rgb.size assert self.height <= height and self.width <= width, \ "patch size is larger than the input size" h_start = random.randint(0, height - self.height) w_start = random.randint(0, width - self.width) rgb = TF.crop(rgb, h_start, w_start, self.height, self.width) depth = TF.crop(depth, h_start, w_start, self.height, self.width) confidence = TF.crop(confidence, h_start, w_start, self.height, self.width) gt = TF.crop(gt, h_start, w_start, self.height, self.width) K[2] = K[2] - w_start K[3] = K[3] - h_start rgb = TF.to_tensor(rgb) rgb = TF.normalize(rgb, (0.485, 0.456, 0.406), (0.229, 0.224, 0.225), inplace=True) depth = TF.to_tensor(np.array(depth)) depth = depth / _scale confidence = TF.to_tensor(np.array(confidence)) confidence = confidence / _scale gt = TF.to_tensor(np.array(gt)) gt = gt / _scale elif self.mode in ['train', 'val']: # Top crop if needed if self.args.top_crop > 0: width, height = rgb.size rgb = TF.crop(rgb, self.args.top_crop, 0, height - self.args.top_crop, width) depth = TF.crop(depth, self.args.top_crop, 0, height - self.args.top_crop, width) confidence = TF.crop(confidence, self.args.top_crop, 0, height - self.args.top_crop, width) gt = TF.crop(gt, self.args.top_crop, 0, height - self.args.top_crop, width) K[3] = K[3] - self.args.top_crop # Crop width, height = rgb.size assert self.height <= height and self.width <= width, \ "patch size is larger than the input size" h_start = random.randint(0, height - self.height) w_start = random.randint(0, width - self.width) rgb = TF.crop(rgb, h_start, w_start, self.height, self.width) depth = TF.crop(depth, h_start, w_start, self.height, self.width) confidence = TF.crop(confidence, h_start, w_start, self.height, self.width) gt = TF.crop(gt, h_start, w_start, self.height, self.width) K[2] = K[2] - w_start K[3] = K[3] - h_start rgb = TF.to_tensor(rgb) rgb = TF.normalize(rgb, (0.485, 0.456, 0.406), (0.229, 0.224, 0.225), inplace=True) depth = TF.to_tensor(np.array(depth)) confidence = TF.to_tensor(np.array(confidence)) gt = TF.to_tensor(np.array(gt)) else: if self.args.top_crop > 0 and self.args.test_crop: width, height = rgb.size rgb = TF.crop(rgb, self.args.top_crop, 0, height - self.args.top_crop, width) depth = TF.crop(depth, self.args.top_crop, 0, height - self.args.top_crop, width) confidence = TF.crop(confidence, self.args.top_crop, 0, height - self.args.top_crop, width) gt = TF.crop(gt, self.args.top_crop, 0, height - self.args.top_crop, width) K[3] = K[3] - self.args.top_crop rgb = TF.to_tensor(rgb) rgb = TF.normalize(rgb, (0.485, 0.456, 0.406), (0.229, 0.224, 0.225), inplace=True) depth = TF.to_tensor(np.array(depth)) confidence = TF.to_tensor(np.array(confidence)) gt = TF.to_tensor(np.array(gt)) if self.args.num_sample > 0: depth, confidence = self.get_sparse_depth(depth, confidence, self.args.num_sample) output = { 'rgb': rgb, 'dep': depth, 'confidence': confidence, 'gt': gt, 'K': torch.Tensor(K) } return output
def melanoma_image_aug(image_path): ''' Transformations: horizontal flip vertical flip scale = 0.9 shear = 8.0 rotation = 150.0 brightness factor = 223 / 255 saturation factor = 0.5 ''' # full_rot = 180 # scale = (0.8, 1.2) # shear = 10 cutout = int(16 * (600 / 224)) cutout_coordinate = [100, 200] melanoma_image = Image.open(image_path) horizontal_flip = transforms.RandomHorizontalFlip(p=1.0) # vertical_flip = transforms.RandomVerticalFlip(p=1.0) # Cutout cutout = Cutout_v0(n_holes=1, length=cutout, x=cutout_coordinate[0], y=cutout_coordinate[1]) all_transforms_melanoma_image = melanoma_image horizontal_flip_melanoma_image = horizontal_flip(melanoma_image) all_transforms_melanoma_image = horizontal_flip( all_transforms_melanoma_image) # vertical_flip_melanoma_image = vertical_flip(melanoma_image) # all_transforms_melanoma_image = vertical_flip(all_transforms_melanoma_image) scale_melanoma_image = functional.affine(melanoma_image, angle=0, translate=[0, 0], shear=[0.0], scale=0.9) all_transforms_melanoma_image = functional.affine( all_transforms_melanoma_image, angle=0, translate=[0, 0], shear=[0.0], scale=0.9) shear_melanoma_image = functional.affine(melanoma_image, angle=0, translate=[0, 0], shear=[8.0], scale=1) all_transforms_melanoma_image = functional.affine( all_transforms_melanoma_image, angle=0, translate=[0, 0], shear=[8.0], scale=1) rotate_melanoma_image = functional.affine(melanoma_image, angle=150, translate=[0, 0], shear=[0.0], scale=1, resample=Image.BILINEAR) all_transforms_melanoma_image = functional.affine( all_transforms_melanoma_image, angle=150, translate=[0, 0], shear=[0.0], scale=1, resample=Image.BILINEAR) brightness_melanoma_image = functional.adjust_brightness( melanoma_image, brightness_factor=1 - 32. / 255.) all_transforms_melanoma_image = functional.adjust_brightness( all_transforms_melanoma_image, brightness_factor=1 - 32. / 255.) saturation_melanoma_image = functional.adjust_saturation( melanoma_image, saturation_factor=0.5) all_transforms_melanoma_image = functional.adjust_saturation( all_transforms_melanoma_image, saturation_factor=0.5) cutout_melanoma_image = cutout(melanoma_image) all_transforms_melanoma_image = cutout(all_transforms_melanoma_image) melanoma_image.save( r"C:\Users\Bruger\PycharmProjects\Bachelor\Article_figures\orginial.jpg" ) horizontal_flip_melanoma_image.save( r"C:\Users\Bruger\PycharmProjects\Bachelor\Article_figures\horizontal_flip.jpg" ) # vertical_flip_melanoma_image.save(r"C:\Users\Bruger\PycharmProjects\Bachelor\Article_figures\vertical_flip.jpg") scale_melanoma_image.save( r"C:\Users\Bruger\PycharmProjects\Bachelor\Article_figures\scale.jpg") shear_melanoma_image.save( r"C:\Users\Bruger\PycharmProjects\Bachelor\Article_figures\shear.jpg") rotate_melanoma_image.save( r"C:\Users\Bruger\PycharmProjects\Bachelor\Article_figures\rotate.jpg") brightness_melanoma_image.save( r"C:\Users\Bruger\PycharmProjects\Bachelor\Article_figures\brightness.jpg" ) saturation_melanoma_image.save( r"C:\Users\Bruger\PycharmProjects\Bachelor\Article_figures\saturation.jpg" ) cutout_melanoma_image.save( r"C:\Users\Bruger\PycharmProjects\Bachelor\Article_figures\cutout.jpg") all_transforms_melanoma_image.save( r"C:\Users\Bruger\PycharmProjects\Bachelor\Article_figures\all_transforms.jpg" ) random.seed(42) scale = random.uniform(0.8, 1.2) shear = random.uniform(-10, 10) rotate = random.uniform(-180, 180) brightness = random.uniform(1 - 32. / 255., 1 + 32. / 255.) saturation = random.uniform(0.5, 1.5) cutout_coordiante = [ random.randrange(100, 400), random.randrange(100, 400) ] print("Rand 1") print("Scale " + str(scale)) print("Shear " + str(shear)) print("Rotate " + str(rotate)) print("Brigthness " + str(brightness)) print("Saturation " + str(saturation)) print("Cutout coordinates" + str(cutout_coordiante)) all_transforms_1 = deterministic_daisy_lab_image_data_augmenter( melanoma_image, cutoutCordinates=cutout_coordiante, scale=scale, shear=shear, rotate=rotate, brightness=brightness, saturation=saturation, horizontalFlip=True) all_transforms_1.save( r"C:\Users\Bruger\PycharmProjects\Bachelor\Article_figures\rand_1.jpg") scale = random.uniform(0.8, 1.2) shear = random.uniform(-10, 10) rotate = random.uniform(-180, 180) brightness = random.uniform(1 - 32. / 255., 1 + 32. / 255.) saturation = random.uniform(0.5, 1.5) cutout_coordiante = [ random.randrange(100, 400), random.randrange(100, 400) ] print("Rand 2") print("Scale " + str(scale)) print("Shear " + str(shear)) print("Rotate " + str(rotate)) print("Brigthness " + str(brightness)) print("Saturation " + str(saturation)) print("Cutout " + str(cutout_coordiante)) all_transforms_2 = deterministic_daisy_lab_image_data_augmenter( melanoma_image, cutoutCordinates=cutout_coordiante, scale=scale, shear=shear, rotate=rotate, brightness=brightness, saturation=saturation, horizontalFlip=False) all_transforms_2.save( r"C:\Users\Bruger\PycharmProjects\Bachelor\Article_figures\rand_2.jpg")
def torchvision(self, img): img = torchvision.adjust_hue(img, hue_factor=0.1) img = torchvision.adjust_saturation(img, saturation_factor=1.2) img = torchvision.adjust_brightness(img, brightness_factor=1.2) return img
def __call__(self, img): return F.adjust_brightness(img, self.brightness)