xrheed 0.5.13__tar.gz

xrheed-0.5.13/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Marek Kopciuszynski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

xrheed-0.5.13/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: xrheed
+Version: 0.5.13
+Summary: An xarray-based toolkit for RHEED image analysis
+Author-email: Marek Kopciuszynski <mkopciuszynski@gmail.com>
+License-Expression: MIT
+Keywords: RHEED,diffraction,xarray,analysis
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Intended Audience :: Science/Research
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: xarray>=0.18.2
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: scipy>=1.7.0
+Requires-Dist: matplotlib>=3.4.2
+Requires-Dist: ruptures>=1.1.7
+Requires-Dist: tqdm>=4.62.0
+Requires-Dist: lmfit>=1.1.0
+Requires-Dist: dill>=0.3.4
+Requires-Dist: Pillow>=9.0.0
+Provides-Extra: dev
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: sphinx; extra == "dev"
+Requires-Dist: myst-parser; extra == "dev"
+Requires-Dist: myst-nb; extra == "dev"
+Requires-Dist: nbsphinx; extra == "dev"
+Requires-Dist: sphinx-rtd-theme; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Dynamic: license-file
+
+# xRHEED
+
+📡 An **xarray-based toolkit** for RHEED image analysis.
+
+---
+
+[![CI](https://github.com/mkopciuszynski/xrheed/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/mkopciuszynski/xrheed/actions/workflows/ci.yml)
+[![Documentation Status](https://readthedocs.org/projects/xrheed/badge/?version=latest)](https://xrheed.readthedocs.io/en/latest/?badge=latest)
+[![PyPI version](https://img.shields.io/pypi/v/xrheed.svg)](https://pypi.org/project/xrheed/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Linter: ruff](https://img.shields.io/badge/linter-ruff-46a2f1.svg?logo=ruff)](https://github.com/astral-sh/ruff)
+[![Package manager: uv](https://img.shields.io/badge/packaging-uv-blue)](https://github.com/astral-sh/uv)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.xxxxx.svg)](https://doi.org/10.5281/zenodo.xxxxx)
+
+---
+
+## 🔬 What is RHEED?
+
+**Reflection High-Energy Electron Diffraction (RHEED)** is an experimental technique used to monitor and control the quality of crystal surfaces.  
+A high-energy electron beam (∼20 keV) strikes the surface at a grazing angle (< 5°), making the method highly **surface-sensitive** and probing only a few atomic layers.
+
+---
+
+## 🎯 Project Goals
+
+**xRHEED** provides a flexible and extensible **Python toolkit** for RHEED image analysis:
+
+- 🖼️ Load and preprocess RHEED images  
+- 📈 Generate and analyze intensity profiles  
+- ✨ Overlay predicted diffraction spot positions (kinematic theory & Ewald construction)  
+- 🔄 Transform RHEED images into kx–ky space  
+- 🔍 Search for reconstruction lattice constants and rotations by calculating the matching coefficient between predicted and experimental data  
+
+👉 **Note:** xRHEED is **not a GUI application**. It is designed as an **xarray accessory library**, intended for use in **interactive environments** such as Jupyter notebooks.
+
+---
+
+## ⚡ Installation
+
+You can install **xRHEED** using either [`uv`](https://github.com/astral-sh/uv) or `pip`.
+
+### Using pip (editable install for development)
+
+```bash
+git clone https://github.com/mkopciuszynski/xrheed
+cd xrheed
+pip install -e .
+```
+
+### Using uv (with a virtual environment)
+
+1. Install [`uv`](https://docs.astral.sh/uv/guides/projects/).
+2. Clone the repository:
+   ```bash
+   git clone https://github.com/mkopciuszynski/xrheed
+   cd xrheed
+   ```
+3. Create and activate a virtual environment (depending on your shell: bash, zsh, fish, PowerShell).
+4. Sync dependencies:
+   ```bash
+   uv sync
+   ```
+
+---
+
+## 🚀 Quick Usage
+
+```python
+import matplotlib.pyplot as plt
+import xrheed
+from xrheed.io import load_data
+
+# Load a RHEED image
+rheed_image = load_data("rheed_image.raw", plugin="dsnp_arpes_raw")
+
+# Show image with auto-adjusted levels
+rheed_image.ri.plot_image(auto_levels=2.0)
+plt.show()
+
+# Get intensity profile and plot its origin
+profile = rheed_image.ri.get_profile(center=(0, -5), width=40, height=4,
+                                     plot_origin=True)
+```
+
+---
+
+## 📖 Citation
+
+If you use **xRHEED** in your research, please consider citing this repository:
+
+> Kopciuszynski, M. (2025). *xRHEED: An xarray-based toolkit for RHEED image analysis*.
+> GitHub. https://github.com/mkopciuszynski/xrheed
+
+📌 A formal DOI will be provided in the future via [Zenodo](https://zenodo.org/).
+
+---
+
+📚 👉 See the [full documentation](https://xrheed.readthedocs.io/en/latest/) for tutorials and advanced examples.

xrheed-0.5.13/README.md

@@ -0,0 +1,99 @@
+# xRHEED
+
+📡 An **xarray-based toolkit** for RHEED image analysis.
+
+---
+
+[![CI](https://github.com/mkopciuszynski/xrheed/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/mkopciuszynski/xrheed/actions/workflows/ci.yml)
+[![Documentation Status](https://readthedocs.org/projects/xrheed/badge/?version=latest)](https://xrheed.readthedocs.io/en/latest/?badge=latest)
+[![PyPI version](https://img.shields.io/pypi/v/xrheed.svg)](https://pypi.org/project/xrheed/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Linter: ruff](https://img.shields.io/badge/linter-ruff-46a2f1.svg?logo=ruff)](https://github.com/astral-sh/ruff)
+[![Package manager: uv](https://img.shields.io/badge/packaging-uv-blue)](https://github.com/astral-sh/uv)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.xxxxx.svg)](https://doi.org/10.5281/zenodo.xxxxx)
+
+---
+
+## 🔬 What is RHEED?
+
+**Reflection High-Energy Electron Diffraction (RHEED)** is an experimental technique used to monitor and control the quality of crystal surfaces.  
+A high-energy electron beam (∼20 keV) strikes the surface at a grazing angle (< 5°), making the method highly **surface-sensitive** and probing only a few atomic layers.
+
+---
+
+## 🎯 Project Goals
+
+**xRHEED** provides a flexible and extensible **Python toolkit** for RHEED image analysis:
+
+- 🖼️ Load and preprocess RHEED images  
+- 📈 Generate and analyze intensity profiles  
+- ✨ Overlay predicted diffraction spot positions (kinematic theory & Ewald construction)  
+- 🔄 Transform RHEED images into kx–ky space  
+- 🔍 Search for reconstruction lattice constants and rotations by calculating the matching coefficient between predicted and experimental data  
+
+👉 **Note:** xRHEED is **not a GUI application**. It is designed as an **xarray accessory library**, intended for use in **interactive environments** such as Jupyter notebooks.
+
+---
+
+## ⚡ Installation
+
+You can install **xRHEED** using either [`uv`](https://github.com/astral-sh/uv) or `pip`.
+
+### Using pip (editable install for development)
+
+```bash
+git clone https://github.com/mkopciuszynski/xrheed
+cd xrheed
+pip install -e .
+```
+
+### Using uv (with a virtual environment)
+
+1. Install [`uv`](https://docs.astral.sh/uv/guides/projects/).
+2. Clone the repository:
+   ```bash
+   git clone https://github.com/mkopciuszynski/xrheed
+   cd xrheed
+   ```
+3. Create and activate a virtual environment (depending on your shell: bash, zsh, fish, PowerShell).
+4. Sync dependencies:
+   ```bash
+   uv sync
+   ```
+
+---
+
+## 🚀 Quick Usage
+
+```python
+import matplotlib.pyplot as plt
+import xrheed
+from xrheed.io import load_data
+
+# Load a RHEED image
+rheed_image = load_data("rheed_image.raw", plugin="dsnp_arpes_raw")
+
+# Show image with auto-adjusted levels
+rheed_image.ri.plot_image(auto_levels=2.0)
+plt.show()
+
+# Get intensity profile and plot its origin
+profile = rheed_image.ri.get_profile(center=(0, -5), width=40, height=4,
+                                     plot_origin=True)
+```
+
+---
+
+## 📖 Citation
+
+If you use **xRHEED** in your research, please consider citing this repository:
+
+> Kopciuszynski, M. (2025). *xRHEED: An xarray-based toolkit for RHEED image analysis*.
+> GitHub. https://github.com/mkopciuszynski/xrheed
+
+📌 A formal DOI will be provided in the future via [Zenodo](https://zenodo.org/).
+
+---
+
+📚 👉 See the [full documentation](https://xrheed.readthedocs.io/en/latest/) for tutorials and advanced examples.

xrheed-0.5.13/pyproject.toml

@@ -0,0 +1,47 @@
+[project]
+name = "xrheed"
+version = "0.5.13"
+authors = [
+    {name = "Marek Kopciuszynski", email = "mkopciuszynski@gmail.com"},
+]
+description = "An xarray-based toolkit for RHEED image analysis"
+readme = "README.md"
+requires-python = ">=3.12"
+keywords = ["RHEED", "diffraction", "xarray", "analysis"]
+license = "MIT"
+license-files = ["LICENSE"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Scientific/Engineering :: Physics",
+    "Intended Audience :: Science/Research",
+]
+dependencies = [
+    "xarray>=0.18.2",
+    "numpy>=1.21.0",
+    "scipy>=1.7.0",
+    "matplotlib>=3.4.2",
+    "ruptures>=1.1.7",
+    "tqdm>=4.62.0",
+    "lmfit>=1.1.0",
+    "dill>=0.3.4",
+    "Pillow>=9.0.0",
+]
+
+[build-system]
+requires = ["setuptools>=61", "wheel", "build"]
+build-backend = "setuptools.build_meta"
+
+[project.optional-dependencies]
+dev = [
+    "ruff",
+    "pytest",
+    "sphinx",
+    "myst-parser",
+    "myst-nb",
+    "nbsphinx",
+    "sphinx-rtd-theme",
+    "build",
+]

xrheed-0.5.13/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

xrheed-0.5.13/src/xrheed/__init__.py

@@ -0,0 +1,61 @@
+"""
+xRHEED: An xarray-based toolkit for RHEED image analysis.
+
+This package provides tools to:
+- Load and preprocess RHEED images
+- Extract and analyze intensity profiles
+- Transform images to kx-ky space
+- Predict and visualize diffraction spot positions using kinematic theory and Ewald construction
+xRHEED is designed as an **xarray accessory library** for interactive analysis
+in environments such as Jupyter notebooks. It is **not a GUI application**.
+"""
+
+import importlib
+import logging
+import pkgutil
+from importlib.metadata import PackageNotFoundError, version
+
+# Import xarray accessors
+from . import xarray_accessors as xarray_accessors
+
+# Package version
+try:
+    __version__ = version("xrheed")
+except PackageNotFoundError:
+    __version__ = "0.0.0"
+
+# Configure logging
+logger = logging.getLogger(__name__)
+logger.info(f"xrheed {__version__} initialized successfully. Accessors registered.")
+
+
+# Check if running inside a Jupyter notebook
+def _in_jupyter():
+    try:
+        from IPython import get_ipython
+
+        shell = get_ipython()
+        return shell is not None and shell.__class__.__name__ == "ZMQInteractiveShell"
+    except Exception:
+        return False
+
+
+# Show a welcome message in Jupyter
+if _in_jupyter():
+    print(f"\n🎉 xrheed v{__version__} loaded!")
+
+
+# Plugin discovery
+def discover_plugins():
+    try:
+        import xrheed.plugins
+
+        for _, module_name, is_pkg in pkgutil.iter_modules(xrheed.plugins.__path__):
+            if not is_pkg:
+                importlib.import_module(f"xrheed.plugins.{module_name}")
+    except Exception as e:
+        logger.warning(f"Plugin discovery failed: {e}")
+
+
+# Run plugin discovery after all imports
+discover_plugins()

xrheed-0.5.13/src/xrheed/conversion/__init__.py

@@ -0,0 +1,9 @@
+"""
+Submodule `conversion` handles coordinate and unit conversions for RHEED images,
+e.g., transforming between pixel space and kx-ky space.
+"""
+
+from .base import convert_gx_gy_to_sx_sy, convert_sx_to_ky
+from .image import transform_image_to_kxky
+
+__all__ = ["convert_gx_gy_to_sx_sy", "convert_sx_to_ky", "transform_image_to_kxky"]

xrheed-0.5.13/src/xrheed/conversion/base.py

@@ -0,0 +1,120 @@
+from typing import Optional, Tuple
+
+import numpy as np
+from numpy.typing import NDArray
+
+
+def convert_sx_to_ky(
+    x_coords_mm: NDArray,
+    ewald_sphere_radius: float,
+    screen_sample_distance_mm: float,
+) -> NDArray:
+    """Convert sx coordinates from mm to ky [1/Å] using the Ewald sphere radius and screen-sample distance.
+    Parameters
+    ----------
+    x_coords_mm : NDArray
+        Array of x coordinates in millimeters (mm).
+    ewald_sphere_radius : float
+        Radius of the Ewald sphere in reciprocal space (1/Å).
+    screen_sample_distance_mm : float
+        Distance from the sample to the screen in millimeters (mm).
+
+    Returns
+    -------
+    NDArray
+        Converted x coordinates in ky [1/Å].
+    """
+
+    kx: NDArray = (x_coords_mm / screen_sample_distance_mm) * ewald_sphere_radius
+
+    return kx
+
+
+def convert_gx_gy_to_sx_sy(
+    gx: NDArray[np.float32],
+    gy: NDArray[np.float32],
+    ewald_radius: float,
+    beta: float,
+    screen_sample_distance: float,
+    remove_outside: Optional[bool] = True,
+    **kwargs,
+) -> Tuple[NDArray[np.float32], NDArray[np.float32]]:
+    """
+    Convert reciprocal lattice coordinates (gx, gy) to RHEED screen coordinates (sx, sy)
+    using the Ewald sphere construction.
+
+    Parameters
+    ----------
+    gx : NDArray
+        Array of reciprocal lattice x-coordinates.
+    gy : NDArray
+        Array of reciprocal lattice y-coordinates.
+    ewald_radius : float
+        Radius of the Ewald sphere in reciprocal space (1/Å or same units as gx, gy).
+    beta : float
+        Incident beam angle in degrees relative to the surface normal.
+    screen_sample_distance : float
+        Distance from the sample to the detector/screen.
+    remove_outside : Optional[bool], default=True
+        If True, points outside the Ewald sphere are removed.
+        If False, points outside are set to NaN.
+    **kwargs
+        Additional keyword arguments (currently unused).
+
+    Returns
+    -------
+    sx : NDArray
+        Array of x-coordinates on the RHEED screen corresponding to input gx, gy.
+    sy : NDArray
+        Array of y-coordinates on the RHEED screen corresponding to input gx, gy.
+
+    Notes
+    -----
+    - The function assumes a simple planar screen perpendicular to the z-axis.
+    - The coordinate transformation accounts for the Ewald sphere geometry
+      and the projection of diffraction spots onto the screen.
+    - `beta` is the incident angle of the electron beam relative to the sample surface.
+    - Points outside the Ewald sphere can be optionally removed or set as NaN
+      using the `remove_outside` flag.
+    """
+
+    # Ewald sphere radius
+    k0: np.float32 = np.float32(ewald_radius)
+    # Ewald sphere radius square
+    kk: np.float32 = np.float32(k0**2)
+
+    # calculate the shift between the center of Ewald sphere and the center of reciprocal lattice
+    delta_x: np.float32 = np.float32(k0 * np.cos(np.deg2rad(beta)))
+
+    # shift the center of reciprocal lattice
+    kx: NDArray[np.float32] = gx + delta_x
+    ky: NDArray[np.float32] = gy
+
+    # Check if the kx, ky points are inside Ewald sphere
+    kxy2: NDArray[np.float32] = kx**2 + ky**2
+
+    ind: NDArray[np.bool_] = kxy2 < kk
+
+    # remove those outside or mark as nans
+    if remove_outside:
+        kx = kx[ind]
+        ky = ky[ind]
+    else:
+        kx[~ind] = np.nan
+        ky[~ind] = np.nan
+
+    # calculate the radius r_k
+    rk: NDArray[np.float32] = np.sqrt(k0**2 - kx**2)
+
+    # calculate theta and phi (cos) values
+    phi: NDArray[np.float32] = np.arccos(ky / rk)
+    theta: NDArray[np.float32] = np.arcsin(rk / k0)
+
+    # calculate the radius on the RHEED screen
+    rho: NDArray[np.float32] = screen_sample_distance * np.tan(theta)
+
+    # calculate the spot positions
+    sx: NDArray[np.float32] = rho * np.cos(phi)
+    sy: NDArray[np.float32] = -rho * np.sin(phi)
+
+    return sx, sy

xrheed-0.5.13/src/xrheed/conversion/image.py

@@ -0,0 +1,138 @@
+import numpy as np
+import xarray as xr
+from numpy.typing import NDArray
+from scipy import ndimage  # type: ignore
+
+from .base import convert_gx_gy_to_sx_sy
+
+
+def transform_image_to_kxky(
+    rheed_image: xr.DataArray,
+    rotate: bool = False,
+    point_symmetry: bool = False,
+) -> xr.DataArray:
+    """
+    Transform the RHEED image to kx-ky coordinates.
+
+    Parameters
+    ----------
+    rotate : bool, optional
+        If True, rotate the transformed image (default: True).
+    mirror : bool, optional
+        If True, add mirrored image (default: False).
+
+    Returns
+    -------
+    xr.DataArray
+        Transformed image in kx-ky coordinates.
+    """
+
+    # prepare the data for calculations
+    screen_sample_distance: float = rheed_image.ri.screen_sample_distance
+    beta: float = rheed_image.ri.beta
+    alpha: float = rheed_image.ri.alpha
+
+    ewald_radius: float = np.sqrt(rheed_image.ri.beam_energy) * 0.5123
+
+    # new coordinates for transformation
+    # TODO add the parameter that allows to set kx, ky
+    kx: NDArray[np.float32] = np.arange(-10, 10, 0.01, dtype=np.float32)
+    ky: NDArray[np.float32] = np.arange(-10, 10, 0.01, dtype=np.float32)
+
+    gx: NDArray[np.float32]
+    gy: NDArray[np.float32]
+
+    gx, gy = np.meshgrid(kx, ky, indexing="ij")
+
+    sx_to_kx: NDArray[np.float32]
+    sy_to_ky: NDArray[np.float32]
+
+    sx_to_kx, sy_to_ky = convert_gx_gy_to_sx_sy(
+        gx,
+        gy,
+        ewald_radius=ewald_radius,
+        beta=beta,
+        screen_sample_distance=screen_sample_distance,
+        remove_outside=False,
+    )
+
+    # relation between old and new
+    sx: xr.DataArray = xr.DataArray(
+        sx_to_kx, dims=["kx", "ky"], coords={"kx": kx, "ky": ky}
+    )
+    sy: xr.DataArray = xr.DataArray(
+        sy_to_ky, dims=["kx", "ky"], coords={"kx": kx, "ky": ky}
+    )
+
+    trans_image: xr.DataArray = rheed_image.interp(sx=sx, sy=sy, method="linear")
+
+    if rotate:
+        trans_image_rotated = _rotate_trans_image(trans_image, alpha)
+        trans_image = trans_image_rotated
+
+    if point_symmetry:
+        trans_image_rotated = _rotate_trans_image(trans_image, 180)
+        trans_image = xr.where(np.isnan(trans_image), trans_image_rotated, trans_image)
+
+    trans_image.attrs = rheed_image.attrs
+
+    return trans_image
+
+
+def _rotate_trans_image(
+    trans_image: xr.DataArray, angle: float, mode: str = "nearest"
+) -> xr.DataArray:
+    """
+    Rotate a 2D xarray.DataArray around its center by a given angle.
+
+    Parameters
+    ----------
+    rheed_image : xr.DataArray
+        2D image-like DataArray to rotate.
+    angle : float
+        Rotation angle in degrees (counter-clockwise).
+    mode : str
+        How to handle values outside boundaries ('constant', 'nearest', 'reflect', ...).
+
+    Returns
+    -------
+    rotated : xr.DataArray
+        Rotated DataArray with NaNs preserved.
+    """
+    if trans_image.ndim != 2:
+        raise ValueError("rotate_xarray expects a 2D DataArray")
+
+    # Assert that coordinates exist
+    if "kx" not in trans_image.coords or "ky" not in trans_image.coords:
+        raise ValueError("rotate_xarray requires coordinates 'kx' and 'ky'")
+
+    # Assert that kx and ky are identical
+    if not np.allclose(trans_image["kx"].values, trans_image["ky"].values):
+        raise ValueError("rotate_xarray requires kx and ky coordinates to be identical")
+
+    # Build mask for NaNs
+    nan_mask: NDArray[np.bool_] = ~np.isnan(trans_image.values)
+    filled: xr.DataArray = trans_image.fillna(0)
+
+    # Rotate data and mask
+    rotated_data: NDArray[np.uint8] = ndimage.rotate(
+        filled.values, angle, reshape=False, mode=mode, order=1
+    ).astype(np.uint8)
+
+    rotated_mask: NDArray[np.bool_] = (
+        ndimage.rotate(
+            nan_mask.astype(np.uint8), angle, reshape=False, mode=mode, order=0
+        )
+        > 0
+    ).astype(np.bool)
+
+    # Wrap back into DataArray, reusing same coords/dims
+    rotated = xr.DataArray(
+        rotated_data,
+        coords=trans_image.coords,
+        dims=trans_image.dims,
+        attrs=trans_image.attrs,
+        name=trans_image.name,
+    )
+
+    return rotated.where(rotated_mask)