nxs-analysis-tools 0.0.41__tar.gz → 0.0.43__tar.gz

{nxs_analysis_tools-0.0.41/src/nxs_analysis_tools.egg-info → nxs_analysis_tools-0.0.43}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: nxs-analysis-tools
-Version: 0.0.41
+Version: 0.0.43
 Summary: Reduce and transform nexus format (.nxs) scattering data.
 Author-email: "Steven J. Gomez Alvarado" <stevenjgomez@ucsb.edu>
 License: MIT License

{nxs_analysis_tools-0.0.41 → nxs_analysis_tools-0.0.43}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = 'setuptools.build_meta'
 
 [project]
 name = 'nxs-analysis-tools'
-version = '0.0.41'
+version = '0.0.43'
 description = 'Reduce and transform nexus format (.nxs) scattering data.'
 readme = 'README.md'
 requires-python = '>=3.7'

{nxs_analysis_tools-0.0.41 → nxs_analysis_tools-0.0.43}/src/_meta/__init__.py

@@ -6,5 +6,5 @@ __author__ = 'Steven J. Gomez Alvarado'
 __email__ = 'stevenjgomez@ucsb.edu'
 __copyright__ = f"2023, {__author__}"
 __license__ = 'MIT'
-__version__ = '0.0.41'
+__version__ = '0.0.43'
 __repo_url__ = 'https://github.com/stevenjgomez/nxs_analysis_tools'

{nxs_analysis_tools-0.0.41 → nxs_analysis_tools-0.0.43}/src/nxs_analysis_tools/chess.py

@@ -8,6 +8,7 @@ import re
 
 import matplotlib.pyplot as plt
 import matplotlib as mpl
+import pandas as pd
 import numpy as np
 from IPython.display import display, Markdown
 from nxs_analysis_tools import load_data, Scissors
@@ -190,14 +191,24 @@ class TempDependence:
 
         # Convert all temperatures to int temporarily to sort temperatures list before loading
         self.temperatures = [int(t) for t in self.temperatures]
-        self.temperatures.sort()
+
+        loading_template = pd.DataFrame({'temperature': self.temperatures, 'filename': items_to_load})
+        loading_template = loading_template.sort_values(by='temperature')
+        self.temperatures = loading_template['temperature']
         self.temperatures = [str(t) for t in self.temperatures]
+        items_to_load = loading_template['filename'].to_list()
 
         for i, item in enumerate(items_to_load):
             path = os.path.join(self.sample_directory, item)
 
             # Save dataset
-            self.datasets[self.temperatures[i]] = load_transform(path)
+            try:
+                self.datasets[self.temperatures[i]] = load_transform(path)
+            except Exception as e:
+                # Report temperature that was unable to load, then raise exception.
+                temp_failed = self.temperatures[i]
+                print(f"Failed to load data for temperature {temp_failed} K from file {item}. Error: {e}")
+                raise  # Re-raise the exception
 
             # Initialize scissors object
             self.scissors[self.temperatures[i]] = Scissors()

{nxs_analysis_tools-0.0.41 → nxs_analysis_tools-0.0.43}/src/nxs_analysis_tools/datareduction.py

@@ -185,14 +185,14 @@ def plot_slice(data, X=None, Y=None, transpose=False, vmin=None, vmax=None,
     """
     if isinstance(data, np.ndarray):
         if X is None:
-            X = NXfield(np.linspace(0, data.shape[1], data.shape[1]), name='x')
+            X = NXfield(np.linspace(0, data.shape[0], data.shape[0]), name='x')
         if Y is None:
-            Y = NXfield(np.linspace(0, data.shape[0], data.shape[0]), name='y')
+            Y = NXfield(np.linspace(0, data.shape[1], data.shape[1]), name='y')
         if transpose:
             X, Y = Y, X
             data = data.transpose()
         data = NXdata(NXfield(data, name='value'), (X, Y))
-        data_arr = data
+        data_arr = data[data.signal].nxdata.transpose()
     elif isinstance(data, (NXdata, NXfield)):
         if X is None:
             X = data[data.axes[0]]
@@ -787,7 +787,8 @@ def rotate_data(data, lattice_angle, rotation_angle, rotation_axis, printout=Fal
 
         p = Padder(sliced_data)
         padding = tuple(len(sliced_data[axis]) for axis in sliced_data.axes)
-        counts = p.pad(padding).counts
+        counts = p.pad(padding)
+        counts = p.padded[p.padded.signal]
 
         counts_skewed = ndimage.affine_transform(counts,
                                                  t.inverted().get_matrix()[:2, :2],
@@ -848,7 +849,7 @@ def rotate_data(data, lattice_angle, rotation_angle, rotation_axis, printout=Fal
         elif rotation_axis == 2:
             output_array[:, :, i] = counts_unpadded
     print('\nDone.')
-    return NXdata(NXfield(output_array, name='counts'),
+    return NXdata(NXfield(output_array, name=p.padded.signal),
                   (data[data.axes[0]], data[data.axes[1]], data[data.axes[2]]))
 
 
@@ -884,7 +885,8 @@ def rotate_data2D(data, lattice_angle, rotation_angle):
 
     p = Padder(data)
     padding = tuple(len(data[axis]) for axis in data.axes)
-    counts = p.pad(padding).counts
+    counts = p.pad(padding)
+    counts = p.padded[p.padded.signal]
 
     counts_skewed = ndimage.affine_transform(counts,
                                              t.inverted().get_matrix()[:2, :2],
@@ -937,7 +939,7 @@ def rotate_data2D(data, lattice_angle, rotation_angle):
     counts_unpadded = p.unpad(counts_unskewed)
 
     print('\nDone.')
-    return NXdata(NXfield(counts_unpadded, name='counts'),
+    return NXdata(NXfield(counts_unpadded, name=p.padded.signal),
                   (data[data.axes[0]], data[data.axes[1]]))
 
 

{nxs_analysis_tools-0.0.41 → nxs_analysis_tools-0.0.43}/src/nxs_analysis_tools/pairdistribution.py

@@ -185,23 +185,58 @@ class Symmetrizer2D:
         q1 = data_padded[data.axes[0]]
         q2 = data_padded[data.axes[1]]
 
-        # Define signal to be symmetrized
-        counts = data_padded[data.signal].nxdata
-
         # Calculate the angle for each data point
         theta = np.arctan2(q1.reshape((-1, 1)), q2.reshape((1, -1)))
         # Create a boolean array for the range of angles
         symmetrization_mask = np.logical_and(theta >= theta_min * np.pi / 180,
                                              theta <= theta_max * np.pi / 180)
-        self.symmetrization_mask = NXdata(NXfield(p.unpad(symmetrization_mask),
-                                                  name='mask'),
-                                          (data[data.axes[0]], data[data.axes[1]])
-                                          )
 
-        self.wedge = NXdata(NXfield(p.unpad(counts * symmetrization_mask),
-                                    name=data.signal),
-                            (data[data.axes[0]], data[data.axes[1]])
-                            )
+        # Define signal to be transformed
+        counts = symmetrization_mask
+
+        # Scale and skew counts
+        skew_angle_adj = 90 - self.skew_angle
+
+        scale2 = counts.shape[0] / counts.shape[1]
+        counts_unscaled2 = ndimage.affine_transform(counts,
+                                                    Affine2D().scale(scale2, 1).inverted().get_matrix()[:2, :2],
+                                                    offset=[-(1 - scale2) * counts.shape[
+                                                        0] / 2 / scale2, 0],
+                                                    order=0,
+                                                    )
+
+        scale1 = np.cos(skew_angle_adj * np.pi / 180)
+        counts_unscaled1 = ndimage.affine_transform(counts_unscaled2,
+                                                    Affine2D().scale(scale1, 1).inverted().get_matrix()[:2, :2],
+                                                    offset=[-(1 - scale1) * counts.shape[
+                                                        0] / 2 / scale1, 0],
+                                                    order=0,
+                                                    )
+
+        mask = ndimage.affine_transform(counts_unscaled1,
+                                        t.get_matrix()[:2, :2],
+                                        offset=[-counts.shape[0] / 2
+                                                * np.sin(skew_angle_adj * np.pi / 180), 0],
+                                        order=0,
+                                        )
+
+        # Convert mask to nxdata
+        mask = array_to_nxdata(mask, data_padded)
+
+        # Save mask for user interaction
+        self.symmetrization_mask = p.unpad(mask)
+
+        # Perform masking
+        wedge = mask * data_padded
+
+        # Save wedge for user interaction
+        self.wedge = p.unpad(wedge)
+
+        # Convert wedge back to array for further transformations
+        wedge = wedge[data.signal].nxdata
+
+        # Define signal to be transformed
+        counts = wedge
 
         # Scale and skew counts
         skew_angle_adj = 90 - self.skew_angle
@@ -216,7 +251,7 @@ class Symmetrizer2D:
                                          Affine2D().scale(scale1, 1).get_matrix()[:2, :2],
                                          offset=[(1 - scale1) * counts.shape[0] / 2, 0],
                                          order=0,
-                                         ) * symmetrization_mask
+                                         )
 
         scale2 = counts.shape[0] / counts.shape[1]
         wedge = ndimage.affine_transform(wedge,
@@ -325,15 +360,24 @@ class Symmetrizer2D:
         symm_test = s.symmetrize_2d(data)
         fig, axesarr = plt.subplots(2, 2, figsize=(10, 8))
         axes = axesarr.reshape(-1)
+
+        # Plot the data
         plot_slice(data, skew_angle=s.skew_angle, ax=axes[0], title='data', **kwargs)
-        plot_slice(s.symmetrization_mask, skew_angle=s.skew_angle, ax=axes[1], title='mask')
+
+        # Filter kwargs to exclude 'vmin' and 'vmax'
+        filtered_kwargs = {key: value for key, value in kwargs.items() if key not in ('vmin', 'vmax')}
+        # Plot the mask
+        plot_slice(s.symmetrization_mask, skew_angle=s.skew_angle, ax=axes[1], title='mask', **filtered_kwargs)
+
+        # Plot the wedge
         plot_slice(s.wedge, skew_angle=s.skew_angle, ax=axes[2], title='wedge', **kwargs)
+
+        # Plot the symmetrized data
         plot_slice(symm_test, skew_angle=s.skew_angle, ax=axes[3], title='symmetrized', **kwargs)
         plt.subplots_adjust(wspace=0.4)
         plt.show()
         return fig, axesarr
 
-
 class Symmetrizer3D:
     """
     A class to symmetrize 3D datasets by performing sequential 2D symmetrization on

{nxs_analysis_tools-0.0.41 → nxs_analysis_tools-0.0.43/src/nxs_analysis_tools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: nxs-analysis-tools
-Version: 0.0.41
+Version: 0.0.43
 Summary: Reduce and transform nexus format (.nxs) scattering data.
 Author-email: "Steven J. Gomez Alvarado" <stevenjgomez@ucsb.edu>
 License: MIT License

{nxs_analysis_tools-0.0.41 → nxs_analysis_tools-0.0.43}/src/nxs_analysis_tools.egg-info/SOURCES.txt

@@ -19,4 +19,6 @@ tests/test_chess_fitting.py
 tests/test_datareduction.py
 tests/test_fitting.py
 tests/test_lmfit.py
-tests/test_pairdistribution.py
+tests/test_mask_plotting.py
+tests/test_pairdistribution.py
+tests/test_plot_slice_with_ndarray.py

nxs_analysis_tools-0.0.43/tests/test_mask_plotting.py

@@ -0,0 +1,388 @@
+import time
+import os
+import gc
+import math
+from scipy import ndimage
+import scipy
+import matplotlib.pyplot as plt
+from matplotlib.transforms import Affine2D
+from nexusformat.nexus import nxsave, NXroot, NXentry, NXdata, NXfield
+import numpy as np
+from astropy.convolution import Kernel, convolve_fft
+import pyfftw
+from nxs_analysis_tools import *
+from nxs_analysis_tools.datareduction import Padder, array_to_nxdata
+
+"""
+Tools for generating single crystal pair distribution functions.
+"""
+import time
+import os
+import gc
+import math
+from scipy import ndimage
+import scipy
+import matplotlib.pyplot as plt
+from matplotlib.transforms import Affine2D
+from nexusformat.nexus import nxsave, NXroot, NXentry, NXdata, NXfield
+import numpy as np
+from astropy.convolution import Kernel, convolve_fft
+import pyfftw
+# from .datareduction import plot_slice, reciprocal_lattice_params, Padder, \
+#     array_to_nxdata
+
+# __all__ = ['Symmetrizer2D', 'Symmetrizer3D', 'Puncher', 'Interpolator',
+#            'fourier_transform_nxdata', 'Gaussian3DKernel', 'DeltaPDF',
+#            'generate_gaussian'
+#            ]
+
+
+class Symmetrizer2D:
+    """
+    A class for symmetrizing 2D datasets.
+
+    The `Symmetrizer2D` class provides functionality to apply symmetry
+    operations such as rotation and mirroring to 2D datasets.
+
+    Attributes
+    ----------
+    mirror_axis : int or None
+        The axis along which mirroring is performed. Default is None, meaning
+        no mirroring is applied.
+    symmetrized : NXdata or None
+        The symmetrized dataset after applying the symmetrization operations.
+        Default is None until symmetrization is performed.
+    wedges : NXdata or None
+        The wedges extracted from the dataset based on the angular limits.
+        Default is None until symmetrization is performed.
+    rotations : int or None
+        The number of rotations needed to reconstruct the full dataset from
+        a single wedge. Default is None until parameters are set.
+    transform : Affine2D or None
+        The transformation matrix used for skewing and scaling the dataset.
+        Default is None until parameters are set.
+    mirror : bool or None
+        Indicates whether mirroring is performed during symmetrization.
+        Default is None until parameters are set.
+    skew_angle : float or None
+        The skew angle (in degrees) between the principal axes of the plane
+         to be symmetrized. Default is None until parameters are set.
+    theta_max : float or None
+        The maximum angle (in degrees) for symmetrization. Default is None
+         until parameters are set.
+    theta_min : float or None
+        The minimum angle (in degrees) for symmetrization. Default is None
+         until parameters are set.
+    wedge : NXdata or None
+        The dataset wedge used in the symmetrization process. Default is
+         None until symmetrization is performed.
+    symmetrization_mask : NXdata or None
+        The mask used for selecting the region of the dataset to be symmetrized.
+         Default is None until symmetrization is performed.
+
+    Methods
+    -------
+    __init__(**kwargs):
+        Initializes the Symmetrizer2D object and optionally sets the parameters
+         using `set_parameters`.
+    set_parameters(theta_min, theta_max, lattice_angle=90, mirror=True, mirror_axis=0):
+        Sets the parameters for the symmetrization operation, including angle limits,
+         lattice angle, and mirroring options.
+    symmetrize_2d(data):
+        Symmetrizes a 2D dataset based on the set parameters.
+    test(data, **kwargs):
+        Performs a test visualization of the symmetrization process, displaying the
+         original data, mask, wedge, and symmetrized result.
+    """
+    symmetrization_mask: NXdata
+
+    def __init__(self, **kwargs):
+        """
+        Initializes the Symmetrizer2D object.
+
+        Parameters
+        ----------
+        **kwargs : dict, optional
+            Keyword arguments that can be passed to the `set_parameters` method to
+             set the symmetrization parameters during initialization.
+        """
+        self.mirror_axis = None
+        self.symmetrized = None
+        self.wedges = None
+        self.rotations = None
+        self.transform = None
+        self.mirror = None
+        self.skew_angle = None
+        self.theta_max = None
+        self.theta_min = None
+        self.wedge = None
+        if kwargs:
+            self.set_parameters(**kwargs)
+
+    def set_parameters(self, theta_min, theta_max, lattice_angle=90, mirror=True, mirror_axis=0):
+        """
+        Sets the parameters for the symmetrization operation, and calculates the
+         required transformations and rotations.
+
+        Parameters
+        ----------
+        theta_min : float
+            The minimum angle in degrees for symmetrization.
+        theta_max : float
+            The maximum angle in degrees for symmetrization.
+        lattice_angle : float, optional
+            The angle in degrees between the two principal axes of the plane to be
+             symmetrized (default: 90).
+        mirror : bool, optional
+            If True, perform mirroring during symmetrization (default: True).
+        mirror_axis : int, optional
+            The axis along which to perform mirroring (default: 0).
+        """
+        self.theta_min = theta_min
+        self.theta_max = theta_max
+        self.skew_angle = lattice_angle
+        self.mirror = mirror
+        self.mirror_axis = mirror_axis
+
+        # Define Transformation
+        skew_angle_adj = 90 - lattice_angle
+        t = Affine2D()
+        # Scale y-axis to preserve norm while shearing
+        t += Affine2D().scale(1, np.cos(skew_angle_adj * np.pi / 180))
+        # Shear along x-axis
+        t += Affine2D().skew_deg(skew_angle_adj, 0)
+        # Return to original y-axis scaling
+        t += Affine2D().scale(1, np.cos(skew_angle_adj * np.pi / 180)).inverted()
+        self.transform = t
+
+        # Calculate number of rotations needed to reconstruct the dataset
+        if mirror:
+            rotations = abs(int(360 / (theta_max - theta_min) / 2))
+        else:
+            rotations = abs(int(360 / (theta_max - theta_min)))
+        self.rotations = rotations
+
+        self.symmetrization_mask = None
+
+        self.wedges = None
+
+        self.symmetrized = None
+
+    def symmetrize_2d(self, data):
+        """
+        Symmetrizes a 2D dataset based on the set parameters, applying padding
+         to prevent rotation cutoff and handling overlapping pixels.
+
+        Parameters
+        ----------
+        data : NXdata
+            The input 2D dataset to be symmetrized.
+
+        Returns
+        -------
+        symmetrized : NXdata
+            The symmetrized 2D dataset.
+        """
+        theta_min = self.theta_min
+        theta_max = self.theta_max
+        mirror = self.mirror
+        mirror_axis = self.mirror_axis
+        t = self.transform
+        rotations = self.rotations
+
+        # Pad the dataset so that rotations don't get cutoff if they extend
+        # past the extent of the dataset
+        p = Padder(data)
+        padding = tuple(len(data[axis]) for axis in data.axes)
+        data_padded = p.pad(padding)
+
+        # Define axes that span the plane to be transformed
+        q1 = data_padded[data.axes[0]]
+        q2 = data_padded[data.axes[1]]
+
+        # Calculate the angle for each data point
+        theta = np.arctan2(q1.reshape((-1, 1)), q2.reshape((1, -1)))
+        # Create a boolean array for the range of angles
+        symmetrization_mask = np.logical_and(theta >= theta_min * np.pi / 180,
+                                             theta <= theta_max * np.pi / 180)
+
+        # Define signal to be transformed
+        counts = symmetrization_mask
+
+        # Scale and skew counts
+        skew_angle_adj = 90 - self.skew_angle
+        counts_skew = ndimage.affine_transform(counts,
+                                               t.get_matrix()[:2, :2],
+                                               offset=[-counts.shape[0] / 2
+                                                       * np.sin(skew_angle_adj * np.pi / 180), 0],
+                                               order=0,
+                                               )
+        scale1 = np.cos(skew_angle_adj * np.pi / 180)
+        mask = ndimage.affine_transform(counts_skew,
+                                         Affine2D().scale(scale1, 1).inverted().get_matrix()[:2, :2],
+                                         offset=[-(1 - scale1) * counts.shape[0] / 2, 0],
+                                         order=0,
+                                         )
+
+        scale2 = counts.shape[0] / counts.shape[1]
+        mask = ndimage.affine_transform(mask,
+                                         Affine2D().scale(scale2, 1).inverted().get_matrix()[:2, :2],
+                                         offset=[-(1 - scale2) * counts.shape[0] / 2, 0],
+                                         order=0,
+                                         )
+
+        # Convert mask to nxdata
+        mask = array_to_nxdata(mask, data_padded)
+
+        # Save mask for user interaction
+        self.symmetrization_mask = p.unpad(mask)
+
+        # Perform masking
+        wedge = mask*data_padded
+
+        # Save wedge for user interaction
+        self.wedge = p.unpad(wedge)
+
+        # Convert wedge back to array for further transformations
+        wedge = wedge[data.signal].nxdata
+
+        # Define signal to be transformed
+        counts = wedge
+
+        # Scale and skew counts
+        skew_angle_adj = 90 - self.skew_angle
+        counts_skew = ndimage.affine_transform(counts,
+                                               t.inverted().get_matrix()[:2, :2],
+                                               offset=[counts.shape[0] / 2
+                                                       * np.sin(skew_angle_adj * np.pi / 180), 0],
+                                               order=0,
+                                               )
+        scale1 = np.cos(skew_angle_adj * np.pi / 180)
+        wedge = ndimage.affine_transform(counts_skew,
+                                        Affine2D().scale(scale1, 1).get_matrix()[:2, :2],
+                                        offset=[(1 - scale1) * counts.shape[0] / 2, 0],
+                                        order=0,
+                                        )
+
+        scale2 = counts.shape[0] / counts.shape[1]
+        wedge = ndimage.affine_transform(wedge,
+                                        Affine2D().scale(scale2, 1).get_matrix()[:2, :2],
+                                        offset=[(1 - scale2) * counts.shape[0] / 2, 0],
+                                        order=0,
+                                        )
+
+        # Reconstruct full dataset from wedge
+        reconstructed = np.zeros(counts.shape)
+        for _ in range(0, rotations):
+            # The following are attempts to combine images with minimal overlapping pixels
+            reconstructed += wedge
+            # reconstructed = np.where(reconstructed == 0, reconstructed + wedge, reconstructed)
+
+            wedge = ndimage.rotate(wedge, 360 / rotations, reshape=False, order=0)
+
+        # self.rotated_only = NXdata(NXfield(reconstructed, name=data.signal),
+        #                            (q1, q2))
+
+        if mirror:
+            # The following are attempts to combine images with minimal overlapping pixels
+            reconstructed = np.where(reconstructed == 0,
+                                     reconstructed + np.flip(reconstructed, axis=mirror_axis),
+                                     reconstructed)
+            # reconstructed += np.flip(reconstructed, axis=0)
+
+        # self.rotated_and_mirrored = NXdata(NXfield(reconstructed, name=data.signal),
+        #                                    (q1, q2))
+
+        reconstructed = ndimage.affine_transform(reconstructed,
+                                                 Affine2D().scale(
+                                                     scale2, 1
+                                                 ).inverted().get_matrix()[:2, :2],
+                                                 offset=[-(1 - scale2) * counts.shape[
+                                                     0] / 2 / scale2, 0],
+                                                 order=0,
+                                                 )
+        reconstructed = ndimage.affine_transform(reconstructed,
+                                                 Affine2D().scale(
+                                                     scale1, 1
+                                                 ).inverted().get_matrix()[:2, :2],
+                                                 offset=[-(1 - scale1) * counts.shape[
+                                                     0] / 2 / scale1, 0],
+                                                 order=0,
+                                                 )
+        reconstructed = ndimage.affine_transform(reconstructed,
+                                                 t.get_matrix()[:2, :2],
+                                                 offset=[(-counts.shape[0] / 2
+                                                          * np.sin(skew_angle_adj * np.pi / 180)),
+                                                         0],
+                                                 order=0,
+                                                 )
+
+        reconstructed_unpadded = p.unpad(reconstructed)
+
+        # Fix any overlapping pixels by truncating counts to max
+        reconstructed_unpadded[reconstructed_unpadded > data[data.signal].nxdata.max()] \
+            = data[data.signal].nxdata.max()
+
+        symmetrized = NXdata(NXfield(reconstructed_unpadded, name=data.signal),
+                             (data[data.axes[0]],
+                              data[data.axes[1]]))
+
+        return symmetrized
+
+    def test(self, data, **kwargs):
+        """
+        Performs a test visualization of the symmetrization process to help assess
+         the effect of the parameters.
+
+        Parameters
+        ----------
+        data : ndarray
+            The input 2D dataset to be used for the test visualization.
+        **kwargs : dict
+            Additional keyword arguments to be passed to the plot_slice function.
+
+        Returns
+        -------
+        fig : Figure
+            The matplotlib Figure object that contains the test visualization plot.
+        axesarr : ndarray
+            The numpy array of Axes objects representing the subplots in the test
+             visualization.
+
+        Notes
+        -----
+        This method uses the `symmetrize_2d` method to perform the symmetrization on
+         the input data and visualize the process.
+
+        The test visualization plot includes the following subplots:
+        - Subplot 1: The original dataset.
+        - Subplot 2: The symmetrization mask.
+        - Subplot 3: The wedge slice used for reconstruction of the full symmetrized dataset.
+        - Subplot 4: The symmetrized dataset.
+
+        Example usage:
+        ```
+        s = Symmetrizer2D()
+        s.set_parameters(theta_min, theta_max, skew_angle, mirror)
+        s.test(data)
+        ```
+        """
+        s = self
+        symm_test = s.symmetrize_2d(data)
+        fig, axesarr = plt.subplots(2, 2, figsize=(10, 8))
+        axes = axesarr.reshape(-1)
+        plot_slice(data, skew_angle=s.skew_angle, ax=axes[0], title='data', **kwargs)
+        plot_slice(s.symmetrization_mask, skew_angle=s.skew_angle, ax=axes[1], title='mask')
+        plot_slice(s.wedge, skew_angle=s.skew_angle, ax=axes[2], title='wedge', **kwargs)
+        plot_slice(symm_test, skew_angle=s.skew_angle, ax=axes[3], title='symmetrized', **kwargs)
+        plt.subplots_adjust(wspace=0.4)
+        plt.show()
+        return fig, axesarr
+
+
+data = load_transform(r'K:\wilson-3947-a\nxrefine\LaCd3P3\MLA1\LaCd3P3_300.nxs')[:,:,7.9:8.1]
+data = rotate_data(data, lattice_angle=60, rotation_angle=120, rotation_axis=2, printout=True)
+
+# from nxs_analysis_tools.pairdistribution import Symmetrizer2D
+s2d = Symmetrizer2D(theta_min=-90, theta_max=-90+60, mirror=True, lattice_angle=60, mirror_axis=1)
+s2d.test(data[:,:,8.0], vmin=0, vmax=100, xlim=(-3,2))

nxs_analysis_tools-0.0.43/tests/test_plot_slice_with_ndarray.py

@@ -0,0 +1,277 @@
+from nxs_analysis_tools import *
+from nxs_analysis_tools.datareduction import load_transform
+
+import os
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.transforms import Affine2D
+from matplotlib.markers import MarkerStyle
+from matplotlib.ticker import MultipleLocator
+from matplotlib import colors
+from matplotlib import patches
+from IPython.display import display, Markdown
+from nexusformat.nexus import NXfield, NXdata, nxload, NeXusError, NXroot, NXentry, nxsave
+from scipy import ndimage
+
+
+# def plot_slice(data, X=None, Y=None, transpose=False, vmin=None, vmax=None,
+#                skew_angle=90, ax=None, xlim=None, ylim=None,
+#                xticks=None, yticks=None, cbar=True, logscale=False,
+#                symlogscale=False, cmap='viridis', linthresh=1,
+#                title=None, mdheading=None, cbartitle=None,
+#                **kwargs):
+#     """
+#     Plot a 2D slice of the provided dataset, with optional transformations
+#     and customizations.
+#
+#     Parameters
+#     ----------
+#     data : :class:`nexusformat.nexus.NXdata` or ndarray
+#         The dataset to plot. Can be an `NXdata` object or a `numpy` array.
+#
+#     X : NXfield, optional
+#         The X axis values. If None, a default range from 0 to the number of
+#          columns in `data` is used.
+#
+#     Y : NXfield, optional
+#         The Y axis values. If None, a default range from 0 to the number of
+#          rows in `data` is used.
+#
+#     transpose : bool, optional
+#         If True, transpose the dataset and its axes before plotting.
+#         Default is False.
+#
+#     vmin : float, optional
+#         The minimum value for the color scale. If not provided, the minimum
+#          value of the dataset is used.
+#
+#     vmax : float, optional
+#         The maximum value for the color scale. If not provided, the maximum
+#          value of the dataset is used.
+#
+#     skew_angle : float, optional
+#         The angle in degrees to shear the plot. Default is 90 degrees (no skew).
+#
+#     ax : matplotlib.axes.Axes, optional
+#         The `matplotlib` axis to plot on. If None, a new figure and axis will
+#          be created.
+#
+#     xlim : tuple, optional
+#         The limits for the x-axis. If None, the limits are set automatically
+#          based on the data.
+#
+#     ylim : tuple, optional
+#         The limits for the y-axis. If None, the limits are set automatically
+#          based on the data.
+#
+#     xticks : float or list of float, optional
+#         The major tick interval or specific tick locations for the x-axis.
+#          Default is to use a minor tick interval of 1.
+#
+#     yticks : float or list of float, optional
+#         The major tick interval or specific tick locations for the y-axis.
+#         Default is to use a minor tick interval of 1.
+#
+#     cbar : bool, optional
+#         Whether to include a colorbar. Default is True.
+#
+#     logscale : bool, optional
+#         Whether to use a logarithmic color scale. Default is False.
+#
+#     symlogscale : bool, optional
+#         Whether to use a symmetrical logarithmic color scale. Default is False.
+#
+#     cmap : str or Colormap, optional
+#         The colormap to use for the plot. Default is 'viridis'.
+#
+#     linthresh : float, optional
+#         The linear threshold for symmetrical logarithmic scaling. Default is 1.
+#
+#     title : str, optional
+#         The title for the plot. If None, no title is set.
+#
+#     mdheading : str, optional
+#         A Markdown heading to display above the plot. If 'None' or not provided,
+#          no heading is displayed.
+#
+#     cbartitle : str, optional
+#         The title for the colorbar. If None, the colorbar label will be set to
+#          the name of the signal.
+#
+#     **kwargs
+#         Additional keyword arguments passed to `pcolormesh`.
+#
+#     Returns
+#     -------
+#     p : :class:`matplotlib.collections.QuadMesh`
+#         The `matplotlib` QuadMesh object representing the plotted data.
+#     """
+#     if isinstance(data, np.ndarray):
+#         if X is None:
+#             X = NXfield(np.linspace(0, data.shape[1], data.shape[1]), name='x')
+#         if Y is None:
+#             Y = NXfield(np.linspace(0, data.shape[0], data.shape[0]), name='y')
+#         if transpose:
+#             X, Y = Y, X
+#             data = data.transpose()
+#         data = NXdata(NXfield(data, name='value'), (X, Y))
+#         data_arr = data
+#     elif isinstance(data, (NXdata, NXfield)):
+#         if X is None:
+#             X = data[data.axes[0]]
+#         if Y is None:
+#             Y = data[data.axes[1]]
+#         if transpose:
+#             X, Y = Y, X
+#             data = data.transpose()
+#         data_arr = data[data.signal].nxdata.transpose()
+#     else:
+#         raise TypeError(f"Unexpected data type: {type(data)}. "
+#                         f"Supported types are np.ndarray and NXdata.")
+#
+#     # Display Markdown heading
+#     if mdheading is None:
+#         pass
+#     elif mdheading == "None":
+#         display(Markdown('### Figure'))
+#     else:
+#         display(Markdown('### Figure - ' + mdheading))
+#
+#     # Inherit axes if user provides some
+#     if ax is not None:
+#         fig = ax.get_figure()
+#     # Otherwise set up some default axes
+#     else:
+#         fig = plt.figure()
+#         ax = fig.add_axes([0, 0, 1, 1])
+#
+#     # If limits not provided, use extrema
+#     if vmin is None:
+#         vmin = data_arr.min()
+#     if vmax is None:
+#         vmax = data_arr.max()
+#
+#     # Set norm (linear scale, logscale, or symlogscale)
+#     norm = colors.Normalize(vmin=vmin, vmax=vmax)  # Default: linear scale
+#
+#     if symlogscale:
+#         norm = colors.SymLogNorm(linthresh=linthresh, vmin=-1 * vmax, vmax=vmax)
+#     elif logscale:
+#         norm = colors.LogNorm(vmin=vmin, vmax=vmax)
+#
+#     # Plot data
+#     p = ax.pcolormesh(X.nxdata, Y.nxdata, data_arr, shading='auto', norm=norm, cmap=cmap, **kwargs)
+#
+#     ## Transform data to new coordinate system if necessary
+#     # Correct skew angle
+#     skew_angle_adj = 90 - skew_angle
+#     # Create blank 2D affine transformation
+#     t = Affine2D()
+#     # Scale y-axis to preserve norm while shearing
+#     t += Affine2D().scale(1, np.cos(skew_angle_adj * np.pi / 180))
+#     # Shear along x-axis
+#     t += Affine2D().skew_deg(skew_angle_adj, 0)
+#     # Return to original y-axis scaling
+#     t += Affine2D().scale(1, np.cos(skew_angle_adj * np.pi / 180)).inverted()
+#     ## Correct for x-displacement after shearing
+#     # If ylims provided, use those
+#     if ylim is not None:
+#         # Set ylims
+#         ax.set(ylim=ylim)
+#         ymin, ymax = ylim
+#     # Else, use current ylims
+#     else:
+#         ymin, ymax = ax.get_ylim()
+#     # Use ylims to calculate translation (necessary to display axes in correct position)
+#     p.set_transform(t
+#                     + Affine2D().translate(-ymin * np.sin(skew_angle_adj * np.pi / 180), 0)
+#                     + ax.transData)
+#
+#     # Set x limits
+#     if xlim is not None:
+#         xmin, xmax = xlim
+#     else:
+#         xmin, xmax = ax.get_xlim()
+#     if skew_angle <= 90:
+#         ax.set(xlim=(xmin, xmax + (ymax - ymin) / np.tan((90 - skew_angle_adj) * np.pi / 180)))
+#     else:
+#         ax.set(xlim=(xmin - (ymax - ymin) / np.tan((skew_angle_adj - 90) * np.pi / 180), xmax))
+#
+#     # Correct aspect ratio for the x/y axes after transformation
+#     ax.set(aspect=np.cos(skew_angle_adj * np.pi / 180))
+#
+#     # Add tick marks all around
+#     ax.tick_params(direction='in', top=True, right=True, which='both')
+#
+#     # Set tick locations
+#     if xticks is None:
+#         # Add default minor ticks
+#         ax.xaxis.set_minor_locator(MultipleLocator(1))
+#     else:
+#         # Otherwise use user provided values
+#         ax.xaxis.set_major_locator(MultipleLocator(xticks))
+#         ax.xaxis.set_minor_locator(MultipleLocator(1))
+#     if yticks is None:
+#         # Add default minor ticks
+#         ax.yaxis.set_minor_locator(MultipleLocator(1))
+#     else:
+#         # Otherwise use user provided values
+#         ax.yaxis.set_major_locator(MultipleLocator(yticks))
+#         ax.yaxis.set_minor_locator(MultipleLocator(1))
+#
+#     # Apply transform to tick marks
+#     for i in range(0, len(ax.xaxis.get_ticklines())):
+#         # Tick marker
+#         m = MarkerStyle(3)
+#         line = ax.xaxis.get_majorticklines()[i]
+#         if i % 2:
+#             # Top ticks (translation here makes their direction="in")
+#             m._transform.set(Affine2D().translate(0, -1) + Affine2D().skew_deg(skew_angle_adj, 0))
+#             # This first method shifts the top ticks horizontally to match the skew angle.
+#             # This does not look good in all cases.
+#             # line.set_transform(Affine2D().translate((ymax-ymin)*np.sin(skew_angle*np.pi/180),0) +
+#             #     line.get_transform())
+#             # This second method skews the tick marks in place and
+#             # can sometimes lead to them being misaligned.
+#             line.set_transform(line.get_transform())  # This does nothing
+#         else:
+#             # Bottom ticks
+#             m._transform.set(Affine2D().skew_deg(skew_angle_adj, 0))
+#
+#         line.set_marker(m)
+#
+#     for i in range(0, len(ax.xaxis.get_minorticklines())):
+#         m = MarkerStyle(2)
+#         line = ax.xaxis.get_minorticklines()[i]
+#         if i % 2:
+#             m._transform.set(Affine2D().translate(0, -1) + Affine2D().skew_deg(skew_angle_adj, 0))
+#         else:
+#             m._transform.set(Affine2D().skew_deg(skew_angle_adj, 0))
+#
+#         line.set_marker(m)
+#
+#     if cbar:
+#         colorbar = fig.colorbar(p)
+#         if cbartitle is None:
+#             colorbar.set_label(data.signal)
+#
+#     ax.set(
+#         xlabel=X.nxname,
+#         ylabel=Y.nxname,
+#     )
+#
+#     if title is not None:
+#         ax.set_title(title)
+#
+#     # Return the quadmesh object
+#     return p
+
+
+data = load_transform(r'K:\wilson-3947-a\nxrefine\LaCd3P3\MLA1\LaCd3P3_300.nxs')
+
+# print(data.tree)
+fig = plt.figure(figsize=(5,3))
+ax = fig.add_axes([0,0,1,1])
+plot_slice(data[-1.0:1.0, -0.5:0.5, 0.0].counts.nxdata, vmin=0, vmax=100, cbar=False, ax=ax)
+fig.tight_layout()
+plt.show()