def __init__(self, k=1, name=None, deterministic=False, random_state=None):
super(MedianBlur, self).__init__(name=name,
deterministic=deterministic,
random_state=random_state)
if eu.is_single_number(k):
eu.do_assert(
k % 2 != 0,
"Expected k to be odd, got %d. Add or subtract 1." %
(int(k), ))
self.k = Deterministic(int(k))
elif eu.is_iterable(k):
eu.do_assert(len(k) == 2)
eu.do_assert(all([eu.is_single_number(ki) for ki in k]))
eu.do_assert(
k[0] % 2 != 0,
"Expected k[0] to be odd, got %d. Add or subtract 1." %
(int(k[0]), ))
eu.do_assert(
k[1] % 2 != 0,
"Expected k[1] to be odd, got %d. Add or subtract 1." %
(int(k[1]), ))
self.k = DiscreteUniform(int(k[0]), int(k[1]))
elif isinstance(k, StochasticParameter):
self.k = k
else:
raise Exception(
"Expected int, tuple/list with 2 entries or StochasticParameter. Got %s."
% (type(k), ))
def __init__(self, other_param, minval=None, maxval=None):
super(Clip, self).__init__()
eu.do_assert(isinstance(other_param, StochasticParameter))
eu.do_assert(minval is None or eu.is_single_number(minval))
eu.do_assert(maxval is None or eu.is_single_number(maxval))
self.other_param = other_param
self.minval = minval
self.maxval = maxval
def __init__(self,
sigma=0,
name=None,
deterministic=False,
random_state=None):
super(GaussianBlur, self).__init__(name=name,
deterministic=deterministic,
random_state=random_state)
if eu.is_single_number(sigma):
self.sigma = Deterministic(sigma)
elif eu.is_iterable(sigma):
eu.do_assert(
len(sigma) == 2,
"Expected tuple/list with 2 entries, got %d entries." %
(len(sigma), ))
self.sigma = Uniform(sigma[0], sigma[1])
elif isinstance(sigma, StochasticParameter):
self.sigma = sigma
else:
raise Exception(
"Expected float, int, tuple/list with 2 entries or StochasticParameter. Got %s."
% (type(sigma), ))
self.eps = 0.001 # epsilon value to estimate whether sigma is above 0
def __rtruediv__(self, other):
if eu.is_single_number(other) or isinstance(other,
StochasticParameter):
return Divide(other, self)
else:
raise Exception(
"Invalid datatypes in: %s / StochasticParameter (truediv). Expected second argument to be number or StochasticParameter."
% (type(other), ))
def __rmul__(self, other):
if eu.is_single_number(other) or isinstance(other,
StochasticParameter):
return Multiply(other, self)
else:
raise Exception(
"Invalid datatypes in: %s * StochasticParameter. Expected second argument to be number or StochasticParameter."
% (type(other), ))
def __sub__(self, other):
if eu.is_single_number(other) or isinstance(other,
StochasticParameter):
return Subtract(self, other)
else:
raise Exception(
"Invalid datatypes in: StochasticParameter - %s. Expected second argument to be number or StochasticParameter."
% (type(other), ))
def handle_continuous_param(param,
name,
value_range=None,
tuple_to_uniform=True,
list_to_choice=True):
def check_value_range(v):
if value_range is None:
return True
elif isinstance(value_range, tuple):
eu.do_assert(len(value_range) == 2)
if value_range[0] is None and value_range[1] is None:
return True
elif value_range[0] is None:
eu.do_assert(
v <= value_range[1], "Parameter '%s' is outside "
"of the expected value range (x <= %.4f)" %
(name, value_range[1]))
return True
elif value_range[1] is None:
eu.do_assert(
value_range[0] <= v, "Parameter '%s' is outside "
"of the expected value range (%.4f <= x)" %
(name, value_range[0]))
return True
else:
eu.do_assert(
value_range[0] <= v <= value_range[1],
"Parameter '%s' is outside of the expected value range (%.4f <= x <= %.4f)"
% (name, value_range[0], value_range[1]))
return True
elif eu.is_callable(value_range):
value_range(v)
return True
else:
raise Exception("Unexpected input for value_range, got %s." %
(str(value_range), ))
if eu.is_single_number(param):
check_value_range(param)
return Deterministic(param)
elif tuple_to_uniform and isinstance(param, tuple):
eu.do_assert(len(param) == 2)
check_value_range(param[0])
check_value_range(param[1])
return Uniform(param[0], param[1])
elif list_to_choice and eu.is_iterable(param):
for param_i in param:
check_value_range(param_i)
return Choice(param)
elif isinstance(param, StochasticParameter):
return param
else:
raise Exception(
"Expected number, tuple of two number, list of number or StochasticParameter for %s, got %s."
% (
name,
type(param),
))
def __init__(self, p=0, name=None, deterministic=False, random_state=None):
super(Flipud, self).__init__(name=name,
deterministic=deterministic,
random_state=random_state)
if eu.is_single_number(p):
self.p = Binomial(p)
elif isinstance(p, StochasticParameter):
self.p = p
else:
raise Exception("Expected p type StochasticParameter")
def __init__(self, value):
super(Deterministic, self).__init__()
if isinstance(value, StochasticParameter):
self.value = value.draw_sample()
elif eu.is_single_number(value) or eu.is_string(value):
self.value = value
else:
raise Exception(
"Expected StochasticParameter object or number or string, got %s."
% (type(value), ))
def __rpow__(self, other, z=None):
if z is not None:
raise NotImplementedError(
"Modulo power is currently not supported by StochasticParameter."
)
if eu.is_single_number(other) or isinstance(other,
StochasticParameter):
return Power(other, self)
else:
raise Exception(
"Invalid datatypes in: %s ** StochasticParameter. Expected second argument to be number or StochasticParameter."
% (type(other), ))
def __init__(self,
to_colorspace,
from_colorspace="RGB",
alpha=1.0,
name=None,
deterministic=False,
random_state=None):
super(ChangeColorspace, self).__init__(name=name,
deterministic=deterministic,
random_state=random_state)
if eu.is_single_number(alpha):
self.alpha = Deterministic(alpha)
elif eu.is_iterable(alpha):
eu.do_assert(
len(alpha) == 2,
"Expected tuple/list with 2 entries, got %d entries." %
(len(alpha), ))
self.alpha = Uniform(alpha[0], alpha[1])
elif isinstance(alpha, StochasticParameter):
self.alpha = alpha
else:
raise Exception(
"Expected alpha to be int or float or tuple/list of ints/floats or StochasticParameter, got %s."
% (type(alpha), ))
if eu.is_string(to_colorspace):
eu.do_assert(to_colorspace in ChangeColorspace.COLORSPACES)
self.to_colorspace = Deterministic(to_colorspace)
elif eu.is_iterable(to_colorspace):
eu.do_assert(
all([eu.is_string(colorspace)
for colorspace in to_colorspace]))
eu.do_assert(
all([(colorspace in ChangeColorspace.COLORSPACES)
for colorspace in to_colorspace]))
self.to_colorspace = Choice(to_colorspace)
elif isinstance(to_colorspace, StochasticParameter):
self.to_colorspace = to_colorspace
else:
raise Exception(
"Expected to_colorspace to be string, list of strings or StochasticParameter, got %s."
% (type(to_colorspace), ))
self.from_colorspace = from_colorspace
eu.do_assert(self.from_colorspace in ChangeColorspace.COLORSPACES)
eu.do_assert(from_colorspace != ChangeColorspace.GRAY)
self.eps = 0.001 # epsilon value to check if alpha is close to 1.0 or 0.0
def __init__(self, loc, scale):
super(Normal, self).__init__()
if isinstance(loc, StochasticParameter):
self.loc = loc
elif eu.is_single_number(loc):
self.loc = Deterministic(loc)
else:
raise Exception(
"Expected float, int or StochasticParameter as loc, got %s." %
(type(loc), ))
if isinstance(scale, StochasticParameter):
self.scale = scale
elif eu.is_single_number(scale):
eu.do_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."
% (type(scale), ))
def __init__(self,
value=0,
per_channel=False,
name=None,
deterministic=False,
random_state=None):
super(Add, self).__init__(name=name,
deterministic=deterministic,
random_state=random_state)
if eu.is_single_integer(value):
eu.do_assert(
-255 <= value <= 255,
"Expected value to have range [-255, 255], got value %d." %
(value, ))
self.value = Deterministic(value)
elif eu.is_iterable(value):
eu.do_assert(
len(value) == 2,
"Expected tuple/list with 2 entries, got %d entries." %
(len(value), ))
self.value = DiscreteUniform(value[0], value[1])
elif isinstance(value, StochasticParameter):
self.value = value
else:
raise Exception(
"Expected float or int, tuple/list with 2 entries or StochasticParameter. Got %s."
% (type(value), ))
if per_channel in [True, False, 0, 1, 0.0, 1.0]:
self.per_channel = Deterministic(int(per_channel))
elif eu.is_single_number(per_channel):
eu.do_assert(
0 <= per_channel <= 1.0,
"Expected bool, or number in range [0, 1.0] for per_channel, got %s."
% (type(per_channel), ))
self.per_channel = Binomial(per_channel)
else:
raise Exception(
"Expected per_channel to be boolean or number or StochasticParameter"
)
def __init__(self, k=1, name=None, deterministic=False, random_state=None):
super(AverageBlur, self).__init__(name=name,
deterministic=deterministic,
random_state=random_state)
self.mode = "single"
if eu.is_single_number(k):
self.k = Deterministic(int(k))
elif eu.is_iterable(k):
eu.do_assert(len(k) == 2)
if all([eu.is_single_number(ki) for ki in k]):
self.k = DiscreteUniform(int(k[0]), int(k[1]))
elif all([isinstance(ki, StochasticParameter) for ki in k]):
self.mode = "two"
self.k = (k[0], k[1])
else:
k_tuple = [None, None]
if eu.is_single_number(k[0]):
k_tuple[0] = Deterministic(int(k[0]))
elif eu.is_iterable(k[0]) and all(
[eu.is_single_number(ki) for ki in k[0]]):
k_tuple[0] = 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 eu.is_single_number(k[1]):
k_tuple[1] = Deterministic(int(k[1]))
elif eu.is_iterable(k[1]) and all(
[eu.is_single_number(ki) for ki in k[1]]):
k_tuple[1] = 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, StochasticParameter):
self.k = k
else:
raise Exception(
"Expected int, tuple/list with 2 entries or StochasticParameter. Got %s."
% (type(k), ))
