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)
