def perspective_transform(self): indices = self._random_indices(self.perspective_transform_ratio) keypoints_on_images = [] for target in self.targets[indices]: keypoints = [] for i in range(0, len(target), 2): x = target[i]*48 + 48 y = target[i+1]*48 + 48 keypoints.append(ia.Keypoint(x=x, y=y)) keypoints_on_images.append(ia.KeypointsOnImage(keypoints, shape=(96, 96, 1))) seq = iaa.Sequential([ iaa.PerspectiveTransform(scale=(0.01, 0.1)) ]) seq_det = seq.to_deterministic() self.inputs[indices] = (seq_det.augment_images(self.inputs[indices, :, :, :]*48.0+48.0)-48.0)/48.0 keypoints_aug = seq_det.augment_keypoints(keypoints_on_images) normalized_keypoints_on_images = [] for keypoints_on_image in keypoints_aug: normalized_keypoints = [] for keypoint in keypoints_on_image.get_coords_array(): normalized_x, normalized_y = (keypoint[0]-48)/48, (keypoint[1]-48)/48 normalized_keypoints.append(normalized_x) normalized_keypoints.append(normalized_y) normalized_keypoints_on_images.append(normalized_keypoints) self.targets[indices] = np.array(normalized_keypoints_on_images)
def __init__(self): self.seq = iaa.Sequential( [ iaa.Sometimes( 0.5, iaa.OneOf([ iaa.GaussianBlur( (0, 3.0 )), # blur images with a sigma between 0 and 3.0 iaa.AverageBlur( k=(2, 7) ), # blur image using local means with kernel sizes between 2 and 7 iaa.MedianBlur( k=(3, 11) ), # blur image using local medians with kernel sizes between 2 and 7 ])), iaa.Sometimes( 0.5, iaa.AdditiveGaussianNoise( loc=0, scale=(0.0, 0.05 * 255), per_channel=0.5)), iaa.Sometimes(0.5, iaa.Add((-10, 10), per_channel=0.5)), iaa.Sometimes(0.5, iaa.AddToHueAndSaturation((-20, 20))), iaa.Sometimes( 0.5, iaa.FrequencyNoiseAlpha(exponent=(-4, 0), first=iaa.Multiply( (0.5, 1.5), per_channel=True), second=iaa.LinearContrast( (0.5, 2.0)))), iaa.Sometimes(0.5, iaa.PiecewiseAffine(scale=(0.01, 0.05))), iaa.Sometimes(0.5, iaa.PerspectiveTransform(scale=(0.01, 0.1))) ], random_order=True)
def aug_image(image): seq = iaa.Sequential([ iaa.Fliplr(0.5), iaa.Affine(rotate= (-8, 8), shear = (-8, 8), mode='edge'), iaa.SomeOf((0, 2), [ iaa.GaussianBlur((0, 0.3)), iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.01 * 255), per_channel=0.5), iaa.AddToHueAndSaturation((-5, 5)), # change hue and saturation iaa.PiecewiseAffine(scale=(0.01, 0.03)), iaa.PerspectiveTransform(scale=(0.01, 0.1)), iaa.JpegCompression(20, 40) ], random_order=True ), iaa.Cutout(nb_iterations=1, size=(0.02, 0.2), squared=False) ]) image = seq.augment_image(image) return image
def __init__(self, mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], input_scale_size=224, data_dir='/data/synthesized/model', model_save_name='model.ckpt', batch_size=64): self.DATA_DIR = data_dir self.MODEL_SAVE_NAME = model_save_name self.BATCH_SIZE = batch_size self.IMAGE_SCALE_SIZE = input_scale_size self.MEAN = mean self.STD = std self.data_transforms = { 'train': transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.ImageAugmentaion(), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize(self.MEAN, self.STD) ]), 'test': transforms.Compose([ transforms.ToTensor(), transforms.Normalize(self.MEAN, self.STD) ]) } self.image_datasets = { x: torchvision.datasets.CIFAR10(root='./data', train=(x == 'train'), download=True, transform=self.data_transforms[x]) for x in ['train', 'test'] } self.dataloaders = { x: torch.utils.data.DataLoader(self.image_datasets[x], batch_size=self.BATCH_SIZE, shuffle=True, num_workers=6) for x in ['train', 'test'] } self.dataset_sizes = { x: len(self.image_datasets[x]) for x in ['train', 'test'] } self.class_names = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck') self.iaa_seq = iaa.Sequential([ iaa.PerspectiveTransform(scale=0.075), iaa.Multiply((0.5, 1.5)), iaa.Affine(scale={ "x": (1, 1.1), "y": (1, 1.1) }), iaa.SaltAndPepper((0.05)), iaa.Add((-20, 20)), iaa.GaussianBlur((0, 0.50)), iaa.Scale((1.0, 1.3)), ])
def image_heavy_augmentation(image, det_masks, ratio_operations=0.6): # according to the paper, operations such as shearing, fliping horizontal/vertical, # rotating, zooming and channel shifting will be apply sometimes = lambda aug: iaa.Sometimes(ratio_operations, aug) edge_detect_sometime = lambda aug: iaa.Sometimes(0.1, aug) elasitic_sometime = lambda aug:iaa.Sometimes(0.2, aug) add_gauss_noise = lambda aug: iaa.Sometimes(0.15, aug) hor_flip_angle = np.random.uniform(0, 1) ver_flip_angle = np.random.uniform(0, 1) seq = iaa.Sequential([ iaa.SomeOf((0, 5), [ iaa.Fliplr(hor_flip_angle), iaa.Flipud(ver_flip_angle), iaa.Affine(shear=(-16, 16)), iaa.Affine(scale={'x': (1, 1.6), 'y': (1, 1.6)}), iaa.PerspectiveTransform(scale=(0.01, 0.1)), # These are additional augmentation. #iaa.ContrastNormalization((0.75, 1.5)) ])]) #elasitic_sometime( seq_to_deterministic = seq.to_deterministic() aug_img = seq_to_deterministic.augment_images(image) aug_det_mask = seq_to_deterministic.augment_images(det_masks) return aug_img, aug_det_mask
def _aug(self, image, mask): mask = ia.SegmentationMapsOnImage(mask, image.shape[:2]) seq = iaa.Sequential( [ iaa.Fliplr(0.5), iaa.Rot90([0, 3]), iaa.SomeOf( 1, [ iaa.Affine(scale={"x": (0.7, 1.5), "y": (1.6, 1.5)}), iaa.Affine(rotate=(-30, 30)), # iaa.Add((-110, 111)), # iaa.GaussianBlur(sigma=1.8 * np.random.rand()), # iaa.Emboss(alpha=(0.0, 1.0), strength=(0.5, 1.5)), # iaa.AdditiveGaussianNoise(scale=0.05*255), # iaa.Multiply((0.5, 1.5)), # iaa.Affine(shear=(-20, 20)), # iaa.PiecewiseAffine(scale=(0.01, 0.02)), iaa.PerspectiveTransform(scale=(0.01, 0.1)), ], ), ], random_order=True, ) image, mask = seq(image=image, segmentation_maps=mask) mask = mask.get_arr_int().astype(np.uint8) return image, mask
def image_basic_augmentation(image, masks, ratio_operations=0.9): # without additional operations # according to the paper, operations such as shearing, fliping horizontal/vertical, # rotating, zooming and channel shifting will be apply sometimes = lambda aug: iaa.Sometimes(ratio_operations, aug) hor_flip_angle = np.random.uniform(0, 1) ver_flip_angle = np.random.uniform(0, 1) seq = iaa.Sequential([ sometimes( iaa.SomeOf((0, 5), [ iaa.Fliplr(hor_flip_angle), iaa.Flipud(ver_flip_angle), iaa.Affine(shear=(-16, 16)), iaa.Affine(scale={ 'x': (1, 1.6), 'y': (1, 1.6) }), iaa.PerspectiveTransform(scale=(0.01, 0.1)) ])) ]) det_mask, cls_mask = masks[0], masks[1] seq_to_deterministic = seq.to_deterministic() aug_img = seq_to_deterministic.augment_images(image) aug_det_mask = seq_to_deterministic.augment_images(det_mask) aug_cls_mask = seq_to_deterministic.augment_images(cls_mask) return aug_img, aug_det_mask, aug_cls_mask
def __init__(self): sometimes = lambda aug: iaa.Sometimes(0.3, aug) self.aug = iaa.Sequential(iaa.SomeOf((1, 5), [ # blur sometimes(iaa.OneOf([iaa.GaussianBlur(sigma=(0, 1.0)), iaa.MotionBlur(k=3)])), # color sometimes(iaa.AddToHueAndSaturation(value=(-10, 10), per_channel=True)), sometimes(iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.4, 0.6), per_channel=True)), sometimes(iaa.Invert(0.25, per_channel=0.5)), sometimes(iaa.Solarize(0.5, threshold=(32, 128))), sometimes(iaa.Dropout2d(p=0.5)), sometimes(iaa.Multiply((0.5, 1.5), per_channel=0.5)), sometimes(iaa.Add((-40, 40), per_channel=0.5)), sometimes(iaa.JpegCompression(compression=(5, 80))), # distort sometimes(iaa.Crop(percent=(0.01, 0.05), sample_independently=True)), sometimes(iaa.PerspectiveTransform(scale=(0.01, 0.01))), sometimes(iaa.Affine(scale=(0.7, 1.3), translate_percent=(-0.1, 0.1), # rotate=(-5, 5), shear=(-5, 5), order=[0, 1], cval=(0, 255), mode=ia.ALL)), sometimes(iaa.PiecewiseAffine(scale=(0.01, 0.01))), sometimes(iaa.OneOf([iaa.Dropout(p=(0, 0.1)), iaa.CoarseDropout(p=(0, 0.1), size_percent=(0.02, 0.25))])), ], random_order=True), random_order=True)
def aug_image(image, is_infer=False, augment=None): if is_infer: flip_code = augment[0] if flip_code == 1: seq = iaa.Sequential([iaa.Fliplr(1.0)]) elif flip_code == 2: seq = iaa.Sequential([iaa.Flipud(1.0)]) elif flip_code == 3: seq = iaa.Sequential([iaa.Flipud(1.0), iaa.Fliplr(1.0)]) elif flip_code == 0: return image else: seq = iaa.Sequential([ iaa.Affine(rotate=(-15, 15), shear=(-15, 15), mode='edge'), iaa.SomeOf( (0, 2), [ iaa.GaussianBlur((0, 1.5)), iaa.AdditiveGaussianNoise( loc=0, scale=(0.0, 0.01 * 255), per_channel=0.5), iaa.AddToHueAndSaturation( (-5, 5)), # change hue and saturation iaa.PiecewiseAffine(scale=(0.01, 0.03)), iaa.PerspectiveTransform(scale=(0.01, 0.1)) ], random_order=True) ]) image = seq.augment_image(image) return image
def train_augmentors(self): shape_augs = [ iaa.Resize((512, 512), interpolation='nearest'), # iaa.CropToFixedSize(width=800, height=800), ] # sometimes = lambda aug: iaa.Sometimes(0.2, aug) input_augs = [ iaa.OneOf([ iaa.GaussianBlur((0, 3.0)), # gaussian blur with random sigma iaa.MedianBlur(k=(3, 5)), # median with random kernel sizes iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.05 * 255), per_channel=0.5), ]), sometimes(iaa.ElasticTransformation(alpha=(0.5, 3.5), sigma=0.25)), # move pixels locally around (with random strengths) sometimes(iaa.PiecewiseAffine(scale=(0.01, 0.05)) ), # sometimes move parts of the image around sometimes(iaa.PerspectiveTransform(scale=(0.01, 0.1))), iaa.Sequential([ iaa.Add((-26, 26)), iaa.AddToHueAndSaturation((-20, 20)), iaa.LinearContrast((0.75, 1.25), per_channel=1.0), ], random_order=True), sometimes([ iaa.CropAndPad(percent=(-0.05, 0.1), pad_mode="reflect", pad_cval=(0, 255)), ]), ] return shape_augs, input_augs
def __init__(self): sometimes = lambda aug: iaa.Sometimes(0.5, aug) self.seq = iaa.Sequential([ iaa.OneOf([ iaa.Multiply((0.6, 1.0), per_channel=0.5), iaa.Multiply((1.0, 2.0), per_channel=0.5), ]), sometimes( iaa.OneOf([ iaa.Dropout((0.02, 0.03)), iaa.Salt((0.02, 0.03)) ]) ), sometimes(iaa.ChannelShuffle(1.0)), #sometimes(iaa.Invert(1.0, per_channel=True)), #sometimes(iaa.Invert(1.0)), #sometimes(iaa.CropAndPad( # percent=(-0.1, 0.1), pad_cval=(0,255) #)), iaa.Affine( #scale={"x": (0.8, 1.1), "y": (0.8, 1.1)}, # scale images to 80-120% of their size, individually per axis rotate=(-10, 10), # rotate by -45 to +45 degrees mode=ia.ALL # use any of scikit-image's warping modes (see 2nd image from the top for examples) ), sometimes(iaa.PerspectiveTransform(scale=(0.01, 0.04))), sometimes(iaa.AdditiveGaussianNoise((0.02, 0.1))), sometimes(iaa.AdditivePoissonNoise((0.02,0.1))), #sometimes(iaa.Pad( # percent=(0, 0.15), pad_mode=["edge"] #)) ])
def __init__(self): sometimes = lambda aug: iaa.Sometimes(0.3, aug) self.seq = iaa.Sequential([ sometimes(iaa.CropToFixedSize(width=640, height=640)), iaa.Fliplr(0.5), iaa.Flipud(0.5), iaa.MultiplyAndAddToBrightness(mul=(0.9, 1.1), add=(-5, 5)), iaa.Affine( rotate=(-380, 380), scale=(0.7, 1.3), translate_percent={ 'x': (-0.2, 0.2), 'y': (-0.2, 0.2) }, #mode=['symmetric', 'reflect'], # bbox는 reflect 되지 않음 cval=(0, 0)), sometimes( iaa.SomeOf(1, [ iaa.GaussianBlur(sigma=(0.6, 1.4)), iaa.AverageBlur(k=(1, 3)), iaa.MedianBlur(k=(1, 3)), iaa.BilateralBlur(d=(5, 7), sigma_space=(10, 250)) ])), sometimes(iaa.PerspectiveTransform(scale=(0.01, 0.11))), sometimes(iaa.Grayscale(alpha=(0.0, 0.3))), ])
def augment_function(augmentation_probability): sometimes_aug = lambda aug: iaa.Sometimes(augmentation_probability, aug) # sometimes augment function seq = iaa.Sequential( [ sometimes_aug(iaa.Add((-50, 50))), iaa.Fliplr(augmentation_probability), sometimes_aug(iaa.Affine( scale={ 'x': (0.8, 1.2), 'y': (0.8, 1.2), }, translate_percent={ 'x': (-0.1, 0.1), 'y': (-0.1, 0.1) }, shear=(-30, 30), )), sometimes_aug(iaa.PerspectiveTransform( scale=(0.0, 0.08), keep_size=True, )) ] ) return seq
def test_TGS_salt_aug_callback(): # image + mask # from 101*101 x, y = load_sample_image() x = x[:5] y = y[:5] # x = np.concatenate([x[:1] for i in range(5)]) # y = np.concatenate([y[:1] for i in range(5)]) import random ia.seed(random.randint(1, 10000)) sometimes = lambda aug: iaa.Sometimes(0.5, aug) # bright add # contrast multiply seq = iaa.Sequential([ iaa.OneOf([ iaa.PiecewiseAffine((0.002, 0.1), name='PiecewiseAffine'), iaa.Affine(rotate=(-20, 20)), iaa.Affine(shear=(-45, 45)), iaa.Affine(translate_percent=(0, 0.3), mode='symmetric'), iaa.Affine(translate_percent=(0, 0.3), mode='wrap'), iaa.PerspectiveTransform((0.0, 0.3)) ], name='affine'), iaa.Fliplr(0.5, name="horizontal flip"), iaa.Crop(percent=(0, 0.3), name='crop'), # image only iaa.OneOf([ iaa.Add((-45, 45), name='bright'), iaa.Multiply((0.5, 1.5), name='contrast')] ), iaa.OneOf([ iaa.AverageBlur((1, 5), name='AverageBlur'), # iaa.BilateralBlur(), iaa.GaussianBlur((0.1, 2), name='GaussianBlur'), iaa.MedianBlur((1, 7), name='MedianBlur'), ], name='blur'), # scale to 128 * 128 iaa.Scale((128, 128), name='to 128 * 128'), ]) activator = ActivatorMask(['bright', 'contrast', 'AverageBlur', 'GaussianBlur', 'MedianBlur']) hook_func = ia.HooksImages(activator=activator) n_iter = 5 tile = [] for idx in range(n_iter): print(idx) seq_det = seq.to_deterministic() image_aug = seq_det.augment_images(x) mask_aug = seq_det.augment_images(y, hooks=hook_func) tile += [image_aug] tile += [mask_aug] tile = np.concatenate(tile) plot.plot_image_tile(tile, title=f'test_image_aug', column=5, )
def word_persp_trans(self, img, p1=0.1, p2=0.1): seq = iaa.Sequential([ iaa.PerspectiveTransform(scale=(p1, p2), deterministic=True, keep_size=True) ]) img_aug = seq.augment_image(img) return img_aug
def __init__(self, thresh: float, scale_limit: list): self.name = "perspective" assert 0.0 <= thresh <= 1.0 self.thresh = thresh self.transform = iaa.PerspectiveTransform(scale=(scale_limit[0], scale_limit[1]), keep_size=True, fit_output=True)
def getAuger_online(contrast_range,Perspective_range): roate=random.randint(0,4) seq = iaa.Sequential([ iaa.Rot90(roate), iaa.ContrastNormalization(contrast_range), iaa.PerspectiveTransform(scale=Perspective_range), ], random_order=False) return seq
def geometric(): return iaa.OneOf([ iaa.Affine(scale=2.0), iaa.ElasticTransformation(alpha=(0.0, 70.0), sigma=5.0), iaa.PerspectiveTransform(scale=(0.01, 0.10)), # iaa.PiecewiseAffine(scale=(0.01, 0.05)), # iaa.Rot90((1, 3), keep_size=False) ])
def data_aug(img_paths): c = Configs() sometimes = lambda aug: iaa.Sometimes(0.5, aug) imgs = [] key_pts = [] fr_classes = [] for img_path in img_paths: img = cv2.imread(img_path) cv2.cvtColor(img, cv2.COLOR_BGR2RGB) imgs.append(img) if c.dataset_code in ['CCPD_FR']: vertices_info = CCPD_FR_vertices_info front_rear_info = CCPD_FR_front_rear_info elif c.dataset_code in ['vernex']: vertices_info = vernex_vertices_info front_rear_info = vernex_front_rear_info fr_classes.append(vernex_fr_class_info(img_path)) if c.model_code in [ 'Hourglass+Vernex_lp', 'Hourglass+WPOD', 'WPOD+WPOD' ]: vertices = np.array(vertices_info(img_path)) elif c.model_code in ['Hourglass+Vernex_lpfr', 'WPOD+vernex_lpfr']: vertices = np.array( vertices_info(img_path) + front_rear_info(img_path)) key_pts.append(vertices) seq = iaa.Sequential([ sometimes( iaa.Affine(scale={ "x": (0.5, 1), "y": (0.5, 1) }, shear=(-60, 60), rotate=(-25, 25), cval=255)), sometimes( iaa.PerspectiveTransform( scale=(0.05, 0.1), keep_size=False, cval=255)), iaa.AddToHueAndSaturation(value=(-50, 50)), iaa.Fliplr(0.5), iaa.Affine(scale=(0.2, 1), cval=255) ], random_order=True) ''' seq = iaa.Sequential([iaa.Fliplr(0.5)]) ''' imgs_aug, vertices_aug = seq(images=imgs, keypoints=key_pts) for img_aug in imgs_aug: cv2.cvtColor(img_aug, cv2.COLOR_RGB2BGR) return imgs_aug, vertices_aug, fr_classes
def extend_with_augmented_entries(roidb, dataset, aug_samples=1): """Flip each entry in the given roidb and return a new roidb that is the concatenation of the original roidb and the flipped entries. "Flipping" an entry means that that image and associated metadata (e.g., ground truth boxes and object proposals) are horizontally flipped. """ augmented_roidb = [] for aug_i in range(aug_samples): for entry in roidb: aug_seq = iaa.Sequential( [ iaa.Sometimes( 0.5, iaa.Sequential([ iaa.Fliplr( 0.1), # horizontally flip 50% of the images iaa.Flipud(0.1), iaa.Affine(scale=(0.7, 0.9), rotate=(-90, 90)), iaa.PerspectiveTransform(scale=(0.01, 0.1)), ]), iaa.Sequential([ iaa.Fliplr( 0.1), # horizontally flip 50% of the images iaa.Flipud(0.1), iaa.Affine(scale=(0.7, 0.9), rotate=(-90, 90), shear=(-8, 8)) ])), iaa.Sometimes( 0.3, iaa.SomeOf(3, [ iaa.MotionBlur(k=(5, 8), angle=(0, 25)), iaa.GammaContrast(gamma=(0.5, 1.75)), iaa.Add(value=(-10, 40)), iaa.AdditivePoissonNoise(lam=(5, 10)), iaa.CoarseDropout(p=0.05, size_percent=0.02) ])) ], random_order=True) seq_det = aug_seq.to_deterministic() boxes = entry['boxes'].copy() ia_boxes = ia.BoundingBoxesOnImage.from_xyxy_array( boxes, shape=(entry['height'], entry['width'], 3)) ia_boxes_aug = seq_det.augment_bounding_boxes([ia_boxes])[0] boxes = ia_boxes_aug.to_xyxy_array() augmented_entry = {} dont_copy = ('boxes', 'augmented') for k, v in entry.items(): if k not in dont_copy: augmented_entry[k] = v augmented_entry['boxes'] = boxes augmented_entry['augmented'] = (True, seq_det) augmented_roidb.append(augmented_entry) roidb.extend(augmented_roidb)
def __init__(self, options, data_path=None, sample_list=None, mode='train', encode_label=False): self.path = data_path if data_path != None else options.data_path self.output_scale = options.output_scale self.img_height = options.img_height self.img_width = options.img_width self.mode = mode self.encode_label = encode_label ## data samples sample_path = sample_list if sample_list != None else options.sample_path self.sample_list = open(sample_path).read().splitlines() self.n_class = 3 ia.seed(int(time.time())) self.aug_seq = iaa.OneOf([ iaa.Sequential([ iaa.Fliplr(0.5), iaa.PiecewiseAffine(scale=(0.0, 0.03)), iaa.PerspectiveTransform(scale=(0.0, 0.1)) ], random_order=True), iaa.Sequential([ iaa.Flipud(0.5), iaa.PiecewiseAffine(scale=(0.0, 0.03)), iaa.PerspectiveTransform(scale=(0.0, 0.1)) ], random_order=True), iaa.Sequential([ iaa.Fliplr(0.25), iaa.Dropout([0.05, 0.15]), iaa.PiecewiseAffine(scale=(0.0, 0.03)), iaa.PerspectiveTransform(scale=(0.0, 0.1)) ], random_order=True) ]) # transforms self.to_tensor = transforms.ToTensor() self.normalize = transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))
def __init__(self): self._img_allowed_scales = [0.25, 0.5, .75, 1, 1.25, 1.5, 2] sometimes = lambda aug: iaa.Sometimes(0.5, aug) self._aug_pipe_object = iaa.Sequential( [ iaa.Fliplr(0.5), sometimes(iaa.Affine( rotate=(-20, 20), )), iaa.SomeOf((0, 5), [ sometimes(iaa.Superpixels(p_replace=(0.20, 0.5), n_segments=(20, 100))), iaa.OneOf([ iaa.GaussianBlur((0, 3.0)), iaa.AverageBlur(k=(2, 7)), iaa.MedianBlur(k=(3, 11)), ]), sometimes(iaa.PerspectiveTransform(scale=(0.025, 0.075))), iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.05 * 255), per_channel=0.5), iaa.OneOf([ iaa.Dropout((0.01, 0.1), per_channel=0.5), iaa.CoarseDropout((0.03, 0.15), size_percent=(0.02, 0.05), per_channel=0.2), ]), iaa.Add((-10, 10), per_channel=0.5), iaa.Multiply((0.5, 1.5), per_channel=0.5), iaa.ContrastNormalization((0.5, 2.0), per_channel=0.5), ], random_order=True ) ], random_order=True ) self._aug_pipe_sample = iaa.Sequential( [ iaa.SomeOf((0, 3), [ sometimes(iaa.Superpixels(p_replace=(0.20, 0.5), n_segments=(20, 100))), iaa.OneOf([ iaa.GaussianBlur((0, 3.0)), iaa.AverageBlur(k=(2, 7)), iaa.MedianBlur(k=(3, 11)), ]), iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.05 * 255), per_channel=0.5), ], random_order=True ), iaa.Add((-25, 25), per_channel=0.5), iaa.Multiply((0.5, 1.5), per_channel=0.5), iaa.ContrastNormalization((0.5, 2.0), per_channel=0.5), ], random_order=True )
def perform_perspective_transform(x): magnitude = 0.15 X_norm = normalize(x) X_aug_norm = iaa.PerspectiveTransform( scale=(0.01, max(0.02, magnitude))).augment_image(X_norm) # first scale param must be larger np.clip(X_aug_norm, 0.0, 1.0, out=X_aug_norm) x = denormalize(X_aug_norm) return x
def main(): image = ia.quokka(size=0.5) kps = [ ia.KeypointsOnImage([ ia.Keypoint(x=245, y=203), ia.Keypoint(x=365, y=195), ia.Keypoint(x=313, y=269) ], shape=(image.shape[0] * 2, image.shape[1] * 2)) ] kps[0] = kps[0].on(image.shape) print("image shape:", image.shape) augs = [ iaa.PerspectiveTransform(scale=0.01, name="pt001", keep_size=True), iaa.PerspectiveTransform(scale=0.1, name="pt01", keep_size=True), iaa.PerspectiveTransform(scale=0.2, name="pt02", keep_size=True), iaa.PerspectiveTransform(scale=0.3, name="pt03", keep_size=True), iaa.PerspectiveTransform(scale=(0, 0.3), name="pt00to03", keep_size=True) ] print("original", image.shape) misc.imshow(kps[0].draw_on_image(image)) print("-----------------") print("Random aug per image") print("-----------------") for aug in augs: images_aug = [] for _ in range(16): aug_det = aug.to_deterministic() img_aug = aug_det.augment_image(image) kps_aug = aug_det.augment_keypoints(kps)[0] img_aug_kps = kps_aug.draw_on_image(img_aug) img_aug_kps = np.pad(img_aug_kps, ((1, 1), (1, 1), (0, 0)), mode="constant", constant_values=255) #print(aug.name, img_aug_kps.shape, img_aug_kps.shape[1]/img_aug_kps.shape[0]) images_aug.append(img_aug_kps) #misc.imshow(img_aug_kps) print(aug.name) misc.imshow(ia.draw_grid(images_aug))
def main(args): """String-pulling function Basically, channels the args in the right places and ensures that the required command-line arguments were passed to it """ # a hacky way to make sure env. variables don't come in empty if not all([args.extension]): raise RuntimeError("the following arguments are required: " "--extension") # load images and annotations images = load_images(extension=args.extension) size_y, size_x, channels = images[0].shape # FIXME: will break on BW! # FIXME this assumes all images are the same size. Not always true! annotations = load_annotations(size_x, size_y, channels) # 100 angles in +-15 deg range around each of the 90 deg rotations allowed_angles = np.array([ np.linspace(-15, 15, 100) + base_angle for base_angle in [0, 90, 180, 270] ]).flatten() transform = iaa.Sequential([ iaa.Affine(rotate=allowed_angles, fit_output=True), iaa.PerspectiveTransform(scale=(0.02, 0.15)) ]) n_times, update_freq = 100, 100 for i, (img, bbs) in enumerate( zip(mutliplier(images, n_times), mutliplier(annotations, n_times))): if not i % update_freq: logging.info("Augmentation progress: %d/%d", i + 1, len(images) * n_times) img_aug, bbs_aug = transform(image=img, bounding_boxes=bbs) # for local dev, can visualize the image with # imgaug.imshow(bbs_aug.draw_on_image(img_aug, size=15)) filename = str(uuid.uuid4()) fname_img_aug = str(OUTPUT_DIR / (filename + args.extension)) fname_bb_aug = str(OUTPUT_DIR / (filename + ".txt")) # write a shrunken image to a file size_aug_x, size_aug_y = img_aug.shape[:2][::-1] # numpy array out_img = Image.fromarray(img_aug) out_img.save(fname_img_aug) # place .txt yolo annotations alongside with open(fname_bb_aug, "w+") as csvfile: for bounding_box in bbs_aug: bb_clipped = bounding_box.clip_out_of_image(img_aug.shape) yolo_line = _xy_box_to_yolo_str(bb_clipped, size_aug_x, size_aug_y) csvfile.write(yolo_line + '\n')
def __call__(self, image): im = image.copy() pix = np.array(im, dtype='float32') pix = iaa.Fliplr(0.5).augment_image(pix) aug_ratate = iaa.OneOf([ iaa.PerspectiveTransform(scale=(0, 0.015)), iaa.Rotate((-10, 10)) ]) pix = aug_ratate.augment_image(pix) if self.istest: return pix pix = self.rand_brightness(pix) if random.randint(2): self.aumentone(pix) #distort = SSD_Compose(self.pd[:-1]) else: self.aumenttwo(pix) #distort = SSD_Compose(self.pd[1:]) #pix = distort(pix) #pix = pix.astype('uint8') pix = np.where(pix > 255, 255, pix) pix = np.where(pix < 0, 0, pix) #im = Image.fromarray(pix, 'RGB') #self.rand_light_noise(pix) # aug = iaa.Sequential(iaa.SomeOf(2, [ # iaa.AdditiveGaussianNoise(scale=(0, 0.1*255)), # iaa.Dropout(p=(0, 0.1), per_channel=0.5), # iaa.SaltAndPepper(p=(0, 0.1), per_channel=True), # iaa.GaussianBlur(sigma=(0.0, 3.0)), # iaa.MotionBlur(k=15, angle=[-45, 45]), # iaa.AverageBlur(k=((0, 5), (0, 5))) # ], random_order=True)) aug_noise = iaa.OneOf([ iaa.AdditiveGaussianNoise(scale=(0, 0.1 * 255)), iaa.Dropout(p=(0, 0.1), per_channel=0.5), iaa.SaltAndPepper(p=(0, 0.1), per_channel=True), ]) aug_blur = iaa.OneOf([ iaa.GaussianBlur(sigma=(0.0, 1.5)), iaa.MotionBlur(k=7, angle=[-20, 20]), iaa.AverageBlur(k=((0, 2.5), (0, 2.5))) ]) pix = aug_noise.augment_image(pix) pix = aug_blur.augment_image(pix) return pix / 255.0
def get_transform(train): transforms = iaa.Identity() if train: transforms = iaa.SomeOf((0, None), [ iaa.Affine(scale=(1.0, 1.5)), iaa.PerspectiveTransform(scale=(0.01, 0.1)), iaa.Fliplr(), iaa.MotionBlur(k=(3, 7)) ]) return transforms
def Tilt(self, image, **kwargs): # 透射改变视角, 即倾斜图片 assert len(image.shape) == 3 image_augs = [] List = [0, 0.03, 0.05, 0.07, 0.09] for scale in List: seq = iaa.Sequential([iaa.PerspectiveTransform(scale)]) image_aug = seq.augment_image(image) image_augs.append(image_aug) return image_augs, List
def augmentor(self, images, targets): '''Augments each batch of data with random transformations''' sometimes = lambda aug: iaa.Sometimes(0.5, aug) seq = iaa.Sequential([ iaa.Fliplr(0.5, name="Fliplr"), iaa.Flipud(0.5, name="Flipud"), sometimes( iaa.SomeOf((0, 2), [ iaa.Affine(translate_percent={ "x": (-0.1, 0.1), "y": (-0.1, 0.1) }, rotate=(-25, 25), name="Affine"), iaa.ElasticTransformation(alpha=(0.01, 0.1), sigma=0.15, name="ElasticTransformation"), iaa.PiecewiseAffine(scale=(0.001, 0.03), name="PiecewiseAffine"), iaa.PerspectiveTransform(scale=(0.01, 0.05), name="PerspectiveTransform"), ], random_order=True)), sometimes( iaa.OneOf([ iaa.GaussianBlur(sigma=(0, 0.2)), iaa.AverageBlur(k=3), iaa.MedianBlur(k=3), ])), sometimes( iaa.OneOf([ iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.01 * 255)), iaa.AddElementwise((-5, 5)), ])), sometimes( iaa.OneOf([ iaa.GammaContrast(gamma=(0.75, 1.50)), iaa.HistogramEqualization(), iaa.Multiply((0.80, 1.15)), iaa.Add((-20, 15)), iaa.Sharpen(alpha=(0, 0.5), lightness=(0.7, 1.5)), iaa.Emboss(alpha=(0, 0.5), strength=(0.7, 1.5)), ])), ], random_order=True) seq_det = seq.to_deterministic() images = seq_det.augment_images(images) targets = seq_det.augment_segmentation_maps([ ia.SegmentationMapOnImage(t.astype(bool), shape=t.shape) for t in targets ]) targets = np.array([t.get_arr_int() for t in targets]) return images, targets
def __init__(self): self.img_h = 560 self.img_w = 1280 ia.seed(2) self.seq = iaa.Sequential([ iaa.CropToFixedSize(width=500, height=500, position='uniform'), #crop iaa.PerspectiveTransform(scale=(0, 0.40), keep_size=True, cval=0), #perspective iaa.Affine( scale={ "x": (0.5, 2.0), "y": (0.5, 2.0) }, #scale, rotation rotate=(-180, 180), cval=0), iaa.CropToFixedSize(width=256, height=256, position='center'), #set size iaa.Fliplr(0.5), #flip iaa.Multiply((0.5, 1.5)), #brightness iaa.Sharpen(alpha=(0.0, 0.4), lightness=(0.8, 1.2)), sometimes( iaa.OneOf([ iaa.AverageBlur(k=(1, 3)), iaa.MedianBlur(k=(1, 3)), iaa.GaussianBlur(sigma=(0, 0.2)) ])), sometimes( iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.05 * 255), per_channel=0.5)), sometimes(iaa.Grayscale((0.0, 1.0))) ]) self.examples = [] for train_dir in train_data_path: file_dir = os.path.join(train_dir, "*.png") file_list = glob.glob(file_dir) for file_path in file_list: img_path = file_path.replace('Labels_', 'ColorImage_resize_') img_path = img_path.replace('Label', 'ColorImage') img_path = img_path.replace('_bin.png', '.jpg') label_path = file_path.replace('Labels_', 'Trainid_') if os.path.exists(img_path) and os.path.exists(label_path): example = {} example["img_path"] = img_path example["label_img_path"] = label_path self.examples.append(example) self.num_examples = len(self.examples)