xpunwrap 0.0.0__tar.gz

xpunwrap-0.0.0/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2026 Eoghan O'Connell
+
+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.

xpunwrap-0.0.0/PKG-INFO

@@ -0,0 +1,225 @@
+Metadata-Version: 2.4
+Name: xpunwrap
+Version: 0.0.0
+Summary: Phase unwrapping algorithms which are CPU and GPU agnostic
+Author: Conrad Möckel, Eoghan O'Connell
+Maintainer-email: Eoghan O'Connell <eoclives@hotmail.com>
+Requires-Python: <4,>=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.2.6
+Provides-Extra: cupy-cuda12x
+Requires-Dist: cupy-cuda12x; extra == "cupy-cuda12x"
+Provides-Extra: cupy-cuda13x
+Requires-Dist: cupy-cuda13x; extra == "cupy-cuda13x"
+Provides-Extra: scikit-image
+Requires-Dist: scikit-image>=0.20.0; extra == "scikit-image"
+Provides-Extra: fftw
+Requires-Dist: pyfftw>=0.15.0; extra == "fftw"
+Dynamic: license-file
+
+<!-- sphinx-logo-start -->
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="docs/logos/xpunwrap_animated_dark.gif">
+  <img src="docs/logos/xpunwrap_animated_light.gif" alt="XPUnwrap">
+</picture>
+<!-- sphinx-logo-end -->
+
+
+# xpUnwrap
+**Phase Unwrapping on GPU (and CPU), with Python**
+
+There are many phase unwrapping algorithms out there. Many are implemented in
+CUDA, C++ etc. I haven't yet found any algorithm that interfaces 
+**easily** with Python via the wonderful GPU-based package CuPy.
+Please inform me if you know of one that is open-source.
+
+<!-- there is one via pytorch -->
+
+This package aims to make GPU-based phase unwrapping in Python seamless.
+If you don't have a GPU, don't worry, all the code works on the CPU
+(albeit slower).
+
+## What does "xp" stand for?
+
+The ``xp`` in xpUnwrap references several things: 
+ - CuPy's [agnostic code idea](https://docs.cupy.dev/en/stable/user_guide/basic.html#how-to-write-cpu-gpu-agnostic-code)
+   where ``cp`` is for cupy and ``np`` is for numpy.
+ - the "G" in GPU and "C" in CPU.
+ - the "Q" from QPI (Quantitative Phase Imaging) e.g., from the sister package [qpretrieve](https://github.com/RI-imaging/qpretrieve). 
+
+## Installation
+<!-- sphinx-after-installation-heading -->
+
+```bash
+
+    # if you have the CUDA Toolkit version 12x use:
+    pip install xpunwrap[cupy-cuda12x]
+
+    # if you have the CUDA Toolkit version 13x use:
+    pip install xpunwrap[cupy-cuda13x]
+
+    # to install and just use on the CPU, just don't use any optional dependencies:
+    pip install xpunwrap
+
+    # to also use skimage's unwrap (CPU-only):
+    pip install xpunwrap[scikit-image]
+
+    # for faster CPU Fourier transforms via pyFFTW:
+    pip install xpunwrap[FFTW]
+```
+
+On the CPU backend, `xpunwrap` automatically uses pyFFTW for the Fourier
+transforms in the least-squares solvers when it is installed, falling back to
+NumPy otherwise. On the GPU backend, CuPy's FFT is always used.
+
+## Compatible Phase Retrieval and Numerical Refocusing GPU packages
+
+In the same group on GitHub, we have two other packages that work seamlessy
+with `xpunwrap`.
+- Phase Retrieval that works on CPU and GPU: 
+  [qpretrieve](https://github.com/RI-imaging/qpretrieve)
+- Numerical Refocussing that works on CPU and GPU: 
+  [nrefocus](https://github.com/RI-imaging/nrefocus)
+- If you are looking for a file format that can also work with the GPU, try 
+  out [zarr-python](https://zarr.readthedocs.io/en/stable/user-guide/gpu/) 
+
+
+## Documentation and Citations
+
+Check out the Documentation and Examples here: https://xpunwrap.readthedocs.io/
+
+<!-- ## Citing this work -->
+
+
+## Using `xpunwrap`
+
+There are several phase unwrapping algorithms to choose from:
+- `algo_ls_poisson`: Least-squares Poisson solver
+- `algo_ls_poisson_pg`: Least-squares unwrapping with periodic gradient enforcement
+- `algo_ls_weighted`: Weighted least-squares unwrapping with border masking
+- `algo_skimage_unwrap`: Scikit-Image's Path Following algorithm 
+  (Herraez et al.) is included for comparison. It only works on the CPU,
+  as it is not suitable for use with GPU.
+
+```python
+"""
+Field retrieval (qpretrieve) and phase unwrapping (xpunwrap) on GPU.
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+import qpretrieve
+import xpunwrap
+
+# Force GPU backend for both libraries.
+qpretrieve.set_ndarray_backend("cupy")
+xpunwrap.set_ndarray_backend("cupy")
+xp = xpunwrap.get_ndarray_backend()
+
+fft_interface = qpretrieve.fourier.FFTFilterCupy
+edata = np.load("./data/hologram_cell.npz")
+holo = qpretrieve.OffAxisHologram(edata["data"], fft_interface)
+bg = qpretrieve.OffAxisHologram(edata["bg_data"], fft_interface)
+
+holo.run_pipeline(filter_name="disk", filter_size=1 / 2, scale_to_filter=True)
+bg.process_like(holo)
+phase_wrapped = xp.asarray(holo.phase - bg.phase).astype(xp.float32)
+
+# Unwrap the phase with all available algorithms
+outputs = {}
+for algo_name, algo in xpunwrap.algos_available().items():
+    outputs[algo_name] = algo(phase_wrapped)
+skimage_out = outputs.get("algo_skimage_unwrap", None)
+if skimage_out is not None:
+    outputs_no_skimage = {k: v for k, v in outputs.items() if k != "algo_skimage_unwrap"}
+else:
+    outputs_no_skimage = outputs
+
+# plot the wrapped and unwrapped phases
+plt.style.use("dark_background")
+fig, axes = plt.subplots(2, 3, figsize=(8, 6))
+fig.suptitle("Field Retrieval + Phase Unwrapping (GPU)", fontsize=18)
+axes = axes.flatten(order="F")
+
+axes[0].imshow(phase_wrapped.get()[0])
+axes[0].set_title("Wrapped Phase")
+
+# With column-major flattening, bottom-right is index 5.
+skimage_ax = axes[5]
+
+# Fill remaining non-skimage algorithms first (slots 1..4).
+plot_slots = [2, 3, 4]
+for slot, (algo_name, arr) in zip(plot_slots, outputs_no_skimage.items()):
+    ax = axes[slot]
+    ax.imshow(arr.get()[0])
+    ax.set_title(f"Unwrapped\n{algo_name}")
+
+if skimage_out is not None:
+    skimage_ax.imshow(skimage_out.get()[0])
+    skimage_ax.set_title("Unwrapped (CPU-only)\nalgo_skimage_unwrap")
+else:
+    skimage_ax.text(0.5, 0.5, "skimage missing", ha="center", va="center")
+    skimage_ax.set_title("Unwrapped\nalgo_skimage_unwrap")
+
+for ax in axes:
+    ax.set_axis_off()
+
+plt.tight_layout(w_pad=4.5)
+# plt.savefig("gpu_field_retr_phase_unwrapping.png")
+plt.show()
+```
+
+![gpu_field_retr_phase_unwrapping.png](./examples/gpu_field_retr_phase_unwrapping.png)
+
+
+## Developers
+
+Install everything you need with (for example for cuda12x)
+```bash
+pip install -e .[cupy-cuda12x] --group dev
+```
+
+
+Run the unit tests with `pytest`
+```bash
+pip install --group tests
+pytest tests
+```
+
+Build docs with `sphinx`
+
+```bash
+pip install --group docs
+cd docs
+sphinx-build . _build
+```
+
+Check the docs locally by opening `docs/_build/index.html` file in your browser.
+
+### Package management with `uv`
+
+If you wish to use `uv` to handle package management, then you need to first
+install `uv` and then run:
+
+For example, for the optional `cupy-cuda12x`
+
+```bash
+uv sync -active --all-groups --all-extras
+```
+
+Which should install all dev dependencies.
+
+
+## Other phase unwrapping packages
+
+Here are several phase unwrapping packages that exist in Python:
+- https://github.com/blakedewey/phase_unwrap (CPU)
+- Scikit-image (CPU)
+
+## Use of AI
+
+This package used Codex (mostly 5.4-Mini) to translate the source citations
+(see documentation website) into Python code, as well as the mathematical derivations.
+All code and documents were then human-verified and verified with Claude Opus,
+and tested against known input data.

xpunwrap-0.0.0/README.md

@@ -0,0 +1,205 @@
+<!-- sphinx-logo-start -->
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="docs/logos/xpunwrap_animated_dark.gif">
+  <img src="docs/logos/xpunwrap_animated_light.gif" alt="XPUnwrap">
+</picture>
+<!-- sphinx-logo-end -->
+
+
+# xpUnwrap
+**Phase Unwrapping on GPU (and CPU), with Python**
+
+There are many phase unwrapping algorithms out there. Many are implemented in
+CUDA, C++ etc. I haven't yet found any algorithm that interfaces 
+**easily** with Python via the wonderful GPU-based package CuPy.
+Please inform me if you know of one that is open-source.
+
+<!-- there is one via pytorch -->
+
+This package aims to make GPU-based phase unwrapping in Python seamless.
+If you don't have a GPU, don't worry, all the code works on the CPU
+(albeit slower).
+
+## What does "xp" stand for?
+
+The ``xp`` in xpUnwrap references several things: 
+ - CuPy's [agnostic code idea](https://docs.cupy.dev/en/stable/user_guide/basic.html#how-to-write-cpu-gpu-agnostic-code)
+   where ``cp`` is for cupy and ``np`` is for numpy.
+ - the "G" in GPU and "C" in CPU.
+ - the "Q" from QPI (Quantitative Phase Imaging) e.g., from the sister package [qpretrieve](https://github.com/RI-imaging/qpretrieve). 
+
+## Installation
+<!-- sphinx-after-installation-heading -->
+
+```bash
+
+    # if you have the CUDA Toolkit version 12x use:
+    pip install xpunwrap[cupy-cuda12x]
+
+    # if you have the CUDA Toolkit version 13x use:
+    pip install xpunwrap[cupy-cuda13x]
+
+    # to install and just use on the CPU, just don't use any optional dependencies:
+    pip install xpunwrap
+
+    # to also use skimage's unwrap (CPU-only):
+    pip install xpunwrap[scikit-image]
+
+    # for faster CPU Fourier transforms via pyFFTW:
+    pip install xpunwrap[FFTW]
+```
+
+On the CPU backend, `xpunwrap` automatically uses pyFFTW for the Fourier
+transforms in the least-squares solvers when it is installed, falling back to
+NumPy otherwise. On the GPU backend, CuPy's FFT is always used.
+
+## Compatible Phase Retrieval and Numerical Refocusing GPU packages
+
+In the same group on GitHub, we have two other packages that work seamlessy
+with `xpunwrap`.
+- Phase Retrieval that works on CPU and GPU: 
+  [qpretrieve](https://github.com/RI-imaging/qpretrieve)
+- Numerical Refocussing that works on CPU and GPU: 
+  [nrefocus](https://github.com/RI-imaging/nrefocus)
+- If you are looking for a file format that can also work with the GPU, try 
+  out [zarr-python](https://zarr.readthedocs.io/en/stable/user-guide/gpu/) 
+
+
+## Documentation and Citations
+
+Check out the Documentation and Examples here: https://xpunwrap.readthedocs.io/
+
+<!-- ## Citing this work -->
+
+
+## Using `xpunwrap`
+
+There are several phase unwrapping algorithms to choose from:
+- `algo_ls_poisson`: Least-squares Poisson solver
+- `algo_ls_poisson_pg`: Least-squares unwrapping with periodic gradient enforcement
+- `algo_ls_weighted`: Weighted least-squares unwrapping with border masking
+- `algo_skimage_unwrap`: Scikit-Image's Path Following algorithm 
+  (Herraez et al.) is included for comparison. It only works on the CPU,
+  as it is not suitable for use with GPU.
+
+```python
+"""
+Field retrieval (qpretrieve) and phase unwrapping (xpunwrap) on GPU.
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+import qpretrieve
+import xpunwrap
+
+# Force GPU backend for both libraries.
+qpretrieve.set_ndarray_backend("cupy")
+xpunwrap.set_ndarray_backend("cupy")
+xp = xpunwrap.get_ndarray_backend()
+
+fft_interface = qpretrieve.fourier.FFTFilterCupy
+edata = np.load("./data/hologram_cell.npz")
+holo = qpretrieve.OffAxisHologram(edata["data"], fft_interface)
+bg = qpretrieve.OffAxisHologram(edata["bg_data"], fft_interface)
+
+holo.run_pipeline(filter_name="disk", filter_size=1 / 2, scale_to_filter=True)
+bg.process_like(holo)
+phase_wrapped = xp.asarray(holo.phase - bg.phase).astype(xp.float32)
+
+# Unwrap the phase with all available algorithms
+outputs = {}
+for algo_name, algo in xpunwrap.algos_available().items():
+    outputs[algo_name] = algo(phase_wrapped)
+skimage_out = outputs.get("algo_skimage_unwrap", None)
+if skimage_out is not None:
+    outputs_no_skimage = {k: v for k, v in outputs.items() if k != "algo_skimage_unwrap"}
+else:
+    outputs_no_skimage = outputs
+
+# plot the wrapped and unwrapped phases
+plt.style.use("dark_background")
+fig, axes = plt.subplots(2, 3, figsize=(8, 6))
+fig.suptitle("Field Retrieval + Phase Unwrapping (GPU)", fontsize=18)
+axes = axes.flatten(order="F")
+
+axes[0].imshow(phase_wrapped.get()[0])
+axes[0].set_title("Wrapped Phase")
+
+# With column-major flattening, bottom-right is index 5.
+skimage_ax = axes[5]
+
+# Fill remaining non-skimage algorithms first (slots 1..4).
+plot_slots = [2, 3, 4]
+for slot, (algo_name, arr) in zip(plot_slots, outputs_no_skimage.items()):
+    ax = axes[slot]
+    ax.imshow(arr.get()[0])
+    ax.set_title(f"Unwrapped\n{algo_name}")
+
+if skimage_out is not None:
+    skimage_ax.imshow(skimage_out.get()[0])
+    skimage_ax.set_title("Unwrapped (CPU-only)\nalgo_skimage_unwrap")
+else:
+    skimage_ax.text(0.5, 0.5, "skimage missing", ha="center", va="center")
+    skimage_ax.set_title("Unwrapped\nalgo_skimage_unwrap")
+
+for ax in axes:
+    ax.set_axis_off()
+
+plt.tight_layout(w_pad=4.5)
+# plt.savefig("gpu_field_retr_phase_unwrapping.png")
+plt.show()
+```
+
+![gpu_field_retr_phase_unwrapping.png](./examples/gpu_field_retr_phase_unwrapping.png)
+
+
+## Developers
+
+Install everything you need with (for example for cuda12x)
+```bash
+pip install -e .[cupy-cuda12x] --group dev
+```
+
+
+Run the unit tests with `pytest`
+```bash
+pip install --group tests
+pytest tests
+```
+
+Build docs with `sphinx`
+
+```bash
+pip install --group docs
+cd docs
+sphinx-build . _build
+```
+
+Check the docs locally by opening `docs/_build/index.html` file in your browser.
+
+### Package management with `uv`
+
+If you wish to use `uv` to handle package management, then you need to first
+install `uv` and then run:
+
+For example, for the optional `cupy-cuda12x`
+
+```bash
+uv sync -active --all-groups --all-extras
+```
+
+Which should install all dev dependencies.
+
+
+## Other phase unwrapping packages
+
+Here are several phase unwrapping packages that exist in Python:
+- https://github.com/blakedewey/phase_unwrap (CPU)
+- Scikit-image (CPU)
+
+## Use of AI
+
+This package used Codex (mostly 5.4-Mini) to translate the source citations
+(see documentation website) into Python code, as well as the mathematical derivations.
+All code and documents were then human-verified and verified with Claude Opus,
+and tested against known input data.

xpunwrap-0.0.0/pyproject.toml

@@ -0,0 +1,62 @@
+[project]
+name = "xpunwrap"
+description = "Phase unwrapping algorithms which are CPU and GPU agnostic"
+authors = [
+    # In alphabetical order.
+    {name = "Conrad Möckel"},
+    {name = "Eoghan O'Connell"},
+]
+maintainers = [
+    {name = "Eoghan O'Connell", email="eoclives@hotmail.com"},
+]
+
+readme = "README.md"
+license-files = ["LICENSE"]
+requires-python = ">=3.11, <4"
+dependencies = [
+    "numpy>=2.2.6",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+# cupy has several installation options, depending on your CUDA Toolkit version
+cupy-cuda12x = ["cupy-cuda12x"]
+cupy-cuda13x = ["cupy-cuda13x"]
+scikit-image = ["scikit-image>=0.20.0"]
+# faster CPU Fourier transforms (numpy>=2 requires pyfftw>=0.15)
+FFTW = ["pyfftw>=0.15.0"]
+
+[dependency-groups]
+tests = [
+    "pytest>=9.0.2",
+    "pytest-benchmark>=5.2.3",
+    "qpretrieve[FFTW]>=0.6.1",
+]
+docs = [
+    "sphinx>=7.2",
+    "sphinx-rtd-theme>=2.0",
+    "myst-parser>=2.0",
+]
+examples = [
+    "matplotlib>=3.10.8",
+    "qpretrieve>=0.6.0",
+    "zarr>=3.1.0",
+    "scikit-image>=0.24.0",
+    "cupy-cuda12x",
+]
+dev = [
+    { include-group = "tests" },
+    { include-group = "docs" },
+    { include-group = "examples" },
+    "flake8>=7.3.0",
+]
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.packages.find]
+include = ["xpunwrap*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "--ignore=benchmarking"

xpunwrap-0.0.0/setup.cfg

@@ -0,0 +1,9 @@
+[flake8]
+per-file-ignores = 
+	__init__.py:F401
+	examples/*.py:E501
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

xpunwrap-0.0.0/tests/test_fft_engines.py

@@ -0,0 +1,70 @@
+import numpy as np
+import pytest
+
+import xpunwrap
+from xpunwrap.fourier import (
+    FFTEngineCupy,
+    FFTEngineNumpy,
+    FFTEnginePyFFTW,
+    get_best_engine,
+    get_fft_engine,
+)
+
+pyfftw_missing = FFTEnginePyFFTW is None
+cupy_missing = FFTEngineCupy is None or not FFTEngineCupy.is_available
+
+
+def test_select_numpy_when_forced(numpy_backend, preferred_engine):
+    preferred_engine("FFTEngineNumpy")
+    assert get_best_engine() is FFTEngineNumpy
+
+
+@pytest.mark.skipif(pyfftw_missing, reason="pyfftw not installed")
+def test_select_pyfftw_by_default(numpy_backend, preferred_engine):
+    preferred_engine(None)
+    assert get_best_engine() is FFTEnginePyFFTW
+
+
+def test_get_fft_engine_caches_instance(numpy_backend):
+    assert get_fft_engine() is get_fft_engine()
+
+
+@pytest.mark.skipif(cupy_missing, reason="cupy not installed")
+def test_select_cupy_under_cupy_backend():
+    xpunwrap.set_ndarray_backend("cupy")
+    try:
+        assert get_best_engine() is FFTEngineCupy
+    finally:
+        xpunwrap.set_ndarray_backend("numpy")
+
+
+@pytest.mark.skipif(pyfftw_missing, reason="pyfftw not installed")
+def test_pyfftw_matches_numpy(numpy_backend, preferred_engine):
+    # float64 isolates the FFT convention (normalisation) from single-precision
+    # rounding, so the two engines must agree to near machine precision.
+    rng = np.random.default_rng(7)
+    wrapped = rng.uniform(-np.pi, np.pi, size=(3, 32, 24))
+
+    preferred_engine("FFTEngineNumpy")
+    out_np = xpunwrap.algo_ls_poisson(wrapped)
+
+    preferred_engine("FFTEnginePyFFTW")
+    out_fftw = xpunwrap.algo_ls_poisson(wrapped)
+
+    assert np.allclose(out_np, out_fftw, rtol=1e-9, atol=1e-9)
+
+
+@pytest.mark.skipif(cupy_missing, reason="cupy not installed")
+def test_cupy_matches_numpy(numpy_backend, preferred_engine):
+    rng = np.random.default_rng(7)
+    wrapped = rng.uniform(-np.pi, np.pi, size=(3, 32, 24))
+
+    preferred_engine("FFTEngineNumpy")
+    out_np = xpunwrap.algo_ls_poisson(wrapped)
+
+    preferred_engine("FFTEngineCupy")
+    xpunwrap.set_ndarray_backend("cupy")
+    _cp = xpunwrap.get_ndarray_backend()
+    out_cp = xpunwrap.algo_ls_poisson(_cp.asarray(wrapped))
+
+    assert np.allclose(out_np, out_cp.get(), rtol=1e-9, atol=1e-9)

xpunwrap-0.0.0/tests/test_ls_poisson.py

@@ -0,0 +1,21 @@
+from xpunwrap.algorithms import algo_ls_poisson
+
+from tests.helper_methods import assert_shape_dtype
+
+
+def test_ls_poisson_stack(fake_phase_data):
+    phase_stack = fake_phase_data["stack"]
+    out = algo_ls_poisson(phase_stack)
+    assert_shape_dtype(out, phase_stack.shape)
+
+
+def test_ls_poisson_2d(fake_phase_data):
+    phase_single = fake_phase_data["single"]
+    out = algo_ls_poisson(phase_single)
+    assert_shape_dtype(out, phase_single.shape)
+
+
+def test_ls_poisson_stack_real_data(cell_phase_data):
+    phase_stack = cell_phase_data
+    out = algo_ls_poisson(phase_stack)
+    assert_shape_dtype(out, phase_stack.shape)

xpunwrap-0.0.0/tests/test_ls_poisson_periodic_grad.py

@@ -0,0 +1,31 @@
+import xpunwrap
+from xpunwrap.algorithms import algo_ls_poisson_pg
+
+from tests.helper_methods import assert_shape_dtype
+
+
+def test_ls_poisson_periodic_grad_2d(fake_phase_data):
+    phase_single = fake_phase_data["single"]
+    out = algo_ls_poisson_pg(phase_single)
+    assert_shape_dtype(out, phase_single.shape)
+
+
+def test_ls_poisson_periodic_grad_3d(fake_phase_data):
+    phase_stack = fake_phase_data["stack"]
+    out = algo_ls_poisson_pg(phase_stack)
+    assert_shape_dtype(out, phase_stack.shape)
+
+
+def test_ls_poisson_periodic_grad_different_shape():
+    xp = xpunwrap.get_ndarray_backend()
+    rng = xp.random.default_rng(11)
+    phase_stack = rng.uniform(
+        -xp.pi, xp.pi, size=(2, 24, 20)).astype(xp.float32)
+    out = algo_ls_poisson_pg(phase_stack)
+    assert_shape_dtype(out, phase_stack.shape)
+
+
+def test_ls_poisson_stack_real_data(cell_phase_data):
+    phase_stack = cell_phase_data
+    out = algo_ls_poisson_pg(phase_stack)
+    assert_shape_dtype(out, phase_stack.shape)

xpunwrap-0.0.0/tests/test_ls_weighted.py

@@ -0,0 +1,29 @@
+from xpunwrap.algorithms import algo_ls_weighted
+
+from tests.helper_methods import assert_shape_dtype
+
+
+def test_ls_weighted_stack(fake_phase_data):
+    phase_stack = fake_phase_data["stack"]
+    out = algo_ls_weighted(
+        phase_stack,
+        border_thresh=1.0,
+        n_iter=5,
+    )
+    assert_shape_dtype(out, phase_stack.shape)
+
+
+def test_ls_weighted_2d(fake_phase_data):
+    phase_single = fake_phase_data["single"]
+    out = algo_ls_weighted(
+        phase_single,
+        border_thresh=2.0,
+        n_iter=3,
+    )
+    assert_shape_dtype(out, phase_single.shape)
+
+
+def test_ls_poisson_stack_real_data(cell_phase_data):
+    phase_stack = cell_phase_data
+    out = algo_ls_weighted(phase_stack)
+    assert_shape_dtype(out, phase_stack.shape)