Refactor orientation mapping3

.github/workflows/build.yml

@@ -22,7 +22,7 @@ jobs:
           - os: ubuntu-latest
             python-version: 3.8
 
-            DEPENDENCIES: diffsims==0.5.0 hyperspy~=2.0.rc0 lmfit==0.9.12 matplotlib==3.6 orix==0.9.0 scikit-image==0.19.0 scikit-learn==1.0.0
+            DEPENDENCIES: diffsims==0.6.rc1 hyperspy~=2.0.rc0 lmfit==0.9.12 matplotlib==3.7.5 orix==0.12.1 scikit-image==0.19.0 scikit-learn==1.0.0
             LABEL: -oldest
     steps:
       - uses: actions/checkout@v3

CHANGELOG.rst

@@ -7,6 +7,23 @@ All notable changes to this project will be documented in this file.
 The format is based on `Keep a Changelog <https://keepachangelog.com/en/1.0.0/>`_,
 and this project adheres to `Semantic Versioning <https://semver.org/spec/v2.0.0.html>`_.
 
+Unreleased
+==========
+Fixed
+-----
+- Fixed indexing error in :meth:`~pyxem.signals.Diffraction2D.get_direct_beam_position` (#1080)
+
+Added
+-----
+- Added Examples for doing a Circular Hough Transform and Increased Documentation for Filtering Data (#1082)
+Added
+-----
+- Added `circular_background` to :meth:`~pyxem.signals.Diffraction2D.template_match_disk` to account for
+  an amorphous circular background when template matching (#1084)
+
+- Added new datasets of in situ crystalization, Ag SPED,
+  Organic Semiconductor Orientation mapping, Orientation Mapping, and DPC (#1081)
+
 
 2024-05-08 - version 0.18.0
 ==========

doc/_static/switcher.json

@@ -6,9 +6,13 @@
     },
     {
         "name": "stable",
-        "version": "0.17.0",
+        "version": "0.18.0",
         "url": "https://pyxem.readthedocs.io/en/stable/"
     },
+    {
+        "version": "0.17.0",
+        "url": "https://pyxem.readthedocs.io/en/v0.17.0/"
+    },
     {
         "version": "0.16.0",
         "url": "https://pyxem.readthedocs.io/en/v0.16.0/"

doc/bibliography.bib

@@ -42,7 +42,7 @@ @article{Pekin:17
 keywords = { Strain measurement,Nanobeam electron diffraction},
 pages = {170--176},
 title = {{Optimizing disk registration algorithms for nanobeam electron diffraction strain mapping}},
-url = {https://www.sciencedirect.com/science/article/pii/S0304399116304065},
+url = {https://doi.org/10.1016/j.ultramic.2016.12.021},
 volume = {176},
 year = {2017}
 }
@@ -90,4 +90,13 @@ @article{Viladot:13
 volume = {252},
 journal = {Journal of microscopy},
 doi = {10.1111/jmi.12065}
+}
+@article{pyxemorientationmapping2022,
+    title={Free, flexible and fast: Orientation mapping using the multi-core and GPU-accelerated template matching capabilities in the python-based open source 4D-STEM analysis toolbox Pyxem},
+    author={Cautaerts, Niels and Crout, Phillip and {\AA}nes, H{\aa}kon Wiik and Prestat, Eric and Jeong, Jiwon and Dehm, Gerhard and Liebscher, Christian H},
+    journal={Ultramicroscopy},
+    pages={113517},
+    year={2022},
+    publisher={Elsevier},
+    doi={10.1016/j.ultramic.2022.113517}
 }

doc/conf.py

@@ -81,6 +81,7 @@
     "http://dx.doi.org/10.1088/0965-0393/23/8/083501",  # 403 Client Error: Forbidden for url
     "https://doi.org/10.1111/jmi.12065",  # 403 Client Error: Forbidden for url
     "https://doi.org/10.1111/j.0022-2720.2004.01293.x",  # 403 Client Error: Forbidden for url
+    "https://doi.org/10.1016/j.ultramic.2016.12.021",
 ]
 
 

examples/orientation_mapping/README.rst

@@ -0,0 +1,3 @@
+Orientation Mapping
+===================
+Below is a gallery of examples on how to do orientation mapping in pyxem.

examples/orientation_mapping/mulit_phase_orientation.py

@@ -0,0 +1,65 @@
+"""
+Multi Phase Orientation Mapping
+===============================
+You can also calculate the orientation of the grains for multiple phases using the
+:meth:`pyxem.signals.PolarSignal2D.get_orientation` method. This requires that you
+simulate the entire S2 space for the phase and then compare to the simulated diffraction.
+
+For more information on the orientation mapping process see :cite:`pyxemorientationmapping2022`
+"""
+
+import pyxem as pxm
+from pyxem.data import fe_multi_phase_grains, fe_bcc_phase, fe_fcc_phase
+from diffsims.generators.simulation_generator import SimulationGenerator
+from orix.quaternion import Rotation
+from orix.sampling import get_sample_reduced_fundamental
+
+mulit_phase = fe_multi_phase_grains()
+
+# %%
+# First we center the diffraction patterns and get a polar signal
+# Increasing the number of npt_azim with give better polar sampling
+# but will take longer to compute the orientation map
+# The mean=True argument will return the mean pixel value in each bin rather than the sum
+# this makes the high k values more visible
+
+mulit_phase.calibration.center = None
+polar_multi = mulit_phase.get_azimuthal_integral2d(
+    npt=100, npt_azim=360, inplace=False, mean=True
+)
+polar_multi.plot()
+
+# %%
+# Now we can get make a simulation. In this case we want to set a minimum_intensity which removes the low intensity reflections.
+# we also sample the S2 space using the :func`orix.sampling.get_sample_reduced_fundamental`
+# We have two phases here so we can make a simulation object with both of the phases.
+
+bcc = fe_bcc_phase()
+fcc = fe_fcc_phase()
+bcc.name = "BCC Phase"
+fcc.name = "FCC Phase"
+fcc.color = "red"
+bcc.color = "blue"
+
+generator = SimulationGenerator(200, minimum_intensity=0.05)
+rotations_bcc = get_sample_reduced_fundamental(
+    resolution=1, point_group=bcc.point_group
+)
+rotations_fcc = get_sample_reduced_fundamental(
+    resolution=1, point_group=fcc.point_group
+)
+
+sim = generator.calculate_diffraction2d(
+    [bcc, fcc],
+    rotation=[rotations_bcc, rotations_fcc],
+    max_excitation_error=0.1,
+    reciprocal_radius=2,
+    with_direct_beam=False,
+)
+orientation_map = polar_multi.get_orientation(sim)
+
+
+cmap = orientation_map.to_crystal_map()
+cmap.plot()
+# %%
+# sphinx_gallery_thumbnail_number = 3

examples/orientation_mapping/on_zone_orientation.py

@@ -0,0 +1,62 @@
+"""
+On Zone Orientation
+===================
+Sometimes you have a tilt boundary and you might want to know the orientation of the
+grains on each side of the boundary. This can be done using the
+:meth:`pyxem.signals.PolarSignal2D.get_orientation` method.
+
+For more information on the orientation mapping process see :cite:`pyxemorientationmapping2022`
+"""
+
+from pyxem.data import si_tilt, si_phase
+from diffsims.generators.simulation_generator import SimulationGenerator
+from orix.quaternion import Rotation
+from orix.vector import Vector3d
+
+simulated_si_tilt = si_tilt()
+
+# %%
+# Pre-Processing
+# --------------
+# First we center the diffraction patterns and get a polar signal
+# Increasing the number of npt_azim with give better polar sampling
+# but will take longer to compute the orientation map
+# The mean=True argument will return the mean pixel value in each bin rather than the sum
+# this makes the high k values more visible
+
+simulated_si_tilt.calibration.center = None
+polar_si_tilt = simulated_si_tilt.get_azimuthal_integral2d(
+    npt=100, npt_azim=360, inplace=False, mean=True
+)
+polar_si_tilt.plot()
+
+# %%
+
+# Building a Simulation
+# ---------------------
+# Now we can get make the orientation map.  In this case we have aligned the tilt axis with the z-axis
+# so we can use the :func:`orix.vector.Vector3d.from_euler` method to get the rotation axis.
+# As always ``with_direct_beam=False`` is important to make sure that the center
+# beam does not affect the orientation mapping.
+
+
+phase = si_phase()
+generator = SimulationGenerator(200)
+sim = generator.calculate_diffraction2d(
+    phase,
+    rotation=Rotation.from_euler(
+        [[0, 0, 0], [0, 0, 0]],
+        degrees=True,
+    ),
+    max_excitation_error=0.1,
+    reciprocal_radius=1.5,
+    with_direct_beam=False,
+)
+# Getting the Orientation
+# -----------------------
+# This should be fairly good at finding the orientation of the grains on each side of the tilt boundary.
+# The rotation is stored in the rotation column of the orientation map or .isg[2,0] if you want to use the
+# rotation as a navigator or plot it directly.
+
+orientation_map = polar_si_tilt.get_orientation(sim)
+orientation_map.plot_over_signal(simulated_si_tilt)

examples/orientation_mapping/single_phase_orientation.py

@@ -0,0 +1,63 @@
+"""
+Single Phase Orientation Mapping
+================================
+You can also calculate the orientation of the grains in a single phase sample using the
+:meth:`pyxem.signals.PolarSignal2D.get_orientation` method. This requires that you
+simulate the entire S2 space for the phase and then compare to the simulated diffraction.
+
+For more information on the orientation mapping process see :cite:`pyxemorientationmapping2022`
+"""
+
+from pyxem.data import si_phase, si_grains
+from diffsims.generators.simulation_generator import SimulationGenerator
+from orix.sampling import get_sample_reduced_fundamental
+
+simulated_si = si_grains()
+
+# %%
+# Pre-Processing
+# --------------
+# First we center the diffraction patterns and get a polar signal
+# Increasing the number of npt_azim with give better polar sampling
+# but will take longer to compute the orientation map
+# The mean=True argument will return the mean pixel value in each bin rather than the sum
+# this makes the high k values more visible
+
+simulated_si.calibration.center = None
+polar_si = simulated_si.get_azimuthal_integral2d(
+    npt=100, npt_azim=360, inplace=False, mean=True
+)
+polar_si.plot()
+
+# %%
+# Building a Simulation
+# ---------------------
+# Now we can get make a simulation. In this case we want to set a minimum_intensity which removes the low intensity reflections.
+# we also sample the S2 space using the :func`orix.sampling.get_sample_reduced_fundamental`.  Make sure that you set
+# ``with_direct_beam=False`` or the orientation mapping will be unduely affected by the center beam.
+phase = si_phase()
+generator = SimulationGenerator(200, minimum_intensity=0.05)
+rotations = get_sample_reduced_fundamental(resolution=1, point_group=phase.point_group)
+sim = generator.calculate_diffraction2d(
+    phase,
+    rotation=rotations,
+    max_excitation_error=0.1,
+    reciprocal_radius=2,
+    with_direct_beam=False,
+)  # Make sure that with_direct_beam ==False
+
+# %%
+# Getting the Orientation
+# -----------------------
+# By default the `get_orientation` function uses a gamma correction equilivent to polar_si**0.5.  For noisy datasets
+# it might be a good idea to reduce the noise (Maybe by averaging neighboring patterns?) or simple background subtraction,
+# otherwise the gamma correction will increase the effects of noise on the data. This tries to focus on  "Is the Bragg vector
+# there?" rather than "Is the Bragg vector the right intensity?" patially because the intensity of the Bragg vector might have
+# many different effects.
+
+
+orientation_map = polar_si.get_orientation(sim)
+orientation_map.plot_over_signal(simulated_si, vmax="96th")
+
+# %%
+# sphinx_gallery_thumbnail_number = 4