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