def __init__(self):
self.convert_RGB_to_HSV = ConvertColor(current='RGB', to='HSV')
self.convert_HSV_to_RGB = ConvertColor(current='HSV', to='RGB')
self.convert_to_float32 = ConvertDataType(to='float32')
self.convert_to_uint8 = ConvertDataType(to='uint8')
self.convert_to_3_channels = ConvertTo3Channels()
self.random_brightness = RandomBrightness(lower=-32,
upper=32,
prob=0.5)
self.random_contrast = RandomContrast(lower=0.5, upper=1.5, prob=0.5)
self.random_saturation = RandomSaturation(lower=0.5,
upper=1.5,
prob=0.5)
self.random_hue = RandomHue(max_delta=18, prob=0.5)
self.random_channel_swap = RandomChannelSwap(prob=0.0)
self.sequence1 = [
self.convert_to_3_channels, self.convert_to_float32,
self.random_brightness, self.random_contrast,
self.convert_to_uint8, self.convert_RGB_to_HSV,
self.convert_to_float32, self.random_saturation, self.random_hue,
self.convert_to_uint8, self.convert_HSV_to_RGB,
self.random_channel_swap
]
self.sequence2 = [
self.convert_to_3_channels, self.convert_to_float32,
self.random_brightness, self.convert_to_uint8,
self.convert_RGB_to_HSV, self.convert_to_float32,
self.random_saturation, self.random_hue, self.convert_to_uint8,
self.convert_HSV_to_RGB, self.convert_to_float32,
self.random_contrast, self.convert_to_uint8,
self.random_channel_swap
]
def __init__(self,
random_brightness=(-48, 48, 0.5),
random_contrast=(0.5, 1.8, 0.5),
random_saturation=(0.5, 1.8, 0.5),
random_hue=(18, 0.5),
random_flip=0.5,
random_translate=((0.03, 0.5), (0.03, 0.5), 0.5),
random_scale=(0.5, 2.0, 0.5),
n_trials_max=3,
clip_boxes=True,
overlap_criterion='area',
bounds_box_filter=(0.3, 1.0),
bounds_validator=(0.5, 1.0),
n_boxes_min=1,
background=(0, 0, 0),
labels_format={
'class_id': 0,
'xmin': 1,
'ymin': 2,
'xmax': 3,
'ymax': 4
}):
if (random_scale[0] >= 1) or (random_scale[1] <= 1):
raise ValueError(
"This sequence of transformations only makes sense if the minimum scaling factor is <1 and the maximum scaling factor is >1."
)
self.n_trials_max = n_trials_max
self.clip_boxes = clip_boxes
self.overlap_criterion = overlap_criterion
self.bounds_box_filter = bounds_box_filter
self.bounds_validator = bounds_validator
self.n_boxes_min = n_boxes_min
self.background = background
self.labels_format = labels_format
# 图像变换之后保留哪些boxes
self.box_filter = BoxFilter(check_overlap=True,
check_min_area=True,
check_degenerate=True,
overlap_criterion=self.overlap_criterion,
overlap_bounds=self.bounds_box_filter,
min_area=16,
labels_format=self.labels_format)
# 训练图像是否有效
self.image_validator = ImageValidator(
overlap_criterion=self.overlap_criterion,
bounds=self.bounds_validator,
n_boxes_min=self.n_boxes_min,
labels_format=self.labels_format)
# Utility distortions
self.convert_RGB_to_HSV = ConvertColor(current='RGB', to='HSV')
self.convert_HSV_to_RGB = ConvertColor(current='HSV', to='RGB')
self.convert_to_float32 = ConvertDataType(to='float32')
self.convert_to_uint8 = ConvertDataType(to='uint8')
self.convert_to_3_channels = ConvertTo3Channels() # 确保所有图像3通道
# Photometric transformations
self.random_brightness = RandomBrightness(lower=random_brightness[0],
upper=random_brightness[1],
prob=random_brightness[2])
self.random_contrast = RandomContrast(lower=random_contrast[0],
upper=random_contrast[1],
prob=random_contrast[2])
self.random_saturation = RandomSaturation(lower=random_saturation[0],
upper=random_saturation[1],
prob=random_saturation[2])
self.random_hue = RandomHue(max_delta=random_hue[0],
prob=random_hue[1])
# Geometric transformations
self.random_flip = RandomFlip(dim='horizontal',
prob=random_flip,
labels_format=self.labels_format)
self.random_translate = RandomTranslate(
dy_minmax=random_translate[0],
dx_minmax=random_translate[1],
prob=random_translate[2],
clip_boxes=self.clip_boxes,
box_filter=self.box_filter,
image_validator=self.image_validator,
n_trials_max=self.n_trials_max,
background=self.background,
labels_format=self.labels_format)
self.random_zoom_in = RandomScale(min_factor=1.0,
max_factor=random_scale[1],
prob=random_scale[2],
clip_boxes=self.clip_boxes,
box_filter=self.box_filter,
image_validator=self.image_validator,
n_trials_max=self.n_trials_max,
background=self.background,
labels_format=self.labels_format)
self.random_zoom_out = RandomScale(
min_factor=random_scale[0],
max_factor=1.0,
prob=random_scale[2],
clip_boxes=self.clip_boxes,
box_filter=self.box_filter,
image_validator=self.image_validator,
n_trials_max=self.n_trials_max,
background=self.background,
labels_format=self.labels_format)
# 放大
self.sequence1 = [
self.convert_to_3_channels, self.convert_to_float32,
self.random_brightness, self.random_contrast,
self.convert_to_uint8, self.convert_RGB_to_HSV,
self.convert_to_float32, self.random_saturation, self.random_hue,
self.convert_to_uint8, self.convert_HSV_to_RGB,
self.random_translate, self.random_zoom_in, self.random_flip
]
# 缩小
self.sequence2 = [
self.convert_to_3_channels, self.convert_to_float32,
self.random_brightness, self.convert_to_uint8,
self.convert_RGB_to_HSV, self.convert_to_float32,
self.random_saturation, self.random_hue, self.convert_to_uint8,
self.convert_HSV_to_RGB, self.convert_to_float32,
self.random_contrast, self.convert_to_uint8, self.random_zoom_out,
self.random_translate, self.random_flip
]
def __init__(self,
resize_height,
resize_width,
random_brightness=(-48, 48, 0.5),
random_contrast=(0.5, 1.8, 0.5),
random_saturation=(0.5, 1.8, 0.5),
random_hue=(18, 0.5),
random_flip=0.5,
min_scale=0.3,
max_scale=2.0,
min_aspect_ratio=0.5,
max_aspect_ratio=2.0,
n_trials_max=3,
clip_boxes=True,
overlap_criterion='area',
bounds_box_filter=(0.3, 1.0),
bounds_validator=(0.5, 1.0),
n_boxes_min=1,
background=(0, 0, 0),
labels_format={'class_id': 0, 'xmin': 1, 'ymin': 2, 'xmax': 3, 'ymax': 4}):
self.n_trials_max = n_trials_max
self.clip_boxes = clip_boxes
self.overlap_criterion = overlap_criterion
self.bounds_box_filter = bounds_box_filter
self.bounds_validator = bounds_validator
self.n_boxes_min = n_boxes_min
self.background = background
self.labels_format = labels_format
# Determines which boxes are kept in an image after the transformations have been applied.
self.box_filter_patch = BoxFilter(check_overlap=True,
check_min_area=False,
check_degenerate=False,
overlap_criterion=self.overlap_criterion,
overlap_bounds=self.bounds_box_filter,
labels_format=self.labels_format)
self.box_filter_resize = BoxFilter(check_overlap=False,
check_min_area=True,
check_degenerate=True,
min_area=16,
labels_format=self.labels_format)
# Determines whether the result of the transformations is a valid training image.
self.image_validator = ImageValidator(overlap_criterion=self.overlap_criterion,
bounds=self.bounds_validator,
n_boxes_min=self.n_boxes_min,
labels_format=self.labels_format)
# Utility transformations
self.convert_to_3_channels = ConvertTo3Channels() # Make sure all images end up having 3 channels.
self.convert_RGB_to_HSV = ConvertColor(current='RGB', to='HSV')
self.convert_HSV_to_RGB = ConvertColor(current='HSV', to='RGB')
self.convert_to_float32 = ConvertDataType(to='float32')
self.convert_to_uint8 = ConvertDataType(to='uint8')
self.resize = Resize(height=resize_height,
width=resize_width,
box_filter=self.box_filter_resize,
labels_format=self.labels_format)
# Photometric transformations
self.random_brightness = RandomBrightness(lower=random_brightness[0], upper=random_brightness[1],
prob=random_brightness[2])
self.random_contrast = RandomContrast(lower=random_contrast[0], upper=random_contrast[1],
prob=random_contrast[2])
self.random_saturation = RandomSaturation(lower=random_saturation[0], upper=random_saturation[1],
prob=random_saturation[2])
self.random_hue = RandomHue(max_delta=random_hue[0], prob=random_hue[1])
# Geometric transformations
self.random_flip = RandomFlip(dim='horizontal', prob=random_flip, labels_format=self.labels_format)
self.patch_coord_generator = PatchCoordinateGenerator(must_match='w_ar',
min_scale=min_scale,
max_scale=max_scale,
scale_uniformly=False,
min_aspect_ratio=min_aspect_ratio,
max_aspect_ratio=max_aspect_ratio)
self.random_patch = RandomPatch(patch_coord_generator=self.patch_coord_generator,
box_filter=self.box_filter_patch,
image_validator=self.image_validator,
n_trials_max=self.n_trials_max,
clip_boxes=self.clip_boxes,
prob=1.0,
can_fail=False,
labels_format=self.labels_format)
# Define the processing chain
self.transformations = [self.convert_to_3_channels,
self.convert_to_float32,
self.random_brightness,
self.random_contrast,
self.convert_to_uint8,
self.convert_RGB_to_HSV,
self.convert_to_float32,
self.random_saturation,
self.random_hue,
self.convert_to_uint8,
self.convert_HSV_to_RGB,
self.random_patch,
self.random_flip,
self.resize]
def __init__(self,
resize_height,
resize_width,
random_brightness=(-20, 20, 0.5),
random_contrast=(0.8, 1.0, 0.5),
random_saturation=(0.8, 1.8, 0.5),
random_hue=(10, 0.5),
random_flip=0.5,
random_rotate_small=([np.pi / 40, np.pi / 30], 0.5),
random_rotate_big=([np.pi / 2, np.pi, 3 * np.pi / 2], 0.5),
min_scale=0.8,
max_scale=1.05,
min_aspect_ratio=0.8,
max_aspect_ratio=1.2,
n_trials_max=3,
overlap_criterion='center_point',
bounds_box_filter=(0.3, 1.0),
bounds_validator=(0.5, 1.0),
n_boxes_min=1,
random_translate=((0.03, 0.05), (0.03, 0.05), 0.5),
random_scale=(0.9, 1.1, 0.5),
proba_no_aug=1 / 3):
self.n_trials_max = n_trials_max
self.overlap_criterion = overlap_criterion
self.bounds_box_filter = bounds_box_filter
self.bounds_validator = bounds_validator
self.n_boxes_min = n_boxes_min
self.proba_no_aug = proba_no_aug # the probability of not performing any transformations
# Determines which boxes are kept in an image after the transformations have been applied.
self.box_filter = BoxFilter(check_overlap=True,
check_min_area=False,
check_degenerate=False,
overlap_criterion=self.overlap_criterion,
overlap_bounds=self.bounds_box_filter)
self.box_filter_resize = BoxFilter(check_overlap=False,
check_min_area=True,
check_degenerate=True,
min_area=16)
# Determines whether the result of the transformations is a valid training image.
self.image_validator = ImageValidator(
overlap_criterion=self.overlap_criterion,
bounds=self.bounds_validator,
n_boxes_min=self.n_boxes_min)
# Utility transformations
self.convert_to_3_channels = ConvertTo3Channels(
) # Make sure all images end up having 3 channels.
self.convert_RGB_to_HSV = ConvertColor(current='RGB', to='HSV')
self.convert_HSV_to_RGB = ConvertColor(current='HSV', to='RGB')
self.convert_to_float32 = ConvertDataType(to='float32')
self.convert_to_uint8 = ConvertDataType(to='uint8')
self.resize = Resize(height=resize_height,
width=resize_width,
box_filter=self.box_filter_resize)
# Photometric transformations
self.random_brightness = RandomBrightness(lower=random_brightness[0],
upper=random_brightness[1],
prob=random_brightness[2])
self.random_contrast = RandomContrast(lower=random_contrast[0],
upper=random_contrast[1],
prob=random_contrast[2])
self.random_saturation = RandomSaturation(lower=random_saturation[0],
upper=random_saturation[1],
prob=random_saturation[2])
self.random_hue = RandomHue(max_delta=random_hue[0],
prob=random_hue[1])
# Geometric transformations
self.random_horizontal_flip = RandomFlip(dim='horizontal',
prob=random_flip)
self.random_vertical_flip = RandomFlip(dim='vertical',
prob=random_flip)
self.random_translate = RandomTranslate(
dy_minmax=random_translate[0],
dx_minmax=random_translate[1],
prob=random_translate[2],
box_filter=self.box_filter,
image_validator=self.image_validator,
n_trials_max=self.n_trials_max)
self.random_rotate_small = RandomRotate(
angles=random_rotate_small[0],
prob=random_rotate_small[1],
box_filter=self.box_filter,
image_validator=self.image_validator,
n_trials_max=self.n_trials_max)
self.random_rotate_big = RandomRotate(
angles=random_rotate_big[0],
prob=random_rotate_big[1],
box_filter=self.box_filter,
image_validator=self.image_validator,
n_trials_max=self.n_trials_max)
self.random_zoom_in = RandomScale(min_factor=1.0,
max_factor=random_scale[1],
prob=random_scale[2],
box_filter=self.box_filter,
image_validator=self.image_validator,
n_trials_max=self.n_trials_max)
self.random_zoom_out = RandomScale(
min_factor=random_scale[0],
max_factor=random_scale[0],
prob=random_scale[2],
box_filter=self.box_filter,
image_validator=self.image_validator,
n_trials_max=self.n_trials_max)
# random patch generator is not used for the moment but it could be useful in your project
self.patch_coord_generator = PatchCoordinateGenerator(
must_match='h_w',
min_scale=min_scale,
max_scale=max_scale,
scale_uniformly=False,
min_aspect_ratio=min_aspect_ratio,
max_aspect_ratio=max_aspect_ratio)
self.random_patch = RandomPatch(
patch_coord_generator=self.patch_coord_generator,
box_filter=self.box_filter,
image_validator=self.image_validator,
n_trials_max=self.n_trials_max,
prob=0.5,
can_fail=False)
# If we zoom in, do translation before scaling.
self.sequence1 = [
self.convert_to_3_channels, self.convert_to_float32,
self.random_brightness, self.random_contrast,
self.convert_to_uint8, self.convert_RGB_to_HSV,
self.convert_to_float32, self.random_saturation, self.random_hue,
self.convert_to_uint8, self.convert_HSV_to_RGB,
self.random_horizontal_flip, self.random_vertical_flip,
self.random_translate, self.random_rotate_big,
self.random_rotate_small, self.random_zoom_in, self.random_patch,
self.resize
]
# If we zoom out, do translation after scaling.
self.sequence2 = [
self.convert_to_3_channels, self.convert_to_float32,
self.random_brightness, self.random_contrast,
self.convert_to_uint8, self.convert_RGB_to_HSV,
self.convert_to_float32, self.random_saturation, self.random_hue,
self.convert_to_uint8, self.convert_HSV_to_RGB,
self.random_horizontal_flip, self.random_vertical_flip,
self.random_zoom_out, self.random_translate,
self.random_rotate_big, self.random_rotate_small,
self.random_patch, self.resize
]
self.sequence3 = [
self.convert_to_3_channels, self.convert_to_uint8,
self.random_horizontal_flip, self.random_vertical_flip,
self.random_translate, self.random_rotate_big,
self.random_rotate_small, self.resize
]
def __init__(
self,
random_brightness=(-48, 48, 0.5),
random_contrast=(0.5, 1.8, 0.5),
random_saturation=(0.5, 1.8, 0.5),
random_hue=(18, 0.5),
random_flip=0.5,
# 最后一个元素表示 prob
random_translate=((0.03, 0.5), (0.03, 0.5), 0.5),
# 最后一个元素表示 prob
random_scale=(0.5, 2.0, 0.5),
# translate or scale 后的 image 如果不合格可以重复进行的最大次数
n_trials_max=3,
clip_boxes=True,
overlap_criterion_box_filter='area',
overlap_criterion_validator='area',
bounds_box_filter=(0.3, 1.0),
bounds_validator=(0.5, 1.0),
n_boxes_min=1,
background=(0, 0, 0),
labels_format=('class_id', 'xmin', 'ymin', 'xmax', 'ymax')):
if (random_scale[0] >= 1) or (random_scale[1] <= 1):
raise ValueError(
"This sequence of transformations only makes sense"
"if the minimum scaling factor is <1 and the maximum scaling factor is >1."
)
self.n_trials_max = n_trials_max
self.clip_boxes = clip_boxes
self.overlap_criterion_box_filter = overlap_criterion_box_filter
self.overlap_criterion_validator = overlap_criterion_validator
self.bounds_box_filter = bounds_box_filter
self.bounds_validator = bounds_validator
self.n_boxes_min = n_boxes_min
self.background = background
self.labels_format = labels_format
# Determines which boxes are kept in an image after the transformations have been applied.
self.box_filter = BoxFilter(
check_overlap=True,
check_min_area=True,
check_degenerate=True,
overlap_criterion=self.overlap_criterion_box_filter,
overlap_bounds=self.bounds_box_filter,
min_area=16,
labels_format=self.labels_format)
# Determines whether the result of the transformations is a valid training image.
self.image_validator = ImageValidator(
overlap_criterion=self.overlap_criterion_validator,
overlap_bounds=self.bounds_validator,
n_boxes_min=self.n_boxes_min,
labels_format=self.labels_format)
# Utility distortions
self.convert_RGB_to_HSV = ConvertColor(current='RGB', to='HSV')
self.convert_HSV_to_RGB = ConvertColor(current='HSV', to='RGB')
self.convert_to_float32 = ConvertDataType(to='float32')
self.convert_to_uint8 = ConvertDataType(to='uint8')
# Make sure all images end up having 3 channels.
self.convert_to_3_channels = ConvertTo3Channels()
# Photometric transformations
self.random_brightness = RandomBrightness(lower=random_brightness[0],
upper=random_brightness[1],
prob=random_brightness[2])
self.random_contrast = RandomContrast(lower=random_contrast[0],
upper=random_contrast[1],
prob=random_contrast[2])
self.random_saturation = RandomSaturation(lower=random_saturation[0],
upper=random_saturation[1],
prob=random_saturation[2])
self.random_hue = RandomHue(max_delta=random_hue[0],
prob=random_hue[1])
# Geometric transformations
self.random_flip = RandomFlip(dim='horizontal',
prob=random_flip,
labels_format=self.labels_format)
self.random_translate = RandomTranslate(
dy_minmax=random_translate[0],
dx_minmax=random_translate[1],
prob=random_translate[2],
clip_boxes=self.clip_boxes,
box_filter=self.box_filter,
image_validator=self.image_validator,
n_trials_max=self.n_trials_max,
background=self.background,
labels_format=self.labels_format)
self.random_zoom_in = RandomScale(min_factor=1.0,
max_factor=random_scale[1],
prob=random_scale[2],
clip_boxes=self.clip_boxes,
box_filter=self.box_filter,
image_validator=self.image_validator,
n_trials_max=self.n_trials_max,
background=self.background,
labels_format=self.labels_format)
self.random_zoom_out = RandomScale(
min_factor=random_scale[0],
max_factor=1.0,
prob=random_scale[2],
clip_boxes=self.clip_boxes,
box_filter=self.box_filter,
image_validator=self.image_validator,
n_trials_max=self.n_trials_max,
background=self.background,
labels_format=self.labels_format)
# If we zoom in, do translation before scaling.
self.sequence1 = [
self.convert_to_3_channels, self.convert_to_float32,
self.random_brightness, self.random_contrast,
self.convert_to_uint8, self.convert_RGB_to_HSV,
self.convert_to_float32, self.random_saturation, self.random_hue,
self.convert_to_uint8, self.convert_HSV_to_RGB,
self.random_translate, self.random_zoom_in, self.random_flip
]
# If we zoom out, do scaling before translation.
self.sequence2 = [
self.convert_to_3_channels, self.convert_to_float32,
self.random_brightness, self.random_contrast,
self.convert_to_uint8, self.convert_RGB_to_HSV,
self.convert_to_float32, self.random_saturation, self.random_hue,
self.convert_to_uint8, self.convert_HSV_to_RGB,
self.convert_to_float32, self.random_zoom_out,
self.random_translate, self.random_flip
]
def __init__(
self,
random_brightness=(-48, 48, 0.5),
random_contrast=(0.5, 1.8, 0.5),
random_saturation=(0.5, 1.8, 0.5),
random_hue=(18, 0.5),
random_flip=0.5,
random_translate=((0.03, 0.5), (0.03, 0.5), 0.5),
random_scale=(0.5, 2.0, 0.5),
random_gaussian_noise=(0.5, 0., 10), # gaussine noise
random_poisson_noise=(0.5, 60), # poisson noise
random_salt_pepper_noise=(0.5, 0.5,
0.005), # salt&pepper or impalse noise
random_row_defect=(0.5, 1), # row defect
random_col_defect=(0.5, 1), # col defect
n_trials_max=3,
clip_boxes=True,
overlap_criterion='area',
bounds_box_filter=(0.3, 1.0),
bounds_validator=(0.5, 1.0),
n_boxes_min=1,
background=(0, 0, 0),
labels_format={
'class_id': 0,
'xmin': 1,
'ymin': 2,
'xmax': 3,
'ymax': 4
}):
if (random_scale[0] >= 1) or (random_scale[1] <= 1):
raise ValueError(
"This sequence of transformations only makes sense if the minimum scaling factor is <1 and the maximum scaling factor is >1."
)
self.n_trials_max = n_trials_max
self.clip_boxes = clip_boxes
self.overlap_criterion = overlap_criterion
self.bounds_box_filter = bounds_box_filter
self.bounds_validator = bounds_validator
self.n_boxes_min = n_boxes_min
self.background = background
self.labels_format = labels_format
# Determines which boxes are kept in an image after the transformations have been applied.
self.box_filter = BoxFilter(check_overlap=True,
check_min_area=True,
check_degenerate=True,
overlap_criterion=self.overlap_criterion,
overlap_bounds=self.bounds_box_filter,
min_area=16,
labels_format=self.labels_format)
# Determines whether the result of the transformations is a valid training image.
self.image_validator = ImageValidator(
overlap_criterion=self.overlap_criterion,
bounds=self.bounds_validator,
n_boxes_min=self.n_boxes_min,
labels_format=self.labels_format)
# Utility distortions
self.convert_RGB_to_HSV = ConvertColor(current='RGB', to='HSV')
self.convert_HSV_to_RGB = ConvertColor(current='HSV', to='RGB')
self.convert_to_float32 = ConvertDataType(to='float32')
self.convert_to_uint8 = ConvertDataType(to='uint8')
self.convert_to_3_channels = ConvertTo3Channels(
) # Make sure all images end up having 3 channels.
self.convert_to_1_channel = ConvertTo1Channel(
) # Make sure all images end up having 3 channels.
# Photometric transformations
self.random_brightness = RandomBrightness(lower=random_brightness[0],
upper=random_brightness[1],
prob=random_brightness[2])
self.random_contrast = RandomContrast(lower=random_contrast[0],
upper=random_contrast[1],
prob=random_contrast[2])
self.random_saturation = RandomSaturation(lower=random_saturation[0],
upper=random_saturation[1],
prob=random_saturation[2])
self.random_hue = RandomHue(max_delta=random_hue[0],
prob=random_hue[1])
# Geometric transformations
self.random_flip = RandomFlip(dim='horizontal',
prob=random_flip,
labels_format=self.labels_format)
self.random_translate = RandomTranslate(
dy_minmax=random_translate[0],
dx_minmax=random_translate[1],
prob=random_translate[2],
clip_boxes=self.clip_boxes,
box_filter=self.box_filter,
image_validator=self.image_validator,
n_trials_max=self.n_trials_max,
background=self.background,
labels_format=self.labels_format)
self.random_zoom_in = RandomScale(min_factor=1.0,
max_factor=random_scale[1],
prob=random_scale[2],
clip_boxes=self.clip_boxes,
box_filter=self.box_filter,
image_validator=self.image_validator,
n_trials_max=self.n_trials_max,
background=self.background,
labels_format=self.labels_format)
self.random_zoom_out = RandomScale(
min_factor=random_scale[0],
max_factor=1.0,
prob=random_scale[2],
clip_boxes=self.clip_boxes,
box_filter=self.box_filter,
image_validator=self.image_validator,
n_trials_max=self.n_trials_max,
background=self.background,
labels_format=self.labels_format)
# noises and sensor defects
self.random_RowDefect = RandomRowDefect(prob=random_row_defect[0],
thikness=random_row_defect[1])
self.random_col_defect = RandomColDefect(prob=random_col_defect[0],
thikness=random_col_defect[1])
self.random_salt_pepper = RandomSaltPepperNoise(
prob=random_salt_pepper_noise[0],
salt_vs_pepper_ratio=random_salt_pepper_noise[1],
percentage=random_salt_pepper_noise[2])
self.random_poisson = RandomPoissonNoise(
prob=random_poisson_noise[0], Lambda=random_poisson_noise[1])
self.random_gaussian = RandomGaussianNoise(
prob=random_gaussian_noise[0],
mean=random_gaussian_noise[1],
sigma=random_gaussian_noise[2])
# If we zoom in, do translation before scaling.
self.sequence1 = [
self.convert_to_1_channel,
self.convert_to_float32,
self.random_brightness,
self.random_contrast,
# self.convert_to_uint8,
# self.convert_RGB_to_HSV,
# self.convert_to_float32,
# self.random_saturation,
# self.random_hue,
self.convert_to_uint8,
# self.convert_HSV_to_RGB,
self.random_translate,
self.random_zoom_in,
self.random_flip,
self.random_salt_pepper,
self.random_poisson,
self.random_gaussian,
self.random_col_defect,
self.convert_to_1_channel
]
# If we zoom out, do scaling before translation.
self.sequence2 = [
self.convert_to_1_channel,
self.convert_to_float32,
self.random_brightness,
# self.convert_to_uint8,
# self.convert_RGB_to_HSV,
# self.convert_to_float32,
# self.random_saturation,
# self.random_hue, #
# self.convert_to_uint8,
# self.convert_HSV_to_RGB,
self.convert_to_float32,
self.random_contrast,
self.convert_to_uint8,
self.random_zoom_out,
self.random_translate,
self.random_flip,
self.random_salt_pepper,
self.random_poisson,
self.random_gaussian,
self.random_col_defect,
self.convert_to_1_channel
]