nxs-analysis-tools 0.1.10__py3-none-any.whl → 0.1.11__py3-none-any.whl

_meta/__init__.py

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

nxs_analysis_tools/__init__.py

@@ -9,7 +9,7 @@ from .chess import TempDependence
 
 # What to import when running "from nxs_analysis_tools import *"
 __all__ = ['load_data', 'load_transform', 'plot_slice', 'Scissors',
-           'reciprocal_lattice_params', 'rotate_data', 'rotate_data_2D',
+           'reciprocal_lattice_params', 'rotate_data',
            'convert_to_inverse_angstroms', 'array_to_nxdata', 'Padder',
            'rebin_nxdata', 'rebin_3d', 'rebin_1d', 'TempDependence',
            'animate_slice_temp', 'animate_slice_axis']

nxs_analysis_tools/datareduction.py

@@ -15,12 +15,14 @@ from matplotlib import colors
 from matplotlib import patches
 from IPython.display import display, Markdown, HTML, Image
 from nexusformat.nexus import NXfield, NXdata, nxload, NeXusError, NXroot, NXentry, nxsave
-from scipy import ndimage
+from scipy.ndimage import rotate
+
+from .lineartransformations import ShearTransformer
 
 
 # Specify items on which users are allowed to perform standalone imports
 __all__ = ['load_data', 'load_transform', 'plot_slice', 'Scissors',
-           'reciprocal_lattice_params', 'rotate_data', 'rotate_data_2D',
+           'reciprocal_lattice_params', 'rotate_data',
            'convert_to_inverse_angstroms', 'array_to_nxdata', 'Padder',
            'rebin_nxdata', 'rebin_3d', 'rebin_1d', 'animate_slice_temp',
            'animate_slice_axis']
@@ -503,17 +505,8 @@ def plot_slice(data, X=None, Y=None, sum_axis=None, transpose=False, vmin=None,
     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
+    t = ShearTransformer(skew_angle)
+
     # If ylims provided, use those
     if ylim is not None:
         # Set ylims
@@ -523,8 +516,8 @@ def plot_slice(data, X=None, Y=None, sum_axis=None, transpose=False, vmin=None,
     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)
+    p.set_transform(t.t
+                    + Affine2D().translate(-ymin * np.sin(t.shear_angle * np.pi / 180), 0)
                     + ax.transData)
 
     # Set x limits
@@ -533,12 +526,12 @@ def plot_slice(data, X=None, Y=None, sum_axis=None, transpose=False, vmin=None,
     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)))
+        ax.set(xlim=(xmin, xmax + (ymax - ymin) / np.tan((90 - t.shear_angle) * np.pi / 180)))
     else:
-        ax.set(xlim=(xmin - (ymax - ymin) / np.tan((skew_angle_adj - 90) * np.pi / 180), xmax))
+        ax.set(xlim=(xmin - (ymax - ymin) / np.tan((t.shear_angle - 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))
+    ax.set(aspect=np.cos(t.shear_angle * np.pi / 180))
 
 
     # Automatically set tick locations, only if NXdata or if X,Y axes are provided for an array
@@ -570,7 +563,7 @@ def plot_slice(data, X=None, Y=None, sum_axis=None, transpose=False, vmin=None,
         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))
+            m._transform.set(Affine2D().translate(0, -1) + Affine2D().skew_deg(t.shear_angle, 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) +
@@ -580,7 +573,7 @@ def plot_slice(data, X=None, Y=None, sum_axis=None, transpose=False, vmin=None,
             line.set_transform(line.get_transform())  # This does nothing
         else:
             # Bottom ticks
-            m._transform.set(Affine2D().skew_deg(skew_angle_adj, 0))
+            m._transform.set(Affine2D().skew_deg(t.shear_angle, 0))
 
         line.set_marker(m)
 
@@ -588,9 +581,9 @@ def plot_slice(data, X=None, Y=None, sum_axis=None, transpose=False, vmin=None,
         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))
+            m._transform.set(Affine2D().translate(0, -1) + Affine2D().skew_deg(t.shear_angle, 0))
         else:
-            m._transform.set(Affine2D().skew_deg(skew_angle_adj, 0))
+            m._transform.set(Affine2D().skew_deg(t.shear_angle, 0))
 
         line.set_marker(m)
 
@@ -1234,9 +1227,9 @@ def convert_to_inverse_angstroms(data, lattice_params):
     return NXdata(new_data, (a_star, b_star, c_star))
 
 
-def rotate_data(data, lattice_angle, rotation_angle, rotation_axis, printout=False):
+def rotate_data(data, lattice_angle, rotation_angle, rotation_axis=None, printout=False):
     """
-    Rotates 3D data around a specified axis.
+    Rotates slices of data around the normal axis.
 
     Parameters
     ----------
@@ -1246,13 +1239,12 @@ def rotate_data(data, lattice_angle, rotation_angle, rotation_axis, printout=Fal
         Angle between the two in-plane lattice axes in degrees.
     rotation_angle : float
         Angle of rotation in degrees.
-    rotation_axis : int
-        Axis of rotation (0, 1, or 2).
+    rotation_axis : int, optional
+        Axis of rotation (0, 1, or 2). Only necessary when data is three-dimensional.
     printout : bool, optional
-        Enables printout of rotation progress. If set to True, information
-        about each rotation slice will be printed to the console, indicating
-        the axis being rotated and the corresponding coordinate value.
-        Defaults to False.
+        Enables printout of rotation progress for three-dimensional data. If set to True,
+        information about each rotation slice will be printed to the console, indicating
+        the axis being rotated and the corresponding coordinate value. Defaults to False.
 
 
     Returns
@@ -1260,36 +1252,36 @@ def rotate_data(data, lattice_angle, rotation_angle, rotation_axis, printout=Fal
     rotated_data : :class:`nexusformat.nexus.NXdata`
         Rotated data as an NXdata object.
     """
+
+    if data.ndim == 3 and rotation_axis is None:
+        raise ValueError('rotation_axis must be specified for three-dimensional datasets.')
+    
+    if not((data.ndim == 2) or (data.ndim == 3)):
+        raise ValueError('Data must be 2 or 3 dimensional.')
+    
     # Define output array
     output_array = np.zeros(data.nxsignal.shape)
 
-    # Define shear 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()
-
     # Iterate over all layers perpendicular to the rotation axis
-    for i in range(len(data[data.axes[rotation_axis]])):
-        # Print progress
-        if printout:
-            print(f'\rRotating {data.axes[rotation_axis]}'
-                  f'={data[data.axes[rotation_axis]][i]}...                      ',
-                  end='', flush=True)
-
-        # Identify current slice
-        if rotation_axis == 0:
-            sliced_data = data[i, :, :]
-        elif rotation_axis == 1:
-            sliced_data = data[:, i, :]
-        elif rotation_axis == 2:
-            sliced_data = data[:, :, i]
-        else:
-            sliced_data = None
+    if data.ndim == 3:
+        num_slices = len(data.nxaxes[rotation_axis])
+    elif data.ndim == 2:
+        num_slices = 1
+    
+    for i in range(num_slices):
+        
+        if data.ndim == 3:
+            # Print progress
+            if printout:
+                print(f'\rRotating {data.axes[rotation_axis]}'
+                f'={data.nxaxes[rotation_axis][i]}...                      ',
+                end='', flush=True)
+            index = [slice(None)] * 3
+            index[rotation_axis] = i
+            sliced_data = data[tuple(index)]
+            
+        elif data.ndim == 2:
+            sliced_data = data
 
         # Add padding to avoid data cutoff during rotation
         p = Padder(sliced_data)
@@ -1297,76 +1289,38 @@ def rotate_data(data, lattice_angle, rotation_angle, rotation_axis, printout=Fal
         counts = p.pad(padding)
         counts = p.padded[p.padded.signal]
 
-        # Perform shear operation
-        counts_skewed = 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,
-                                                 )
-        # Scale data based on skew angle
-        scale1 = np.cos(skew_angle_adj * np.pi / 180)
-        counts_scaled1 = ndimage.affine_transform(counts_skewed,
-                                                  Affine2D().scale(scale1, 1).get_matrix()[:2, :2],
-                                                  offset=[(1 - scale1) * counts.shape[0] / 2, 0],
-                                                  order=0,
-                                                  )
-        # Scale data based on ratio of array dimensions
-        scale2 = 1 # counts.shape[0] / counts.shape[1]
-        counts_scaled2 = ndimage.affine_transform(counts_scaled1,
-                                                  Affine2D().scale(scale2, 1).get_matrix()[:2, :2],
-                                                  offset=[(1 - scale2) * counts.shape[0] / 2, 0],
-                                                  order=0,
-                                                  )
+        # Skew data to match lattice angle
+        t = ShearTransformer(lattice_angle)
+        counts = t.apply(counts)
 
         # Perform rotation
-        counts_rotated = ndimage.rotate(counts_scaled2, rotation_angle, reshape=False, order=0)
-
-        # Undo scaling 2
-        counts_unscaled2 = ndimage.affine_transform(counts_rotated,
-                                                    Affine2D().scale(
-                                                        scale2, 1
-                                                    ).inverted().get_matrix()[:2, :2],
-                                                    offset=[-(1 - scale2) * counts.shape[
-                                                        0] / 2 / scale2, 0],
-                                                    order=0,
-                                                    )
-        # Undo scaling 1
-        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,
-                                                    )
-        # Undo shear operation
-        counts_unskewed = 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,
-                                                   )
+        counts = rotate(counts, rotation_angle, reshape=False, order=0)
+
+        # Undo skew transformation
+        counts = t.invert(counts)
+        
         # Remove padding
-        counts_unpadded = p.unpad(counts_unskewed)
-
-        # Write current slice
-        if rotation_axis == 0:
-            output_array[i, :, :] = counts_unpadded
-        elif rotation_axis == 1:
-            output_array[:, i, :] = counts_unpadded
-        elif rotation_axis == 2:
-            output_array[:, :, i] = counts_unpadded
-    print('\nDone.')
+        counts = p.unpad(counts)
+
+        # Write slice
+        if data.ndim == 3:
+            index = [slice(None)] * 3
+            index[rotation_axis] = i
+            output_array[tuple(index)] = counts
+        elif data.ndim == 2:
+            output_array = counts
+
+    print('\nRotation completed.')
+
     return NXdata(NXfield(output_array, name=p.padded.signal),
-                  (data.nxaxes[0], data.nxaxes[1], data.nxaxes[2]))
+                  ([axis for axis in data.nxaxes]))
+
 
 
 def rotate_data_2D(data, lattice_angle, rotation_angle):
     """
+    DEPRECATED: Use `rotate_data` instead.
+
     Rotates 2D data.
 
     Parameters
@@ -1378,86 +1332,20 @@ def rotate_data_2D(data, lattice_angle, rotation_angle):
     rotation_angle : float
         Angle of rotation in degrees.
 
-
     Returns
     -------
     rotated_data : :class:`nexusformat.nexus.NXdata`
         Rotated data as an NXdata object.
     """
+    warnings.warn(
+        "rotate_data_2D is deprecated and will be removed in a future release. "
+        "Use rotate_data instead.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
 
-    # 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()
-
-    # Add padding to avoid data cutoff during rotation
-    p = Padder(data)
-    padding = tuple(len(data[axis]) for axis in data.axes)
-    counts = p.pad(padding)
-    counts = p.padded[p.padded.signal]
-
-    # Perform shear operation
-    counts_skewed = 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,
-                                             )
-    # Scale data based on skew angle
-    scale1 = np.cos(skew_angle_adj * np.pi / 180)
-    counts_scaled1 = ndimage.affine_transform(counts_skewed,
-                                              Affine2D().scale(scale1, 1).get_matrix()[:2, :2],
-                                              offset=[(1 - scale1) * counts.shape[0] / 2, 0],
-                                              order=0,
-                                              )
-    # Scale data based on ratio of array dimensions
-    scale2 = 1 # counts.shape[0] / counts.shape[1]
-    counts_scaled2 = ndimage.affine_transform(counts_scaled1,
-                                              Affine2D().scale(scale2, 1).get_matrix()[:2, :2],
-                                              offset=[(1 - scale2) * counts.shape[0] / 2, 0],
-                                              order=0,
-                                              )
-    # Perform rotation
-    counts_rotated = ndimage.rotate(counts_scaled2, rotation_angle, reshape=False, order=0)
-
-    # Undo scaling 2
-    counts_unscaled2 = ndimage.affine_transform(counts_rotated,
-                                                Affine2D().scale(
-                                                    scale2, 1
-                                                ).inverted().get_matrix()[:2, :2],
-                                                offset=[-(1 - scale2) * counts.shape[
-                                                    0] / 2 / scale2, 0],
-                                                order=0,
-                                                )
-    # Undo scaling 1
-    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,
-                                                )
-    # Undo shear operation
-    counts_unskewed = 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,
-                                               )
-    # Remove padding
-    counts_unpadded = p.unpad(counts_unskewed)
-
-    print('\nDone.')
-    return NXdata(NXfield(counts_unpadded, name=p.padded.signal),
-                  (data.nxaxes[0], data.nxaxes[1]))
+    # Call the new general function
+    return rotate_data(data, lattice_angle=lattice_angle, rotation_angle=rotation_angle)
 
 
 class Padder:

nxs_analysis_tools/lineartransformations.py

@@ -0,0 +1,51 @@
+import numpy as np
+from scipy.ndimage import affine_transform
+from matplotlib.transforms import Affine2D
+
+def shear_transformation(angle):
+    # Define shear transformation
+    t = Affine2D()
+
+    # Scale y-axis to preserve norm while shearing
+    t += Affine2D().scale(1, np.cos(angle * np.pi / 180))
+
+    # Shear along x-axis
+    t += Affine2D().skew_deg(angle, 0)
+
+    # Return to original y-axis scaling
+    t += Affine2D().scale(1, np.cos(angle * np.pi / 180)).inverted()
+
+    return t
+
+class ShearTransformer():
+    def __init__(self, angle):
+        self.shear_angle = 90 - angle
+        self.t = shear_transformation(self.shear_angle)
+        self.scale = np.cos(self.shear_angle * np.pi / 180)
+
+    def apply(self, image):
+        # Perform shear operation
+        image_skewed = affine_transform(image, self.t.inverted().get_matrix()[:2, :2], 
+                                        offset=[image.shape[0] / 2 * np.sin(self.shear_angle * np.pi / 180), 0], 
+                                        order=0
+                                        )
+        # Scale data based on skew angle
+        image_scaled = affine_transform(image_skewed, Affine2D().scale(self.scale, 1).get_matrix()[:2, :2],
+                                        offset=[(1 - self.scale) * image.shape[0] / 2, 0],
+                                        order=0
+                                        )
+        return image_scaled
+
+    def invert(self, image):
+
+        # Undo scaling
+        image_unscaled = affine_transform(image, Affine2D().scale(self.scale, 1).inverted().get_matrix()[:2, :2],
+                                          offset=[-(1 - self.scale) * image.shape[0] / 2 / self.scale, 0],
+                                          order=0
+                                          )
+        # Undo shear operation
+        image_unskewed = affine_transform(image_unscaled, self.t.get_matrix()[:2, :2],
+                                          offset=[(-image.shape[0] / 2 * np.sin(self.shear_angle * np.pi / 180)), 0],
+                                          order=0
+                                          )
+        return image_unskewed

nxs_analysis_tools/pairdistribution.py

@@ -5,7 +5,7 @@ import time
 import os
 import gc
 import math
-from scipy import ndimage
+from scipy.ndimage import rotate, affine_transform
 import scipy
 import matplotlib.pyplot as plt
 from matplotlib.transforms import Affine2D
@@ -15,6 +15,7 @@ from astropy.convolution import Kernel, convolve_fft
 import pyfftw
 from .datareduction import plot_slice, reciprocal_lattice_params, Padder, \
     array_to_nxdata
+from .lineartransformations import ShearTransformer
 
 __all__ = ['Symmetrizer2D', 'Symmetrizer3D', 'Puncher', 'Interpolator',
            'fourier_transform_nxdata', 'Gaussian3DKernel', 'DeltaPDF',
@@ -37,9 +38,6 @@ class Symmetrizer2D:
     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.
@@ -93,7 +91,6 @@ class Symmetrizer2D:
         """
         self.mirror_axis = None
         self.symmetrized = None
-        self.wedges = None
         self.rotations = None
         self.transform = None
         self.mirror = None
@@ -129,16 +126,8 @@ class Symmetrizer2D:
         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
+        self.transformer = ShearTransformer(lattice_angle)
+        self.transform = self.transformer.t
 
         # Calculate number of rotations needed to reconstruct the dataset
         if mirror:
@@ -172,7 +161,6 @@ class Symmetrizer2D:
         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
@@ -191,37 +179,9 @@ class Symmetrizer2D:
         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
-
-        scale2 = 1 # q1.max()/q2.max() # TODO: Need to double check this
-        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)
+        # Bring mask from skewed basis to data array basis
+        mask = array_to_nxdata(self.transformer.invert(symmetrization_mask), data_padded)
+
 
         # Save mask for user interaction
         self.symmetrization_mask = p.unpad(mask)
@@ -235,84 +195,49 @@ class Symmetrizer2D:
         # Convert wedge back to array for further transformations
         wedge = wedge[data.signal].nxdata
 
-        # Define signal to be transformed
-        counts = wedge
+        # Bring wedge from data array basis to skewed basis for reconstruction
+        wedge = self.transformer.apply(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],
+        # Apply additional scaling before rotations
+        scale = wedge.shape[0]/wedge.shape[1]
+        wedge = affine_transform(wedge,
+                                         Affine2D().scale(scale, 1).get_matrix()[:2, :2],
+                                         offset=[(1 - scale) * wedge.shape[0] / 2, 0],
                                          order=0,
                                          )
 
         # Reconstruct full dataset from wedge
-        reconstructed = np.zeros(counts.shape)
+        reconstructed = np.zeros(wedge.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))
+            wedge = rotate(wedge, 360 / rotations, reshape=False, order=0)
 
         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,
+        # Undo scaling transformation
+        reconstructed = affine_transform(reconstructed,
                                                  Affine2D().scale(
-                                                     scale1, 1
+                                                     scale, 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],
+                                                 offset=[-(1 - scale) * wedge.shape[
+                                                     0] / 2 / scale, 0],
                                                  order=0,
                                                  )
+        
+        reconstructed = self.transformer.invert(reconstructed)
 
-        reconstructed_unpadded = p.unpad(reconstructed)
+        reconstructed = p.unpad(reconstructed)
 
         # Fix any overlapping pixels by truncating counts to max
-        reconstructed_unpadded[reconstructed_unpadded > data[data.signal].nxdata.max()] \
+        reconstructed[reconstructed > data[data.signal].nxdata.max()] \
             = data[data.signal].nxdata.max()
 
-        symmetrized = NXdata(NXfield(reconstructed_unpadded, name=data.signal),
+        symmetrized = NXdata(NXfield(reconstructed, name=data.signal),
                              (data[data.axes[0]],
                               data[data.axes[1]]))
 

{nxs_analysis_tools-0.1.10.dist-info → nxs_analysis_tools-0.1.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nxs-analysis-tools
-Version: 0.1.10
+Version: 0.1.11
 Summary: Reduce and transform nexus format (.nxs) scattering data.
 Author-email: "Steven J. Gomez Alvarado" <stevenjgomez@ucsb.edu>
 License-Expression: MIT
@@ -14,11 +14,10 @@ Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Science/Research
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Topic :: Scientific/Engineering :: Image Processing
 Classifier: Topic :: Scientific/Engineering
-Requires-Python: >=3.7
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: matplotlib>=3.10.0
@@ -57,7 +56,7 @@ Dynamic: license-file
 
 ## Overview
 
-nxs-analysis-tools provides a suite of tools for slicing (2D), cutting (1D), and transforming (_e.g._, symmetrization, interpolation, delta-PDF) nexus format (.nxs) scattering data.
+nxs-analysis-tools provides a suite of tools for performing slices (2D), cuts (1D), and transformations (_e.g._, symmetrization, interpolation, delta-PDF) on nexus format (.nxs) scattering data.
 
 View the documentation [here](https://nxs-analysis-tools.readthedocs.io/en/stable/).
 

nxs_analysis_tools-0.1.11.dist-info/RECORD

@@ -0,0 +1,13 @@
+_meta/__init__.py,sha256=O-Csyugy_6ZYl7nR_6FgU1-D1-64dSBtRSRzDF1aiq4,347
+nxs_analysis_tools/__init__.py,sha256=Gs61l3FrgmhVRv77oqz58W6vmxFhNARfcioYA0FZbqU,604
+nxs_analysis_tools/chess.py,sha256=_gFkLZnoYSCOKPZHm0b1CileCveHJpOszLufeg4QKFg,34086
+nxs_analysis_tools/datareduction.py,sha256=Ky8Q5izEXmOUj3OKOlvZ8A-YeKRdAOD22luggiZtLoY,52181
+nxs_analysis_tools/datasets.py,sha256=KnJBdxuCV7n2Q6MOM0Cv5-Dq6x1hvrrEXIc3Jn7Xsos,3497
+nxs_analysis_tools/fitting.py,sha256=kRMhjObetGqmZ5-Jk1OHKGrXW4qI4D37s8VeC2ygJV8,10275
+nxs_analysis_tools/lineartransformations.py,sha256=-Ce2RzcRcUgg8_kM1o0kO9lOpS_nC2AxRyZTUA1tAe8,2144
+nxs_analysis_tools/pairdistribution.py,sha256=u4WyOfK_nBX78QJr7QO8QWGKV9bH_sBWtdzVaqs2wWo,61238
+nxs_analysis_tools-0.1.11.dist-info/licenses/LICENSE,sha256=bE6FnYixueAGAnEfUuumbkSeMgdBguAAkheVgjv47Jo,1086
+nxs_analysis_tools-0.1.11.dist-info/METADATA,sha256=sdphx8gVih0ZeQOPEHw4_R-sS6D6XlQNZWc6JOxAB5g,3493
+nxs_analysis_tools-0.1.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nxs_analysis_tools-0.1.11.dist-info/top_level.txt,sha256=8U000GNPzo6T6pOMjRdgOSO5heMzLMGjkxa1CDtyMHM,25
+nxs_analysis_tools-0.1.11.dist-info/RECORD,,

nxs_analysis_tools-0.1.10.dist-info/RECORD

@@ -1,12 +0,0 @@
-_meta/__init__.py,sha256=PpRK3SY3jA8q8ioGFF4DEjAaUUb35J7AB3hwAZ2iiMw,347
-nxs_analysis_tools/__init__.py,sha256=lutfLk7oBaMpKq2G2hf6V59SNqAhzSUyKLXGwTI_iDg,622
-nxs_analysis_tools/chess.py,sha256=_gFkLZnoYSCOKPZHm0b1CileCveHJpOszLufeg4QKFg,34086
-nxs_analysis_tools/datareduction.py,sha256=BexXztaNQ4yNJko_MBQy-eVF2J5C7BTANehvqkwRu_E,59314
-nxs_analysis_tools/datasets.py,sha256=KnJBdxuCV7n2Q6MOM0Cv5-Dq6x1hvrrEXIc3Jn7Xsos,3497
-nxs_analysis_tools/fitting.py,sha256=kRMhjObetGqmZ5-Jk1OHKGrXW4qI4D37s8VeC2ygJV8,10275
-nxs_analysis_tools/pairdistribution.py,sha256=bY80N9y50yPjVKPzWfcPSAtiA8UDPDNCblVXGOw2Lzo,65605
-nxs_analysis_tools-0.1.10.dist-info/licenses/LICENSE,sha256=bE6FnYixueAGAnEfUuumbkSeMgdBguAAkheVgjv47Jo,1086
-nxs_analysis_tools-0.1.10.dist-info/METADATA,sha256=f9qlf_zWAWqRPXqw6D-pJRiFcWV7xiS5vgrGXGJLE98,3529
-nxs_analysis_tools-0.1.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nxs_analysis_tools-0.1.10.dist-info/top_level.txt,sha256=8U000GNPzo6T6pOMjRdgOSO5heMzLMGjkxa1CDtyMHM,25
-nxs_analysis_tools-0.1.10.dist-info/RECORD,,