def __init__(self):
self.aug = iaa.Sequential([
iaa.Sometimes(
0.15,
iaa.OneOf([
iaa.GammaContrast(gamma=(0, 1.75)),
iaa.pillike.Autocontrast(cutoff=(0, 15.0))
])),
iaa.Sometimes(
0.15,
iaa.OneOf([
iaa.HistogramEqualization(),
iaa.pillike.Equalize(),
])),
iaa.Sometimes(0.1, iaa.Grayscale(alpha=(0.05, 1.0))),
iaa.Sometimes(0.2, iaa.JpegCompression(compression=(70, 99))),
iaa.Sometimes(0.1,
iaa.UniformColorQuantizationToNBits(nb_bits=(2, 8))),
iaa.Sometimes(
0.3,
iaa.MultiplyAndAddToBrightness(mul=(0.5, 1.5), add=(-30, 30))),
iaa.Sometimes(
0.2,
iaa.Cutout(
fill_mode="constant", cval=(0, 255), fill_per_channel=0.5))
],
random_order=True)
def data_aug(images):
seq = iaa.Sometimes(
0.5, iaa.Identity(),
iaa.Sometimes(
0.5,
iaa.Sequential([
iaa.Sometimes(
0.5,
iaa.OneOf([
iaa.AdditiveGaussianNoise(scale=(0, 0.1 * 255)),
iaa.AdditiveLaplaceNoise(scale=(0, 0.1 * 255)),
iaa.ReplaceElementwise(0.03, [0, 255]),
iaa.GaussianBlur(sigma=(0.0, 3.0)),
iaa.BilateralBlur(d=(3, 10),
sigma_color=(10, 250),
sigma_space=(10, 250))
])),
iaa.OneOf([
iaa.Add((-40, 40)),
iaa.AddElementwise((-20, 20)),
iaa.pillike.EnhanceBrightness()
]),
iaa.OneOf([
iaa.GammaContrast((0.2, 2.0)),
iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.4, 0.6)),
iaa.LogContrast(gain=(0.6, 1.4)),
iaa.AllChannelsCLAHE(),
iaa.Sharpen(alpha=(0.0, 1.0), lightness=(0.75, 2.0)),
])
])))
images = seq(images=images)
return images
def data_aug_v2(image, label, prob=0.5):
image = image.numpy()
aug = iaa.Sequential([
iaa.Sometimes(
prob,
iaa.OneOf(
[iaa.Multiply((0.4, 1.5)),
iaa.GammaContrast((0.3, 2.0))])),
iaa.Sometimes(
prob,
iaa.OneOf([
iaa.Grayscale((0, 0.3)),
iaa.ContrastNormalization((0.3, 2.5)),
iaa.AddToHueAndSaturation((-50, 50))
])),
iaa.Sometimes(
prob,
iaa.OneOf([
iaa.AverageBlur(k=((1, 4), (1, 4))),
iaa.GaussianBlur(sigma=(0.0, 1.5)),
iaa.MedianBlur(k=(1, 5)),
iaa.MotionBlur(k=[5, 19], angle=(0, 360))
])),
iaa.Sometimes(
prob, iaa.AdditiveGaussianNoise(scale=(0, 10), per_channel=0.5))
])
image = aug.augment_image(image)
image = (image / 255).astype(dtype=np.float32)
return image, label
def __getitem__(self, item):
data_item = self.data_list[item]
data_path = data_item["..."]
label = data_item["label"]
# 读图
raw_data = cv2.imread(data_path)
# raw_data = cv2.resize(raw_data, (W, H))
seq = iaa.Sequential([
iaa.Fliplr(0.5),
iaa.Crop(percent=(0, 0.1)),
iaa.Sometimes(0.5, iaa.GaussianBlur(sigma=(0, 0.5))),
iaa.Sometimes(0.5, iaa.GammaContrast((0.6, 1.67))),
iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.05*255)),
iaa.Multiply((0.8, 1.2), per_channel=0.2),
iaa.Affine(
scale={"x": (0.8, 1.2), "y": (0.8, 1.2)},
translate_percent={"x": (-0.2, 0.2), "y": (-0.2, 0.2)},
rotate=(-25, 25),
shear=(-8, 8)
)], random_order=True)
seq_same = seq.to_deterministic()
if self.mode == "train":
# cv2.imwrite('./data/original'+str(item)+'.png', raw_data) # 保存原图
processed_data = seq_same(image=raw_data)
# cv2.imwrite('./data/augmentation'+str(item)+'.png', processed_data) # 观察增强效果
else:
processed_data = raw_data
data = torch.from_numpy(processed_data.transpose((2, 0, 1)).astype(np.float32)/255)
label = torch.from_numpy(np.array(label, dtype=np.int64))
return data, label
def process_image_iaa(img):
sometimes = lambda aug: iaa.Sometimes(0.5, aug)
seq = iaa.Sequential([
sometimes(iaa.Crop(percent=(0, 0.2))),
sometimes(iaa.GammaContrast((0.5, 1.5))),
sometimes(iaa.Sharpen(alpha=(0, 0.5), lightness=(0.8, 1.2))),
sometimes(iaa.Affine(
scale={"x": (0.8, 1.2), "y": (0.8, 1.2)},# scale images to 80-120% of their size, individually per axis
translate_percent={"x": (-0.2, 0.2), "y": (-0.2, 0.2)}, # translate by -20 to +20 percent (per axis)
rotate=(-45, 45), # rotate by -45 to +45 degrees
shear=(-16, 16), # shear by -16 to +16 degrees
order=[0, 1], # use nearest neighbour or bilinear interpolation (fast)
cval=(0, 255), # if mode is constant, use a cval between 0 and 255
mode=ia.ALL # use any of scikit-image's warping modes (see 2nd image from the top for examples)
)),
iaa.Fliplr(0.5),
iaa.Flipud(0.5),
iaa.SomeOf((0, 4), [
iaa.Affine(rotate=90),
iaa.Affine(rotate=180),
iaa.Affine(rotate=270),
]),
sometimes(iaa.OneOf([
iaa.GaussianBlur((0, 0.5)), # blur images with a sigma between 0 and 3.0
iaa.AverageBlur(k=(2, 5)), # blur image using local means with kernel sizes between 2 and 7
iaa.MedianBlur(k=(3, 5)), # blur image using local medians with kernel sizes between 2 and 7
])),
], random_order=True)
image_aug = seq.augment_image(img)
return image_aug
def contrast(image_np, save_dir, input_filename, is_groud_true, out_count=1):
"""
Change the constrast of images: GammaContrast
:param image_np: 'images' should be either a 4D numpy array of shape (N, height, width, channels)
:param save_dir:
:param input_filename: File base name (e.g basename.tif)
:param is_groud_true: if ground truth, just copy the image
:param :
:return:
"""
file_basename = os.path.basename(input_filename)
basename = os.path.splitext(file_basename)[0]
ext = os.path.splitext(file_basename)[1]
for idx in range(out_count):
save_path = os.path.join(save_dir,
basename + '_contrast' + str(idx) + ext)
if is_groud_true is True:
# just copy the groud true
images_con = image_np
else:
contrast = iaa.GammaContrast(
(0.5, 1.5)
) # a random gamma value between the range, a large gamma make image darker
images_con = contrast.augment_image(image_np)
io.imsave(save_path, images_con)
return True
def augument(impath):
ia.seed(1)
image = imageio.imread(impath)
bbs = BoundingBoxesOnImage([
BoundingBox(x1=170, y1=130, x2=252, y2=248, label='18'),
BoundingBox(x1=100, y1=154, x2=120, y2=175, label='1')
],
shape=image.shape)
ia.imshow(bbs.draw_on_image(image, size=2))
# apply augumentation
# We choose a simple contrast augmentation (affects only the image) and an affine transformation (affects image and bounding boxes).
seq = iaa.Sequential([
iaa.GammaContrast(1.5),
iaa.Affine(translate_percent={"x": 0.1}, scale=0.8)
])
image_aug, bbs_aug = seq(image=image, bounding_boxes=bbs)
ia.imshow(bbs_aug.draw_on_image(image_aug, size=2))
# we apply an affine transformation consisting only of rotation.
image_aug, bbs_aug = iaa.Affine(rotate=50)(image=image, bounding_boxes=bbs)
ia.imshow(bbs_aug.draw_on_image(image_aug))
def build_augmenter(self):
augmenter = iaa.Sometimes(
0.7,
iaa.Sequential([
iaa.Sequential([
iaa.Resize(
{
'longer-side': (96, 48),
'shorter-side': 'keep-aspect-ratio'
},
interpolation=ia.ALL),
iaa.Resize(
{
'longer-side': self.config.image_size,
'shorter-side': 'keep-aspect-ratio'
},
interpolation=ia.ALL)
]),
iaa.Affine(
scale=(0.8, 1.2),
translate_percent={
"x": (-0.2, 0.2),
"y": (-0.2, 0.2)
},
rotate=(-15, 15),
order=[0, 1],
mode=ia.ALL,
),
iaa.OneOf([
iaa.Noop(),
iaa.Multiply((0.2, 2.0)),
iaa.GammaContrast((0.5, 1.7)),
]),
iaa.OneOf([
iaa.Noop(),
iaa.JpegCompression(compression=(85, 95)),
iaa.GaussianBlur(sigma=(0.75, 2.25)),
iaa.MotionBlur(k=(10, 15))
]),
iaa.OneOf([
iaa.Noop(),
iaa.OneOf([
iaa.Crop(percent=((0.2, 0.5), 0, 0, 0),
keep_size=False),
iaa.Crop(percent=(0, (0.2, 0.5), 0, 0),
keep_size=False),
iaa.Crop(percent=(0, 0, (0.2, 0.5), 0),
keep_size=False),
iaa.Crop(percent=(0, 0, 0, (0.2, 0.5)),
keep_size=False),
iaa.Crop(percent=((0.1, 0.3), 0, (0.1, 0.3), 0),
keep_size=False),
iaa.Crop(percent=(0, (0.1, 0.3), 0, (0.1, 0.3)),
keep_size=False)
]),
iaa.PerspectiveTransform(0.1)
])
]))
return augmenter
def chapter_augmenters_gammacontrast():
fn_start = "contrast/gammacontrast"
aug = iaa.GammaContrast((0.5, 2.0))
run_and_save_augseq(fn_start + ".jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
cols=4,
rows=2)
aug = iaa.GammaContrast((0.5, 2.0), per_channel=True)
run_and_save_augseq(fn_start + "_per_channel.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
cols=4,
rows=2)
def augment():
return iaa.SomeOf(
(0, 4),
[
# iaa.Add((-50, 50)),
iaa.CropAndPad(percent=(-0.4, 0.4)),
iaa.Fliplr(0.5),
iaa.Flipud(0.5),
iaa.Affine(scale={
"x": (0.85, 1.15),
"y": (0.85, 1.15)
},
translate_percent={
"x": (-0.15, 0.15),
"y": (-0.15, 0.15)
},
rotate=(-90, 90)),
iaa.SomeOf(
(1, 3),
[
iaa.Dropout(p=(0.01, 0.2)),
iaa.GaussianBlur(sigma=(0.0, 1.5)),
iaa.AverageBlur(k=(3, 7)),
# iaa.MedianBlur(k=(3, 7)),
iaa.MotionBlur(k=(3, 7)),
iaa.AdditiveGaussianNoise(scale=(0, 0.1 * 255)),
iaa.SaltAndPepper(p=0.2),
iaa.GammaContrast((0.5, 2.0))
])
],
random_order=True)
def __init__(self):
self.aug = iaa.Sequential([
iaa.Sometimes(0.75, iaa.GammaContrast((0.8, 1.25)) ),
iaa.Fliplr(0.5),
iaa.Sometimes(0.75, iaa.Affine(rotate=(-15, 15)) ),
])
def get_training_augmentation(**kwargs):
seq = iaa.Sequential([
iaa.Resize({
'height': kwargs['crop_sz'],
'width': kwargs['crop_sz']
}),
iaa.flip.Fliplr(p=0.5),
iaa.OneOf(
[iaa.GaussianBlur(sigma=(0.0, 1.0)),
iaa.MotionBlur(k=(3, 5))]),
iaa.OneOf([
iaa.GammaContrast((0.8, 1.0)),
iaa.LinearContrast((0.75, 1.5)),
iaa.LogContrast((0.8, 1.0))
]),
iaa.AdditiveGaussianNoise(loc=0,
scale=(0.0, 0.05 * 255),
per_channel=0.5),
iaa.Crop(px=(0, 2 * (kwargs['crop_sz'] - kwargs['inp_sz']))),
iaa.Resize({
'height': kwargs['inp_sz'],
'width': kwargs['inp_sz']
})
])
return seq
def __augmentation_operations(self):
self.aug_ops = iaa.Sequential([
self.__sometimes(iaa.Fliplr(1), 0.5),
self.__sometimes(
iaa.Affine(scale=iap.Uniform(1.0, 1.2).draw_samples(1)), 0.3),
self.__sometimes(iaa.AdditiveGaussianNoise(scale=0.05 * 255), 0.2),
self.__sometimes(
iaa.OneOf([
iaa.CropAndPad(percent=(iap.Uniform(
0.0, 0.20).draw_samples(1)[0], iap.Uniform(
0.0, 0.20).draw_samples(1)[0]),
pad_mode=["constant"],
pad_cval=(0, 128)),
iaa.Crop(
percent=(iap.Uniform(0.0, 0.15).draw_samples(1)[0],
iap.Uniform(0.0, 0.15).draw_samples(1)[0]))
])),
self.__sometimes(
iaa.OneOf([
iaa.LogContrast(
gain=iap.Uniform(0.9, 1.2).draw_samples(1)),
iaa.GammaContrast(
gamma=iap.Uniform(1.5, 2.5).draw_samples(1))
]))
],
random_order=True)
return None
def __init__(self, data_root, image_shape, plus1, mode, \
use_subset=False, no_flow=False, precomputed_val=None, \
sample_length=5):
self.no_flow = no_flow
self.mode = mode
self.precomputed_val = precomputed_val
self.sample_length = sample_length
assert self.mode in ['train', 'val']
if self.precomputed_val is not None:
assert self.mode == 'val'
self.data_root = data_root
if plus1:
self.image_shape = [image_shape[0] + 1, image_shape[1] + 1]
else:
self.image_shape = list(image_shape)
setname = '{}_videos_subset.txt' if use_subset else '{}_videos.txt'
setname = setname.format(self.mode)
with open(os.path.join(self.data_root, 'frame_corr.json'), 'r') as f:
self.frame_corr = json.load(f)
with open(os.path.join(self.data_root, setname), 'r') as f:
self.samples = self.parse(f)
#self.samples = self.samples[:240]
self.dataset_length = len(self.samples)
# apply to fg, bg
self.pixel_aug = iaa.Sequential([
iaa.MultiplyHueAndSaturation(mul=iap.TruncatedNormal(
1.0, 0.2, 0.5, 1.5)), # mean, std, low, high
iaa.GammaContrast(gamma=iap.TruncatedNormal(1.0, 0.2, 0.5, 1.5)),
iaa.AddToHue(value=iap.TruncatedNormal(0.0, 0.1 * 100, -0.2 *
255, 0.2 * 255)),
])
self.jpeg_aug = iaa.Sometimes(
0.6, iaa.JpegCompression(compression=(70, 99)))
def aug(self, img):
seq = iaa.Sequential(
[iaa.GammaContrast(gamma=1.5),
iaa.GaussianBlur(sigma=(0, 2.))])
return seq(images=img)
def __init__(self):
self.aug = iaa.Sequential([
iaa.Sometimes(0.2, iaa.GaussianBlur(sigma=(0, 3.0))),
iaa.Affine(rotate=(-20, 20), mode='symmetric'),
iaa.Sometimes(0.2, iaa.GammaContrast((0.5, 2.0)))
# iaa.AddToHueAndSaturation(value=(-10, 10), per_channel=True)
])
def augment_3(self, image, depth, lidar, crop_size, degree):
# rsz = iaa.Resize({"height": resize_size[0], "width": resize_size[1]})
seq = iaa.Sequential(
[
iaa.PadToFixedSize(height=crop_size[0],
width=crop_size[1]), # 保证可crop
iaa.CropToFixedSize(height=crop_size[0],
width=crop_size[1]), # random crop
iaa.Fliplr(0.5),
# iaa.Flipud(0.5),
iaa.Rotate((-degree, degree)),
iaa.GammaContrast((0.9, 1.1)),
iaa.Multiply((0.9, 1.1)),
],
random_order=True)
depth, lidar = np.expand_dims(depth, 2), np.expand_dims(lidar, 2)
tmp = np.concatenate((depth, lidar), axis=2)
tmp = (tmp * 1000).astype(np.int32) # 米单位*1000保留精度
tmp = SegmentationMapsOnImage(tmp, shape=tmp.shape)
# image, tmp = rsz(image=image, segmentation_maps=tmp)
image, tmp = seq(image=image, segmentation_maps=tmp)
tmp = tmp.arr
tmp = tmp.astype(np.float32) / 1000 # 再转回米
depth, lidar = tmp[:, :, 0], tmp[:, :, 1]
return image, depth, lidar
def __init__(self, dataset_path, batch_size):
self.size = 128
self.batch_size = batch_size
self.names = {}
self.boxes = self.load_bbox(dataset_path)
self.count = len(self.boxes)
self.num_classes = len(self.names)
self.seq = np.arange(self.count)
np.random.shuffle(self.seq)
sometimes = lambda aug: iaa.Sometimes(0.5, aug)
self.aug = iaa.Sequential([
iaa.Fliplr(0.5), # horizontally flip 50% of the images
iaa.GaussianBlur(
sigma=(0, 2.0)), # blur images with a sigma of 0 to 2.0
iaa.GammaContrast(gamma=(0.3, 2.0)),
iaa.AdditiveGaussianNoise(loc=0,
scale=(0.0, 0.01 * 255),
per_channel=0.5),
sometimes(iaa.PiecewiseAffine(scale=(0.01, 0.05))),
])
# Train eval split
self.count_train = int(self.count * 0.9)
self.count_eval = self.count - self.count_train
self.eval_dataset = self.EvalDataset(self)
def __init__(self):
self.aug = iaa.Sequential([
# iaa.Sometimes(0.25, iaa.GammaContrast(gamma=(0, 1.75))),
# iaa.Sometimes(0.25, iaa.GaussianBlur(sigma=(0, 1.3))),
# iaa.Sometimes(0.25, iaa.pillike.Autocontrast(cutoff=(0, 15.0))),
# iaa.Grayscale(alpha=(0.0, 1.0)),
# iaa.Sometimes(0.15, iaa.MotionBlur(k=5, angle=[-45, 45])),
iaa.Sometimes(
0.35,
iaa.OneOf([
iaa.MultiplyAndAddToBrightness(mul=(0.5, 1.5),
add=(-30, 30)),
iaa.GammaContrast(gamma=(0, 1.75)),
iaa.pillike.Autocontrast(cutoff=(0, 15.0)),
iaa.Sometimes(0.25, iaa.GaussianBlur(sigma=(0, 1.3)))
])),
# iaa.Fliplr(0.5),
# iaa.Sometimes(0.35,
# iaa.OneOf([iaa.Dropout(p=(0, 0.1)),
# iaa.Dropout2d(p=0.5),
# iaa.CoarseDropout(0.1, size_percent=0.5),
# iaa.SaltAndPepper(0.1),
# ])),
# iaa.Sometimes(0.15,
# iaa.OneOf([
# iaa.Clouds(),
# iaa.Fog(),
# iaa.Snowflakes(flake_size=(0.1, 0.4), speed=(0.01, 0.05)),
# iaa.Rain(speed=(0.1, 0.3))
# ])),
# iaa.Sometimes(0.5, iaa.MultiplyAndAddToBrightness(mul=(0.5, 1.5), add=(-30, 30)))
])
def __init__(self, scale_size, crop_size):
self.aug = iaa.Sequential([
iaa.Scale((scale_size, scale_size)),
iaa.Sometimes(
0.25,
iaa.OneOf([
iaa.GaussianBlur(sigma=(0, 3.0)),
iaa.AverageBlur(k=(1, 5)),
iaa.MedianBlur(k=(1, 5))
])),
iaa.Fliplr(p=0.5),
iaa.Affine(rotate=(-20, 20), mode='symmetric'),
iaa.Sometimes(
0.25,
iaa.OneOf([
iaa.Dropout(p=(0, 0.1)),
iaa.Add((-20, 20)),
iaa.SaltAndPepper(p=0.01),
])),
iaa.Sometimes(
0.25,
iaa.OneOf([
iaa.AddToHueAndSaturation(value=(-10, 10),
per_channel=True),
iaa.Grayscale(alpha=(0, 1.0))
])),
iaa.GammaContrast(gamma=(0.5, 1.5))
])
self.crop_size = crop_size
def apply_augmentation(images):
seq = iaa.Sequential([
# Blur
iaa.SomeOf((0, 1), [
iaa.GaussianBlur(sigma=(1., 2.5)),
iaa.AverageBlur(k=(2, 5))
]),
# Rotation and padding
iaa.SomeOf((0,1), [
iaa.Affine(translate_percent={"x": (-0.1, 0.1), "y": (-0.1, 0.1)}),
]),
# Light
iaa.SomeOf((0,2), [
iaa.GammaContrast((0.5, 2.0)),
iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.4, 0.6)),
iaa.Multiply((0.5, 1.5)),
iaa.ContrastNormalization((0.5, 1.5))
]),
# Noise
iaa.SomeOf((0, 1), [
iaa.AdditiveGaussianNoise(scale=(0, 0.1*255)),
iaa.AdditiveLaplaceNoise(scale=(0, 0.1*255)),
iaa.SaltAndPepper(0.02),
])
])
image = seq(images=images)
return image
def imgaugRGB(img):
print(img.shape)
seq = iaa.Sequential(
[
# blur
iaa.SomeOf((0, 2), [
iaa.GaussianBlur((0.0, 2.0)),
iaa.AverageBlur(k=(3, 7)),
iaa.MedianBlur(k=(3, 7)),
iaa.BilateralBlur(d=(1, 7)),
iaa.MotionBlur(k=(3, 7))
]),
#color
iaa.SomeOf(
(0, 2),
[
#iaa.WithColorspace(),
iaa.AddToHueAndSaturation((-20, 20)),
#iaa.ChangeColorspace(to_colorspace[], alpha=0.5),
iaa.Grayscale(alpha=(0.0, 0.2))
]),
#brightness
iaa.OneOf([
iaa.Sequential([
iaa.Add((-10, 10), per_channel=0.5),
iaa.Multiply((0.5, 1.5), per_channel=0.5)
]),
iaa.Add((-10, 10), per_channel=0.5),
iaa.Multiply((0.5, 1.5), per_channel=0.5),
iaa.FrequencyNoiseAlpha(exponent=(-4, 0),
first=iaa.Multiply(
(0.5, 1.5), per_channel=0.5),
second=iaa.ContrastNormalization(
(0.5, 2.0), per_channel=0.5))
]),
#contrast
iaa.SomeOf((0, 2), [
iaa.GammaContrast((0.5, 1.5), per_channel=0.5),
iaa.SigmoidContrast(
gain=(0, 10), cutoff=(0.25, 0.75), per_channel=0.5),
iaa.LogContrast(gain=(0.75, 1), per_channel=0.5),
iaa.LinearContrast(alpha=(0.7, 1.3), per_channel=0.5)
]),
#arithmetic
iaa.SomeOf((0, 3), [
iaa.AdditiveGaussianNoise(scale=(0, 0.05), per_channel=0.5),
iaa.AdditiveLaplaceNoise(scale=(0, 0.05), per_channel=0.5),
iaa.AdditivePoissonNoise(lam=(0, 8), per_channel=0.5),
iaa.Dropout(p=(0, 0.05), per_channel=0.5),
iaa.ImpulseNoise(p=(0, 0.05)),
iaa.SaltAndPepper(p=(0, 0.05)),
iaa.Salt(p=(0, 0.05)),
iaa.Pepper(p=(0, 0.05))
]),
#iaa.Sometimes(p=0.5, iaa.JpegCompression((0, 30)), None),
],
random_order=True)
return seq.augment_image(img)
def __init__(self):
self.aug = iaa.Sequential([
iaa.Fliplr(0.5),
iaa.Affine(rotate=(-90, 90), mode='symmetric'),
iaa.GammaContrast((0.5, 1.5)),
iaa.Multiply((0.5, 1.5)),
iaa.AddToHueAndSaturation(value=(-10, 10), per_channel=True)
])
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 non_spatial(self, cfg):
aug = iaa.Sequential([
iaa.AddToHueAndSaturation(value_hue=[-11, 11],
value_saturation=[-10, 10],
from_colorspace='BGR'),
iaa.GammaContrast()
])
# iaa.GammaContrast((0.5, 2.0), per_channel=True)
return aug
def change_gamma_contrast(self, image: np.ndarray) -> np.ndarray:
gamma = random.random() * 4
gamma = gamma if gamma > 0 else gamma * -1
gamma = gamma * 2 if gamma > 1 else gamma / 2
gamma = max(2, gamma)
gamma = min(0.5, gamma)
contrast = iaa.GammaContrast(gamma=gamma)
return contrast.augment_image(image)
def contrast():
return iaa.OneOf([
iaa.ContrastNormalization((0.5, 1.5), per_channel=0.5),
iaa.GammaContrast((0.5, 1.5), per_channel=0.5),
iaa.HistogramEqualization(),
iaa.LinearContrast((0.5, 1.5), per_channel=0.5),
iaa.LogContrast((0.5, 1.5), per_channel=0.5),
iaa.SigmoidContrast((5, 20), (0.25, 0.75), per_channel=0.5),
])
def np_augmentation(images, heatmaps):
seq = iaa.Sequential([
iaa.GaussianBlur((0, 1.0)),
iaa.Fliplr(0.5),
iaa.Flipud(0.5),
iaa.GammaContrast((0.8, 1.2)),
iaa.Affine(scale=(0.95, 1.05), rotate=(-180, 180), translate_px={"x": (-50, 50), 'y': (-50, 50)})
])
return seq(images=images.numpy(), heatmaps=heatmaps.numpy())
def brightness(self):
logging.warning('Darking')
for img, filename in zip(self.images, self.filenames):
contrast = iaa.GammaContrast(gamma=2.0)
contrast_image = contrast.augment_image(img)
cv2.imwrite(
self.base + self.path__dark_brightness + filename +
'_dark_brightness.png', contrast_image)
logging.warning('Done.')
def __init__(self):
self.aug = iaa.SomeOf(
(1, 2),
[
iaa.GammaContrast((0.5, 2.0)),
iaa.Multiply(),
iaa.GaussianBlur(1.0),
iaa.AddToHueAndSaturation(value=(-10, 10),
per_channel=True) # 增加飽和度
])
