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

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: nxs-analysis-tools
-Version: 0.0.43
+Version: 0.0.44
 Summary: Reduce and transform nexus format (.nxs) scattering data.
 Author-email: "Steven J. Gomez Alvarado" <stevenjgomez@ucsb.edu>
 License: MIT License
@@ -66,6 +66,7 @@ Requires-Dist: sphinx-autobuild>=2021.3.14; extra == "dev"
 Requires-Dist: sphinx-copybutton>=0.5.0; extra == "dev"
 Requires-Dist: sphinxext-opengraph>=0.6.3; extra == "dev"
 Requires-Dist: twine>=4.0.1; extra == "dev"
+Dynamic: license-file
 
 # nxs-analysis-tools
 

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

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

{nxs_analysis_tools-0.0.43 → nxs_analysis_tools-0.0.44}/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.43'
+__version__ = '0.0.44'
 __repo_url__ = 'https://github.com/stevenjgomez/nxs_analysis_tools'

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

@@ -50,6 +50,8 @@ class TempDependence:
     -------
     set_temperatures(temperatures):
         Set the list of temperatures for the datasets.
+    find_temperatures():
+        Set the list of temperatures by automatically scanning the sample directory.
     set_sample_directory(path):
         Set the directory path where the datasets are located.
     initialize():
@@ -105,7 +107,7 @@ class TempDependence:
         Initialize the TempDependence class with default values.
         """
 
-        self.sample_directory = ''
+        self.sample_directory = None
         self.xlabel = ''
         self.datasets = {}
         self.temperatures = []
@@ -127,6 +129,31 @@ class TempDependence:
         """
         self.temperatures = temperatures
 
+    def find_temperatures(self):
+        """
+        Set the list of temperatures by automatically scanning the sample directory.
+        """
+
+        # Assert that self.sample_directory must exist
+        if self.sample_directory is None:
+            raise ValueError("Sample directory is not set. Use set_sample_directory(path) first.")
+
+        # Clear existing temperatures
+        self.temperatures = []
+
+        # Search for nxrefine .nxs files
+        for item in os.listdir(self.sample_directory):
+            pattern = r'_(\d+)\.nxs'
+            match = re.search(pattern, item)
+            if match:
+                # Identify temperature
+                temperature = match.group(1)
+                self.temperatures.append(temperature)
+        # Convert all temperatures to int temporarily to sort temperatures list
+        self.temperatures = [int(t) for t in self.temperatures]
+        self.temperatures.sort()
+        self.temperatures = [str(t) for t in self.temperatures]
+
     def set_sample_directory(self, path):
         """
         Set the directory path where the datasets are located.
@@ -172,6 +199,9 @@ class TempDependence:
         if temperatures_list:
             temperatures_list = [str(t) for t in temperatures_list]
 
+        # Clear existing temperatures before loading files
+        self.temperatures = []
+
         # Identify files to load
         items_to_load = []
         # Search for nxrefine .nxs files
@@ -179,7 +209,6 @@ class TempDependence:
             pattern = r'_(\d+)\.nxs'
             match = re.search(pattern, item)
             if match:
-                print(f'Found {item}')
                 # Identify temperature
                 temperature = match.group(1)
                 # print(f'Temperature = {temperature}')
@@ -188,7 +217,6 @@ class TempDependence:
                     self.temperatures.append(temperature)
                     items_to_load.append(item)
                     # print(f'Preparing to load {temperature} K data: {item}')
-
         # Convert all temperatures to int temporarily to sort temperatures list before loading
         self.temperatures = [int(t) for t in self.temperatures]
 
@@ -238,9 +266,6 @@ class TempDependence:
         temperature_folders.sort()  # Sort from low to high T
         temperature_folders = [str(i) for i in temperature_folders]  # Convert to strings
 
-        print('Found temperature folders:')
-        [print('[' + str(i) + '] ' + folder) for i, folder in enumerate(temperature_folders)]
-
         self.temperatures = temperature_folders
 
         if temperatures_list is not None:
@@ -251,9 +276,6 @@ class TempDependence:
             for file in os.listdir(os.path.join(self.sample_directory, T)):
                 if file.endswith(file_ending):
                     filepath = os.path.join(self.sample_directory, T, file)
-                    print('-----------------------------------------------')
-                    print('Loading ' + T + ' K indexed .nxs files...')
-                    print('Found ' + filepath)
 
                     # Load dataset at each temperature
                     self.datasets[T] = load_data(filepath)

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

@@ -15,7 +15,7 @@ from scipy import ndimage
 
 # Specify items on which users are allowed to perform standalone imports
 __all__ = ['load_data', 'load_transform', 'plot_slice', 'Scissors',
-           'reciprocal_lattice_params', 'rotate_data',
+           'reciprocal_lattice_params', 'rotate_data', 'rotate_data_2D'
            'array_to_nxdata', 'Padder']
 
 
@@ -853,7 +853,7 @@ def rotate_data(data, lattice_angle, rotation_angle, rotation_axis, printout=Fal
                   (data[data.axes[0]], data[data.axes[1]], data[data.axes[2]]))
 
 
-def rotate_data2D(data, lattice_angle, rotation_angle):
+def rotate_data_2D(data, lattice_angle, rotation_angle):
     """
     Rotates 2D data.
 

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

@@ -197,7 +197,7 @@ class Symmetrizer2D:
         # Scale and skew counts
         skew_angle_adj = 90 - self.skew_angle
 
-        scale2 = counts.shape[0] / counts.shape[1]
+        scale2 = q1.max()/q2.max()
         counts_unscaled2 = ndimage.affine_transform(counts,
                                                     Affine2D().scale(scale2, 1).inverted().get_matrix()[:2, :2],
                                                     offset=[-(1 - scale2) * counts.shape[
@@ -253,7 +253,7 @@ class Symmetrizer2D:
                                          order=0,
                                          )
 
-        scale2 = counts.shape[0] / counts.shape[1]
+        scale2 = q1.max()/q2.max()
         wedge = ndimage.affine_transform(wedge,
                                          Affine2D().scale(scale2, 1).get_matrix()[:2, :2],
                                          offset=[(1 - scale2) * counts.shape[0] / 2, 0],
@@ -477,7 +477,7 @@ class Symmetrizer3D:
         q1, q2, q3 = self.q1, self.q2, self.q3
         out_array = np.zeros(data[data.signal].shape)
 
-        if self.plane1symmetrizer.theta_max:
+        if self.plane1symmetrizer.theta_max is not None:
             print('Symmetrizing ' + self.plane1 + ' planes...')
             for k, value in enumerate(q3):
                 print(f'Symmetrizing {q3.nxname}={value:.02f}...', end='\r')
@@ -485,7 +485,7 @@ class Symmetrizer3D:
                 out_array[:, :, k] = data_symmetrized[data.signal].nxdata
             print('\nSymmetrized ' + self.plane1 + ' planes.')
 
-        if self.plane2symmetrizer.theta_max:
+        if self.plane2symmetrizer.theta_max is not None:
             print('Symmetrizing ' + self.plane2 + ' planes...')
             for j, value in enumerate(q2):
                 print(f'Symmetrizing {q2.nxname}={value:.02f}...', end='\r')
@@ -495,7 +495,7 @@ class Symmetrizer3D:
                 out_array[:, j, :] = data_symmetrized[data.signal].nxdata
             print('\nSymmetrized ' + self.plane2 + ' planes.')
 
-        if self.plane3symmetrizer.theta_max:
+        if self.plane3symmetrizer.theta_max is not None:
             print('Symmetrizing ' + self.plane3 + ' planes...')
             for i, value in enumerate(q1):
                 print(f'Symmetrizing {q1.nxname}={value:.02f}...', end='\r')
@@ -536,7 +536,7 @@ class Symmetrizer3D:
         print("Output file saved to: " + os.path.join(os.getcwd(), fout_name))
 
 
-def generate_gaussian(H, K, L, amp, stddev, lattice_params, coeffs=None):
+def generate_gaussian(H, K, L, amp, stddev, lattice_params, coeffs=None, center=None):
     """
     Generate a 3D Gaussian distribution.
 
@@ -558,16 +558,23 @@ def generate_gaussian(H, K, L, amp, stddev, lattice_params, coeffs=None):
         Coefficients for the Gaussian expression, including cross-terms between axes.
          Default is [1, 0, 1, 0, 1, 0],
          corresponding to (1*H**2 + 0*H*K + 1*K**2 + 0*K*L + 1*L**2 + 0*L*H).
+    center : tuple
+        Tuple of coordinates for the center of the Gaussian. Default is (0,0,0).
 
     Returns
     -------
     gaussian : ndarray
         3D Gaussian distribution array.
     """
+    if center is None:
+        center=(0,0,0)
     if coeffs is None:
         coeffs = [1, 0, 1, 0, 1, 0]
     a, b, c, al, be, ga = lattice_params
     a_, b_, c_, _, _, _ = reciprocal_lattice_params((a, b, c, al, be, ga))
+    H = H-center[0]
+    K = K-center[1]
+    L = L-center[2]
     H, K, L = np.meshgrid(H, K, L, indexing='ij')
     gaussian = amp * np.exp(-(coeffs[0] * H ** 2 +
                               coeffs[1] * (b_ * a_ / (a_ ** 2)) * H * K +
@@ -581,7 +588,6 @@ def generate_gaussian(H, K, L, amp, stddev, lattice_params, coeffs=None):
         gaussian = gaussian.transpose()
     return gaussian.transpose(1, 0, 2)
 
-
 class Puncher:
     """
     A class for applying masks to 3D datasets, typically for data processing in reciprocal space.

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: nxs-analysis-tools
-Version: 0.0.43
+Version: 0.0.44
 Summary: Reduce and transform nexus format (.nxs) scattering data.
 Author-email: "Steven J. Gomez Alvarado" <stevenjgomez@ucsb.edu>
 License: MIT License
@@ -66,6 +66,7 @@ Requires-Dist: sphinx-autobuild>=2021.3.14; extra == "dev"
 Requires-Dist: sphinx-copybutton>=0.5.0; extra == "dev"
 Requires-Dist: sphinxext-opengraph>=0.6.3; extra == "dev"
 Requires-Dist: twine>=4.0.1; extra == "dev"
+Dynamic: license-file
 
 # nxs-analysis-tools
 

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

@@ -21,4 +21,5 @@ tests/test_fitting.py
 tests/test_lmfit.py
 tests/test_mask_plotting.py
 tests/test_pairdistribution.py
-tests/test_plot_slice_with_ndarray.py
+tests/test_plot_slice_with_ndarray.py
+tests/test_symmetrizer_rectangular_plane.py

nxs_analysis_tools-0.0.44/tests/test_symmetrizer_rectangular_plane.py

@@ -0,0 +1,383 @@
+from nxs_analysis_tools import load_data, plot_slice
+from nxs_analysis_tools.datareduction import Padder, array_to_nxdata
+from nxs_analysis_tools.pairdistribution import Symmetrizer3D
+import matplotlib.pyplot as plt
+
+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
+
+data = load_data('../docs/source/examples/example_data/pairdistribution_data/test_hkli.nxs')
+
+
+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
+
+        scale2 = q1.max()/q2.max()
+        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,
+                                                    )
+        plot_slice(counts_unscaled2)
+
+        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
+        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 = q1.max()/q2.max()
+        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 the data
+        plot_slice(data, skew_angle=s.skew_angle, ax=axes[0], title='data', **kwargs)
+
+        # 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
+
+
+s2d = Symmetrizer2D(theta_min=0, theta_max=45)
+
+symmetrized_data = s2d.test(data[:, :, 0.0])
+plt.show()