Python源码示例:imgaug.augmenters.AddToHueAndSaturation()
示例1
def main():
image = data.astronaut()
cv2.namedWindow("aug", cv2.WINDOW_NORMAL)
cv2.imshow("aug", image)
cv2.waitKey(TIME_PER_STEP)
# for value in cycle(np.arange(-255, 255, VAL_PER_STEP)):
for value in np.arange(-255, 255, VAL_PER_STEP):
aug = iaa.AddToHueAndSaturation(value=value)
img_aug = aug.augment_image(image)
img_aug = iaa.pad(img_aug, bottom=40)
img_aug = ia.draw_text(img_aug, x=0, y=img_aug.shape[0]-38, text="value=%d" % (value,), size=30)
cv2.imshow("aug", img_aug)
cv2.waitKey(TIME_PER_STEP)
images_aug = iaa.AddToHueAndSaturation(value=(-255, 255), per_channel=True).augment_images([image] * 64)
ia.imshow(ia.draw_grid(images_aug))
image = ia.quokka_square((128, 128))
images_aug = []
images_aug.extend(iaa.AddToHue().augment_images([image] * 10))
images_aug.extend(iaa.AddToSaturation().augment_images([image] * 10))
ia.imshow(ia.draw_grid(images_aug, rows=2))
示例2
def test_augment_images__value_hue__multi_image_sampling(self):
base_img = self.create_base_image()
class _DummyParam(iap.StochasticParameter):
def _draw_samples(self, size, random_state):
return np.float32([10, 20, 30])
aug = iaa.AddToHueAndSaturation(value_hue=_DummyParam())
img_expected1 = self._add_hue_saturation(base_img, value_hue=10)
img_expected2 = self._add_hue_saturation(base_img, value_hue=20)
img_expected3 = self._add_hue_saturation(base_img, value_hue=30)
img_observed1, img_observed2, img_observed3 = \
aug.augment_images([base_img] * 3)
assert np.array_equal(img_observed1, img_expected1)
assert np.array_equal(img_observed2, img_expected2)
assert np.array_equal(img_observed3, img_expected3)
示例3
def test_augment_images__value_saturation__multi_image_sampling(self):
base_img = self.create_base_image()
class _DummyParam(iap.StochasticParameter):
def _draw_samples(self, size, random_state):
return np.float32([10, 20, 30])
aug = iaa.AddToHueAndSaturation(value_saturation=_DummyParam())
img_expected1 = self._add_hue_saturation(base_img, value_saturation=10)
img_expected2 = self._add_hue_saturation(base_img, value_saturation=20)
img_expected3 = self._add_hue_saturation(base_img, value_saturation=30)
img_observed1, img_observed2, img_observed3 = \
aug.augment_images([base_img] * 3)
assert np.array_equal(img_observed1, img_expected1)
assert np.array_equal(img_observed2, img_expected2)
assert np.array_equal(img_observed3, img_expected3)
示例4
def test_augment_images__value_hue_and_value_saturation(self):
base_img = self.create_base_image()
class _DummyParam(iap.StochasticParameter):
def _draw_samples(self, size, random_state):
return np.float32([10, 20, 30])
aug = iaa.AddToHueAndSaturation(value_hue=_DummyParam(),
value_saturation=_DummyParam()+40)
img_expected1 = self._add_hue_saturation(base_img, value_hue=10,
value_saturation=40+10)
img_expected2 = self._add_hue_saturation(base_img, value_hue=20,
value_saturation=40+20)
img_expected3 = self._add_hue_saturation(base_img, value_hue=30,
value_saturation=40+30)
img_observed1, img_observed2, img_observed3 = \
aug.augment_images([base_img] * 3)
assert np.array_equal(img_observed1, img_expected1)
assert np.array_equal(img_observed2, img_expected2)
assert np.array_equal(img_observed3, img_expected3)
示例5
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)
示例6
def create_augmenter(stage: str = "train"):
if stage == "train":
return iaa.Sequential([
iaa.Fliplr(0.5),
iaa.CropAndPad(px=(0, 112), sample_independently=False),
iaa.Affine(translate_percent={"x": (-0.4, 0.4), "y": (-0.4, 0.4)}),
iaa.SomeOf((0, 3), [
iaa.AddToHueAndSaturation((-10, 10)),
iaa.Affine(scale={"x": (0.9, 1.1), "y": (0.9, 1.1)}),
iaa.GaussianBlur(sigma=(0, 1.0)),
iaa.AdditiveGaussianNoise(scale=0.05 * 255)
])
])
elif stage == "val":
return iaa.Sequential([
iaa.CropAndPad(px=(0, 112), sample_independently=False),
iaa.Affine(translate_percent={"x": (-0.4, 0.4), "y": (-0.4, 0.4)}),
])
elif stage == "test":
return iaa.Sequential([])
示例7
def init_augmentations(self):
if self.transform_probability > 0 and self.use_imgaug:
augmentations = iaa.Sometimes(
self.transform_probability,
iaa.Sequential([
iaa.SomeOf(
(1, None),
[
iaa.AddToHueAndSaturation(iap.Uniform(-20, 20), per_channel=True),
iaa.GaussianBlur(sigma=(0, 1.0)),
iaa.LinearContrast((0.75, 1.0)),
iaa.PiecewiseAffine(scale=(0.01, 0.02), mode='edge'),
],
random_order=True
),
iaa.Resize(
{"height": (16, self.image_size.height), "width": "keep-aspect-ratio"},
interpolation=imgaug.ALL
),
])
)
else:
augmentations = None
return augmentations
示例8
def amaugimg(image):
#数据增强
image = cv2.cvtColor(np.asarray(image), cv2.COLOR_RGB2BGR)
seq = iaa.Sequential([
# iaa.Affine(rotate=(-5, 5),
# shear=(-5, 5),
# 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)
image = Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
return image
示例9
def test___init__(self):
aug = iaa.AddToHueAndSaturation((-20, 20))
assert is_parameter_instance(aug.value, iap.DiscreteUniform)
assert aug.value.a.value == -20
assert aug.value.b.value == 20
assert aug.value_hue is None
assert aug.value_saturation is None
assert is_parameter_instance(aug.per_channel, iap.Deterministic)
assert aug.per_channel.value == 0
示例10
def test___init___value_none(self):
aug = iaa.AddToHueAndSaturation(value_hue=(-20, 20),
value_saturation=[0, 5, 10])
assert aug.value is None
assert is_parameter_instance(aug.value_hue, iap.DiscreteUniform)
assert is_parameter_instance(aug.value_saturation, iap.Choice)
assert aug.value_hue.a.value == -20
assert aug.value_hue.b.value == 20
assert aug.value_saturation.a == [0, 5, 10]
assert is_parameter_instance(aug.per_channel, iap.Deterministic)
assert aug.per_channel.value == 0
示例11
def test___init___per_channel(self):
aug = iaa.AddToHueAndSaturation(per_channel=0.5)
assert aug.value is None
assert aug.value_hue is not None
assert aug.value_saturation is not None
assert is_parameter_instance(aug.per_channel, iap.Binomial)
assert np.isclose(aug.per_channel.p.value, 0.5)
示例12
def test__generate_lut_table(self):
def _hue(v):
return np.mod(v, 180)
def _sat(v):
return np.clip(v, 0, 255)
tables = iaa.AddToHueAndSaturation._generate_lut_table()
table_hue, table_saturation = tables
intensity_values = [0, 1, 128, 254, 255] # = pixel values
for iv in intensity_values:
with self.subTest(intensity=iv):
assert table_hue[0, iv] == _hue(iv-255) # add value: -255
assert table_hue[1, iv] == _hue(iv-254) # add value: -254
assert table_hue[254, iv] == _hue(iv-1) # add value: -1
assert table_hue[255, iv] == _hue(iv-0) # add value: 0
assert table_hue[256, iv] == _hue(iv+1) # add value: 1
assert table_hue[509, iv] == _hue(iv+254) # add value: 254
assert table_hue[510, iv] == _hue(iv+255) # add value: 255
assert table_saturation[0, iv] == _sat(iv-255) # input: -255
assert table_saturation[1, iv] == _sat(iv-254) # input: -254
assert table_saturation[254, iv] == _sat(iv-1) # input: -1
assert table_saturation[255, iv] == _sat(iv+0) # input: 0
assert table_saturation[256, iv] == _sat(iv+1) # input: 1
assert table_saturation[509, iv] == _sat(iv+254) # input: 254
assert table_saturation[510, iv] == _sat(iv+255) # input: 255
示例13
def test_augment_images(self):
base_img = self.create_base_image()
gen = itertools.product([False, True], ["cv2", "numpy"])
for per_channel, backend in gen:
with self.subTest(per_channel=per_channel, backend=backend):
aug = iaa.AddToHueAndSaturation(0, per_channel=per_channel)
aug.backend = backend
observed = aug.augment_image(base_img)
expected = base_img
assert np.allclose(observed, expected)
aug = iaa.AddToHueAndSaturation(30, per_channel=per_channel)
aug.backend = backend
observed = aug.augment_image(base_img)
expected = self._add_hue_saturation(base_img, 30)
diff = np.abs(observed.astype(np.float32) - expected)
assert np.all(diff <= 1)
aug = iaa.AddToHueAndSaturation(255, per_channel=per_channel)
aug.backend = backend
observed = aug.augment_image(base_img)
expected = self._add_hue_saturation(base_img, 255)
diff = np.abs(observed.astype(np.float32) - expected)
assert np.all(diff <= 1)
aug = iaa.AddToHueAndSaturation(-255, per_channel=per_channel)
aug.backend = backend
observed = aug.augment_image(base_img)
expected = self._add_hue_saturation(base_img, -255)
diff = np.abs(observed.astype(np.float32) - expected)
assert np.all(diff <= 1)
示例14
def test_augment_images__different_hue_and_saturation__no_per_channel(self):
base_img = self.create_base_image()
class _DummyParam(iap.StochasticParameter):
def _draw_samples(self, size, random_state):
arr = np.float32([10, 20])
return np.tile(arr[np.newaxis, :], (size[0], 1))
aug = iaa.AddToHueAndSaturation(value=_DummyParam(), per_channel=False)
img_expected = self._add_hue_saturation(base_img, value=10)
img_observed = aug.augment_image(base_img)
assert np.array_equal(img_observed, img_expected)
示例15
def test_augment_images__different_hue_and_saturation__per_channel(self):
base_img = self.create_base_image()
class _DummyParam(iap.StochasticParameter):
def _draw_samples(self, size, random_state):
arr = np.float32([10, 20])
return np.tile(arr[np.newaxis, :], (size[0], 1))
aug = iaa.AddToHueAndSaturation(value=_DummyParam(), per_channel=True)
img_expected = self._add_hue_saturation(
base_img, value_hue=10, value_saturation=20)
img_observed = aug.augment_image(base_img)
assert np.array_equal(img_observed, img_expected)
示例16
def test_augment_images__different_hue_and_saturation__mixed_perchan(self):
base_img = self.create_base_image()
class _DummyParamValue(iap.StochasticParameter):
def _draw_samples(self, size, random_state):
arr = np.float32([10, 20])
return np.tile(arr[np.newaxis, :], (size[0], 1))
class _DummyParamPerChannel(iap.StochasticParameter):
def _draw_samples(self, size, random_state):
assert size == (3,)
return np.float32([1.0, 0.0, 1.0])
aug = iaa.AddToHueAndSaturation(
value=_DummyParamValue(), per_channel=_DummyParamPerChannel())
img_expected1 = self._add_hue_saturation(
base_img, value_hue=10, value_saturation=20)
img_expected2 = self._add_hue_saturation(
base_img, value_hue=10, value_saturation=10)
img_expected3 = self._add_hue_saturation(
base_img, value_hue=10, value_saturation=20)
img_observed1, img_observed2, img_observed3, = \
aug.augment_images([base_img] * 3)
assert np.array_equal(img_observed1, img_expected1)
assert np.array_equal(img_observed2, img_expected2)
assert np.array_equal(img_observed3, img_expected3)
示例17
def test_augment_images__list_as_value(self):
base_img = self.create_base_image()
aug = iaa.AddToHueAndSaturation([0, 10, 20])
base_img = base_img[1:2, 0:1, :]
expected_imgs = [
iaa.AddToHueAndSaturation(0).augment_image(base_img),
iaa.AddToHueAndSaturation(10).augment_image(base_img),
iaa.AddToHueAndSaturation(20).augment_image(base_img)
]
assert not np.array_equal(expected_imgs[0], expected_imgs[1])
assert not np.array_equal(expected_imgs[1], expected_imgs[2])
assert not np.array_equal(expected_imgs[0], expected_imgs[2])
nb_iterations = 300
seen = dict([(i, 0) for i, _ in enumerate(expected_imgs)])
for _ in sm.xrange(nb_iterations):
observed = aug.augment_image(base_img)
for i, expected_img in enumerate(expected_imgs):
if np.allclose(observed, expected_img):
seen[i] += 1
assert np.sum(list(seen.values())) == nb_iterations
n_exp = nb_iterations / 3
n_exp_tol = nb_iterations * 0.1
assert all([n_exp - n_exp_tol < v < n_exp + n_exp_tol
for v in seen.values()])
示例18
def test_augment_images__value_saturation(self):
base_img = self.create_base_image()
for value_saturation in [-255, -254, -128, -64, -10,
0, 10, 64, 128, 254, 255]:
with self.subTest(value_hue=value_saturation):
aug = iaa.AddToHueAndSaturation(
value_saturation=value_saturation)
img_expected = self._add_hue_saturation(
base_img, value_saturation=value_saturation)
img_observed = aug(image=base_img)
assert np.array_equal(img_observed, img_expected)
示例19
def test_get_parameters(self):
aug = iaa.AddToHueAndSaturation((-20, 20), per_channel=0.5)
params = aug.get_parameters()
assert is_parameter_instance(params[0], iap.DiscreteUniform)
assert params[0].a.value == -20
assert params[0].b.value == 20
assert params[1] is None
assert params[2] is None
assert is_parameter_instance(params[3], iap.Binomial)
assert np.isclose(params[3].p.value, 0.5)
示例20
def test_pickleable(self):
aug = iaa.AddToHueAndSaturation(value_hue=(-50, 50),
value_saturation=(-50, 50),
seed=1)
runtest_pickleable_uint8_img(aug, iterations=10, shape=(50, 50, 3))
示例21
def test_returns_correct_class(self):
aug = iaa.AddToHue((-20, 20))
assert isinstance(aug, iaa.AddToHueAndSaturation)
assert is_parameter_instance(aug.value_hue, iap.DiscreteUniform)
assert aug.value_hue.a.value == -20
assert aug.value_hue.b.value == 20
示例22
def test_returns_correct_class(self):
aug = iaa.AddToSaturation((-20, 20))
assert isinstance(aug, iaa.AddToHueAndSaturation)
assert is_parameter_instance(aug.value_saturation, iap.DiscreteUniform)
assert aug.value_saturation.a.value == -20
assert aug.value_saturation.b.value == 20
示例23
def __init__(self):
self.imgaug_transform = iaa.AddToHueAndSaturation((20, 20), per_channel=False)
self.solt_stream = slc.Stream([slt.ImageRandomHSV(p=1, h_range=(20, 20), s_range=(20, 20), v_range=(20, 20))])
示例24
def get_augmentations():
# applies the given augmenter in 50% of all cases,
sometimes = lambda aug: iaa.Sometimes(0.5, aug)
# Define our sequence of augmentation steps that will be applied to every image
seq = iaa.Sequential([
# execute 0 to 5 of the following (less important) augmenters per image
iaa.SomeOf((0, 5),
[
iaa.OneOf([
iaa.GaussianBlur((0, 3.0)),
iaa.AverageBlur(k=(2, 7)),
iaa.MedianBlur(k=(3, 11)),
]),
iaa.Sharpen(alpha=(0, 1.0), lightness=(0.75, 1.5)),
iaa.Emboss(alpha=(0, 1.0), strength=(0, 2.0)),
# search either for all edges or for directed edges,
# blend the result with the original image using a blobby mask
iaa.SimplexNoiseAlpha(iaa.OneOf([
iaa.EdgeDetect(alpha=(0.5, 1.0)),
iaa.DirectedEdgeDetect(alpha=(0.5, 1.0), direction=(0.0, 1.0)),
])),
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), # randomly remove up to 10% of the pixels
iaa.CoarseDropout((0.03, 0.15), size_percent=(0.02, 0.05), per_channel=0.2),
]),
iaa.Add((-10, 10), per_channel=0.5), # change brightness of images (by -10 to 10 of original value)
iaa.AddToHueAndSaturation((-20, 20)), # change hue and saturation
# either change the brightness of the whole image (sometimes
# per channel) or change the brightness of subareas
iaa.OneOf([
iaa.Multiply((0.5, 1.5), per_channel=0.5),
iaa.FrequencyNoiseAlpha(
exponent=(-4, 0),
first=iaa.Multiply((0.5, 1.5), per_channel=True),
second=iaa.ContrastNormalization((0.5, 2.0))
)
]),
iaa.ContrastNormalization((0.5, 2.0), per_channel=0.5), # improve or worsen the contrast
sometimes(iaa.ElasticTransformation(alpha=(0.5, 3.5), sigma=0.25)), # move pixels locally around (with random strengths)
],
random_order=True
)
],
random_order=True
)
return seq
### data transforms