pyxem / kikuchipy / 534

pending completion

Build # 534

Build Type

Pull #239

travis-ci-com

Committed by

web-flow

Commit Message

<a href="https://github.com/pyxem/kikuchipy/commit/<a class=hub.com/pyxem/kikuchipy/commit/<a class="double-link" href="https://git"><a class=hub.com/pyxem/kikuchipy/commit/<a class="double-link" href="https://git"><a class=hub.com/pyxem/kikuchipy/commit/9062e3badb9ee29eea6ea782f05f247caea38feb">9062e3bad<a href="https://github.com/pyxem/kikuchipy/commit/9062e3badb9ee29eea6ea782f05f247caea38feb">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/pyxem/kikuchipy/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/pyxem/kikuchipy/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/pyxem/kikuchipy/commit/9062e3badb9ee29eea6ea782f05f247caea38feb&quot;&gt;9062e3bad&lt;/a&gt;&lt;a href=&quot;https://github.com/pyxem/kikuchipy/commit/9062e3badb9ee29eea6ea782f05f247caea38feb&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/pyxem/kikuchipy/commit/9062e3badb9ee29eea6ea782f05f247c&lt;/a&gt;aea38feb">&quot;&gt;Merge &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/pyxem/kikuchipy/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/pyxem/kikuchipy/commit/<a class="double-link" href="https://github.com/pyxem/kikuchipy/commit/bf0b8972af043625b13c1ce2f7001d25d0e1bde0">bf0b8972a</a><a href="https://github.com/pyxem/kikuchipy/commit/9062e3badb9ee29eea6ea782f05f247caea38feb">&amp;quot;&amp;gt;bf0b8972a&amp;lt;/a&amp;gt;&amp;quot;&amp;gt;bf0b8972a&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/pyxem/kikuchipy/commit/9062e3badb9ee29eea6ea782f05f247caea38&lt;/a&gt;feb&quot;&gt; into &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/pyxem/kikuchipy/commit/<a class="double-link" href="https://github.com/pyxem/kikuchipy/commit/d1c799a21">d1c799a21">d1c799a21</a>

Pull Request Pull Request #239: Detector Pattern Simulation

Run Details

214 of 214 new or added lines in 3 files covered. (100.0%)

6881 of 6882 relevant lines covered (99.99%)

5.0 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.25

/kikuchipy/signals/ebsd_master_pattern.py

# -*- coding: utf-8 -*-
# Copyright 2019-2020 The kikuchipy developers
#
# This file is part of kikuchipy.
#
# kikuchipy is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# kikuchipy is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with kikuchipy. If not, see <http://www.gnu.org/licenses/>.


from typing import Optional, Union

import dask.array as da
from hyperspy._lazy_signals import LazySignal2D
from hyperspy._signals.signal2d import Signal2D
import numpy as np
from orix.crystal_map import Phase
from orix.vector import Vector3d
from orix.quaternion import Rotation

from kikuchipy.detectors.ebsd_detector import EBSDDetector
from kikuchipy.pattern import rescale_intensity
from kikuchipy.projections.lambert_projection import LambertProjection
from kikuchipy.signals import LazyEBSD, EBSD
from kikuchipy.signals._common_image import CommonImage


class EBSDMasterPattern(CommonImage, Signal2D):
    """Simulated Electron Backscatter Diffraction (EBSD) master pattern.

    This class extends HyperSpy's Signal2D class for EBSD master
    patterns. Methods inherited from HyperSpy can be found in the
    HyperSpy user guide. See the docstring of
    :class:`hyperspy.signal.BaseSignal` for a list of additional
    attributes.

    Attributes
    ----------
    projection : str
        Which projection the pattern is in: "spherical" or "lambert".
    hemisphere : str
        Which hemisphere the data contains: "north", "south" or "both".
    phase : orix.crystal_map.phase_list.Phase
        Phase describing the crystal structure used in the master
        pattern simulation.
    """

    _signal_type = "EBSDMasterPattern"
    _alias_signal_types = ["ebsd_master_pattern", "master_pattern"]
    _lazy = False

    phase = Phase()
    projection = None
    hemisphere = None

    def __init__(self, *args, **kwargs):
        """Create an :class:`~kikuchipy.signals.EBSDMasterPattern`
        object from a :class:`hyperspy.signals.Signal2D` or a
        :class:`numpy.ndarray`.
        """
        Signal2D.__init__(self, *args, **kwargs)
        self.phase = kwargs.pop("phase", Phase())
        self.projection = kwargs.pop("projection", None)
        self.hemisphere = kwargs.pop("hemisphere", None)

    def get_patterns(
        self,
        rotations: Rotation,
        detector: EBSDDetector,
        energy: int,
        n_chunk: Optional[int] = None,
        dtype_out: type = np.float32,
        compute: bool = False,
    ) -> Union[EBSD, LazyEBSD]:
        """Creates a dictionary of EBSD patterns for a sample in the EDAX TSL
        (RD, TD, ND) reference frame, given a set of local crystal lattice
        rotations and a detector model from a master pattern in the Lambert
        projection.

        Parameters
        ----------
        rotations : Rotation
            Set of unit cell rotations to get patterns from.
        detector : EBSDDetector
            EBSDDetector object describing the detector geometry with a single,
            fixed projection/pattern center.
        energy : int
            The wanted energy in the master pattern.
        n_chunk : int, optional
            The number of chunks the data should be split up into. By default,
            this is set so each chunk is around 100 MB.
        dtype_out : type, optional
            Data type of the returned patterns, by default np.float32.
        compute : bool, optional
            Whether or not the dask.compute() function should be called and
            read the patterns into memory, by default false.
            For more information see: :func:`dask.array.Array.compute`.

        Returns
        -------
        EBSD or LazyEBSD
            All the simulated EBSD patterns with the shape (number of rotations,
            detector pixels in x direction, detector pixels in y direction).

        Notes
        -----
        If the master pattern phase has a non-centrosymmetric point group, both
        the northern and southern hemispheres must be provided.
        For more details regarding the reference frame visit the reference frame
        user guide at: https://kikuchipy.org/en/latest/reference_frames.html.
        """

        if self.projection != "lambert":
            raise NotImplementedError(
                "Method only supports master patterns in Lambert projection!"
            )
        pc = detector.pc_emsoft()
        if len(pc) > 1:
            raise ValueError(
                "Method only supports a single projection/pattern center!"
            )

        # 4 cases
        # Has energies, has hemis - Case 1
        if len(self.axes_manager.shape) == 4:
            energies = self.axes_manager["energy"].axis
            energy_index = (np.abs(energies - energy)).argmin()
            mpn = self.data[0, energy_index]
            mps = self.data[1, energy_index]
        # no energies, no hemis - Case 2
        elif len(self.axes_manager.shape) == 2:
            if not self.phase.point_group.contains_inversion:
                raise AttributeError(
                    "For phases without inversion symmetry, "
                    "both hemispheres must be in master pattern!"
                )
            mpn = self.data
            mps = mpn
        else:
            try:  # has energies, no hemi - Case 3
                energies = self.axes_manager["energy"].axis
                if not self.phase.point_group.contains_inversion:
                    raise AttributeError(
                        "For phases without inversion symmetry, both"
                        "hemispheres must be in master pattern!"
                    )
                energy_index = (np.abs(energies - energy)).argmin()
                mpn = self.data[energy_index]
                mps = mpn
            except ValueError:  # no energies, yes hemi - Case 4
                mpn = self.data[0]
                mps = self.data[1]

        npx, npy = self.axes_manager.signal_shape
        dc = _get_direction_cosines(detector)
        n = rotations.size
        det_y, det_x = detector.shape
        dtype_out = dtype_out

        if not n_chunk:
            n_chunk = _min_number_of_chunks(detector.shape, n, dtype_out)

        out_shape = (n, det_y, det_x)
        chunks = (int(abs(np.ceil(n / n_chunk))), det_y, det_x)

        rescale = False
        if dtype_out != np.float32:
            rescale = True

        r_da = da.from_array(rotations.data, chunks=(chunks[0], -1))

        simulated = r_da.map_blocks(
            _get_patterns_chunk,
            dc=dc,
            master_north=mpn,
            master_south=mps,
            npx=npx,
            npy=npy,
            rescale=rescale,
            dtype_out=dtype_out,
            drop_axis=1,
            new_axis=(1, 2),
            chunks=chunks,
            dtype=dtype_out,
        )

        names = ["x", "dy", "dx"]
        scales = np.ones(3)

        # Create axis objects for each axis
        axes = [
            {
                "size": out_shape[i],
                "index_in_array": i,
                "name": names[i],
                "scale": scales[i],
                "offset": 0.0,
                "units": "px",
            }
            for i in range(simulated.ndim)
        ]
        if compute:
            return EBSD(simulated.compute(), axes=axes)
        return LazyEBSD(simulated, axes=axes)


class LazyEBSDMasterPattern(EBSDMasterPattern, LazySignal2D):
    """Lazy implementation of the :class:`EBSDMasterPattern` class.

    This class extends HyperSpy's LazySignal2D class for EBSD master
    patterns. Methods inherited from HyperSpy can be found in the
    HyperSpy user guide. See docstring of :class:`EBSDMasterPattern`
    for attributes and methods.
    """

    _lazy = True

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


def _get_direction_cosines(detector: EBSDDetector) -> Vector3d:
    """Get the direction cosines between the detector and sample as done in
    EMsoft and [Callahan2013]_.

    Parameters
    ----------
    detector : EBSDDetector
        EBSDDetector object with a certain detector geometry and one
        projection center.

    Returns
    -------
    Vector3d
        Direction cosines for each detector pixel.
    """

    pc = detector.pc_emsoft()
    xpc = pc[..., 0]
    ypc = pc[..., 1]
    L = pc[..., 2]

    # Detector coordinates in microns
    det_x = (
        -((-xpc - (1.0 - detector.ncols) * 0.5) - np.arange(0, detector.ncols))
        * detector.px_size
    )
    det_y = (
        (ypc - (1.0 - detector.nrows) * 0.5) - np.arange(0, detector.nrows)
    ) * detector.px_size

    # Auxilliary angle to rotate between reference frames
    theta_c = np.radians(detector.tilt)
    sigma = np.radians(detector.sample_tilt)

    alpha = (np.pi / 2) - sigma + theta_c
    ca = np.cos(alpha)
    sa = np.sin(alpha)

    # TODO: Enable detector azimuthal angle
    omega = np.radians(0)  # angle between normal of sample and detector
    cw = np.cos(omega)
    sw = np.sin(omega)

    r_g_array = np.zeros((detector.nrows, detector.ncols, 3))

    Ls = -sw * det_x + L * cw
    Lc = cw * det_x + L * sw

    i, j = np.meshgrid(
        np.arange(detector.nrows - 1, -1, -1),
        np.arange(detector.ncols),
        indexing="ij",
    )

    r_g_array[..., 0] = det_y[i] * ca + sa * Ls[j]
    r_g_array[..., 1] = Lc[j]
    r_g_array[..., 2] = -sa * det_y[i] + ca * Ls[j]
    r_g = Vector3d(r_g_array)

    return r_g.unit


def _get_lambert_interpolation_parameters(
    rotated_direction_cosines: Vector3d,
    scale: Union[int, float],
    npx: int,
    npy: int,
) -> tuple:
    """Get Lambert interpolation parameters as described in EMsoft.

    Parameters
    ----------
    rotated_direction_cosines : Vector3d
        Rotated direction cosines vector.
    scale : int
        Factor to scale up from Rosca-Lambert projection to the master pattern.
    npx : int
        Number of pixels on the master pattern in the x direction.
    npy : int
        Number of pixels on the master pattern in the y direction.

    Returns
    -------
    nii : numpy.ndarray
        Row coordinate of a point.
    nij : numpy.ndarray
        Column coordinate of a point.
    niip : numpy.ndarray
        Row coordinate of neighboring point.
    nijp : numpy.ndarray
        Column coordinate of a neighboring point.
    di : numpy.ndarray
        Row interpolation weight factor.
    dj : numpy.ndarray
        Column interpolation weight factor.
    dim : numpy.ndarray
        Row interpolation weight factor.
    djm : numpy.ndarray
        Column interpolation weight factor.
    """
    # Direction cosines to Rosca-Lambert projection
    xy = (
        scale
        * LambertProjection.project(rotated_direction_cosines)
        / (np.sqrt(np.pi / 2))
    )

    i = xy[..., 0]
    j = xy[..., 1]
    nii = (i + scale).astype(int)
    nij = (j + scale).astype(int)
    niip = nii + 1
    nijp = nij + 1
    niip = np.where(niip < npx, niip, nii).astype(int)
    nijp = np.where(nijp < npy, nijp, nij).astype(int)
    nii = np.where(nii < 0, niip, nii).astype(int)
    nij = np.where(nij < 0, nijp, nij).astype(int)
    di = i - nii + scale
    dj = j - nij + scale
    dim = 1.0 - di
    djm = 1.0 - dj

    return nii, nij, niip, nijp, di, dj, dim, djm


def _get_patterns_chunk(
    r: Rotation,
    dc: Vector3d,
    master_north: np.ndarray,
    master_south: np.ndarray,
    npx: int,
    npy: int,
    rescale: bool,
    dtype_out: Optional[type] = np.float32,
) -> np.ndarray:
    """Get the EBSD patterns on the detector for each rotation in the chunk.
    Each pattern is found by a bi-quadratic interpolation of the master pattern
    as described in EMsoft.

    Parameters
    ----------
    r : Rotation
        Rotation object with all the rotations for a given chunk.
    dc : Vector3d
        Direction cosines unit vector between detector and sample.
    master_north : numpy.ndarray
        Northern hemisphere of the master pattern.
    master_south : numpy.ndarray
        Southern hemisphere of the master pattern.
    npx : int
        Number of pixels in the x-direction on the master pattern.
    npy: int
        Number of pixels in the y-direction on the master pattern.
    rescale : bool
        Whether to call rescale_intensities() or not.
    dtype_out : type, optional
        Data type of the returned patterns, by default np.float32.

    Returns
    -------
    numpy.ndarray
        (n, y, x) array containing all the simulated patterns.
    """
    m = r.shape[0]
    simulated = np.empty(shape=(m,) + dc.shape, dtype=dtype_out)
    scale_factor = (npx - 1) / 2
    for i in range(m):
        rot_dc = Rotation(r[i]) * dc
        (
            nii,
            nij,
            niip,
            nijp,
            di,
            dj,
            dim,
            djm,
        ) = _get_lambert_interpolation_parameters(
            rotated_direction_cosines=rot_dc,
            scale=scale_factor,
            npx=npx,
            npy=npy,
        )
        pattern = np.where(
            rot_dc.z >= 0,
            (
                master_north[nii, nij] * dim * djm
                + master_north[niip, nij] * di * djm
                + master_north[nii, nijp] * dim * dj
                + master_north[niip, nijp] * di * dj
            ),
            (
                master_south[nii, nij] * dim * djm
                + master_south[niip, nij] * di * djm
                + master_south[nii, nijp] * dim * dj
                + master_south[niip, nijp] * di * dj
            ),
        )
        if rescale:
            pattern = rescale_intensity(pattern, dtype_out=dtype_out)
        simulated[i] = pattern
    return simulated


def _min_number_of_chunks(
    detector_shape: tuple, n_rotations: int, dtype_out: type
) -> int:
    """Returns the minimum number of chunks required for our detector model and
    set of unit cell rotations so that each chunk is around 100 MB.

    Parameters
    ----------
    detector_shape : tuple
        Shape of the detector in pixels.
    n_rotations : int
        Number of rotations.
    dtype_out : type
        Data type used for the simulated patterns.

    Returns
    -------
    int
       The minimum number of chunks required so each chunk is around 100 MB.
    """
    dy, dx = detector_shape
    nbytes = dy * dx * n_rotations * np.dtype(dtype_out).itemsize
    nbytes_goal = 100e6  # 100 MB
    n_chunks = int(np.ceil(nbytes / nbytes_goal))
    return n_chunks

1	# -- coding: utf-8 --
2	# Copyright 2019-2020 The kikuchipy developers
3	#
4	# This file is part of kikuchipy.
5	#
6	# kikuchipy is free software: you can redistribute it and/or modify
7	# it under the terms of the GNU General Public License as published by
8	# the Free Software Foundation, either version 3 of the License, or
9	# (at your option) any later version.
10	#
11	# kikuchipy is distributed in the hope that it will be useful,
12	# but WITHOUT ANY WARRANTY; without even the implied warranty of
13	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	# GNU General Public License for more details.
15	#
16	# You should have received a copy of the GNU General Public License
17	# along with kikuchipy. If not, see <http://www.gnu.org/licenses/>.
18
19
20	from typing import Optional, Union	5✔
21
22	import dask.array as da	5✔
23	from hyperspy._lazy_signals import LazySignal2D	5✔
24	from hyperspy._signals.signal2d import Signal2D	5✔
25	import numpy as np	5✔
26	from orix.crystal_map import Phase	5✔
27	from orix.vector import Vector3d	5✔
28	from orix.quaternion import Rotation	5✔
29
30	from kikuchipy.detectors.ebsd_detector import EBSDDetector	5✔
31	from kikuchipy.pattern import rescale_intensity	5✔
32	from kikuchipy.projections.lambert_projection import LambertProjection	5✔
33	from kikuchipy.signals import LazyEBSD, EBSD	5✔
34	from kikuchipy.signals._common_image import CommonImage	5✔
35
36
37	class EBSDMasterPattern(CommonImage, Signal2D):	5✔
38	"""Simulated Electron Backscatter Diffraction (EBSD) master pattern.
39
40	This class extends HyperSpy's Signal2D class for EBSD master
41	patterns. Methods inherited from HyperSpy can be found in the
42	HyperSpy user guide. See the docstring of
43	:class:`hyperspy.signal.BaseSignal` for a list of additional
44	attributes.
45
46	Attributes
47	----------
48	projection : str
49	Which projection the pattern is in: "spherical" or "lambert".
50	hemisphere : str
51	Which hemisphere the data contains: "north", "south" or "both".
52	phase : orix.crystal_map.phase_list.Phase
53	Phase describing the crystal structure used in the master
54	pattern simulation.
55	"""
56
57	_signal_type = "EBSDMasterPattern"	5✔
58	_alias_signal_types = ["ebsd_master_pattern", "master_pattern"]	5✔
59	_lazy = False	5✔
60
61	phase = Phase()	5✔
62	projection = None	5✔
63	hemisphere = None	5✔
64
65	def __init__(self, args, *kwargs):	5✔
66	"""Create an :class:`~kikuchipy.signals.EBSDMasterPattern`
67	object from a :class:`hyperspy.signals.Signal2D` or a
68	:class:`numpy.ndarray`.
69	"""
70	Signal2D.__init__(self, args, *kwargs)	5✔
71	self.phase = kwargs.pop("phase", Phase())	5✔
72	self.projection = kwargs.pop("projection", None)	5✔
73	self.hemisphere = kwargs.pop("hemisphere", None)	5✔
74
75	def get_patterns(	5✔
76	self,
77	rotations: Rotation,
78	detector: EBSDDetector,
79	energy: int,
80	n_chunk: Optional[int] = None,
81	dtype_out: type = np.float32,
82	compute: bool = False,
83	) -> Union[EBSD, LazyEBSD]:
84	"""Creates a dictionary of EBSD patterns for a sample in the EDAX TSL
85	(RD, TD, ND) reference frame, given a set of local crystal lattice
86	rotations and a detector model from a master pattern in the Lambert
87	projection.
88
89	Parameters
90	----------
91	rotations : Rotation
92	Set of unit cell rotations to get patterns from.
93	detector : EBSDDetector
94	EBSDDetector object describing the detector geometry with a single,
95	fixed projection/pattern center.
96	energy : int
97	The wanted energy in the master pattern.
98	n_chunk : int, optional
99	The number of chunks the data should be split up into. By default,
100	this is set so each chunk is around 100 MB.
101	dtype_out : type, optional
102	Data type of the returned patterns, by default np.float32.
103	compute : bool, optional
104	Whether or not the dask.compute() function should be called and
105	read the patterns into memory, by default false.
106	For more information see: :func:`dask.array.Array.compute`.
107
108	Returns
109	-------
110	EBSD or LazyEBSD
111	All the simulated EBSD patterns with the shape (number of rotations,
112	detector pixels in x direction, detector pixels in y direction).
113
114	Notes
115	-----
116	If the master pattern phase has a non-centrosymmetric point group, both
117	the northern and southern hemispheres must be provided.
118	For more details regarding the reference frame visit the reference frame
119	user guide at: https://kikuchipy.org/en/latest/reference_frames.html.
120	"""
121
122	if self.projection != "lambert":	5✔
123	raise NotImplementedError(	5✔
124	"Method only supports master patterns in Lambert projection!"
125	)
126	pc = detector.pc_emsoft()	5✔
127	if len(pc) > 1:	5✔
128	raise ValueError(	5✔
129	"Method only supports a single projection/pattern center!"
130	)
131
132	# 4 cases
133	# Has energies, has hemis - Case 1
134	if len(self.axes_manager.shape) == 4:	5✔
135	energies = self.axes_manager["energy"].axis	5✔
136	energy_index = (np.abs(energies - energy)).argmin()	5✔
137	mpn = self.data[0, energy_index]	5✔
138	mps = self.data[1, energy_index]	5✔
139	# no energies, no hemis - Case 2
140	elif len(self.axes_manager.shape) == 2:	5✔
141	if not self.phase.point_group.contains_inversion:	5✔
142	raise AttributeError(	5✔
143	"For phases without inversion symmetry, "
144	"both hemispheres must be in master pattern!"
145	)
146	mpn = self.data	5✔
147	mps = mpn	5✔
148	else:
149	try: # has energies, no hemi - Case 3	5✔
150	energies = self.axes_manager["energy"].axis	5✔
151	if not self.phase.point_group.contains_inversion:	5✔
152	raise AttributeError(	5✔
153	"For phases without inversion symmetry, both"
154	"hemispheres must be in master pattern!"
155	)
156	energy_index = (np.abs(energies - energy)).argmin()	5✔
157	mpn = self.data[energy_index]	5✔
158	mps = mpn	5✔
159	except ValueError: # no energies, yes hemi - Case 4	5✔
160	mpn = self.data[0]	5✔
161	mps = self.data[1]	5✔
162
163	npx, npy = self.axes_manager.signal_shape	5✔
164	dc = _get_direction_cosines(detector)	5✔
165	n = rotations.size	5✔
166	det_y, det_x = detector.shape	5✔
167	dtype_out = dtype_out	5✔
168
169	if not n_chunk:	5✔
170	n_chunk = _min_number_of_chunks(detector.shape, n, dtype_out)	×
171
172	out_shape = (n, det_y, det_x)	5✔
173	chunks = (int(abs(np.ceil(n / n_chunk))), det_y, det_x)	5✔
174
175	rescale = False	5✔
176	if dtype_out != np.float32:	5✔
177	rescale = True	5✔
178
179	r_da = da.from_array(rotations.data, chunks=(chunks[0], -1))	5✔
180
181	simulated = r_da.map_blocks(	5✔
182	_get_patterns_chunk,
183	dc=dc,
184	master_north=mpn,
185	master_south=mps,
186	npx=npx,
187	npy=npy,
188	rescale=rescale,
189	dtype_out=dtype_out,
190	drop_axis=1,
191	new_axis=(1, 2),
192	chunks=chunks,
193	dtype=dtype_out,
194	)
195
196	names = ["x", "dy", "dx"]	5✔
197	scales = np.ones(3)	5✔
198
199	# Create axis objects for each axis
200	axes = [	5✔
201	{
202	"size": out_shape[i],
203	"index_in_array": i,
204	"name": names[i],
205	"scale": scales[i],
206	"offset": 0.0,
207	"units": "px",
208	}
209	for i in range(simulated.ndim)
210	]
211	if compute:	5✔
212	return EBSD(simulated.compute(), axes=axes)	5✔
213	return LazyEBSD(simulated, axes=axes)	5✔
214
215
216	class LazyEBSDMasterPattern(EBSDMasterPattern, LazySignal2D):	5✔
217	"""Lazy implementation of the :class:`EBSDMasterPattern` class.
218
219	This class extends HyperSpy's LazySignal2D class for EBSD master
220	patterns. Methods inherited from HyperSpy can be found in the
221	HyperSpy user guide. See docstring of :class:`EBSDMasterPattern`
222	for attributes and methods.
223	"""
224
225	_lazy = True	5✔
226
227	def __init__(self, args, *kwargs):	5✔
228	super().__init__(args, *kwargs)	5✔
229
230
231	def _get_direction_cosines(detector: EBSDDetector) -> Vector3d:	5✔
232	"""Get the direction cosines between the detector and sample as done in
233	EMsoft and [Callahan2013]_.
234
235	Parameters
236	----------
237	detector : EBSDDetector
238	EBSDDetector object with a certain detector geometry and one
239	projection center.
240
241	Returns
242	-------
243	Vector3d
244	Direction cosines for each detector pixel.
245	"""
246
247	pc = detector.pc_emsoft()	5✔
248	xpc = pc[..., 0]	5✔
249	ypc = pc[..., 1]	5✔
250	L = pc[..., 2]	5✔
251
252	# Detector coordinates in microns
253	det_x = (	5✔
254	-((-xpc - (1.0 - detector.ncols) * 0.5) - np.arange(0, detector.ncols))
255	* detector.px_size
256	)
257	det_y = (	5✔
258	(ypc - (1.0 - detector.nrows) * 0.5) - np.arange(0, detector.nrows)
259	) * detector.px_size
260
261	# Auxilliary angle to rotate between reference frames
262	theta_c = np.radians(detector.tilt)	5✔
263	sigma = np.radians(detector.sample_tilt)	5✔
264
265	alpha = (np.pi / 2) - sigma + theta_c	5✔
266	ca = np.cos(alpha)	5✔
267	sa = np.sin(alpha)	5✔
268
269	# TODO: Enable detector azimuthal angle
270	omega = np.radians(0) # angle between normal of sample and detector	5✔
271	cw = np.cos(omega)	5✔
272	sw = np.sin(omega)	5✔
273
274	r_g_array = np.zeros((detector.nrows, detector.ncols, 3))	5✔
275
276	Ls = -sw * det_x + L * cw	5✔
277	Lc = cw * det_x + L * sw	5✔
278
279	i, j = np.meshgrid(	5✔
280	np.arange(detector.nrows - 1, -1, -1),
281	np.arange(detector.ncols),
282	indexing="ij",
283	)
284
285	r_g_array[..., 0] = det_y[i] * ca + sa * Ls[j]	5✔
286	r_g_array[..., 1] = Lc[j]	5✔
287	r_g_array[..., 2] = -sa * det_y[i] + ca * Ls[j]	5✔
288	r_g = Vector3d(r_g_array)	5✔
289
290	return r_g.unit	5✔
291
292
293	def _get_lambert_interpolation_parameters(	5✔
294	rotated_direction_cosines: Vector3d,
295	scale: Union[int, float],
296	npx: int,
297	npy: int,
298	) -> tuple:
299	"""Get Lambert interpolation parameters as described in EMsoft.
300
301	Parameters
302	----------
303	rotated_direction_cosines : Vector3d
304	Rotated direction cosines vector.
305	scale : int
306	Factor to scale up from Rosca-Lambert projection to the master pattern.
307	npx : int
308	Number of pixels on the master pattern in the x direction.
309	npy : int
310	Number of pixels on the master pattern in the y direction.
311
312	Returns
313	-------
314	nii : numpy.ndarray
315	Row coordinate of a point.
316	nij : numpy.ndarray
317	Column coordinate of a point.
318	niip : numpy.ndarray
319	Row coordinate of neighboring point.
320	nijp : numpy.ndarray
321	Column coordinate of a neighboring point.
322	di : numpy.ndarray
323	Row interpolation weight factor.
324	dj : numpy.ndarray
325	Column interpolation weight factor.
326	dim : numpy.ndarray
327	Row interpolation weight factor.
328	djm : numpy.ndarray
329	Column interpolation weight factor.
330	"""
331	# Direction cosines to Rosca-Lambert projection
332	xy = (	5✔
333	scale
334	* LambertProjection.project(rotated_direction_cosines)
335	/ (np.sqrt(np.pi / 2))
336	)
337
338	i = xy[..., 0]	5✔
339	j = xy[..., 1]	5✔
340	nii = (i + scale).astype(int)	5✔
341	nij = (j + scale).astype(int)	5✔
342	niip = nii + 1	5✔
343	nijp = nij + 1	5✔
344	niip = np.where(niip < npx, niip, nii).astype(int)	5✔
345	nijp = np.where(nijp < npy, nijp, nij).astype(int)	5✔
346	nii = np.where(nii < 0, niip, nii).astype(int)	5✔
347	nij = np.where(nij < 0, nijp, nij).astype(int)	5✔
348	di = i - nii + scale	5✔
349	dj = j - nij + scale	5✔
350	dim = 1.0 - di	5✔
351	djm = 1.0 - dj	5✔
352
353	return nii, nij, niip, nijp, di, dj, dim, djm	5✔
354
355
356	def _get_patterns_chunk(	5✔
357	r: Rotation,
358	dc: Vector3d,
359	master_north: np.ndarray,
360	master_south: np.ndarray,
361	npx: int,
362	npy: int,
363	rescale: bool,
364	dtype_out: Optional[type] = np.float32,
365	) -> np.ndarray:
366	"""Get the EBSD patterns on the detector for each rotation in the chunk.
367	Each pattern is found by a bi-quadratic interpolation of the master pattern
368	as described in EMsoft.
369
370	Parameters
371	----------
372	r : Rotation
373	Rotation object with all the rotations for a given chunk.
374	dc : Vector3d
375	Direction cosines unit vector between detector and sample.
376	master_north : numpy.ndarray
377	Northern hemisphere of the master pattern.
378	master_south : numpy.ndarray
379	Southern hemisphere of the master pattern.
380	npx : int
381	Number of pixels in the x-direction on the master pattern.
382	npy: int
383	Number of pixels in the y-direction on the master pattern.
384	rescale : bool
385	Whether to call rescale_intensities() or not.
386	dtype_out : type, optional
387	Data type of the returned patterns, by default np.float32.
388
389	Returns
390	-------
391	numpy.ndarray
392	(n, y, x) array containing all the simulated patterns.
393	"""
394	m = r.shape[0]	5✔
395	simulated = np.empty(shape=(m,) + dc.shape, dtype=dtype_out)	5✔
396	scale_factor = (npx - 1) / 2	5✔
397	for i in range(m):	5✔
398	rot_dc = Rotation(r[i]) * dc	5✔
399	(	5✔
400	nii,
401	nij,
402	niip,
403	nijp,
404	di,
405	dj,
406	dim,
407	djm,
408	) = _get_lambert_interpolation_parameters(
409	rotated_direction_cosines=rot_dc,
410	scale=scale_factor,
411	npx=npx,
412	npy=npy,
413	)
414	pattern = np.where(	5✔
415	rot_dc.z >= 0,
416	(
417	master_north[nii, nij] * dim * djm
418	+ master_north[niip, nij] * di * djm
419	+ master_north[nii, nijp] * dim * dj
420	+ master_north[niip, nijp] * di * dj
421	),
422	(
423	master_south[nii, nij] * dim * djm
424	+ master_south[niip, nij] * di * djm
425	+ master_south[nii, nijp] * dim * dj
426	+ master_south[niip, nijp] * di * dj
427	),
428	)
429	if rescale:	5✔
430	pattern = rescale_intensity(pattern, dtype_out=dtype_out)	5✔
431	simulated[i] = pattern	5✔
432	return simulated	5✔
433
434
435	def _min_number_of_chunks(	5✔
436	detector_shape: tuple, n_rotations: int, dtype_out: type
437	) -> int:
438	"""Returns the minimum number of chunks required for our detector model and
439	set of unit cell rotations so that each chunk is around 100 MB.
440
441	Parameters
442	----------
443	detector_shape : tuple
444	Shape of the detector in pixels.
445	n_rotations : int
446	Number of rotations.
447	dtype_out : type
448	Data type used for the simulated patterns.
449
450	Returns
451	-------
452	int
453	The minimum number of chunks required so each chunk is around 100 MB.
454	"""
455	dy, dx = detector_shape	5✔
456	nbytes = dy * dx * n_rotations * np.dtype(dtype_out).itemsize	5✔
457	nbytes_goal = 100e6 # 100 MB	5✔
458	n_chunks = int(np.ceil(nbytes / nbytes_goal))	5✔
459	return n_chunks	5✔

pyxem / kikuchipy / 534

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous