def __glass_blur(self,img):
transform = A.Compose([
A.GlassBlur(sigma=2.0,max_delta=3),
A.GlassBlur(sigma=4.0,max_delta=1),
A.GlassBlur(sigma=1.0,max_delta=5),
])
transformed = transform(image=img)
transformed_image = transformed["image"]
return transformed_image
def __init__(self, data_dir, is_train=True):
self.paths = sorted(glob.glob(data_dir + '/*/*'))
self.transform_train = A.Compose([
A.Resize(height=1000, width=1000),
A.RandomBrightnessContrast(brightness_limit=0.1,
contrast_limit=0.1,
p=0.5),
A.RandomGamma(p=0.5),
A.HorizontalFlip(p=0.5),
A.OneOf([
A.MotionBlur(blur_limit=3),
A.GlassBlur(max_delta=3),
A.GaussianBlur(blur_limit=3)
],
p=0.5),
A.GaussNoise(p=0.5),
A.Normalize(mean=(0.446, 0.469, 0.472),
std=(0.326, 0.330, 0.338),
max_pixel_value=255.0,
p=1.0),
ToTensorV2(p=1.0),
])
self.transform_valid = A.Compose([
A.Resize(height=1000, width=1000),
A.Normalize(mean=(0.446, 0.469, 0.472),
std=(0.326, 0.330, 0.338),
max_pixel_value=255.0,
p=1.0),
ToTensorV2(p=1.0),
])
if is_train:
self.data_transforms = self.transform_train
else:
self.data_transforms = self.transform_valid
def c_crop_g_blur(i_height=256, i_width=256, p=1.0):
return albumentations.Compose([
albumentations.CenterCrop(height=150, width=150, p=p),
albumentations.Resize(i_height, i_width),
albumentations.GlassBlur(p=p),
albumentations.RandomContrast(p=p)
],
p=p)
def __init__(self, resize, mean, std, **args):
self.transform = A.Compose([
A.Resize(resize, resize, p=1.0),
A.ShiftScaleRotate(p = 0.5),
A.IAAAffine(scale = [0.8, 1.2], rotate = [-10, 10], shear = 10, p = 0.5),
A.GaussNoise(var_limit=(10.0, 50.0), mean=0, always_apply=False, p=0.5),
A.GaussianBlur(blur_limit=(3, 7), sigma_limit=0, always_apply=False, p=0.5),
A.OneOf([
A.MedianBlur(blur_limit=7, always_apply=False, p=1.0),
A.MotionBlur(blur_limit=7, always_apply=False, p=1.0),
], p = 0.5),
A.OneOf([
A.GlassBlur(sigma=0.7, max_delta=4, iterations=2, always_apply=False, mode='fast', p=1.0),
A.Blur(blur_limit=7, always_apply=False, p=1.0),
], p = 0.5),
A.Normalize(mean = mean, std = std, max_pixel_value = 255.0, p = 1.0),
ToTensorV2(p = 1.0),
])
def test_glass_blur_float_uint8_diff_less_than_two(val_uint8):
x_uint8 = np.zeros((5, 5)).astype(np.uint8)
x_uint8[2, 2] = val_uint8
x_float32 = np.zeros((5, 5)).astype(np.float32)
x_float32[2, 2] = val_uint8 / 255.0
glassblur = A.GlassBlur(always_apply=True, max_delta=1)
np.random.seed(0)
blur_uint8 = glassblur(image=x_uint8)["image"]
np.random.seed(0)
blur_float32 = glassblur(image=x_float32)["image"]
# Before comparison, rescale the blur_float32 to [0, 255]
diff = np.abs(blur_uint8 - blur_float32 * 255)
# The difference between the results of float32 and uint8 will be at most 2.
assert np.all(diff <= 2.0)
def __call__(self, data):
rgb, thermal, depth, audio, label, id = data
#depth = depth.astype(np.float32)
albumentations_transform_pixel = {
'Blur': albumentations.Blur(),
'MedianBlur': albumentations.MedianBlur(),
'MotionBlur': albumentations.MotionBlur(),
'GaussNoise': albumentations.GaussNoise(),
'GaussianBlur': albumentations.GaussianBlur(),
'GlassBlur': albumentations.GlassBlur(),
'IAAAdditiveGaussianNoise':
albumentations.IAAAdditiveGaussianNoise(),
}
transform = np.random.choice(
['None'] + list(albumentations_transform_pixel.keys()))
if transform in albumentations_transform_pixel:
aug = albumentations.Compose(
[albumentations_transform_pixel[transform]],
bbox_params={
'format': 'pascal_voc',
'label_fields': ['labels']
})
try:
annots = np.array(annots).astype(np.float32)
aug_result = aug(image=depth,
bboxes=annots[:, :4],
labels=annots[:, 4])
depth = aug_result['image']
except Exception as e:
print(
f"transform={transform} aug_result['bboxes']={aug_result['bboxes']} aug_result['labels']={aug_result['labels']}"
)
raise Exception(e)
return rgb, thermal, depth, audio, label, id
# parse_yolo_label('/media/sc/unitek/data/lishui_lights/23262brightness0.txt')
category_id_to_name = {0: 'red', 1: "green"}
# 定义变换
transform = A.Compose(
[
# A.RandomCrop(),
# A.HorizontalFlip(p=0.5),
A.RandomBrightnessContrast(p=0.6),
# A.RandomRotate90(),
A.Rotate(limit=25, p=0.2), # 限制旋转角度为25度
A.GaussNoise(),
A.GlassBlur(),
A.RandomGamma(),
# A.RandomRain(p=0.1),
# A.RandomSunFlare(p=0.1),
# A.CenterCrop(height=50,width=50) #从图像中间裁剪出h*w的区域
],
bbox_params=A.BboxParams(format='yolo', label_fields=['category_ids']))
# 对某个目录下的图像开始增强
def process(dir):
files = os.listdir(dir)
for file in files:
suffix = '.png'
if file.endswith(suffix) and 'trans' not in file:
origin_img_name = "{}/{}".format(dir, file)
def get_images(self, imgpath):
# Pick random clone, crypt or fufi
u01 = np.random.uniform()
if u01 < self.cpfr_frac[0]:
img, mask = self.all_svs_opened[imgpath].fetch_clone(
prop_displ=0.45)
elif u01 < np.sum(self.cpfr_frac[0:2]):
img, mask = self.all_svs_opened[imgpath].fetch_partial(
prop_displ=0.45)
elif u01 < np.sum(self.cpfr_frac[0:3]):
img, mask = self.all_svs_opened[imgpath].fetch_fufi(
prop_displ=0.45)
else:
img, mask = self.all_svs_opened[imgpath].fetch_rndmtile()
if self.dilate_masks == True:
n_dil = int(5 / self.um_per_pixel) # if mpp is one or less than 1
# dilate if desired
for i in range(mask.shape[2]):
mask[:, :, i] = cv2.morphologyEx(mask[:, :, i].copy(),
cv2.MORPH_DILATE,
st_3,
iterations=n_dil)
if self.aug == True:
composition = A.Compose([
A.HorizontalFlip(),
A.VerticalFlip(),
A.Rotate(border_mode=cv2.BORDER_CONSTANT),
A.OneOf([
A.ElasticTransform(alpha=1000,
sigma=30,
alpha_affine=30,
border_mode=cv2.BORDER_CONSTANT,
p=1),
A.GridDistortion(border_mode=cv2.BORDER_CONSTANT, p=1),
],
p=0.5),
A.CLAHE(p=0.2),
A.HueSaturationValue(hue_shift_limit=12,
sat_shift_limit=12,
val_shift_limit=12,
p=0.3),
A.RandomBrightnessContrast(p=0.3),
A.Posterize(p=0.1, num_bits=4),
A.OneOf([
A.JpegCompression(p=1),
A.MedianBlur(p=1),
A.Blur(p=1),
A.GlassBlur(p=1, max_delta=2, sigma=0.4),
A.IAASharpen(p=1)
],
p=0.3)
],
p=1)
transformed = composition(image=img, mask=mask)
img, mask = transformed['image'], transformed['mask']
mask_list = [mask[:, :, ii] for ii in range(mask.shape[2])]
if self.stride_bool:
mask_list = [cv2.pyrDown(mask_ii.copy()) for mask_ii in mask_list]
mask_list = [
cv2.threshold(mask_ii, 120, 255, cv2.THRESH_BINARY)[1]
for mask_ii in mask_list
]
## convert to floating point space, normalize and mask non-used clones
img = img.astype(np.float32) / 255
mask_list = [mask_ii.astype(np.float32) / 255 for mask_ii in mask_list]
if self.normalize:
img = (img - self.norm_mean) / self.norm_std
return img, np.stack(mask_list, axis=2)
def augmentation_train():
train_transform = [
albu.HorizontalFlip(p=0.5),
albu.VerticalFlip(p=0.5),
albu.OneOf([
albu.InvertImg(p=0.5),
albu.RandomBrightnessContrast(brightness_limit=(-0.5, 0.3),
contrast_limit=(-0.5, 0.3),
brightness_by_max=False,
p=0.5),
albu.RandomGamma(gamma_limit=(50, 120), p=.5),
albu.RandomToneCurve(scale=0.4, p=.5),
albu.HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=20,
val_shift_limit=20,
p=.5),
albu.ChannelShuffle(p=.5),
albu.RGBShift(
r_shift_limit=20, g_shift_limit=20, b_shift_limit=20, p=.5),
],
p=0.5),
albu.OneOf([
albu.RandomFog(
fog_coef_lower=0.1, fog_coef_upper=.4, alpha_coef=0.06, p=0.5),
albu.MotionBlur(blur_limit=7, p=0.5),
albu.MedianBlur(blur_limit=7, p=0.5),
albu.GlassBlur(sigma=0.5, max_delta=2, p=0.5),
albu.Sharpen(alpha=(0.1, 0.3), lightness=(0.7, 1.1), p=0.5)
],
p=0.5),
albu.OneOf([
albu.GaussNoise(var_limit=0.03, mean=0, p=0.5),
albu.MultiplicativeNoise(multiplier=(0.98, 1.02), p=0.5),
albu.ISONoise(
color_shift=(0.01, 0.02), intensity=(0.1, 0.3), p=0.5),
],
p=0.3),
albu.OneOf([
albu.ElasticTransform(border_mode=cv2.BORDER_CONSTANT,
interpolation=cv2.INTER_CUBIC,
alpha=1,
sigma=50,
alpha_affine=50,
p=0.5),
albu.GridDistortion(border_mode=cv2.BORDER_CONSTANT,
interpolation=cv2.INTER_CUBIC,
distort_limit=(-0.3, 0.3),
num_steps=5,
p=0.5),
albu.OpticalDistortion(border_mode=cv2.BORDER_CONSTANT,
interpolation=cv2.INTER_CUBIC,
distort_limit=(-.05, .05),
shift_limit=(-0.05, 0.05),
p=0.5),
albu.ShiftScaleRotate(border_mode=cv2.BORDER_CONSTANT,
interpolation=cv2.INTER_CUBIC,
shift_limit=(0.05, 0.02),
scale_limit=(-.1, 0),
rotate_limit=2,
p=0.5),
],
p=0.5),
]
return albu.Compose(train_transform)
def get_augmentation(version):
if version == "v1":
return {
"train":
A.Compose([
A.Flip(p=0.5),
A.Rotate(p=0.5),
A.Resize(height=256, width=256, p=1.0),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Resize(height=256, width=256, p=1.0),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v2":
return {
"train":
A.Compose([
A.Flip(p=0.5),
A.Rotate(p=0.5),
A.OneOf([
A.RandomCrop(height=256, width=256, p=1),
A.RandomCrop(height=384, width=384, p=1),
A.RandomCrop(height=512, width=512, p=1),
A.RandomCrop(height=640, width=640, p=1),
],
p=0.5),
A.Resize(height=256, width=256, p=1.0),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Resize(height=256, width=256, p=1.0),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v3":
return {
"train":
A.Compose([
A.RandomCrop(height=1024, width=1024, p=1),
A.Flip(p=0.5),
A.Rotate(p=0.5),
A.Resize(height=256, width=256, p=1.0),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Resize(height=256, width=256, p=1.0),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v4":
# for 3x-scaled dataset | 256x256
return {
"train":
A.Compose([
A.RandomCrop(height=512, width=512, p=1),
A.Flip(p=0.5),
A.Rotate(p=0.5),
A.Resize(height=256, width=256, p=1.0),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Resize(height=256, width=256, p=1.0),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v5":
# for 3x-scaled dataset | 512x512
return {
"train":
A.Compose([
A.RandomCrop(height=512, width=512, p=1),
A.Flip(p=0.5),
A.Rotate(p=0.5),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v6":
# for 3x-scaled dataset | 512x512
return {
"train":
A.Compose([
A.Flip(p=0.5),
A.Rotate(p=0.5),
A.HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=20,
always_apply=False,
p=0.25),
A.RandomBrightness(limit=0.4, always_apply=False, p=0.25),
A.RandomContrast(limit=0.2, always_apply=False, p=0.25),
A.RandomShadow(shadow_roi=(0, 0, 1, 1),
num_shadows_lower=1,
num_shadows_upper=50,
shadow_dimension=5,
always_apply=False,
p=0.25),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v7":
# for 3x-scaled dataset | 512x512
return {
"train":
A.Compose([
A.Flip(p=0.5),
A.Rotate(p=0.5),
A.RandomCrop(height=768, width=768, p=1),
A.Resize(height=256, width=256, p=1.0),
A.HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=20,
always_apply=False,
p=0.25),
A.RandomBrightness(limit=0.4, always_apply=False, p=0.25),
A.RandomContrast(limit=0.2, always_apply=False, p=0.25),
A.RandomShadow(shadow_roi=(0, 0, 1, 1),
num_shadows_lower=1,
num_shadows_upper=50,
shadow_dimension=5,
always_apply=False,
p=0.25),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Resize(height=256, width=256, p=1.0),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v8":
# for 3x-scaled dataset | 512x512
return {
"train":
A.Compose([
A.Rotate(p=0.5),
A.RandomCrop(height=512, width=512, p=1),
A.Flip(p=0.5),
# color
A.HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=20,
always_apply=False,
p=0.25),
A.RandomBrightness(limit=0.4, always_apply=False, p=0.25),
A.RandomContrast(limit=0.2, always_apply=False, p=0.25),
A.RandomShadow(shadow_roi=(0, 0, 1, 1),
num_shadows_lower=1,
num_shadows_upper=50,
shadow_dimension=5,
always_apply=False,
p=0.25),
# transform
A.ElasticTransform(p=1, alpha=120, sigma=6, alpha_affine=0.25),
A.GridDistortion(p=0.25),
A.OpticalDistortion(distort_limit=2, shift_limit=0.5, p=0.25),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v9":
# for 3x-scaled dataset | 512x512
return {
"train":
A.Compose([
A.Flip(p=0.5),
A.Rotate(p=0.5),
A.HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=20,
always_apply=False,
p=0.25),
A.RandomBrightness(limit=0.4, always_apply=False, p=0.25),
A.RandomContrast(limit=0.2, always_apply=False, p=0.25),
A.RandomShadow(shadow_roi=(0, 0, 1, 1),
num_shadows_lower=1,
num_shadows_upper=50,
shadow_dimension=5,
always_apply=False,
p=0.25),
# transform
A.OneOf([
A.ElasticTransform(
alpha=120, sigma=6, alpha_affine=0.25, p=0.25),
A.GridDistortion(p=0.25),
A.OpticalDistortion(
distort_limit=2, shift_limit=0.5, p=0.25)
],
p=0.75),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v10":
# for 3x-scaled dataset | 512x512
return {
"train":
A.Compose([
A.Flip(p=0.5),
A.Rotate(p=0.5),
# size
A.OneOf([
A.CropNonEmptyMaskIfExists(height=128, width=128, p=1.0),
A.CropNonEmptyMaskIfExists(height=256, width=256, p=1.0),
A.CropNonEmptyMaskIfExists(height=384, width=384, p=1.0)
],
p=0.25),
A.PadIfNeeded(min_height=512,
min_width=512,
border_mode=4,
p=1),
# array shuffle
A.OneOf([A.MaskDropout(p=1),
A.RandomGridShuffle(p=1)], p=0.5),
# quality
A.Downscale(scale_min=0.25,
scale_max=0.75,
interpolation=0,
always_apply=False,
p=0.5),
A.GaussNoise(p=0.5),
A.OneOf([
A.GlassBlur(p=1),
A.GaussianBlur(p=1),
], p=0.5),
# colors
A.HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=20,
always_apply=False,
p=0.5),
A.RandomBrightness(limit=0.4, always_apply=False, p=0.5),
A.RandomContrast(limit=0.2, always_apply=False, p=0.5),
A.RandomShadow(shadow_roi=(0, 0, 1, 1),
num_shadows_lower=1,
num_shadows_upper=50,
shadow_dimension=5,
always_apply=False,
p=0.5),
A.CLAHE(p=0.5),
A.Equalize(p=0.5),
A.ChannelShuffle(p=0.5),
# transform
A.OneOf([
A.ElasticTransform(
alpha=120, sigma=6, alpha_affine=0.25, p=1),
A.GridDistortion(p=1),
A.OpticalDistortion(distort_limit=2, shift_limit=0.5, p=1)
],
p=0.5),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v11":
# custom normalization (see other/img_normalization.py)
return {
"train":
A.Compose([
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v12":
# for 3x-scaled dataset | 512x512
return {
"train":
A.Compose([
A.Flip(p=0.5),
A.Rotate(p=0.5),
# size / quality
A.OneOf([
A.CropNonEmptyMaskIfExists(height=128, width=128, p=1.0),
A.CropNonEmptyMaskIfExists(height=256, width=256, p=1.0),
A.CropNonEmptyMaskIfExists(height=384, width=384, p=1.0),
A.Downscale(scale_min=0.25,
scale_max=0.75,
interpolation=0,
always_apply=False,
p=1.0),
],
p=0.25),
A.PadIfNeeded(min_height=512,
min_width=512,
border_mode=4,
p=1),
# array shuffle
A.OneOf([A.MaskDropout(p=1),
A.RandomGridShuffle(p=1)], p=0.15),
# noise
A.OneOf([
A.GaussNoise(p=1),
A.GlassBlur(p=1),
A.GaussianBlur(p=1),
],
p=0.15),
# colors
A.HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=20,
always_apply=False,
p=0.15),
A.RandomBrightness(limit=0.4, always_apply=False, p=0.15),
A.RandomContrast(limit=0.2, always_apply=False, p=0.15),
A.RandomShadow(shadow_roi=(0, 0, 1, 1),
num_shadows_lower=1,
num_shadows_upper=50,
shadow_dimension=5,
always_apply=False,
p=0.15),
A.OneOf([
A.CLAHE(p=1),
A.Equalize(p=1),
A.ChannelShuffle(p=1),
],
p=0.15),
# transform
A.OneOf([
A.ElasticTransform(
alpha=120, sigma=6, alpha_affine=0.25, p=1),
A.GridDistortion(p=1),
A.OpticalDistortion(distort_limit=2, shift_limit=0.5, p=1)
],
p=0.15),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
else:
raise Exception(f"Augmentation version '{version}' is UNKNOWN!")
def defend_GB(img, sigma=0.9, max_delta = 1, iterations = 1):
aug = albumentations.GlassBlur(sigma=sigma,max_delta=max_delta,iterations=iterations,p=1)
augmented = aug(image=(img*255).astype(np.uint8))
auged = augmented['image']/255
return auged
