pyxem / kikuchipy / 480

pending completion

Build # 480

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/0eedfe270ad13c24519720e953c7060d2b72fd30">0eedfe270<a href="https://github.com/pyxem/kikuchipy/commit/0eedfe270ad13c24519720e953c7060d2b72fd30">">Merge </a><a class="double-link" href="https://github.com/pyxem/kikuchipy/commit/<a class="double-link" href="https://github.com/pyxem/kikuchipy/commit/1f34fbd31ead9e2a726ad44ccac16c71ef4d8327">1f34fbd31</a>">1f34fbd31</a><a href="https://github.com/pyxem/kikuchipy/commit/0eedfe270ad13c24519720e953c7060d2b72fd30"> into fc05696a5">fc05696a5</a>

Pull Request Pull Request #239: Detector Pattern Simulation

Run Details

257 of 257 new or added lines in 4 files covered. (100.0%)

6121 of 6361 relevant lines covered (96.23%)

4.81 hits per line

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

0.0

/kikuchipy/signals/ebsd_detector_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 Union

import numpy as np
from orix.quaternion import rotation as rot
from orix.vector import Vector3d
from orix import sampling
import matplotlib.pyplot as plt


from kikuchipy.detectors.ebsd_detector import EBSDDetector
from kikuchipy.projections.lambert_projection import LambertProjection
from kikuchipy import load

master_pattern = load(
    r"C:\Users\laler\Desktop\Project - Kikuchipy\Ni-MP.h5",
    projection="lambert",
    hemisphere="both",
)

euler_angles = r"C:\Users\laler\EMsoftData\testfile.txt"

xpc = 0
ypc = 0
L = 15000
theta_c = 10
sigma = 70
delta = 50

detector = EBSDDetector(
    shape=(480, 640),  # row, columns - y, x
    px_size=delta,
    pc=(xpc, ypc, L),
    # convention="emsoft",
    tilt=theta_c,
    sample_tilt=sigma,
)

r = sampling.sample_generators.get_sample_fundamental(
    resolution=58, space_group=225
)


class EBSDDetectorPattern:
    @classmethod
    def get_patterns(cls, master_pattern, rotations, detector: EBSDDetector):

        number_of_rotations = rotations.shape[0]

        pattern_catalogue = np.zeros(
            (detector.nrows, detector.ncols, number_of_rotations)
        )

        num_rotations = np.arange(0, number_of_rotations)
        direction_cosines = _get_direction_cosines(
            detector, number_of_rotations
        )

        master_north = master_pattern.data[0]
        master_south = master_pattern.data[1]

        # npx assuming (row, col) these should be equal
        npx = master_pattern.data.shape[3]
        # npy
        npy = master_pattern.data.shape[2]

        # Sum the energy axis
        master_north = np.sum(master_north, 0)
        master_south = np.sum(master_south, 0)

        scale_factor = (npx - 1) / 2

        ii, jj = np.meshgrid(
            np.arange(0, detector.nrows),
            np.arange(0, detector.ncols),
            indexing="ij",
        )

        # Current direction cosines output (column, row, rotation, xyz)
        rotated_dc = rotations * direction_cosines[jj, ii]

        (
            nix,
            niy,
            nixp,
            niyp,
            dx,
            dy,
            dxm,
            dym,
        ) = _get_lambert_interpolation_parameters(
            rotated_dc, scale_factor, npx, npy
        )

        pattern_catalogue[..., num_rotations] = np.where(
            rotated_dc.z >= 0,
            (
                +master_north[niy, nix] * dxm * dym
                + master_north[niyp, nix] * dx * dym
                + master_north[niy, nixp] * dxm * dy
                + master_north[niyp, nixp] * dx * dy
            ),
            (
                +master_south[niy, nix] * dxm * dym
                + master_south[niyp, nix] * dx * dym
                + master_south[niy, nixp] * dxm * dy
                + master_south[niyp, nixp] * dx * dy
            ),
        )
        pattern_catalogue = np.rot90(pattern_catalogue, 2)
        return pattern_catalogue


def _get_direction_cosines(detector: EBSDDetector, num_rot):
    xpc = detector.pc[..., 0]
    ypc = detector.pc[..., 1]
    L = detector.pc[..., 2]  # This will be wrong in the future
    # Scintillator coordinates in microns
    scin_x = (
        -((-xpc - (1.0 - detector.ncols) * 0.5) - np.arange(0, detector.ncols))
        * detector.px_size
    )
    scin_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)

    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.ncols, detector.nrows, 3))

    ii, jj = np.meshgrid(
        np.arange(0, detector.nrows),
        np.arange(0, detector.ncols),
        indexing="ij",
    )

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

    r_g_array[jj, ii, 0] = scin_y[ii] * ca + sa * Ls[jj]
    r_g_array[jj, ii, 1] = Lc[jj]
    r_g_array[jj, ii, 2] = -sa * scin_y[ii] + ca * Ls[jj]

    r_g_array = np.repeat(r_g_array[:, :, np.newaxis, :], num_rot, axis=2)
    r_g_array = np.flipud(r_g_array)
    r_g = Vector3d(r_g_array)

    return r_g.unit


def _get_lambert_interpolation_parameters(
    rotated_direction_cosines, scale, npx, npy
):
    # Normalized direction cosines to Rosca-Lambert projection
    xy = (
        scale
        * LambertProjection.project(rotated_direction_cosines)
        / (np.sqrt(np.pi / 2))
    )

    x = xy[..., 0]
    y = xy[..., 1]
    nix = x.astype(int) + scale
    niy = y.astype(int) + scale
    nixp = nix + 1
    niyp = niy + 1
    nixp = np.where(nixp < npx - 1, nixp, nix)
    niyp = np.where(niyp < npy - 1, niyp, niy)
    nix = np.where(nix < 0, nixp, nix)
    niy = np.where(niy < 0, niyp, niy)
    dx = x - nix + scale
    dy = y - niy + scale
    dxm = 1.0 - dx
    dym = 1.0 - dy

    return (
        nix.astype(int),
        niy.astype(int),
        nixp.astype(int),
        niyp.astype(int),
        dx,
        dy,
        dxm,
        dym,
    )


patterns = EBSDDetectorPattern.get_patterns(master_pattern, r, detector)

plt.imshow(patterns[..., 0], cmap="gray")
plt.show()

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	from typing import Union	×
20
21	import numpy as np	×
22	from orix.quaternion import rotation as rot	×
23	from orix.vector import Vector3d	×
24	from orix import sampling	×
25	import matplotlib.pyplot as plt	×
26
27
28	from kikuchipy.detectors.ebsd_detector import EBSDDetector	×
29	from kikuchipy.projections.lambert_projection import LambertProjection	×
30	from kikuchipy import load	×
31
32	master_pattern = load(	×
33	r"C:\Users\laler\Desktop\Project - Kikuchipy\Ni-MP.h5",
34	projection="lambert",
35	hemisphere="both",
36	)
37
38	euler_angles = r"C:\Users\laler\EMsoftData\testfile.txt"	×
39
40	xpc = 0	×
41	ypc = 0	×
42	L = 15000	×
43	theta_c = 10	×
44	sigma = 70	×
45	delta = 50	×
46
47	detector = EBSDDetector(	×
48	shape=(480, 640), # row, columns - y, x
49	px_size=delta,
50	pc=(xpc, ypc, L),
51	# convention="emsoft",
52	tilt=theta_c,
53	sample_tilt=sigma,
54	)
55
56	r = sampling.sample_generators.get_sample_fundamental(	×
57	resolution=58, space_group=225
58	)
59
60
61	class EBSDDetectorPattern:	×
62	@classmethod	×
63	def get_patterns(cls, master_pattern, rotations, detector: EBSDDetector):	×
64
65	number_of_rotations = rotations.shape[0]	×
66
67	pattern_catalogue = np.zeros(	×
68	(detector.nrows, detector.ncols, number_of_rotations)
69	)
70
71	num_rotations = np.arange(0, number_of_rotations)	×
72	direction_cosines = _get_direction_cosines(	×
73	detector, number_of_rotations
74	)
75
76	master_north = master_pattern.data[0]	×
77	master_south = master_pattern.data[1]	×
78
79	# npx assuming (row, col) these should be equal
80	npx = master_pattern.data.shape[3]	×
81	# npy
82	npy = master_pattern.data.shape[2]	×
83
84	# Sum the energy axis
85	master_north = np.sum(master_north, 0)	×
86	master_south = np.sum(master_south, 0)	×
87
88	scale_factor = (npx - 1) / 2	×
89
90	ii, jj = np.meshgrid(	×
91	np.arange(0, detector.nrows),
92	np.arange(0, detector.ncols),
93	indexing="ij",
94	)
95
96	# Current direction cosines output (column, row, rotation, xyz)
97	rotated_dc = rotations * direction_cosines[jj, ii]	×
98
99	(	×
100	nix,
101	niy,
102	nixp,
103	niyp,
104	dx,
105	dy,
106	dxm,
107	dym,
108	) = _get_lambert_interpolation_parameters(
109	rotated_dc, scale_factor, npx, npy
110	)
111
112	pattern_catalogue[..., num_rotations] = np.where(	×
113	rotated_dc.z >= 0,
114	(
115	+master_north[niy, nix] * dxm * dym
116	+ master_north[niyp, nix] * dx * dym
117	+ master_north[niy, nixp] * dxm * dy
118	+ master_north[niyp, nixp] * dx * dy
119	),
120	(
121	+master_south[niy, nix] * dxm * dym
122	+ master_south[niyp, nix] * dx * dym
123	+ master_south[niy, nixp] * dxm * dy
124	+ master_south[niyp, nixp] * dx * dy
125	),
126	)
127	pattern_catalogue = np.rot90(pattern_catalogue, 2)	×
128	return pattern_catalogue	×
129
130
131	def _get_direction_cosines(detector: EBSDDetector, num_rot):	×
132	xpc = detector.pc[..., 0]	×
133	ypc = detector.pc[..., 1]	×
134	L = detector.pc[..., 2] # This will be wrong in the future	×
135	# Scintillator coordinates in microns
136	scin_x = (	×
137	-((-xpc - (1.0 - detector.ncols) * 0.5) - np.arange(0, detector.ncols))
138	* detector.px_size
139	)
140	scin_y = (	×
141	(ypc - (1.0 - detector.nrows) * 0.5) - np.arange(0, detector.nrows)
142	) * detector.px_size
143
144	# Auxilliary angle to rotate between reference frames
145	theta_c = np.radians(detector.tilt)	×
146	sigma = np.radians(detector.sample_tilt)	×
147
148	alpha = (np.pi / 2) - sigma + theta_c	×
149	ca = np.cos(alpha)	×
150	sa = np.sin(alpha)	×
151
152	omega = np.radians(0) # angle between normal of sample and detector	×
153	cw = np.cos(omega)	×
154	sw = np.sin(omega)	×
155
156	r_g_array = np.zeros((detector.ncols, detector.nrows, 3))	×
157
158	ii, jj = np.meshgrid(	×
159	np.arange(0, detector.nrows),
160	np.arange(0, detector.ncols),
161	indexing="ij",
162	)
163
164	Ls = -sw * scin_x + L * cw	×
165	Lc = cw * scin_x + L * sw	×
166
167	r_g_array[jj, ii, 0] = scin_y[ii] * ca + sa * Ls[jj]	×
168	r_g_array[jj, ii, 1] = Lc[jj]	×
169	r_g_array[jj, ii, 2] = -sa * scin_y[ii] + ca * Ls[jj]	×
170
171	r_g_array = np.repeat(r_g_array[:, :, np.newaxis, :], num_rot, axis=2)	×
172	r_g_array = np.flipud(r_g_array)	×
173	r_g = Vector3d(r_g_array)	×
174
175	return r_g.unit	×
176
177
178	def _get_lambert_interpolation_parameters(	×
179	rotated_direction_cosines, scale, npx, npy
180	):
181	# Normalized direction cosines to Rosca-Lambert projection
182	xy = (	×
183	scale
184	* LambertProjection.project(rotated_direction_cosines)
185	/ (np.sqrt(np.pi / 2))
186	)
187
188	x = xy[..., 0]	×
189	y = xy[..., 1]	×
190	nix = x.astype(int) + scale	×
191	niy = y.astype(int) + scale	×
192	nixp = nix + 1	×
193	niyp = niy + 1	×
194	nixp = np.where(nixp < npx - 1, nixp, nix)	×
195	niyp = np.where(niyp < npy - 1, niyp, niy)	×
196	nix = np.where(nix < 0, nixp, nix)	×
197	niy = np.where(niy < 0, niyp, niy)	×
198	dx = x - nix + scale	×
199	dy = y - niy + scale	×
200	dxm = 1.0 - dx	×
201	dym = 1.0 - dy	×
202
203	return (	×
204	nix.astype(int),
205	niy.astype(int),
206	nixp.astype(int),
207	niyp.astype(int),
208	dx,
209	dy,
210	dxm,
211	dym,
212	)
213
214
215	patterns = EBSDDetectorPattern.get_patterns(master_pattern, r, detector)	×
216
217	plt.imshow(patterns[..., 0], cmap="gray")	×
218	plt.show()	×

pyxem / kikuchipy / 480

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