def __init__(self,
gamma_log2=0.0,
per_channel=False,
name=None,
deterministic=False,
random_state=None):
super(Gamma, self).__init__(name=name,
deterministic=deterministic,
random_state=random_state)
if ia.is_single_number(gamma_log2):
self.gamma_log2 = iaa.Deterministic(gamma_log2)
elif ia.is_iterable(gamma_log2):
assert len(
gamma_log2
) == 2, "Expected tuple/list with 2 entries, got %d entries." % (
len(gamma_log2), )
self.gamma_log2 = iaa.Uniform(gamma_log2[0], gamma_log2[1])
elif isinstance(gamma_log2, iaa.StochasticParameter):
self.gamma_log2 = gamma_log2
else:
raise Exception(
"Expected float or int, tuple/list with 2 entries or StochasticParameter. Got %s."
% (type(gamma_log2), ))
if per_channel in [True, False, 0, 1, 0.0, 1.0]:
self.per_channel = iaa.Deterministic(int(per_channel))
elif ia.is_single_number(per_channel):
assert 0 <= per_channel <= 1.0
self.per_channel = iaa.Binomial(per_channel)
else:
raise Exception(
"Expected per_channel to be boolean or number or StochasticParameter"
)
def __init__(self,
alpha=(0.0, 1.0),
hysteresis_thresholds=((100 - 40, 100 + 40), (200 - 40,
200 + 40)),
sobel_kernel_size=(3, 7),
colorizer=None,
name=None,
deterministic=False,
random_state=None):
super(Canny, self).__init__(name=name,
deterministic=deterministic,
random_state=random_state)
self.alpha = iap.handle_continuous_param(alpha,
"alpha",
value_range=(0, 1.0),
tuple_to_uniform=True,
list_to_choice=True)
if isinstance(hysteresis_thresholds, tuple) \
and len(hysteresis_thresholds) == 2 \
and not ia.is_single_number(hysteresis_thresholds[0]) \
and not ia.is_single_number(hysteresis_thresholds[1]):
self.hysteresis_thresholds = (iap.handle_discrete_param(
hysteresis_thresholds[0],
"hysteresis_thresholds[0]",
value_range=(0, 255),
tuple_to_uniform=True,
list_to_choice=True,
allow_floats=True),
iap.handle_discrete_param(
hysteresis_thresholds[1],
"hysteresis_thresholds[1]",
value_range=(0, 255),
tuple_to_uniform=True,
list_to_choice=True,
allow_floats=True))
else:
self.hysteresis_thresholds = iap.handle_discrete_param(
hysteresis_thresholds,
"hysteresis_thresholds",
value_range=(0, 255),
tuple_to_uniform=True,
list_to_choice=True,
allow_floats=True)
# we don't use handle_discrete_kernel_size_param() here, because
# cv2.Canny() can't handle independent height/width values, only a
# single kernel size
self.sobel_kernel_size = iap.handle_discrete_param(
sobel_kernel_size,
"sobel_kernel_size",
value_range=(0, 7), # OpenCV only accepts ksize up to 7
tuple_to_uniform=True,
list_to_choice=True,
allow_floats=False)
self.colorizer = (colorizer if colorizer is not None else
RandomColorsBinaryImageColorizer())
def __init__(self, other_param, minval=None, maxval=None):
StochasticParameter.__init__(self)
assert isinstance(other_param, StochasticParameter)
assert minval is None or ia.is_single_number(minval)
assert maxval is None or ia.is_single_number(maxval)
self.other_param = other_param
self.minval = minval
self.maxval = maxval
def __init__(self, other_param, minval=None, maxval=None):
StochasticParameter.__init__(self)
assert isinstance(other_param, StochasticParameter)
assert minval is None or ia.is_single_number(minval)
assert maxval is None or ia.is_single_number(maxval)
self.other_param = other_param
self.minval = minval
self.maxval = maxval
def __init__(self, a, b):
StochasticParameter.__init__(self)
assert isinstance(a, (int, float, StochasticParameter)), "Expected a to be int, float or StochasticParameter, got %s" % (type(a),)
assert isinstance(b, (int, float, StochasticParameter)), "Expected b to be int, float or StochasticParameter, got %s" % (type(b),)
if ia.is_single_number(a):
self.a = Deterministic(a)
else:
self.a = a
if ia.is_single_number(b):
self.b = Deterministic(b)
else:
self.b = b
def Dropout(p=0,
per_channel=False,
name=None,
deterministic=False,
random_state=None):
"""
Copy of IMGAUG dropout,
TODO: how to I basically make imgaug dropout to call my multiply elemenwise ?
"""
if ia.is_single_number(p):
p2 = ia.parameters.Binomial(1 - p)
elif isinstance(p, (tuple, list)):
do_assert(len(p) == 2)
do_assert(p[0] < p[1])
do_assert(0 <= p[0] <= 1.0)
do_assert(0 <= p[1] <= 1.0)
p2 = ia.parameters.Binomial(ia.parameters.Uniform(1 - p[1], 1 - p[0]))
else:
raise Exception(
"Expected p to be float or int or StochasticParameter, got %s." %
(type(p), ))
return MultiplyElementwise(p2,
per_channel=per_channel,
name=name,
deterministic=deterministic,
random_state=random_state)
def __init__(self, loc, scale):
StochasticParameter.__init__(self)
if isinstance(loc, StochasticParameter):
self.loc = loc
elif ia.is_single_number(loc):
self.loc = Deterministic(loc)
else:
raise Exception("Expected float, int or StochasticParameter as loc, got %s, %s." % (type(loc),))
if isinstance(scale, StochasticParameter):
self.scale = scale
elif ia.is_single_number(scale):
assert scale >= 0, "Expected scale to be in range [0, inf) got %s (type %s)." % (scale, type(scale))
self.scale = Deterministic(scale)
else:
raise Exception("Expected float, int or StochasticParameter as scale, got %s, %s." % (type(scale),))
def __init__(self, value):
StochasticParameter.__init__(self)
if isinstance(value, StochasticParameter):
self.value = value.draw_sample()
elif ia.is_single_number(value) or ia.is_string(value):
self.value = value
else:
raise Exception("Expected StochasticParameter object or number or string, got %s." % (type(value),))
def __init__(self, p):
StochasticParameter.__init__(self)
if isinstance(p, StochasticParameter):
self.p = p
elif ia.is_single_number(p):
assert 0 <= p <= 1.0, "Expected probability p to be in range [0.0, 1.0], got %s." % (p,)
self.p = Deterministic(float(p))
else:
raise Exception("Expected StochasticParameter or float/int value, got %s." % (type(p),))
def AdditiveGaussianNoise(loc=0,
scale=0,
per_channel=False,
name='None',
deterministic=False,
random_state=None):
if ia.is_single_number(loc):
loc2 = ia.parameters.Deterministic(loc)
elif ia.is_iterable(loc):
assert len(
loc
) == 2, "Expected tuple/list with 2 entries for argument 'loc', got %d entries." % (
len(scale), )
loc2 = ia.parameters.Uniform(loc[0], loc[1])
elif isinstance(loc, ia.parameters.StochasticParameter):
loc2 = loc
else:
raise Exception(
"Expected float, int, tuple/list with 2 entries or StochasticParameter for argument 'loc'. Got %s."
% (type(loc), ))
if ia.is_single_number(scale):
scale2 = ia.parameters.Deterministic(scale)
elif ia.is_iterable(scale):
assert len(
scale
) == 2, "Expected tuple/list with 2 entries for argument 'scale', got %d entries." % (
len(scale), )
scale2 = ia.parameters.Uniform(scale[0], scale[1])
elif isinstance(scale, ia.parameters.StochasticParameter):
scale2 = scale
else:
raise Exception(
"Expected float, int, tuple/list with 2 entries or StochasticParameter for argument 'scale'. Got %s."
% (type(scale), ))
return AddElementwise(scale,
per_channel=per_channel,
name=name,
deterministic=deterministic,
random_state=random_state)
def __init__(self, value):
StochasticParameter.__init__(self)
if isinstance(value, StochasticParameter):
self.value = value.draw_sample()
elif ia.is_single_number(value) or ia.is_string(value):
self.value = value
else:
raise Exception(
"Expected StochasticParameter object or number or string, got %s."
% (type(value), ))
def __init__(self, a, b):
StochasticParameter.__init__(self)
assert isinstance(
a, (int, float, StochasticParameter)
), "Expected a to be int, float or StochasticParameter, got %s" % (
type(a), )
assert isinstance(
b, (int, float, StochasticParameter)
), "Expected b to be int, float or StochasticParameter, got %s" % (
type(b), )
if ia.is_single_number(a):
self.a = Deterministic(a)
else:
self.a = a
if ia.is_single_number(b):
self.b = Deterministic(b)
else:
self.b = b
def __init__(self, loc, scale):
StochasticParameter.__init__(self)
if isinstance(loc, StochasticParameter):
self.loc = loc
elif ia.is_single_number(loc):
self.loc = Deterministic(loc)
else:
raise Exception(
"Expected float, int or StochasticParameter as loc, got %s, %s."
% (type(loc), ))
if isinstance(scale, StochasticParameter):
self.scale = scale
elif ia.is_single_number(scale):
assert scale >= 0, "Expected scale to be in range [0, inf) got %s (type %s)." % (
scale, type(scale))
self.scale = Deterministic(scale)
else:
raise Exception(
"Expected float, int or StochasticParameter as scale, got %s, %s."
% (type(scale), ))
def __init__(self, p):
super(BinomialColumns, self).__init__()
if isinstance(p, StochasticParameter):
self.p = p
elif ia.is_single_number(p):
assert 0 <= p <= 1.0, "Expected probability p to be in range [0.0, 1.0], got %s." % (
p, )
self.p = Deterministic(float(p))
else:
raise Exception(
"Expected StochasticParameter or float/int value, got %s." %
(type(p), ))
def deepcopy_fast(obj):
if obj is None:
return None
if ia.is_single_number(obj) or ia.is_string(obj):
return obj
if isinstance(obj, list):
return [deepcopy_fast(el) for el in obj]
if isinstance(obj, tuple):
return tuple([deepcopy_fast(el) for el in obj])
if ia.is_np_array(obj):
return np.copy(obj)
if hasattr(obj, "deepcopy"):
return obj.deepcopy()
return copylib.deepcopy(obj)
def __init__(self, k=1, name=None, deterministic=False, random_state=None):
super(AverageBlur, self).__init__(name=name,
deterministic=deterministic,
random_state=random_state)
# TODO replace this by iap.handle_discrete_kernel_size()
self.mode = "single"
if ia.is_single_number(k):
self.k = iap.Deterministic(int(k))
elif ia.is_iterable(k):
assert len(k) == 2, (
"Expected iterable 'k' to contain exactly 2 entries, "
"got %d." % (len(k), ))
if all([ia.is_single_number(ki) for ki in k]):
self.k = iap.DiscreteUniform(int(k[0]), int(k[1]))
elif all([isinstance(ki, iap.StochasticParameter) for ki in k]):
self.mode = "two"
self.k = (k[0], k[1])
else:
k_tuple = [None, None]
if ia.is_single_number(k[0]):
k_tuple[0] = iap.Deterministic(int(k[0]))
elif ia.is_iterable(k[0]) and all(
[ia.is_single_number(ki) for ki in k[0]]):
k_tuple[0] = iap.DiscreteUniform(int(k[0][0]),
int(k[0][1]))
else:
raise Exception(
"k[0] expected to be int or tuple of two ints, got %s"
% (type(k[0]), ))
if ia.is_single_number(k[1]):
k_tuple[1] = iap.Deterministic(int(k[1]))
elif ia.is_iterable(k[1]) and all(
[ia.is_single_number(ki) for ki in k[1]]):
k_tuple[1] = iap.DiscreteUniform(int(k[1][0]),
int(k[1][1]))
else:
raise Exception(
"k[1] expected to be int or tuple of two ints, got %s"
% (type(k[1]), ))
self.mode = "two"
self.k = k_tuple
elif isinstance(k, iap.StochasticParameter):
self.k = k
else:
raise Exception(
"Expected int, tuple/list with 2 entries or StochasticParameter. Got %s."
% (type(k), ))
def CoarseDropout(p=0,
size_px=None,
size_percent=None,
per_channel=False,
min_size=4,
name=None,
deterministic=False,
random_state=None):
"""
The version exactly the same, it would be nice to just route the calling from IMGaug
"""
if ia.is_single_number(p):
p2 = ia.parameters.Binomial(1 - p)
elif ia.is_iterable(p):
do_assert(len(p) == 2)
do_assert(p[0] < p[1])
do_assert(0 <= p[0] <= 1.0)
do_assert(0 <= p[1] <= 1.0)
p2 = ia.parameters.Binomial(ia.parameters.Uniform(1 - p[1], 1 - p[0]))
elif isinstance(p, ia.parameters.StochasticParameter):
p2 = p
else:
raise Exception(
"Expected p to be float or int or StochasticParameter, got %s." %
(type(p), ))
if size_px is not None:
p3 = ia.parameters.FromLowerResolution(other_param=p2,
size_px=size_px,
min_size=min_size)
elif size_percent is not None:
p3 = ia.parameters.FromLowerResolution(other_param=p2,
size_percent=size_percent,
min_size=min_size)
else:
raise Exception("Either size_px or size_percent must be set.")
return MultiplyElementwise(p3,
per_channel=per_channel,
name=name,
deterministic=deterministic,
random_state=random_state)
def __init__(self, k=1, name=None, deterministic=False, random_state=None):
super(AverageBlur, self).__init__(name=name, deterministic=deterministic, random_state=random_state)
# TODO replace this by iap.handle_discrete_kernel_size()
self.mode = "single"
if ia.is_single_number(k):
self.k = iap.Deterministic(int(k))
elif ia.is_iterable(k):
ia.do_assert(len(k) == 2)
if all([ia.is_single_number(ki) for ki in k]):
self.k = iap.DiscreteUniform(int(k[0]), int(k[1]))
elif all([isinstance(ki, iap.StochasticParameter) for ki in k]):
self.mode = "two"
self.k = (k[0], k[1])
else:
k_tuple = [None, None]
if ia.is_single_number(k[0]):
k_tuple[0] = iap.Deterministic(int(k[0]))
elif ia.is_iterable(k[0]) and all([ia.is_single_number(ki) for ki in k[0]]):
k_tuple[0] = iap.DiscreteUniform(int(k[0][0]), int(k[0][1]))
else:
raise Exception("k[0] expected to be int or tuple of two ints, got %s" % (type(k[0]),))
if ia.is_single_number(k[1]):
k_tuple[1] = iap.Deterministic(int(k[1]))
elif ia.is_iterable(k[1]) and all([ia.is_single_number(ki) for ki in k[1]]):
k_tuple[1] = iap.DiscreteUniform(int(k[1][0]), int(k[1][1]))
else:
raise Exception("k[1] expected to be int or tuple of two ints, got %s" % (type(k[1]),))
self.mode = "two"
self.k = k_tuple
elif isinstance(k, iap.StochasticParameter):
self.k = k
else:
raise Exception("Expected int, tuple/list with 2 entries or StochasticParameter. Got %s." % (type(k),))
