pyxem / kikuchipy / 483

pending completion

Build # 483

Build Type

Pull #234

travis-ci-com

Committed by

web-flow

Commit Message

<a href="https://github.com/pyxem/kikuchipy/commit/<a class=hub.com/pyxem/kikuchipy/commit/1c4ff2496fa721aaa22ebb59ed2836dd3e73e08d">1c4ff2496<a href="https://github.com/pyxem/kikuchipy/commit/1c4ff2496fa721aaa22ebb59ed2836dd3e73e08d">">Merge </a><a class="double-link" href="https://github.com/pyxem/kikuchipy/commit/<a class="double-link" href="https://github.com/pyxem/kikuchipy/commit/c56a972fb0144038cc594135f06c0df2ef2d7e55">c56a972fb</a>">c56a972fb</a><a href="https://github.com/pyxem/kikuchipy/commit/1c4ff2496fa721aaa22ebb59ed2836dd3e73e08d"> into fc05696a5">fc05696a5</a>

Pull Request Pull Request #234: Static Dictionary Indexing and Orientation Similarity Map

Run Details

191 of 191 new or added lines in 10 files covered. (100.0%)

6293 of 6298 relevant lines covered (99.92%)

5.0 hits per line

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

94.12

/kikuchipy/indexing/static_dictionary_indexing.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, List
import dask.array as da
from dask.diagnostics import ProgressBar
import numpy as np
from h5py import File

from orix.quaternion.rotation import Rotation
from orix.crystal_map.crystal_map import CrystalMap, PhaseList, Phase

from kikuchipy.indexing import pattern_match

from kikuchipy.indexing.osm import orientation_similarity_map
from kikuchipy.indexing.similarity_metrics import (
    SimilarityMetric,
    SIMILARITY_METRICS,
)

from kikuchipy.indexing.merge_crystalmaps import merge_crystalmaps


class StaticDictionaryIndexing:
    """Indexing against pre-computed dictionaries from EMsoft's EMEBSD.f90 program"""

    def __init__(
        self,
        dictionaries: Union[
            "EBSD", "LazyEBSD", List[Union["EBSD", "LazyEBSD"]]
        ],
    ):
        """Initialize with one or more dictionaries before indexing patterns.

        Parameters
        ----------
        dictionaries : Union[EBSD, LazyEBSD, List[Union[EBSD, LazyEBSD]]]
            Dictionaries as EBSD Signals with one-dimensional navigation axis
            and with the `xmap` property set.
        """
        self.dictionaries = (
            dictionaries if isinstance(dictionaries, list) else [dictionaries]
        )

    def index(
        self,
        patterns: Union["EBSD", "LazyEBSD"],
        metric: Union[str, SimilarityMetric] = "zncc",
        keep_n: int = 1,
        n_slices: int = 1,
        merge_xmaps: bool = True,
        osm: bool = True,
    ) -> List[CrystalMap]:
        """Perform Dictionary Indexing on patterns against preloaded dictionaries.[ref here or elsewhere?]

        Produce a `CrystalMap` for each dictionary with `metric_results` and `template_indices` as properties.

        Parameters
        ----------
        patterns : Union[EBSD, LazyEBSD]
            Patterns
        metric : Union[str, SimilarityMetric], optional
            Similarity metric, by default "zncc".
        keep_n : int, optional
            Number of sorted results to keep, by default 1.
        n_slices : int, optional
            Number of template slices to process sequentially, by default 1.
        merge_xmaps : bool, optional
            Produce a merged crystal map from best results, by default True.
            See also `merge_crystalmaps`.
        osm : bool, optional
            Orientation Similarity Maps as property `osm`, by default True.

        Returns
        -------
        xmaps : List[CrystalMap]
            A crystal map for each dictionary loaded and one merged map if `merge_xmaps = True`.
        """

        # This needs a rework before sent to cluster and possibly more automatic slicing with dask
        num_templates = self.dictionaries[0].data.shape[0]
        if num_templates // n_slices > 13500:
            answer = input(
                f"You should probably increase n_slices depending on your available memory, try above {num_templates // 13500}. Do you want to proceed? [y/n]"
            )
            if answer != "y":
                return

        #        n_slices = None if n_slices == 1 else n_slices

        metric = SIMILARITY_METRICS.get(metric, metric)

        # Naively let dask compute them seperately, should try in the future combined compute for better performance
        match_results = [
            pattern_match(
                patterns.data,
                dictionary.data,
                metric=metric,
                keep_n=keep_n,
                n_slices=n_slices,
            )
            for dictionary in self.dictionaries
        ]

        axm = patterns.axes_manager
        scan_unit = axm.navigation_axes[0].units
        x1, x2, y1, y2 = axm.navigation_extent
        scale_x, scale_y = (axm.navigation_axes[i].scale for i in range(2))
        nav_shape = axm.navigation_shape
        x = np.tile(np.arange(x1, x2 + scale_x, scale_x), nav_shape[1])
        y = np.tile(np.arange(y1, y2 + scale_y, scale_y), nav_shape[0])

        #
        # Create crystal map for each match_result, i.e. each phase
        #

        def match_result_2_xmap(i, mr):
            t_indices, coeffs = mr
            xmap = self.dictionaries[i].xmap
            phase_list = xmap.phases_in_data
            rotations = xmap.rotations[t_indices]
            return CrystalMap(
                rotations,
                x=x,
                y=y,
                phase_list=phase_list,
                prop={"metric_results": coeffs, "template_indices": t_indices},
                scan_unit=scan_unit,
            )

        xmaps = [
            match_result_2_xmap(i, mr) for i, mr in enumerate(match_results)
        ]

        #
        # Creating one CrystalMap using best metric result accross all dictionaries
        #
        if merge_xmaps and len(self.dictionaries) > 1:
            # Cummulative summation of the dictionary lengths to create unique template ids across dictionaries
            cum_sum_dict_lengths = np.cumsum(
                [d.data.shape[0] for d in self.dictionaries]
            )

            def adjust_t_ids(i, xmap):
                if i == 0:
                    return xmap
                xmap.prop["template_indices"] += cum_sum_dict_lengths[i - 1]
                return xmap

            xmaps_unique_t_ids = [
                adjust_t_ids(i, xmap) for i, xmap in enumerate(xmaps)
            ]
            xmap_merged = merge_crystalmaps(xmaps_unique_t_ids, metric=metric)
            xmaps.append(xmap_merged)

        # Orientation Similarity Maps
        if osm:
            print("Computing Orientation Similarity Maps.")
            for xmap in xmaps:
                xmap.prop["osm"] = orientation_similarity_map(
                    xmap, n_largest=keep_n
                ).flatten()

        return xmaps

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, List	5✔
20	import dask.array as da	5✔
21	from dask.diagnostics import ProgressBar	5✔
22	import numpy as np	5✔
23	from h5py import File	5✔
24
25	from orix.quaternion.rotation import Rotation	5✔
26	from orix.crystal_map.crystal_map import CrystalMap, PhaseList, Phase	5✔
27
28	from kikuchipy.indexing import pattern_match	5✔
29
30	from kikuchipy.indexing.osm import orientation_similarity_map	5✔
31	from kikuchipy.indexing.similarity_metrics import (	5✔
32	SimilarityMetric,
33	SIMILARITY_METRICS,
34	)
35
36	from kikuchipy.indexing.merge_crystalmaps import merge_crystalmaps	5✔
37
38
39	class StaticDictionaryIndexing:	5✔
40	"""Indexing against pre-computed dictionaries from EMsoft's EMEBSD.f90 program"""
41
42	def __init__(	5✔
43	self,
44	dictionaries: Union[
45	"EBSD", "LazyEBSD", List[Union["EBSD", "LazyEBSD"]]
46	],
47	):
48	"""Initialize with one or more dictionaries before indexing patterns.
49
50	Parameters
51	----------
52	dictionaries : Union[EBSD, LazyEBSD, List[Union[EBSD, LazyEBSD]]]
53	Dictionaries as EBSD Signals with one-dimensional navigation axis
54	and with the `xmap` property set.
55	"""
56	self.dictionaries = (	5✔
57	dictionaries if isinstance(dictionaries, list) else [dictionaries]
58	)
59
60	def index(	5✔
61	self,
62	patterns: Union["EBSD", "LazyEBSD"],
63	metric: Union[str, SimilarityMetric] = "zncc",
64	keep_n: int = 1,
65	n_slices: int = 1,
66	merge_xmaps: bool = True,
67	osm: bool = True,
68	) -> List[CrystalMap]:
69	"""Perform Dictionary Indexing on patterns against preloaded dictionaries.[ref here or elsewhere?]
70
71	Produce a `CrystalMap` for each dictionary with `metric_results` and `template_indices` as properties.
72
73	Parameters
74	----------
75	patterns : Union[EBSD, LazyEBSD]
76	Patterns
77	metric : Union[str, SimilarityMetric], optional
78	Similarity metric, by default "zncc".
79	keep_n : int, optional
80	Number of sorted results to keep, by default 1.
81	n_slices : int, optional
82	Number of template slices to process sequentially, by default 1.
83	merge_xmaps : bool, optional
84	Produce a merged crystal map from best results, by default True.
85	See also `merge_crystalmaps`.
86	osm : bool, optional
87	Orientation Similarity Maps as property `osm`, by default True.
88
89	Returns
90	-------
91	xmaps : List[CrystalMap]
92	A crystal map for each dictionary loaded and one merged map if `merge_xmaps = True`.
93	"""
94
95	# This needs a rework before sent to cluster and possibly more automatic slicing with dask
96	num_templates = self.dictionaries[0].data.shape[0]	5✔
97	if num_templates // n_slices > 13500:	5✔
98	answer = input(	×
99	f"You should probably increase n_slices depending on your available memory, try above {num_templates // 13500}. Do you want to proceed? [y/n]"
100	)
101	if answer != "y":	×
102	return	×
103
104	# n_slices = None if n_slices == 1 else n_slices
105
106	metric = SIMILARITY_METRICS.get(metric, metric)	5✔
107
108	# Naively let dask compute them seperately, should try in the future combined compute for better performance
109	match_results = [	5✔
110	pattern_match(
111	patterns.data,
112	dictionary.data,
113	metric=metric,
114	keep_n=keep_n,
115	n_slices=n_slices,
116	)
117	for dictionary in self.dictionaries
118	]
119
120	axm = patterns.axes_manager	5✔
121	scan_unit = axm.navigation_axes[0].units	5✔
122	x1, x2, y1, y2 = axm.navigation_extent	5✔
123	scale_x, scale_y = (axm.navigation_axes[i].scale for i in range(2))	5✔
124	nav_shape = axm.navigation_shape	5✔
125	x = np.tile(np.arange(x1, x2 + scale_x, scale_x), nav_shape[1])	5✔
126	y = np.tile(np.arange(y1, y2 + scale_y, scale_y), nav_shape[0])	5✔
127
128	#
129	# Create crystal map for each match_result, i.e. each phase
130	#
131
132	def match_result_2_xmap(i, mr):	5✔
133	t_indices, coeffs = mr	5✔
134	xmap = self.dictionaries[i].xmap	5✔
135	phase_list = xmap.phases_in_data	5✔
136	rotations = xmap.rotations[t_indices]	5✔
137	return CrystalMap(	5✔
138	rotations,
139	x=x,
140	y=y,
141	phase_list=phase_list,
142	prop={"metric_results": coeffs, "template_indices": t_indices},
143	scan_unit=scan_unit,
144	)
145
146	xmaps = [	5✔
147	match_result_2_xmap(i, mr) for i, mr in enumerate(match_results)
148	]
149
150	#
151	# Creating one CrystalMap using best metric result accross all dictionaries
152	#
153	if merge_xmaps and len(self.dictionaries) > 1:	5✔
154	# Cummulative summation of the dictionary lengths to create unique template ids across dictionaries
155	cum_sum_dict_lengths = np.cumsum(	5✔
156	[d.data.shape[0] for d in self.dictionaries]
157	)
158
159	def adjust_t_ids(i, xmap):	5✔
160	if i == 0:	5✔
161	return xmap	5✔
162	xmap.prop["template_indices"] += cum_sum_dict_lengths[i - 1]	5✔
163	return xmap	5✔
164
165	xmaps_unique_t_ids = [	5✔
166	adjust_t_ids(i, xmap) for i, xmap in enumerate(xmaps)
167	]
168	xmap_merged = merge_crystalmaps(xmaps_unique_t_ids, metric=metric)	5✔
169	xmaps.append(xmap_merged)	5✔
170
171	# Orientation Similarity Maps
172	if osm:	5✔
173	print("Computing Orientation Similarity Maps.")	5✔
174	for xmap in xmaps:	5✔
175	xmap.prop["osm"] = orientation_similarity_map(	5✔
176	xmap, n_largest=keep_n
177	).flatten()
178
179	return xmaps	5✔

pyxem / kikuchipy / 483

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