def strong_aug(p=0.5, crop_size=(512, 512)):
return Compose([
RandomResizedCrop(crop_size[0],
crop_size[1],
scale=(0.3, 1.0),
ratio=(0.75, 1.3),
interpolation=4,
p=1.0),
RandomRotate90(),
Flip(),
Transpose(),
OneOf([
IAAAdditiveGaussianNoise(),
GaussNoise(),
], p=0.8),
OneOf([
MotionBlur(p=0.5),
MedianBlur(blur_limit=3, p=0.5),
Blur(blur_limit=3, p=0.5),
],
p=0.3),
ShiftScaleRotate(
shift_limit=0.2, scale_limit=0.5, rotate_limit=180, p=0.8),
OneOf([
OpticalDistortion(p=0.5),
GridDistortion(p=0.5),
IAAPiecewiseAffine(p=0.5),
ElasticTransform(p=0.5),
],
p=0.3),
OneOf([
CLAHE(clip_limit=2),
IAASharpen(),
IAAEmboss(),
RandomBrightnessContrast(),
],
p=0.3),
OneOf([
GaussNoise(),
RandomRain(
p=0.2, brightness_coefficient=0.9, drop_width=1, blur_value=5),
RandomSnow(p=0.4,
brightness_coeff=0.5,
snow_point_lower=0.1,
snow_point_upper=0.3),
RandomShadow(p=0.2,
num_shadows_lower=1,
num_shadows_upper=1,
shadow_dimension=5,
shadow_roi=(0, 0.5, 1, 1)),
RandomFog(
p=0.5, fog_coef_lower=0.3, fog_coef_upper=0.5, alpha_coef=0.1)
],
p=0.3),
RGBShift(),
HueSaturationValue(p=0.9),
],
p=p)
def __call__(self, image, boxes=None, labels=None):
p = random.uniform(0, 1)
if p >= 0.5:
return image.astype(np.float32), boxes, labels
else:
p = random.uniform(0, 1)
if p < 1 / 2:
image = RandomSnow()(image=image)['image']
return image.astype(np.float32), boxes, labels
else:
image = RandomRain()(image=image)['image']
return image.astype(np.float32), boxes, labels
def get_transforms(self):
list_transforms = []
if self.phase == "train":
list_transforms.extend([
# Spatial transforms
HorizontalFlip(p=0.6),
RandomCrop(self.random_crop_h, self.random_crop_w, p=0.8),
Resize(self.orig_h, self.orig_w, interpolation=4, p=1.0),
# RGB transormations
OneOf([
RandomBrightness(p=0.5, limit=0.2),
RandomContrast(p=0.5, limit=0.2),
RandomGamma(p=0.5, gamma_limit=(80, 120))
],
p=1.)
])
if self.hard_augs:
list_transforms.extend(
# Hard augs
OneOf(
[
RandomFog(p=0.5,
fog_coef_lower=0.1,
fog_coef_upper=.3,
alpha_coef=0.08),
RandomRain(
p=0.5,
slant_lower=-20,
slant_upper=20,
rain_type=None
), # [None, "drizzle", "heavy", "torrestial"]
RandomSnow(p=0.5,
snow_point_lower=0.1,
snow_point_upper=0.3,
brightness_coeff=2.5),
RandomSunFlare(p=0.5,
flare_roi=(0, 0, 1, 0.5),
angle_lower=0,
angle_upper=1,
num_flare_circles_lower=3,
num_flare_circles_upper=6,
src_radius=400,
src_color=(255, 255, 255))
],
p=0.8))
list_transforms.append(Normalize(mean=self.mean, std=self.std, p=1))
list_trfms = Compose(list_transforms)
return list_trfms
def composition(p=1):
"""
:param p: probability of applying list of augmentations
:return: composition of augmentation
"""
rain = random.choice([None, "drizzle", "heavy"])
return Compose([
ShiftScaleRotate(),
OneOf([
Blur(blur_limit=2),
RandomSunFlare(src_radius=20),
RandomBrightnessContrast(),
RandomRain(blur_value=2, drop_width=1, rain_type=rain)
],
p=1)
],
p=p)
def __init__(self):
self.random_brightness_contrast = RandomBrightnessContrast()
self.hue_saturation_value = HueSaturationValue()
self.random_gamma = RandomGamma()
self.clahe = CLAHE()
self.blur = Blur()
self.gauss_noise = GaussNoise()
self.channel_shuffle = ChannelShuffle()
self.rgb_shift = RGBShift()
self.channel_dropout = ChannelDropout()
self.random_fog = RandomFog(fog_coef_upper=0.4)
self.random_rain = RandomRain()
self.random_snow = RandomSnow()
self.random_shadow = RandomShadow()
self.random_sunflare = RandomSunFlare(angle_upper=0.2)
def __init__(self, num_classes, input_size):
super(TuSimpleDataTransform, self).__init__()
random.seed(1000)
height, width = input_size
self._train_transform_list = self._train_transform_list + [
HorizontalFlip(p=0.5),
GaussNoise(p=0.5),
RandomBrightnessContrast(p=0.5),
RandomShadow(p=0.5),
RandomRain(rain_type="drizzle", p=0.5),
ShiftScaleRotate(rotate_limit=10, p=0.5),
RandomResizedCrop(
height=height, width=width, scale=(0.8, 1), p=0.5),
]
self._train_transform_list.append(Resize(height, width))
self._val_transform_list.append(Resize(height, width))
self._train_transform_list.append(ToTensor(num_classes=num_classes))
self._val_transform_list.append(ToTensor(num_classes=num_classes))
self._initialize_transform_dict()
def transform(image, mask, image_name, mask_name):
x, y = image, mask
rand = random.uniform(0, 1)
if (rand > 0.5):
images_name = [f"{image_name}"]
masks_name = [f"{mask_name}"]
images_aug = [x]
masks_aug = [y]
it = iter(images_name)
it2 = iter(images_aug)
imagedict = dict(zip(it, it2))
it = iter(masks_name)
it2 = iter(masks_aug)
masksdict = dict(zip(it, it2))
return imagedict, masksdict
mask_density = np.count_nonzero(y)
## Augmenting only images with Gloms
if (mask_density > 0):
try:
h, w, c = x.shape
except Exception as e:
image = image[:-1]
x, y = image, mask
h, w, c = x.shape
aug = Blur(p=1, blur_limit=3)
augmented = aug(image=x, mask=y)
x0 = augmented['image']
y0 = augmented['mask']
# aug = CenterCrop(p=1, height=32, width=32)
# augmented = aug(image=x, mask=y)
# x1 = augmented['image']
# y1 = augmented['mask']
## Horizontal Flip
aug = HorizontalFlip(p=1)
augmented = aug(image=x, mask=y)
x2 = augmented['image']
y2 = augmented['mask']
aug = VerticalFlip(p=1)
augmented = aug(image=x, mask=y)
x3 = augmented['image']
y3 = augmented['mask']
# aug = Normalize(p=1)
# augmented = aug(image=x, mask=y)
# x4 = augmented['image']
# y4 = augmented['mask']
aug = Transpose(p=1)
augmented = aug(image=x, mask=y)
x5 = augmented['image']
y5 = augmented['mask']
aug = RandomGamma(p=1)
augmented = aug(image=x, mask=y)
x6 = augmented['image']
y6 = augmented['mask']
## Optical Distortion
aug = OpticalDistortion(p=1, distort_limit=2, shift_limit=0.5)
augmented = aug(image=x, mask=y)
x7 = augmented['image']
y7 = augmented['mask']
## Grid Distortion
aug = GridDistortion(p=1)
augmented = aug(image=x, mask=y)
x8 = augmented['image']
y8 = augmented['mask']
aug = RandomGridShuffle(p=1)
augmented = aug(image=x, mask=y)
x9 = augmented['image']
y9 = augmented['mask']
aug = HueSaturationValue(p=1)
augmented = aug(image=x, mask=y)
x10 = augmented['image']
y10 = augmented['mask']
# aug = PadIfNeeded(p=1)
# augmented = aug(image=x, mask=y)
# x11 = augmented['image']
# y11 = augmented['mask']
aug = RGBShift(p=1)
augmented = aug(image=x, mask=y)
x12 = augmented['image']
y12 = augmented['mask']
## Random Brightness
aug = RandomBrightness(p=1)
augmented = aug(image=x, mask=y)
x13 = augmented['image']
y13 = augmented['mask']
## Random Contrast
aug = RandomContrast(p=1)
augmented = aug(image=x, mask=y)
x14 = augmented['image']
y14 = augmented['mask']
#aug = MotionBlur(p=1)
#augmented = aug(image=x, mask=y)
# x15 = augmented['image']
# y15 = augmented['mask']
aug = MedianBlur(p=1, blur_limit=5)
augmented = aug(image=x, mask=y)
x16 = augmented['image']
y16 = augmented['mask']
aug = GaussianBlur(p=1, blur_limit=3)
augmented = aug(image=x, mask=y)
x17 = augmented['image']
y17 = augmented['mask']
aug = GaussNoise(p=1)
augmented = aug(image=x, mask=y)
x18 = augmented['image']
y18 = augmented['mask']
aug = GlassBlur(p=1)
augmented = aug(image=x, mask=y)
x19 = augmented['image']
y19 = augmented['mask']
aug = CLAHE(clip_limit=1.0,
tile_grid_size=(8, 8),
always_apply=False,
p=1)
augmented = aug(image=x, mask=y)
x20 = augmented['image']
y20 = augmented['mask']
aug = ChannelShuffle(p=1)
augmented = aug(image=x, mask=y)
x21 = augmented['image']
y21 = augmented['mask']
aug = ToGray(p=1)
augmented = aug(image=x, mask=y)
x22 = augmented['image']
y22 = augmented['mask']
aug = ToSepia(p=1)
augmented = aug(image=x, mask=y)
x23 = augmented['image']
y23 = augmented['mask']
aug = JpegCompression(p=1)
augmented = aug(image=x, mask=y)
x24 = augmented['image']
y24 = augmented['mask']
aug = ImageCompression(p=1)
augmented = aug(image=x, mask=y)
x25 = augmented['image']
y25 = augmented['mask']
aug = Cutout(p=1)
augmented = aug(image=x, mask=y)
x26 = augmented['image']
y26 = augmented['mask']
# aug = CoarseDropout(p=1, max_holes=8, max_height=32, max_width=32)
# augmented = aug(image=x, mask=y)
# x27 = augmented['image']
# y27 = augmented['mask']
# aug = ToFloat(p=1)
# augmented = aug(image=x, mask=y)
# x28 = augmented['image']
# y28 = augmented['mask']
aug = FromFloat(p=1)
augmented = aug(image=x, mask=y)
x29 = augmented['image']
y29 = augmented['mask']
## Random Brightness and Contrast
aug = RandomBrightnessContrast(p=1)
augmented = aug(image=x, mask=y)
x30 = augmented['image']
y30 = augmented['mask']
aug = RandomSnow(p=1)
augmented = aug(image=x, mask=y)
x31 = augmented['image']
y31 = augmented['mask']
aug = RandomRain(p=1)
augmented = aug(image=x, mask=y)
x32 = augmented['image']
y32 = augmented['mask']
aug = RandomFog(p=1)
augmented = aug(image=x, mask=y)
x33 = augmented['image']
y33 = augmented['mask']
aug = RandomSunFlare(p=1)
augmented = aug(image=x, mask=y)
x34 = augmented['image']
y34 = augmented['mask']
aug = RandomShadow(p=1)
augmented = aug(image=x, mask=y)
x35 = augmented['image']
y35 = augmented['mask']
aug = Lambda(p=1)
augmented = aug(image=x, mask=y)
x36 = augmented['image']
y36 = augmented['mask']
aug = ChannelDropout(p=1)
augmented = aug(image=x, mask=y)
x37 = augmented['image']
y37 = augmented['mask']
aug = ISONoise(p=1)
augmented = aug(image=x, mask=y)
x38 = augmented['image']
y38 = augmented['mask']
aug = Solarize(p=1)
augmented = aug(image=x, mask=y)
x39 = augmented['image']
y39 = augmented['mask']
aug = Equalize(p=1)
augmented = aug(image=x, mask=y)
x40 = augmented['image']
y40 = augmented['mask']
aug = Posterize(p=1)
augmented = aug(image=x, mask=y)
x41 = augmented['image']
y41 = augmented['mask']
aug = Downscale(p=1)
augmented = aug(image=x, mask=y)
x42 = augmented['image']
y42 = augmented['mask']
aug = MultiplicativeNoise(p=1)
augmented = aug(image=x, mask=y)
x43 = augmented['image']
y43 = augmented['mask']
aug = FancyPCA(p=1)
augmented = aug(image=x, mask=y)
x44 = augmented['image']
y44 = augmented['mask']
# aug = MaskDropout(p=1)
# augmented = aug(image=x, mask=y)
# x45 = augmented['image']
# y45 = augmented['mask']
aug = GridDropout(p=1)
augmented = aug(image=x, mask=y)
x46 = augmented['image']
y46 = augmented['mask']
aug = ColorJitter(p=1)
augmented = aug(image=x, mask=y)
x47 = augmented['image']
y47 = augmented['mask']
## ElasticTransform
aug = ElasticTransform(p=1,
alpha=120,
sigma=512 * 0.05,
alpha_affine=512 * 0.03)
augmented = aug(image=x, mask=y)
x50 = augmented['image']
y50 = augmented['mask']
aug = CropNonEmptyMaskIfExists(p=1, height=22, width=32)
augmented = aug(image=x, mask=y)
x51 = augmented['image']
y51 = augmented['mask']
aug = IAAAffine(p=1)
augmented = aug(image=x, mask=y)
x52 = augmented['image']
y52 = augmented['mask']
# aug = IAACropAndPad(p=1)
# augmented = aug(image=x, mask=y)
# x53 = augmented['image']
# y53 = augmented['mask']
aug = IAAFliplr(p=1)
augmented = aug(image=x, mask=y)
x54 = augmented['image']
y54 = augmented['mask']
aug = IAAFlipud(p=1)
augmented = aug(image=x, mask=y)
x55 = augmented['image']
y55 = augmented['mask']
aug = IAAPerspective(p=1)
augmented = aug(image=x, mask=y)
x56 = augmented['image']
y56 = augmented['mask']
aug = IAAPiecewiseAffine(p=1)
augmented = aug(image=x, mask=y)
x57 = augmented['image']
y57 = augmented['mask']
aug = LongestMaxSize(p=1)
augmented = aug(image=x, mask=y)
x58 = augmented['image']
y58 = augmented['mask']
aug = NoOp(p=1)
augmented = aug(image=x, mask=y)
x59 = augmented['image']
y59 = augmented['mask']
# aug = RandomCrop(p=1, height=22, width=22)
# augmented = aug(image=x, mask=y)
# x61 = augmented['image']
# y61 = augmented['mask']
# aug = RandomResizedCrop(p=1, height=22, width=20)
# augmented = aug(image=x, mask=y)
# x63 = augmented['image']
# y63 = augmented['mask']
aug = RandomScale(p=1)
augmented = aug(image=x, mask=y)
x64 = augmented['image']
y64 = augmented['mask']
# aug = RandomSizedCrop(p=1, height=22, width=20, min_max_height = [32,32])
# augmented = aug(image=x, mask=y)
# x66 = augmented['image']
# y66 = augmented['mask']
# aug = Resize(p=1, height=22, width=20)
# augmented = aug(image=x, mask=y)
# x67 = augmented['image']
# y67 = augmented['mask']
aug = Rotate(p=1)
augmented = aug(image=x, mask=y)
x68 = augmented['image']
y68 = augmented['mask']
aug = ShiftScaleRotate(p=1)
augmented = aug(image=x, mask=y)
x69 = augmented['image']
y69 = augmented['mask']
aug = SmallestMaxSize(p=1)
augmented = aug(image=x, mask=y)
x70 = augmented['image']
y70 = augmented['mask']
images_aug.extend([
x, x0, x2, x3, x5, x6, x7, x8, x9, x10, x12, x13, x14, x16, x17,
x18, x19, x20, x21, x22, x23, x24, x25, x26, x29, x30, x31, x32,
x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x46,
x47, x50, x51, x52, x54, x55, x56, x57, x58, x59, x64, x68, x69,
x70
])
masks_aug.extend([
y, y0, y2, y3, y5, y6, y7, y8, y9, y10, y12, y13, y14, y16, y17,
y18, y19, y20, y21, y22, y23, y24, y25, y26, y29, y30, y31, y32,
y33, y34, y35, y36, y37, y38, y39, y40, y41, y42, y43, y44, y46,
y47, y50, y51, y52, y54, y55, y56, y57, y58, y59, y64, y68, y69,
y70
])
idx = -1
images_name = []
masks_name = []
for i, m in zip(images_aug, masks_aug):
if idx == -1:
tmp_image_name = f"{image_name}"
tmp_mask_name = f"{mask_name}"
else:
tmp_image_name = f"{image_name}_{smalllist[idx]}"
tmp_mask_name = f"{mask_name}_{smalllist[idx]}"
images_name.extend(tmp_image_name)
masks_name.extend(tmp_mask_name)
idx += 1
it = iter(images_name)
it2 = iter(images_aug)
imagedict = dict(zip(it, it2))
it = iter(masks_name)
it2 = iter(masks_aug)
masksdict = dict(zip(it, it2))
return imagedict, masksdict
def ImageAugument():
imgs_save_dir = 'data/albu_imgs/'
if not os.path.exists(imgs_save_dir):
os.makedirs(imgs_save_dir)
xmls_save_dir = 'data/albu_xmls/'
if not os.path.exists(xmls_save_dir):
os.makedirs(xmls_save_dir)
path = "data/img" # 文件夹目录
xml_path = "data/xml"
files = os.listdir(path) # 得到文件夹下的所有文件名称
# 遍历文件夹
prefix = path + '/'
print("begin>>>")
for file in tqdm(files):
image = cv2.imread(prefix + file)
# cv2.imwrite("origin.jpg",image)
xml = xml_path + "/" + file[:-4] + ".xml"
#示例：使用具有随机孔径线性大小的中值滤波器来模糊输入图像
aug = MedianBlur(p=1)
aug_image = aug(image=image)['image']
cv2.imwrite(imgs_save_dir + file[:-4] + 'mb' + '.jpg', aug_image)
new_name = xmls_save_dir + "/" + file[:-4] + "mb" + ".xml" # 为文件赋予新名字
shutil.copyfile(xml, new_name)
#随机大小的内核模糊输入图像
aug = Blur(p=1)
aug_image = aug(image=image)['image']
cv2.imwrite(imgs_save_dir + file[:-4] + 'blur' + '.jpg', aug_image)
new_name = xmls_save_dir + "/" + file[:-4] + "blur" + ".xml" # 为文件赋予新名字
shutil.copyfile(xml, new_name)
#高斯模糊
aug = GaussNoise(p=1)
aug_image = aug(image=image)['image']
cv2.imwrite(imgs_save_dir + file[:-4] + 'gau' + '.jpg', aug_image)
new_name = xmls_save_dir + "/" + file[:-4] + "gau" + ".xml" # 为文件赋予新名字
shutil.copyfile(xml, new_name)
#随机雨
aug = RandomRain(p=1)
aug_image = aug(image=image)['image']
cv2.imwrite(imgs_save_dir + file[:-4] + 'rain' + '.jpg', aug_image)
new_name = xmls_save_dir + "/" + file[:-4] + "rain" + ".xml" # 为文件赋予新名字
shutil.copyfile(xml, new_name)
#随机雾
aug = RandomFog(fog_coef_lower=0.2,
fog_coef_upper=0.5,
alpha_coef=0.1,
p=1)
aug_image = aug(image=image)['image']
cv2.imwrite(imgs_save_dir + file[:-4] + 'fog' + '.jpg', aug_image)
new_name = xmls_save_dir + "/" + file[:-4] + "fog" + ".xml" # 为文件赋予新名字
shutil.copyfile(xml, new_name)
#太阳耀斑RandomSunFlare
aug = RandomSunFlare(p=1)
aug_image = aug(image=image)['image']
cv2.imwrite(imgs_save_dir + file[:-4] + 'sun' + '.jpg', aug_image)
new_name = xmls_save_dir + "/" + file[:-4] + "sun" + ".xml" # 为文件赋予新名字
shutil.copyfile(xml, new_name)
#阴影RandomShadow
aug = RandomShadow(p=1)
aug_image = aug(image=image)['image']
cv2.imwrite(imgs_save_dir + file[:-4] + 'shadow' + '.jpg', aug_image)
new_name = xmls_save_dir + "/" + file[:-4] + "shadow" + ".xml" # 为文件赋予新名字
shutil.copyfile(xml, new_name)
#随机雪RandomSnow
aug = RandomSnow(p=1)
aug_image = aug(image=image)['image']
cv2.imwrite(imgs_save_dir + file[:-4] + 'snow' + '.jpg', aug_image)
new_name = xmls_save_dir + "/" + file[:-4] + "snow" + ".xml" # 为文件赋予新名字
shutil.copyfile(xml, new_name)
#随机CoarseDropout
aug = CoarseDropout(p=1)
aug_image = aug(image=image)['image']
cv2.imwrite(imgs_save_dir + file[:-4] + 'drop' + '.jpg', aug_image)
new_name = xmls_save_dir + "/" + file[:-4] + "drop" + ".xml" # 为文件赋予新名字
shutil.copyfile(xml, new_name)
#随机cutout
aug = Cutout(p=1)
aug_image = aug(image=image)['image']
cv2.imwrite(imgs_save_dir + file[:-4] + 'cut' + '.jpg', aug_image)
new_name = xmls_save_dir + "/" + file[:-4] + "cut" + ".xml" # 为文件赋予新名字
shutil.copyfile(xml, new_name)
print("Done")
def main():
dt_config = Config()
dt_config.display()
train_aug = Compose(
[
GaussNoise(p=1.0),
RandomShadow(p=0.5),
RandomRain(p=0.5, rain_type="drizzle"),
RandomContrast(limit=0.2, p=0.5),
RandomGamma(gamma_limit=(80, 120), p=0.5),
RandomBrightness(limit=0.2, p=0.5),
HueSaturationValue(
hue_shift_limit=5, sat_shift_limit=20, val_shift_limit=10, p=0.5
),
CLAHE(p=0.5, clip_limit=2.0),
Normalize(p=1.0),
]
)
val_aug = Compose([Normalize(p=1.0)])
train_set = KittiStixelDataset(
data_path=dt_config.DATA_PATH,
ground_truth_path=dt_config.GROUND_TRUTH_PATH,
batch_size=parsed_args.batch_size,
phase="train",
transform=train_aug,
customized_transform=utility.HorizontalFlip(p=0.5),
)
val_set = KittiStixelDataset(
data_path=dt_config.DATA_PATH,
ground_truth_path=dt_config.GROUND_TRUTH_PATH,
phase="val",
transform=val_aug,
)
model = build_stixel_net()
loss_func = StixelLoss()
opt = optimizers.Adam(0.0001)
callbacks = [
ModelCheckpoint(
os.path.join(dt_config.SAVED_MODELS_PATH, "model-{epoch:03d}.h5"),
monitor="val_loss",
verbose=1,
save_best_only=True,
mode="auto",
period=1,
),
ReduceLROnPlateau(
monitor="val_loss",
factor=0.1,
patience=7,
verbose=0,
mode="auto",
min_lr=0.000001,
),
EarlyStopping(
monitor="val_loss", min_delta=0, patience=10, verbose=0, mode="auto"
),
]
model.compile(loss=loss_func, optimizer=opt)
model.summary()
history = model.fit_generator(
train_set,
steps_per_epoch=len(train_set),
validation_data=val_set,
validation_steps=len(val_set),
epochs=parsed_args.num_epoch,
callbacks=callbacks,
shuffle=True,
)
history_path = os.path.join(dt_config.SAVED_MODELS_PATH, "history.pkl")
np.save(history_path, history.history)
elif augmentation == 'regular_grid_voronoi':
transform = iaa.RegularGridVoronoi(10, 20)
transformed_image = transform(image=image)
elif augmentation == 'relative_regular_grid_voronoi':
transform = iaa.RelativeRegularGridVoronoi(0.1, 0.25)
transformed_image = transform(image=image)
## Weather
elif augmentation == 'fog':
transform = iaa.imgcorruptlike.Fog(severity=2)
transformed_image = transform(image=image)
elif augmentation == 'random_rain':
transform = RandomRain(always_apply=True)
transformed_image = transform(image=image)['image']
elif augmentation == 'rain':
transform = iaa.Rain(speed=(0.1, 0.3))
transformed_image = transform(image=image)
elif augmentation == 'snow':
transform = iaa.imgcorruptlike.Snow(severity=2)
transformed_image = transform(image=image)
elif augmentation == 'snow_flakes':
transform = iaa.Snowflakes(flake_size=(0.1, 0.4), speed=(0.01, 0.05))
transformed_image = transform(image=image)
elif augmentation == 'frost':
def __call__(self, image, boxes=None, labels=None):
image = RandomRain()(image=image)['image']
return image.astype(np.float32), boxes, labels