def get_image_quality( patterns: Union[np.ndarray, da.Array], frequency_vectors: Optional[np.ndarray] = None, inertia_max: Union[None, int, float] = None, normalize: bool = True, ) -> np.ndarray: """Compute the image quality in a chunk of EBSD patterns. The image quality is calculated based on the procedure defined by Krieger Lassen [Lassen1994]_. Parameters ---------- patterns EBSD patterns. frequency_vectors Integer 2D array with values corresponding to the weight given each FFT spectrum frequency component. If None (default), these are calculated from :func:`~kikuchipy.util.pattern.fft_frequency_vectors`. inertia_max Maximum inertia of the FFT power spectrum of the image. If None (default), this is calculated from the `frequency_vectors`. normalize Whether to normalize patterns to a mean of zero and standard deviation of 1 before calculating the image quality. Default is True. Returns ------- image_quality_chunk : numpy.ndarray Image quality of patterns. """ dtype_out = np.float64 image_quality_chunk = np.empty(patterns.shape[:-2], dtype=dtype_out) for nav_idx in np.ndindex(patterns.shape[:-2]): # Get (normalized) pattern if normalize: pattern = pattern_processing.normalize_intensity( pattern=patterns[nav_idx]) else: pattern = patterns[nav_idx] # Compute image quality image_quality_chunk[nav_idx] = pattern_processing.get_image_quality( pattern=pattern, normalize=False, frequency_vectors=frequency_vectors, inertia_max=inertia_max, ) return image_quality_chunk
def normalize_intensity( patterns: Union[np.ndarray, da.Array], num_std: int = 1, divide_by_square_root: bool = False, dtype_out: Optional[np.dtype] = None, ) -> np.ndarray: """Normalize intensities in a chunk of EBSD patterns to a mean of zero with a given standard deviation. Parameters ---------- patterns Patterns to normalize the intensity in. num_std Number of standard deviations of the output intensities. Default is 1. divide_by_square_root Whether to divide output intensities by the square root of the pattern size. Default is False. dtype_out Data type of normalized patterns. If None (default), the input patterns' data type is used. Returns ------- normalized_patterns : numpy.ndarray Normalized patterns. Notes ----- Data type should always be changed to floating point, e.g. ``np.float32`` with :meth:`numpy.ndarray.astype`, before normalizing the intensities. """ if dtype_out is None: dtype_out = patterns.dtype.type normalized_patterns = np.empty_like(patterns, dtype=dtype_out) for nav_idx in np.ndindex(patterns.shape[:-2]): normalized_patterns[nav_idx] = pattern_processing.normalize_intensity( pattern=patterns[nav_idx], num_std=num_std, divide_by_square_root=divide_by_square_root, ) return normalized_patterns