pyxem / kikuchipy / 381

pending completion

Build # 381

Build Type

Pull #214

travis-ci-com

Committed by

web-flow

Commit Message

<a href="https://github.com/pyxem/kikuchipy/commit/<a class=hub.com/pyxem/kikuchipy/commit/354f770d04d35692e5f66228d85f3c78c8bab951">354f770d0<a href="https://github.com/pyxem/kikuchipy/commit/354f770d04d35692e5f66228d85f3c78c8bab951">">Merge </a><a class="double-link" href="https://github.com/pyxem/kikuchipy/commit/<a class="double-link" href="https://github.com/pyxem/kikuchipy/commit/3fe869c5079c2e4d8bc3a933f281cc1deafccd68">3fe869c50</a>">3fe869c50</a><a href="https://github.com/pyxem/kikuchipy/commit/354f770d04d35692e5f66228d85f3c78c8bab951"> into b0846ef48">b0846ef48</a>

Pull Request Pull Request #214: Lambert projection

Run Details

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

4535 of 4936 relevant lines covered (91.88%)

4.59 hits per line

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

71.58

/kikuchipy/projections/lambert_projection.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.vector import Vector3d
from kikuchipy.projections.gnomonic_projection import GnomonicProjection


class LambertProjection:
    """Lambert Projection of a vector as implemented in MTEX"""

    @classmethod
    def project(self, v: Union[Vector3d, np.ndarray]) -> np.ndarray:
        """Convert from Cartesian to the Lambert projection"""
        if isinstance(v, Vector3d):
            x = v.x.data
            y = v.y.data
            z = v.z.data
        else:
            x = v[..., 0]
            y = v[..., 1]
            z = v[..., 2]

        # TODO: Should check if Northern or Southern hemisph and act accordingly

        # Checks if multiple arrays/vectors or a single vector/array
        multi = False
        try:
            size = len(x)
            multi = True
        except TypeError:
            size = 1
        X = np.zeros(size)
        Y = np.zeros(size)

        if multi:
            index = 0
            for x_val, y_val, z_val in zip(x, y, z):

                # x^2 + y^2 + z^2 should equal 1 (Needs to lie on the unit sphere)
                # This checker might be too strict. maybe can format the LHS of the equation to 2 decimals or something

                if round(x_val ** 2 + y_val ** 2 + z_val ** 2, 1) != 1:
                    raise ValueError(
                        "Vector is not on the unit sphere! Make sure x^2 + y^2 + z^2 = 1"
                    )
                if abs(y_val) <= abs(
                    x_val
                ):  # Equation 10a - Requirement: |y| <= |x|
                    X[index] = (
                        np.sign(x_val)
                        * np.sqrt(2 * (1 - z_val))
                        * ((np.sqrt(np.pi)) / 2)
                    )
                    Y[index] = (
                        np.sign(x_val)
                        * np.sqrt(2 * (1 - z_val))
                        * ((2 / (np.sqrt(np.pi))) * np.arctan(y_val / x_val))
                    )
                else:  # Equation 10b - Requirement: |x| <= |y|
                    X[index] = (
                        np.sign(y_val)
                        * np.sqrt(2 * (1 - z_val))
                        * ((2 / (np.sqrt(np.pi))) * np.arctan(x_val / y_val))
                    )
                    Y[index] = (
                        np.sign(y_val)
                        * np.sqrt(2 * (1 - z_val))
                        * ((np.sqrt(np.pi)) / 2)
                    )
                index += 1
        else:
            if abs(y) <= abs(x):
                # Equation 10a - Requirement: |y| <= |x|
                X = np.sign(x) * np.sqrt(2 * (1 - z)) * ((np.sqrt(np.pi)) / 2)
                Y = (
                    np.sign(x)
                    * np.sqrt(2 * (1 - z))
                    * ((2 / (np.sqrt(np.pi))) * np.arctan(y / x))
                )
            else:  # Equation 10b - Requirement: |x| <= |y|
                X = (
                    np.sign(y)
                    * np.sqrt(2 * (1 - z))
                    * ((2 / (np.sqrt(np.pi))) * np.arctan(x / y))
                )
                Y = np.sign(y) * np.sqrt(2 * (1 - z)) * ((np.sqrt(np.pi)) / 2)

        return np.column_stack((X, Y))

    @staticmethod
    def iproject(x: np.ndarray, y: np.ndarray) -> Vector3d:
        """Convert from Lambert to Cartesian coordinates."""
        X = x
        Y = y

        # Checks if multiple arrays/vectors or a single vector/array
        multi = False
        try:
            size = len(x)
            multi = True
        except TypeError:
            size = 1
        x = np.zeros(size)
        y = np.zeros(size)
        z = np.zeros(size)

        if multi:
            index = 0
            for x_val, y_val in zip(X, Y):
                if abs(x_val) > np.sqrt(np.pi / 2) or abs(y_val) > np.sqrt(
                    np.pi / 2
                ):
                    raise ValueError(
                        "The X and Y values MUST NOT be greater than L = sqrt(pi/2)"
                    )
                if (
                    x_val == 0 and y_val == 0
                ):  # This is probably covered in the equations below but it is here now :)
                    x[index] = 0
                    y[index] = 0
                    z[index] = 1
                elif abs(y_val) <= abs(x_val):
                    # 0 < |Y| <= |X| <= L - Equation 8a
                    x[index] = _eq_c(x_val) * np.cos(
                        (y_val * np.pi) / (4 * x_val)
                    )
                    y[index] = _eq_c(x_val) * np.sin(
                        (y_val * np.pi) / (4 * x_val)
                    )
                    z[index] = 1 - (2 * (x_val ** 2)) / np.pi
                else:
                    # 0 < |X| <= |Y| <= L - Equation 8b
                    x[index] = _eq_c(y_val) * np.sin(
                        (x_val * np.pi) / (4 * y_val)
                    )
                    y[index] = _eq_c(y_val) * np.cos(
                        (x_val * np.pi) / (4 * y_val)
                    )
                    z[index] = 1 - (2 * (y_val ** 2)) / np.pi
                index += 1
        else:
            if abs(x) > np.sqrt(np.pi / 2) or abs(y) > np.sqrt(np.pi / 2):
                raise ValueError(
                    "The X and Y values MUST NOT be greater than L = sqrt(pi/2)"
                )
            if (
                X == 0 and Y == 0
            ):  # This is probably covered in the equations below but it is here now :)
                x = 0
                y = 0
                z = 1
            elif abs(Y) <= abs(X):
                # 0 < |Y| <= |X| <= L - Equation 8a
                x = _eq_c(X) * np.cos((Y * np.pi) / (4 * X))
                y = _eq_c(X) * np.sin((Y * np.pi) / (4 * X))
                z = 1 - (2 * (X ** 2)) / np.pi
            else:
                # 0 < |X| <= |Y| <= L - Equation 8b
                x = _eq_c(Y) * np.sin((X * np.pi) / (4 * Y))
                y = _eq_c(Y) * np.cos((X * np.pi) / (4 * Y))
                z = 1 - (2 * (Y ** 2)) / np.pi

        return Vector3d(np.column_stack((x, y, z)))

    @staticmethod
    def lambert_to_gnomonic(v: np.ndarray) -> np.ndarray:
        """Convert from Lambert via Cartesian coordinates to Gnomonic."""
        # These two functions could probably be combined into 1 to decrease runtime
        vec = LambertProjection.iproject(v[..., 0], v[..., 1])
        vec = GnomonicProjection.project(vec)
        return vec

    @staticmethod
    def gnomonic_to_lambert(v: np.ndarray) -> np.ndarray:
        """Convert from Gnomonic via Cartesian coordinates to Lambert."""
        # These two functions could probably be combined into 1 to decrease runtime
        vec = GnomonicProjection.iproject(v[..., 0], v[..., 1])
        vec = LambertProjection.project(vec)
        return vec


def _eq_c(p: np.ndarray) -> np.ndarray:
    """Private function used inside LambertProjection.iproject to increase readability."""
    return (2 * p / np.pi) * np.sqrt(np.pi - p ** 2)

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	5✔
20	import numpy as np	5✔
21	from orix.vector import Vector3d	5✔
22	from kikuchipy.projections.gnomonic_projection import GnomonicProjection	5✔
23
24
25	class LambertProjection:	5✔
26	"""Lambert Projection of a vector as implemented in MTEX"""
27
28	@classmethod	5✔
29	def project(self, v: Union[Vector3d, np.ndarray]) -> np.ndarray:	5✔
30	"""Convert from Cartesian to the Lambert projection"""
31	if isinstance(v, Vector3d):	5✔
32	x = v.x.data	5✔
33	y = v.y.data	5✔
34	z = v.z.data	5✔
35	else:
36	x = v[..., 0]	5✔
37	y = v[..., 1]	5✔
38	z = v[..., 2]	5✔
39
40	# TODO: Should check if Northern or Southern hemisph and act accordingly
41
42	# Checks if multiple arrays/vectors or a single vector/array
43	multi = False	5✔
44	try:	5✔
45	size = len(x)	5✔
46	multi = True	5✔
47	except TypeError:	5✔
48	size = 1	5✔
49	X = np.zeros(size)	5✔
50	Y = np.zeros(size)	5✔
51
52	if multi:	5✔
53	index = 0	5✔
54	for x_val, y_val, z_val in zip(x, y, z):	5✔
55
56	# x^2 + y^2 + z^2 should equal 1 (Needs to lie on the unit sphere)
57	# This checker might be too strict. maybe can format the LHS of the equation to 2 decimals or something
58
59	if round(x_val 2 + y_val 2 + z_val ** 2, 1) != 1:	5✔
60	raise ValueError(	×
61	"Vector is not on the unit sphere! Make sure x^2 + y^2 + z^2 = 1"
62	)
63	if abs(y_val) <= abs(	5✔
64	x_val
65	): # Equation 10a - Requirement: \|y\| <= \|x\|
66	X[index] = (	5✔
67	np.sign(x_val)
68	* np.sqrt(2 * (1 - z_val))
69	* ((np.sqrt(np.pi)) / 2)
70	)
71	Y[index] = (	5✔
72	np.sign(x_val)
73	* np.sqrt(2 * (1 - z_val))
74	* ((2 / (np.sqrt(np.pi))) * np.arctan(y_val / x_val))
75	)
76	else: # Equation 10b - Requirement: \|x\| <= \|y\|
77	X[index] = (	5✔
78	np.sign(y_val)
79	* np.sqrt(2 * (1 - z_val))
80	* ((2 / (np.sqrt(np.pi))) * np.arctan(x_val / y_val))
81	)
82	Y[index] = (	5✔
83	np.sign(y_val)
84	* np.sqrt(2 * (1 - z_val))
85	* ((np.sqrt(np.pi)) / 2)
86	)
87	index += 1	5✔
88	else:
89	if abs(y) <= abs(x):	5✔
90	# Equation 10a - Requirement: \|y\| <= \|x\|
91	X = np.sign(x) * np.sqrt(2 * (1 - z)) * ((np.sqrt(np.pi)) / 2)	5✔
92	Y = (	5✔
93	np.sign(x)
94	* np.sqrt(2 * (1 - z))
95	* ((2 / (np.sqrt(np.pi))) * np.arctan(y / x))
96	)
97	else: # Equation 10b - Requirement: \|x\| <= \|y\|
98	X = (	×
99	np.sign(y)
100	* np.sqrt(2 * (1 - z))
101	* ((2 / (np.sqrt(np.pi))) * np.arctan(x / y))
102	)
103	Y = np.sign(y) * np.sqrt(2 * (1 - z)) * ((np.sqrt(np.pi)) / 2)	×
104
105	return np.column_stack((X, Y))	5✔
106
107	@staticmethod	5✔
108	def iproject(x: np.ndarray, y: np.ndarray) -> Vector3d:	5✔
109	"""Convert from Lambert to Cartesian coordinates."""
110	X = x	5✔
111	Y = y	5✔
112
113	# Checks if multiple arrays/vectors or a single vector/array
114	multi = False	5✔
115	try:	5✔
116	size = len(x)	5✔
117	multi = True	×
118	except TypeError:	5✔
119	size = 1	5✔
120	x = np.zeros(size)	5✔
121	y = np.zeros(size)	5✔
122	z = np.zeros(size)	5✔
123
124	if multi:	5✔
125	index = 0	×
126	for x_val, y_val in zip(X, Y):	×
127	if abs(x_val) > np.sqrt(np.pi / 2) or abs(y_val) > np.sqrt(	×
128	np.pi / 2
129	):
130	raise ValueError(	×
131	"The X and Y values MUST NOT be greater than L = sqrt(pi/2)"
132	)
133	if (	×
134	x_val == 0 and y_val == 0
135	): # This is probably covered in the equations below but it is here now :)
136	x[index] = 0	×
137	y[index] = 0	×
138	z[index] = 1	×
139	elif abs(y_val) <= abs(x_val):	×
140	# 0 < \|Y\| <= \|X\| <= L - Equation 8a
141	x[index] = _eq_c(x_val) * np.cos(	×
142	(y_val * np.pi) / (4 * x_val)
143	)
144	y[index] = _eq_c(x_val) * np.sin(	×
145	(y_val * np.pi) / (4 * x_val)
146	)
147	z[index] = 1 - (2 * (x_val ** 2)) / np.pi	×
148	else:
149	# 0 < \|X\| <= \|Y\| <= L - Equation 8b
150	x[index] = _eq_c(y_val) * np.sin(	×
151	(x_val * np.pi) / (4 * y_val)
152	)
153	y[index] = _eq_c(y_val) * np.cos(	×
154	(x_val * np.pi) / (4 * y_val)
155	)
156	z[index] = 1 - (2 * (y_val ** 2)) / np.pi	×
157	index += 1	×
158	else:
159	if abs(x) > np.sqrt(np.pi / 2) or abs(y) > np.sqrt(np.pi / 2):	5✔
160	raise ValueError(	×
161	"The X and Y values MUST NOT be greater than L = sqrt(pi/2)"
162	)
163	if (	5✔
164	X == 0 and Y == 0
165	): # This is probably covered in the equations below but it is here now :)
166	x = 0	×
167	y = 0	×
168	z = 1	×
169	elif abs(Y) <= abs(X):	5✔
170	# 0 < \|Y\| <= \|X\| <= L - Equation 8a
171	x = _eq_c(X) * np.cos((Y * np.pi) / (4 * X))	5✔
172	y = _eq_c(X) * np.sin((Y * np.pi) / (4 * X))	5✔
173	z = 1 - (2 * (X ** 2)) / np.pi	5✔
174	else:
175	# 0 < \|X\| <= \|Y\| <= L - Equation 8b
176	x = _eq_c(Y) * np.sin((X * np.pi) / (4 * Y))	×
177	y = _eq_c(Y) * np.cos((X * np.pi) / (4 * Y))	×
178	z = 1 - (2 * (Y ** 2)) / np.pi	×
179
180	return Vector3d(np.column_stack((x, y, z)))	5✔
181
182	@staticmethod	5✔
183	def lambert_to_gnomonic(v: np.ndarray) -> np.ndarray:	5✔
184	"""Convert from Lambert via Cartesian coordinates to Gnomonic."""
185	# These two functions could probably be combined into 1 to decrease runtime
186	vec = LambertProjection.iproject(v[..., 0], v[..., 1])	5✔
187	vec = GnomonicProjection.project(vec)	5✔
188	return vec	5✔
189
190	@staticmethod	5✔
191	def gnomonic_to_lambert(v: np.ndarray) -> np.ndarray:	5✔
192	"""Convert from Gnomonic via Cartesian coordinates to Lambert."""
193	# These two functions could probably be combined into 1 to decrease runtime
194	vec = GnomonicProjection.iproject(v[..., 0], v[..., 1])	5✔
195	vec = LambertProjection.project(vec)	5✔
196	return vec	5✔
197
198
199	def _eq_c(p: np.ndarray) -> np.ndarray:	5✔
200	"""Private function used inside LambertProjection.iproject to increase readability."""
201	return (2 * p / np.pi) * np.sqrt(np.pi - p ** 2)	5✔

pyxem / kikuchipy / 381

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