def get_images_from_grid( self, dtype_out: np.dtype = np.float32, ) -> VirtualBSEImage: """Return an in-memory signal with a stack of virtual backscatter electron (BSE) images by integrating the intensities within regions of interest (ROI) defined by the detector `grid_shape`. Parameters ---------- dtype_out Output data type, default is float32. Returns ------- vbse_images : VirtualBSEImage In-memory signal with virtual BSE images. Examples -------- >>> import kikuchipy as kp >>> s = kp.data.nickel_ebsd_small() >>> s <EBSD, title: patterns My awes0m4 ..., dimensions: (3, 3|60, 60)> >>> vbse_gen = kp.generators.VirtualBSEGenerator(s) >>> vbse_gen.grid_shape = (5, 5) >>> vbse = vbse_gen.get_images_from_grid() >>> vbse <VirtualBSEImage, title: , dimensions: (5, 5|3, 3)> """ grid_shape = self.grid_shape new_shape = grid_shape + self.signal.axes_manager.navigation_shape[::-1] images = np.zeros(new_shape, dtype=dtype_out) for row, col in np.ndindex(grid_shape): roi = self.roi_from_grid((row, col)) images[row, col] = self.signal.get_virtual_bse_intensity(roi).data vbse_images = VirtualBSEImage(images) # TODO: Transfer signal's detector axes to new navigation axes # with proper binning vbse_images.axes_manager = _transfer_navigation_axes_to_signal_axes( new_axes=vbse_images.axes_manager, old_axes=self.signal.axes_manager) return vbse_images
def get_rgb_image( self, r: Union[BaseInteractiveROI, Tuple, List[BaseInteractiveROI], List[Tuple], ], g: Union[BaseInteractiveROI, Tuple, List[BaseInteractiveROI], List[Tuple], ], b: Union[BaseInteractiveROI, Tuple, List[BaseInteractiveROI], List[Tuple], ], percentiles: Optional[Tuple] = None, normalize: bool = True, alpha: Union[None, np.ndarray, VirtualBSEImage] = None, dtype_out: Union[np.uint8, np.uint16] = np.uint8, **kwargs, ) -> VirtualBSEImage: """Return an in-memory RGB virtual BSE image from three regions of interest (ROIs) on the EBSD detector, with a potential "alpha channel" in which all three arrays are multiplied by a fourth. Parameters ---------- r One ROI or a list of ROIs, or one tuple or a list of tuples with detector grid indices specifying one or more ROI(s). Intensities within the specified ROI(s) are summed up to form the red color channel. g One ROI or a list of ROIs, or one tuple or a list of tuples with detector grid indices specifying one or more ROI(s). Intensities within the specified ROI(s) are summed up to form the green color channel. b One ROI or a list of ROIs, or one tuple or a list of tuples with detector grid indices specifying one or more ROI(s). Intensities within the specified ROI(s) are summed up to form the blue color channel. normalize Whether to normalize the individual images (channels) before RGB image creation. alpha "Alpha channel". If None (default), no "alpha channel" is added to the image. percentiles Whether to apply contrast stretching with a given percentile tuple with percentages, e.g. (0.5, 99.5), after creating the RGB image. If None (default), no contrast stretching is performed. dtype_out Output data type, either np.uint16 or np.uint8 (default). kwargs Keyword arguments passed to :func:`~kikuchipy.generators.virtual_bse_generator.get_rgb_image`. Returns ------- vbse_rgb_image : VirtualBSEImage Virtual RGB image in memory. See Also -------- ~kikuchipy.signals.EBSD.plot_virtual_bse_intensity ~kikuchipy.signals.EBSD.get_virtual_bse_intensity Notes ----- HyperSpy only allows for RGB signal dimensions with data types unsigned 8 or 16 bit. """ channels = [] for rois in [r, g, b]: if isinstance(rois, tuple) or hasattr(rois, "__iter__") is False: rois = (rois, ) image = np.zeros( self.signal.axes_manager.navigation_shape[::-1], dtype=np.float64, ) for roi in rois: if isinstance(roi, tuple): roi = self.roi_from_grid(roi) roi_image = self.signal.get_virtual_bse_intensity(roi).data if isinstance(roi_image, Array): roi_image = roi_image.compute() image += roi_image channels.append(image) if alpha is not None and isinstance(alpha, Signal2D): alpha = alpha.data rgb_image = get_rgb_image( channels=channels, normalize=normalize, alpha=alpha, percentiles=percentiles, dtype_out=dtype_out, **kwargs, ) rgb_image = rgb_image.astype(dtype_out) vbse_rgb_image = VirtualBSEImage(rgb_image).transpose(signal_axes=1) dtype_rgb = "rgb" + str(8 * np.iinfo(dtype_out).dtype.itemsize) vbse_rgb_image.change_dtype(dtype_rgb) vbse_rgb_image.axes_manager = _transfer_navigation_axes_to_signal_axes( new_axes=vbse_rgb_image.axes_manager, old_axes=self.signal.axes_manager, ) return vbse_rgb_image