Source code for libertem.utils.generate

import numpy as np
from scipy.ndimage import gaussian_filter

from libertem.common.math import prod
from libertem.utils import make_cartesian, make_polar, frame_peaks
import libertem.masks as m

def cbed_frame(
        fy=128, fx=128, zero=None, a=None, b=None, indices=None,
        radius=4, all_equal=False, margin=None):
    if zero is None:
        zero = (fy//2, fx//2)
    zero = np.array(zero)
    if a is None:
        a = (fy//8, 0)
    a = np.array(a)
    if b is None:
        b = make_cartesian(make_polar(a) - (0, np.pi/2))
    b = np.array(b)
    if indices is None:
        indices = np.mgrid[-10:11, -10:11]
    if margin is None:
        margin = radius
    indices, peaks = frame_peaks(fy=fy, fx=fx, zero=zero, a=a, b=b, r=margin, indices=indices)

    data = np.zeros((1, fy, fx), dtype=np.float32)

    dists = np.linalg.norm(peaks - zero, axis=-1)
    max_val = max(dists.max() + 1, len(peaks) + 1)

    for i, p in enumerate(peaks):
        data += m.circular(
        ) * (1 if all_equal else max(1, max_val - dists[i] + i))

    return (data, indices, peaks)

[docs]def hologram_frame(amp, phi, counts=1000., sampling=5., visibility=1., f_angle=30., gaussian_noise=None, poisson_noise=None): """ Generates holograms using phase and amplitude as an input See :ref:`holography app` for detailed application example .. versionadded:: 0.3.0 Notes ----- Theoretical basis for hologram simulations see in: Lichte, H., and M. Lehmann. Rep. Prog. Phys. 71 (2008): 016102. doi:10.1088/0034-4885/71/1/016102 :cite:`Lichte2008` Parameters ---------- amp, phi: np.ndarray, 2d normalized amplitude and phase images of the same shape counts: float, default: 1000. Number of electron counts in vacuum sampling: float, default: 5. Hologram fringe sampling (number of pixels per fringe) visibility: float, default: 1. Hologram fringe visibility (aka fringe contrast) f_angle: float, default: 30. Angle in degrees of hologram fringes with respect to X-axis gaussian_noise: float or int or None, default: None. Amount of Gaussian smoothing determined by sigma parameter applied to the hologram simulating effect of focus spread or PSF of the detector. poisson_noise: float or int or None, default: None. Amount of Poisson applied to the hologram. Returns ------- holo: np.ndarray, 2d hologram image """ if not amp.shape == phi.shape: raise ValueError('Amplitude and phase should be 2d arrays of the same shape.') sy, sx = phi.shape x, y = np.meshgrid(np.arange(sx), np.arange(sy)) f_angle = f_angle / 180. * np.pi holo = counts / 2 * (1. + amp ** 2 + 2. * amp * visibility * np.cos(2. * np.pi * y / sampling * np.cos(f_angle) + 2. * np.pi * x / sampling * np.sin(f_angle) - phi)) if poisson_noise: if not isinstance(poisson_noise, (float, int)): raise ValueError("poisson_noise parameter should be float or int or None.") noise_scale = poisson_noise * counts holo = noise_scale * np.random.poisson(holo / noise_scale) if gaussian_noise: if not isinstance(gaussian_noise, (float, int)): raise ValueError("gaussian_noise parameter should be float or int or None.") holo = gaussian_filter(holo, gaussian_noise) return holo
def gradient_data(nav_dims, sig_dims): data = np.linspace( start=5, stop=30, num=prod(nav_dims) * prod(sig_dims), dtype=np.float32 ) return data.reshape(nav_dims + sig_dims) def exclude_pixels(sig_dims, num_excluded): ''' Generate a list of excluded pixels that can be reconstructed faithfully from their neighbors in a linear gradient dataset ''' if num_excluded == 0: return None # Map of pixels that can be reconstructed faithfully from neighbors in a linear gradient free_map = np.ones(sig_dims, dtype=bool) # Exclude all border pixels for dim in range(len(sig_dims)): selector = tuple(slice(None) if i != dim else (0, -1) for i in range(len(sig_dims))) free_map[selector] = False exclude = [] while len(exclude) < num_excluded: exclude_item = tuple(np.random.randint(low=1, high=s-1) for s in sig_dims) if free_map[exclude_item]: exclude.append(exclude_item) knock_out = tuple(slice(e - 1, e + 2) for e in exclude_item) # Remove the neighbors of a bad pixel # since that can't be reconstructed faithfully from a linear gradient free_map[knock_out] = False # Transform from list of tuples with length of number of dimensions # to array of indices per dimension return np.array(exclude).T