def uniform_noise(space, low=0, high=1, seed=None): """Uniformly distributed noise in ``space``, pointwise ``U(low, high)``. Parameters ---------- space : `TensorSpace` or `ProductSpace` The space in which the noise is created. low : ``space.field`` element or ``space`` `element-like`, optional The lower bound of the uniform noise. If a scalar, it is interpreted as ``low * space.one()``. If ``space`` is complex, the real and imaginary parts are interpreted as their respective part of the noise. high : ``space.field`` element or ``space`` `element-like`, optional The upper bound of the uniform noise. If a scalar, it is interpreted as ``high * space.one()``. If ``space`` is complex, the real and imaginary parts are interpreted as their respective part of the noise. seed : int, optional Random seed to use for generating the noise. For ``None``, use the current seed. Returns ------- white_noise : ``space`` element See Also -------- poisson_noise salt_pepper_noise white_noise numpy.random.normal """ from odl.space import ProductSpace with NumpyRandomSeed(seed): if isinstance(space, ProductSpace): values = [uniform_noise(subspace, low, high) for subspace in space] else: if space.is_complex: real = np.random.uniform(low=low.real, high=high.real, size=space.shape) imag = np.random.uniform(low=low.imag, high=high.imag, size=space.shape) values = real + 1j * imag else: values = np.random.uniform(low=low, high=high, size=space.shape) return space.element(values)
def white_noise(space, mean=0, stddev=1, seed=None): """Standard gaussian noise in space, pointwise ``N(mean, stddev**2)``. Parameters ---------- space : `FnBase` or `ProductSpace` The space in which the noise is created. mean : ``space.field`` element or ``space`` `element-like`, optional The mean of the white noise. If a scalar, it is interpreted as ``mean * space.one()``. If ``space`` is complex, the real and imaginary parts are interpreted as the mean of their respective part of the noise. stddev : `float` or ``space`` `element-like`, optional The standard deviation of the white noise. If a scalar, it is interpreted as ``stddev * space.one()``. seed : int, optional Random seed to use for generating the noise. For ``None``, use the current seed. Returns ------- white_noise : ``space`` element See Also -------- poisson_noise salt_pepper_noise numpy.random.normal """ from odl.space import ProductSpace with NumpyRandomSeed(seed): if isinstance(space, ProductSpace): values = [ white_noise(subspace, mean, stddev) for subspace in space ] else: if space.is_cn: real = np.random.normal(loc=mean.real, scale=stddev, size=space.shape) imag = np.random.normal(loc=mean.imag, scale=stddev, size=space.shape) values = real + 1j * imag else: values = np.random.normal(loc=mean, scale=stddev, size=space.shape) return space.element(values)
def poisson_noise(intensity, seed=None): """Poisson distributed noise with given intensity. Parameters ---------- intensity : `TensorSpace` or `ProductSpace` element The intensity (usually called lambda) parameter of the noise. Returns ------- poisson_noise : ``intensity.space`` element Poisson distributed random variable. seed : int, optional Random seed to use for generating the noise. For ``None``, use the current seed. Notes ----- For a Poisson distributed random variable :math:`X` with intensity :math:`\\lambda`, the probability of it taking the value :math:`k \\in \mathbb{N}_0` is given by .. math:: \\frac{\\lambda^k e^{-\\lambda}}{k!} Note that the function only takes integer values. See Also -------- white_noise salt_pepper_noise uniform_noise numpy.random.poisson """ from odl.space import ProductSpace with NumpyRandomSeed(seed): if isinstance(intensity.space, ProductSpace): values = [ poisson_noise(subintensity) for subintensity in intensity ] else: values = np.random.poisson(intensity.asarray()) return intensity.space.element(values)
def salt_pepper_noise(vector, fraction=0.05, salt_vs_pepper=0.5, low_val=None, high_val=None, seed=None): """Add salt and pepper noise to vector. Salt and pepper noise replaces random elements in ``vector`` with ``low_val`` or ``high_val``. Parameters ---------- vector : `FnBase` or `ProductSpace` The vector that noise should be added to. fraction : float, optional The propotion of the elements in ``vector`` that should be converted to noise. salt_vs_pepper : float, optional Relative aboundance of salt (high) vs pepper (low) noise. A high value means more salt than pepper noise. low_val : float, optional The "pepper" color in the noise. Default: minimum value of ``vector``. For product spaces the minimum value per subspace is taken. each sub-space. high_val : float, optional The "salt" value in the noise. Default: maximuim value of ``vector``. For product spaces the maximum value per subspace is taken. seed : int, optional Random seed to use for generating the noise. For ``None``, use the current seed. Returns ------- salt_pepper_noise : ``vector.space`` element ``vector`` with salt and pepper noise. See Also -------- white_noise poisson_noise """ from odl.space import ProductSpace # Validate input parameters fraction, fraction_in = float(fraction), fraction if not (0 <= fraction <= 1): raise ValueError('`fraction` ({}) should be a float in the interval ' '[0, 1]'.format(fraction_in)) salt_vs_pepper, salt_vs_pepper_in = float(salt_vs_pepper), salt_vs_pepper if not (0 <= salt_vs_pepper <= 1): raise ValueError('`salt_vs_pepper` ({}) should be a float in the ' 'interval [0, 1]'.format(salt_vs_pepper_in)) with NumpyRandomSeed(seed): if isinstance(vector.space, ProductSpace): values = [ salt_pepper_noise(subintensity, fraction, salt_vs_pepper, low_val, high_val) for subintensity in vector ] else: # Extract vector of values values = as_flat_array(vector).copy() # Determine fill-in values if not given if low_val is None: low_val = np.min(values) if high_val is None: high_val = np.max(values) # Create randomly selected points as a subset of image. a = np.arange(vector.size) np.random.shuffle(a) salt_indices = a[:int(fraction * vector.size * salt_vs_pepper)] pepper_indices = a[int(fraction * vector.size * salt_vs_pepper):int(fraction * vector.size)] values[salt_indices] = high_val values[pepper_indices] = -low_val return vector.space.element(values)